এটি কি এক গণ্ডগোল শব্দ?

31

( পাজলিংয়ের উপরে এই চ্যালেঞ্জের দ্বারা অনুপ্রাণিত - সেই ধাঁধার জন্য স্পিলারগুলি নীচে রয়েছে, সুতরাং আপনি যদি নিজেই সেই ধাঁধাটি সমাধান করতে চান তবে এখানে পড়া বন্ধ করুন!)

যদি কোনও শব্দের একটি অক্ষর শব্দের আগের অক্ষরের চেয়ে বর্ণানুক্রমিকভাবে পরে ঘটে থাকে, আমরা এটি দুটি অক্ষরের মধ্যে বৃদ্ধি বলে থাকি । তা না হলে, সহ যদি এটি একই চিঠি , এটি একটি বলা হচ্ছে পতনের ।

উদাহরণ হিসেবে বলা যায়, শব্দ ACEদুটি রি আছে ( Aথেকে Cএবং Cথেকে E) এবং না, পড়ে যখন THEদুই Falls (হয়েছে Tথেকে Hএবং Hথেকে E) এবং কোন রি।

ক্রমটি ক্রমবর্ধমান হয় এবং পর্যায়ক্রমে পড়লে আমরা বম্পি শব্দটিকে ডাকি । উদাহরণস্বরূপ, BUMPবৃদ্ধি ( Bথেকে U) যায় , পড়ে ( Uথেকে M), বৃদ্ধি ( Mথেকে P)। মনে রাখবেন যে প্রথম ক্রমটি বৃদ্ধি হওয়ার দরকার নেই - BALDপতন-উত্থান-পতন হয় এবং এটিও বম্পি।

চ্যালেঞ্জ

একটি শব্দ দেওয়া হয়েছে, আউটপুট এটি Bumpy কিনা।

ইনপুট

  • কোনও উপযুক্ত বিন্যাসে কেবল ASCII বর্ণমালা ( [A-Z]বা [a-z]) অক্ষর সমন্বিত একটি শব্দ (অগত্যা একটি অভিধানের শব্দ নয়) ।
  • আপনার পছন্দটি যদি ইনপুটটি সমস্ত বড় হাতের বা সমস্ত ছোট হাতের হয় তবে এটি অবশ্যই সামঞ্জস্যপূর্ণ।
  • শব্দটির দৈর্ঘ্য কমপক্ষে 3 টি হবে।

আউটপুট

ইনপুট শব্দটি বিড়বিড় (সত্যবাদী) বা বম্পি (মিথ্যা) নয় কিনা এর জন্য একটি সত্যবাদী / মিথ্যা মান।

নিয়ম

  • হয় একটি সম্পূর্ণ প্রোগ্রাম বা একটি ফাংশন গ্রহণযোগ্য।
  • স্ট্যান্ডার্ড লুফোলগুলি নিষিদ্ধ।
  • এটি কোড-গল্ফ তাই সাধারণ গল্ফিংয়ের সমস্ত নিয়ম প্রয়োগ হয় এবং সংক্ষিপ্ততম কোড (বাইটে) জয়ী হয়।

উদাহরণ

Truthy:

ABA
ABB
BAB
BUMP
BALD
BALDY
UPWARD
EXAMINATION
AZBYCXDWEVFUGTHSIRJQKPLOMN

Falsey:

AAA
BBA
ACE
THE
BUMPY
BALDING
ABCDEFGHIJKLMNOPQRSTUVWXYZ

লিডারবোর্ড

নিয়মিত লিডারবোর্ড এবং ভাষার দ্বারা বিজয়ীদের একটি সংক্ষিপ্ত বিবরণ উভয়ই তৈরি করতে এখানে একটি স্ট্যাক স্নিপেট।

আপনার উত্তরটি প্রদর্শিত হয়েছে তা নিশ্চিত করার জন্য, দয়া করে নীচের মার্কডাউন টেম্পলেটটি ব্যবহার করে আপনার উত্তরটি শিরোনাম দিয়ে শুরু করুন:

# Language Name, N bytes

Nআপনার জমা দেওয়ার আকারটি কোথায় ? আপনি যদি নিজের স্কোরটি উন্নত করেন তবে আপনি পুরানো স্কোরগুলি শিরোনামে রেখে দিতে পারেন । এই ক্ষেত্রে:

# Ruby, <s>104</s> <s>101</s> 96 bytes

যদি আপনি নিজের শিরোনামে একাধিক সংখ্যা অন্তর্ভুক্ত করতে চান (যেমন আপনার স্কোর দুটি ফাইলের সমষ্টি বা আপনি পৃথকভাবে দোভাষী পতাকা দণ্ডের তালিকা করতে চান), নিশ্চিত করুন যে আসল স্কোরটি শিরোনামের শেষ সংখ্যা:

# Perl, 43 + 2 (-p flag) = 45 bytes

আপনি ভাষাটির নামটিকে একটি লিঙ্কও বানাতে পারেন যা লিডারবোর্ড স্নিপেটে প্রদর্শিত হবে:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

কোড স্নিপেট দেখান

code-golf  string  decision-problem 
— AdmBorkBork
সূত্র
ধূর. যদি একই চিঠিটি না হয় বা না পড়ে তবে এটি আরও সহজ হবে।
— mbomb007
প্রদত্ত উদাহরণগুলি আমি বুঝতে পারি না: যদি BUMPসত্যবাদী (অর্থাত্‍ বম্পি) তালিকাভুক্ত থাকে তবে ফ্যালাসির তালিকায় কেন BUMPY? "উত্থান এবং বিকল্প ফলস" এর অর্থ কী? দুই উত্থানের ধারাবাহিকভাবে কি হতে পারে না?
— ভোল্যান্ড এবং
4
@ ভোলএন্ড হ্যাঁ, এর অর্থ হ'ল একটি উত্থান সর্বদা পতন এবং তার বিপরীতে হয়। BUMPYমিথ্যা কারণ MPYক্রমাগত দুটি বৃদ্ধি দেয়। অন্য কথায়, শব্দের ঘনঘন হওয়ার জন্য 3 দৈর্ঘ্যের কোনও স্ট্রিংিং আরোহী বা উতরাই বাছাই করতে হবে না (বিশেষত ক্ষেত্রে যেখানে পরপর দুটি অক্ষর অভিন্ন থাকে)।
— মার্টিন এন্ডার
আপনি কি পাজলিং.এসই প্রশ্নের উত্তর ফাঁকি দিতে পারেন তাই অন্যরা যারা নিজেরাই এটি সমাধান করতে চান তারা তা করতে পারে?
— OldBunny2800
1
@ ওল্ডবুনি ২৮০০ আমি একটি সম্পূর্ণ বিলোপকারীকে প্রবেশ করবো না (কোনও স্পয়লারের পিছনে গুরুত্বপূর্ণ তথ্য গোপন করে আমি আমার চ্যালেঞ্জটি এখানে পড়তে খুব কঠিন করতে চাই না), তবে আমি সতর্কতা হিসাবে শীর্ষে কিছু অতিরিক্ত পাঠ্য যুক্ত করব। ধন্যবাদ!
— অ্যাডমবর্কবর্ক

উত্তর:

31

এমএটিএল, 4 বাইট

d0>d

ব্যাখ্যা:

d     % Implicitly take input. Take difference between each element
 0>   % Check whether diff's are positive. Should result in [0 1 0 1 ...] pattern.
   d  % Again take the difference. Any consecutive rises or falls results in a 
      % difference of 0, which is a falsy value in MATL

এটি আমার প্রথম এমএটিএল এন্ট্রি, তাই আমি আমার ম্যাটল্যাব / অক্টাভা প্রচেষ্টা (যা হবে @(a)all(diff(diff(a)>0))) থেকে এই নিষ্পাপ বন্দর থেকে কত উন্নতি হতে পারে তা অবাক করি । নোট করুন যে এটি allপ্রয়োজনীয় নয় কারণ কোনও শূন্য একটি অ্যারেকে মিথ্যা করে তোলে, তাই Aএমএটিএল বন্দরে নেই।

— Sanchises
সূত্র
সংশোধন করা চ্যালেঞ্জ দেখুন। একটি পরীক্ষার ক্ষেত্রে টাইপো ছিল। আপনার পদ্ধতির সঠিক ছিল। আসলে, d0>dকাজ করা উচিত ( Aসত্যবাদী / মিথ্যা আমাদের সংজ্ঞা অনুসারে আপনার প্রয়োজন নেই)
— লুইস মেন্ডো
1
দুর্দান্ত কাজ, নিজের ভাষায় লুইসকে ছাড়িয়ে গেল! আমি আগে চেষ্টা করেছি, এবং এটি কোনও সহজ কাজ নয়। ;)
— ডিজেএমসিএমহেম
@ ডিজেএমসিমেহেম হা হা। চ্যালেঞ্জটি খুব দ্রুত পড়ার জন্য আমি এটাই পাই। আমার প্রতিরক্ষার সাথে, এটি পাল্টা স্বজ্ঞাত যে দুটি সমান অক্ষর একটি পতন। এবং (এখন সংশোধন করা হয়েছে) বিভ্রান্তকারী পরীক্ষার মামলাগুলি
— কোনওভাবেই
1
@ ডিজেএমসিহেম ধন্যবাদ - যদিও আমি সম্ভবত ভাগ্যবান হয়েছি, কারণ আমি আসলে একটানা সমান অক্ষর সম্পর্কে ভাবিনি, তবে এটি ঠিক যা বলা হয়েছিল তা প্রমাণিত হয়েছিল ...
— সানচাইসেস
1
এমিমিবিস ইন এমএটিএল (এবি) এবং অকটাভ, হ্যাঁ। দেখুন এই মেটা উত্তর।
— সান্চাইজস
24

জাভাস্ক্রিপ্ট (ES6), 75 69 63 46 43 বাইট

নীলকে 3 বাইট সংরক্ষণ করা হয়েছে:

f=([c,...s])=>s[1]?c<s[0]^s[0]<s[1]&&f(s):1

এর পরিবর্তে স্ট্রিং প্যারামিটার তৈরি করা s.slice(1)।

পূর্ববর্তী সমাধান:
ETH প্রডাকশনগুলির জন্য 17 বাইট সংরক্ষণ করা:

f=s=>s[2]?s[0]<s[1]^s[1]<s[2]&&f(s.slice(1)):1

ধাপে ধাপে পূর্ববর্তী সমাধান থেকে কী ঘটেছিল:

f=(s,i=0,a=s[i++]<s[i])=>s[i+1]&&(b=a^(a=s[i]<s[i+1]))?f(s,i):b // (63) Original
f=(s,i=0,a=s[i++]<s[i])=>s[i+1]&&(b=a^(s[i]<s[i+1]))?f(s,i):b   // (61) No point in reassigning `a`, it's not used again
f=(s,i=0,a=s[i++]<s[i])=>s[i+1]&&(b=a^s[i]<s[i+1])?f(s,i):b     // (59) Remove unnecessary parentheses
f=(s,i=0)=>s[i+2]&&(b=s[i++]<s[i]^s[i]<s[i+1])?f(s,i):b         // (55) `a` is now just a waste of bytes
f=(s,i=0)=>s[i+2]?(b=s[i++]<s[i]^s[i]<s[i+1])?f(s,i):b:1        // (56) Rearrange conditional expressions to allow for more golfing
f=(s,i=0)=>s[i+2]?(b=s[i++]<s[i]^s[i]<s[i+1])&&f(s,i):1         // (55) Rearrange conditional expression
f=(s,i=0)=>s[i+2]?(s[i++]<s[i]^s[i]<s[i+1])&&f(s,i):1           // (53) `b` is now also a waste of bytes
f=(s,i=0)=>s[i+2]?s[i++]<s[i]^s[i]<s[i+1]&&f(s,i):1             // (51) Remove unnecessary parentheses
f=s=>s[2]?s[0]<s[1]^s[1]<s[2]&&f(s.slice(1)):1                  // (46) Use `s.slice(1)` instead of `i`

পূর্ববর্তী সমাধান:
TH৩ বাইট ইটিএইচ প্রডাকশনগুলিতে ধন্যবাদ:

f=(s,i=0,a=s[i++]<s[i])=>s[i+1]&&(b=a^(a=s[i]<s[i+1]))?f(s,i):b

69 বাইট:

f=(s,i=0,a=s[i++]<s[i])=>i+1<s.length&&(b=a^(a=s[i]<s[i+1]))?f(s,i):b

75 বাইট:

f=(s,a=s[0]<s[1])=>{for(i=1;i+1<s.length&&(b=a^(a=s[i++]<s[i])););return b}

একটি কথায় সমস্ত অক্ষরের অবশ্যই একই কেস থাকতে হবে।

— Hedi
সূত্র
2
আপনি এটিকে আরও খানিকটা গল্ফ করতে পারেন: github.com/ETHproductions/golf/blob/gh-pages/misc/93014.js
— ETHproductions
@ETH প্রোডাকশনগুলি কি আমাকে আপনার লিঙ্কের সামগ্রী পোস্ট করা উচিত?
— হেডি
আপনি চাইলে করতে পারেন :-)
— ETH প্রোডাকশনগুলি
!s[2]|...একই হিসাবে কি করতে পারেন s[2]?...:1?
— তিতাস
1
পার্টিতে দেরি হওয়ার জন্য দুঃখিত, তবে 43 বাইটের জন্য আমি আপনাকে দিচ্ছি:f=([c,...s])=>s[1]?c<s[0]^s[0]<s[1]&&f(s):1
— নিল
14

ল্যাবভিউ, 36 সমমানের বাইট

লজিকাল সমতা ব্যবহার করে গল্ফ ডাউন:

golfed

Ungolfed:

ungolfed

প্রথমে আমরা লোয়ারকেসে রূপান্তর করি, তারপরে বাইট অ্যারেতে। বাইট অ্যারের প্রথম উপাদানটি ছাঁটাই কারণ এটির নজির নেই। তারপরে অ্যারেতে প্রতিটি উপাদানগুলির জন্য, এটি আগেরটির চেয়ে বড় (আপনার প্রত্যাশা অনুযায়ী ইউএস চর মানচিত্র ASCII) এর চেয়ে বড় কিনা এবং পরের পুনরাবৃত্তির জন্য ফলাফলটি সংরক্ষণ করুন, পাশাপাশি সামগ্রিক উদ্বিগ্নতা দেখার জন্য একটি অ্যারেতে। যদি বর্তমান এবং পূর্বের বুলিয়ান চেক সমান হয় তবে আমরা লুপটি শেষ করি এবং এটি জটিল নয়। অন্যথায়, এটি গণ্ডগোল!

— ijustlovemath
সূত্র
1
কি দুর্দান্ত ভাষা! পিপিসিজিতে আপনাকে স্বাগতম!
— ডিজেএমসিএমহেম
1
ধন্যবাদ! আমি কখনই 4 বাইট উত্তরগুলির সাথে প্রতিযোগিতা করব না, তবে এটি আমার দক্ষতা উন্নত করার একটি দুর্দান্ত উপায় :)
— ijustlovemath
এখানে দেখুন । আপনার স্কোরিং অবশ্যই ভুল এবং অতিরিক্ত মাত্রাতিরিক্ত । আমি মনে করি না যে আপনার উত্তরটি সত্যই 246450 - 246549 বাইট।
— এরিক আউটগলফার
আমি মেমোরি ট্যাবটি ছাড়ছিলাম, কারণ আমি জানতাম না যে ল্যাবভিউয়ের জন্য সমতুল্য বাইটের ধারণা রয়েছে। এগুলি গণনা করা হবে এবং আজই উত্তর উত্তর সম্পাদনা করবে।
— 12 এজেড
1
@ এরিক আমি উইন্ডোজের ফায়ারফক্সে রয়েছি, তবে মোবাইলে এটি খোলার ফলে জিনিসগুলিও ভেঙে যায়। শুধু meta.ppcg.lol কাজ করে। যাইহোক, এটি মন্তব্য করার সুযোগের বাইরে।
— ফান্ড মনিকার লসুইট
8

পাইথন, 56 বাইট

lambda s:all((x<y)^(y<z)for x,y,z in zip(s,s[1:],s[2:]))

সমস্ত পরীক্ষার কেস আদর্শে

এর মধ্যে তিনটি অক্ষর এবং পরীক্ষার মাধ্যমে জিপগুলি যে সমস্ত ট্রিপল বাম এবং ডান জোড়গুলির সাথে বিভিন্ন উত্থান / পতনের বৈশিষ্ট্য রয়েছে।
সমস্ত বড় হাতের বা সমস্ত ছোট হাতের জন্য কাজ করে।

— জোনাথন অ্যালান
সূত্র
6

রুবি, 57 48 বাইট

প্রত্যাশা ইনপুটটি সমস্ত বড় হবে।

->s{!s.gsub(/.(?=(.)(.))/){($&<$1)^($1<$2)}[?f]}

এটি repl.it এ দেখুন: https://repl.it/D7SB

ব্যাখ্যা

নিয়মিত এক্সপ্রেশন /.(?=(.)(.))/প্রতিটি চরিত্রের সাথে মিলিত হয় তারপরে আরও দুটি অক্ষর। (?=...)ইতিবাচক চেহারা, যার অর্থ আমরা পরবর্তী দুটি চরিত্রের সাথে মেলে তবে ম্যাচের অংশ হিসাবে এগুলি "গ্রাস" করি না। কোঁকড়া ধনুর্বন্ধনী ভিতরে, $&মিলেছে টেক্সট প্রথম তিন-এবং এর চরিত্র $1এবং $2lookahead ভিতরে বন্দী অক্ষর। অন্য কথায়, যদি স্ট্রিং "BUMPY", এটা প্রথম ম্যাচ হবে "B"(এবং রাখা $&) এবং ক্যাপচার "U"এবং "M"(এবং তাদের রাখা $1এবং $2)। পরবর্তী মিলিয়ে নেবে "U"এবং ক্যাপচার "M"এবং "P", ইত্যাদি।

ব্লকের ভিতরে আমরা পরীক্ষা করে দেখি যে অক্ষরের প্রথম জুড়ি ( $&এবং $1) বৃদ্ধি এবং দ্বিতীয় ( $1এবং $2) একটি পতন বা বিপরীত, অন্যান্য উত্তরগুলির বেশিরভাগের মতো। এই ^প্রকাশটি ফিরে আসে trueবা false, যা স্ট্রিতে রূপান্তরিত হয়ে ম্যাচের জায়গায় sertedোকানো হয়। ফলস্বরূপ, আমাদের উদাহরণ এটি "BUMPY"হয়ে:

"truetruefalsePY"

যেহেতু আমরা জানি যে ইনপুটটি সমস্ত বড় হাতের অক্ষর, আমরা জানি "f"কেবলমাত্র তার অংশ হিসাবে ঘটবে "false"এবং !result[?f]আমাদের উত্তর দেয়।

— জর্ডন
সূত্র
এটা কিভাবে কাজ করে?
— গ্রিনএজজেড
1
@ গ্রীনআসজেড আমি আমার উত্তরে একটি ব্যাখ্যা যুক্ত করেছি।
— জর্ডান
6

সি #, 64 63 55 বাইট

unsafe bool B(char*s)=>1>s[2]||*s<s[1]!=*++s<s[1]&B(s);

-সেফিয়োর পরামর্শ থেকে 8 বাইট

এটি হিডি সি # এর সমাধানের বন্দর । আমিও একটি পুনরাবৃত্ত সমাধান সমাধানে এসেছি, তবে পুনরাবৃত্তি তেমন ভাল ছিল না। আমার মূল সমাধানটি নীচে।

আমার আসল সি #, 96 94 91 বাইট

unsafe bool B(char*s,bool f=1>0,int i=0)=>1>s[1]||(s[0]<s[1]?f:1>i?!(f=!f):!f)&B(s+1,!f,1);

1>0পরিবর্তে ব্যবহার করে -2 বাইট true।

উপরের বন্দর সমাধানের জন্য সিসেফোর পরামর্শ থেকে -3 বাইট

কলগুলি নিজেই পুনরাবৃত্তভাবে পরীক্ষা করে নিচ্ছে যে প্রতিবার উঠতি / পড়ার বিকল্প হয়।

Ungolfed:

// unsafe in order to golf some bytes from string operations.
// f alternates with each recursive call
// i is 0 for the first call, 1 for all subsequent calls
unsafe bool B(char* s, bool f = 1 > 0, int i = 0) =>
    1 > s[1] ? 1 > 0// (instead of 1 == s.Length) check if s[1] = NULL, and return true.
    : (
        s[0] < s[1] ? f // Rising, so use f...
        : // Else falling
            1 > i ? !(f=!f) // But this is the first call, so use true (but flip f)...
            : !f // Not first call, so use !f...
    )
    & B(s+1, !f, 1) // ...AND the previous value with a recursive call
                    // s+1 instead of s.Substring(1)
;
— দুধ
সূত্র
?:অপারেটর বা প্রথম বন্ধনী ছাড়াই শেষের মতো করতে পারে বলে মনে হচ্ছে :unsafe bool B(char*s)=>1>s[2]|s[0]<s[1]!=s[1]<s[2]&B(s+1);
— সিপ্পিও
প্রকৃতপক্ষে, যদিও আমি এটি পরীক্ষা করতে পারছি না, পয়েন্টারটি নিজেই unsafe bool B(char*s)=>1>s[2]|*s<s[1]!=*++s<s[1]&B(s);
— হস্তান্তর করা
@ শেফিও আমি এই পরামর্শগুলির সাথে স্ট্যাকওভারফ্লো এক্সপ্যাকশন পেয়েছি তবে তারা বিটওয়্যার বা এর ||পরিবর্তে বুলিয়ান OR ব্যবহার করে কাজ করে |। ধন্যবাদ পোস্টটি আপডেট করেছেন।
— দুধ
6

সি 59 বাইট

r;f(s)char*s;{for(r=0;r=*s?~r&1<<(*s>=*++s):0;);return!*s;}
— cleblanc
সূত্র
70 বাইটে সমাধান AAA
— কেসটির
আমি ব্যবহার করে পরীক্ষা করছি gcc (GCC) 3.4.4 (cygming special, gdc 0.12, using dmd 0.125)এবং আমি আআ এবং উত্তেজিত হয়ে মিথ্যা পেয়েছি। এই সংস্করণে শূন্য নন মিথ্যা, এবং শূন্য সত্য। আসলে এখনই ভাবছেন যদি এটি অনুমোদিত হয়?
— ক্লাব্ল্যাঙ্ক
f("ABCDEFGHIJKLMNOPQRSTUVWXYZ")ভিজ্যুয়াল স্টুডিও 2012-তে সংকলিত কলটি 23এমন মান প্রদান করে যা মান হিসাবে বিবেচিত হতে পারে Trueতবে প্রশ্নে এই মানটি "ফালসি" বিভাগে রয়েছে, সুতরাং 0প্রত্যাশার মান ।
— ভোল্যান্ড এবং
সত্য এবং ফালসির জন্য কী অনুমোদিত তা আমি ভুল বুঝেছি। এখন আমি সেই পোস্টটি পড়েছি এবং এটি পরিষ্কার হয়ে যায় যে "সি" এর জন্য মানগুলি কী হতে হবে।
— ক্লাব্ল্যাঙ্ক
মেটা sensকমত্যের ভিত্তিতে সত্য এবং মিথ্যা সম্পর্কিত আমাদের মানক সংজ্ঞা এখানে রয়েছে ।
— অ্যাডমবর্কবার্ক
5

জেলি , 6 বাইট

OI>0IẠ

@ সানচাইজির উত্তরের ভিত্তিতে

এটি অনলাইন চেষ্টা করুন! বা সমস্ত যাচাই করুন।

ব্যাখ্যা

OI>0IẠ  Input: string S
O       Convert each char in S to an ordinal
 I      Get the increments between each pair
  >0    Test if each is positive, 1 if true else 0
    I   Get the increments between each pair
     Ạ  Test if the list doesn't contain a zero, 1 if true else 0
— মাইল
সূত্র
5

পাইথন 2, 88 বাইট

সহজ সমাধান।

s=input()
m=map(lambda x,y:y>x,s[:-1],s[1:])
print all(x-y for x,y in zip(m[:-1],m[1:]))

এটি অনলাইনে চেষ্টা করুন

যদি একের পর এক একই অক্ষরগুলির উত্থান বা পতন না থাকে তবে সমাধানটি 79৯ বাইট ছিল:

s=input()
m=map(cmp,s[:-1],s[1:])
print all(x-y for x,y in zip(m[:-1],m[1:]))
— mbomb007
সূত্র
5

পার্ল, 34 বাইট

এর জন্য +3 অন্তর্ভুক্ত -p(কোডটি এতে ব্যবহার করা যায় না 'তাই অন্তর্ভুক্ত -e)

STDIN এ বড় হাতের ইনপুট দিন:

bump.pl <<< AAA

bump.pl

#!/usr/bin/perl -p
s%.%$&.z lt$'|0%eg;$_=!/(.)\1./
— টন হসপেল
সূত্র
5

পাইথন, 51 বাইট

g=lambda a,b,c,*s:((a<b)^(b<c))*(s==()or g(b,c,*s))

যেমন g('B','U','M','P')এবং আউটপুট 1বা ইনপুট লাগে 0।

প্রথম তিনটি অক্ষর নিতে এবং প্রথম দুটি দ্বিতীয় দুটি থেকে আলাদাভাবে তুলনা করে কিনা তা পরীক্ষা করতে আর্গুমেন্ট আনপ্যাকিং ব্যবহার করে। তারপরে, এর জন্য গুণটি ব্যবহার করে, অবশিষ্টটির পুনরাবৃত্তি করে and।

— xnor
সূত্র
ভাল ইনপুট গল্ফ। ;-)
— অ্যাডমবর্কবার্ক
5

জেলি , 6 5 বাইট

-1 বাইট @ ডেনিসকে ধন্যবাদ (ক্রমহ্রাসমান হ্রাস ব্যবহার করুন)

<2\IẠ

সমস্ত পরীক্ষার কেস ট্রাইআইটঅনলাইনে রয়েছে

কিভাবে?

<2\IẠ - main link takes an argument, s,    e.g. "BUMP"    or "BUMPY"
<    - less than comparison (a dyad)
 2   - literal 2 (a nilad)
  \  - n-wise overlapping reduction when preceded by a dyad-nilad chain
       (i.e. reduce the list by pairs with less than)
                                           e.g. [1,0,1]   or [1,0,1,1]
   I  - consecutive differences,           e.g. [-1,1]    or [-1,1,0]
    Ạ - All, 0 if any values are 0 else 1, e.g. 1         or 0

সমস্ত বড় হাতের বা সমস্ত ছোট হাতের জন্য কাজ করে।

— জোনাথন অ্যালান
সূত্র
4

জাপট, 8 বাইট

Uä> ä- e

এটি অনলাইন পরীক্ষা!

কিভাবে এটা কাজ করে

Uä> ä- e  // Implicit: U = input string
Uä>       // Map each pair of chars X, Y in U to X > Y.
    ä-    // Map each pair of items in the result to X - Y.
          // If there are two consecutive rises or falls, the result contains a zero.
       e  // Check that every item is truthy (non-zero).
          // Implicit: output last expression
— ETHproductions
সূত্র
আমার সমাধান হিসাবে একই। 11x খাটো বাদে। : পি
— mbomb007
4

সি # 105 104 বাইট

bool f(char[]x){int t=1;for(int i=2,p=x[1],f=x[0]-p>>7;i<x.Length;)f^=t&=p<(p=x[i++])?1-f:f;return t>0;}

105 বাইট সমাধান:

bool f(char[]x){bool t=1>0,f=x[0]<x[1];for(int i=2,p=x[1];i<x.Length;)f^=t&=p<(p=x[i++])?!f:f;return t;}

এটি অনলাইনে চেষ্টা করুন

অক্ষরের অ্যারে ব্যবহার করে একটি বাইট সংরক্ষণ করা হয়েছে কারণ বন্ধনীগুলির পরে স্থান বাদ দেওয়া যেতে পারে। f(string x)বনামf(char[]x)

এটি 101 বাইট, যদি আমি বুল ট্রু / ভুটের পরিবর্তে কোনও ইনট 1/0 ফেরত দিতে পারি

int f(char[]x){int t=1;for(int i=2,p=x[1],f=x[0]-p>>7;i<x.Length;)f^=t&=p<(p=x[i++])?1-f:f;return t;}
— pinkfloydx33
সূত্র
4

হাস্কেল, 52 বাইট

f x=and$g(/=)$g(>)x
  where g h y=zipWith h(tail y)y

আমার সন্দেহ হয় আমি যদি "যেখানে" তৈরির কাজ থেকে মুক্তি পেতে পারি তবে আমি সম্ভবত জিপউইথ দিয়ে আটকেছি।

এটি রাইজ (ট্রু) এবং ফলস (মিথ্যা) একটি তালিকা তৈরি করে কাজ করে, তারপরে এই তালিকার অ্যাজাসেন্টের এন্ট্রিগুলি আলাদা কিনা তার একটি তালিকা তৈরি করে

এটি এর মধ্যে একটিতে এটি আমার প্রথম প্রয়াস, সুতরাং আমি কোথাও ভয়াবহভাবে ভুল হয়ে গেলে আমি আমার চিন্তা প্রক্রিয়াটি নিয়ে যাব।

অরোগল্ফড সংস্করণ (168 বাইট)

isBumpy :: [Char] -> Bool
isBumpy input = and $ areBumps $ riseFall input
  where
    riseFall ax@(x:xs) = zipWith (>) xs ax
    areBumps ax@(x:xs) = zipWith (/=) xs ax

নামগুলি সংক্ষিপ্ত করুন, প্রকারের তথ্য সরান (100 বাইট)

f x = and $ g $ h x
  where
    h ax@(x:xs) = zipWith (>) xs ax
    g ax@(x:xs) = zipWith (/=) xs ax

এইচটিকে মূল ফাংশনে সরান কারণ এটি কেবল একবার ব্যবহৃত হয় (86tes বাইট)

f ax@(x:xs) = and $ g $ zipWith (>) xs ax
  where
    g ax@(x:xs) = zipWith (/=) xs ax

বুঝতে পারেন যে আরবম্পস এবং রাইজফাল অ্যাবস্ট্রাক্টের জন্য যথেষ্ট (73 বাইট)

f x  = and $ g (/=) $ g (>) x
  where
    g h ya@(y:ys) = zipWith h ys ya

নোট করুন (লেজ y) ইয়া @ (y: ys) (70 বাইট) এর চেয়ে কম

f x  = and $ g (/=) $ g (>) x
  where
    g h y = zipWith h (tail y) y

গোছানো; অপরিবর্তিত স্থানগুলি সরিয়ে ফেলুন (52 বাইট)

f x=and$g(/=)$g(>)x
  where g h y=zipWith h(tail y)y
— Teron
সূত্র
... এবং আমি কেবলমাত্র ছোট্ট হাস্কেল উত্তরটি লক্ষ্য করেছি যা আমার আগে পোস্ট করা হয়েছিল যা মূলত একই জিনিসটি করে। আমি জিনিস স্পট এ ভয়ানক।
— টেরন
আপনি বোঝাতে চান যে কাজ করে না? ;-) আপনি কীওয়ার্ড g h=tail>>=zipWith hএড়ানোর জন্য এটি ব্যবহার এবং এটি একটি বিশ্বব্যাপী ফাংশন তৈরি করতে পারেন where।
— খ্রিস্টান সিভর্স
@ ক্রিশ্চিয়ানসিভারস এটি স্থির করে দিয়েছিল এবং আমি এই উত্তরটি লক্ষ্য করেছি যা এখন আমার মতো ঠিক একই জিনিসটি করেছে, আমার উত্তরটিকে এই মন্তব্যটির জন্য আরও উপযুক্ত উপস্থাপন করছে।
— ব্ল্যাকক্যাপ
4

জাভা 7, 157 153 150 125 117 বাইট

int c(char[]z){for(int i=2,a,b,c;i<z.length;i++)if(((a=z[i-1])<(c=z[i])&(b=z[i-2])<a)|(a>=c&b>=a))return 0;return 1;}

অবহেলিত ও পরীক্ষার কেস:

এখানে চেষ্টা করুন।

class M{
  static int c(char[] z){
    for(int i = 2, a, b, c; i < z.length; i++){
      if(((a = z[i-1]) < (c = z[i]) & (b = z[i-2]) < a) | (a >= c & b >= a)){
        return 0; //false
      }
    }
    return 1; //true
  }

  public static void main(String[] a){
    System.out.print(c("ABA".toCharArray()) + ", ");
    System.out.print(c("ABB".toCharArray()) + ", ");
    System.out.print(c("BAB".toCharArray()) + ", ");
    System.out.print(c("BUMP".toCharArray()) + ", ");
    System.out.print(c("BALD".toCharArray()) + ", ");
    System.out.print(c("BALDY".toCharArray()) + ", ");
    System.out.print(c("UPWARD".toCharArray()) + ", ");
    System.out.print(c("EXAMINATION".toCharArray()) + ", ");
    System.out.print(c("AZBYCXDWEVFUGTHSIRJQKPLOMN".toCharArray()) + ", ");

    System.out.print(c("AAA".toCharArray()) + ", ");
    System.out.print(c("ACE".toCharArray()) + ", ");
    System.out.print(c("THE".toCharArray()) + ", ");
    System.out.print(c("BUMPY".toCharArray()) + ", ");
    System.out.print(c("BALDING".toCharArray()) + ", ");
    System.out.print(c("ABCDEFGHIJKLMNOPQRSTUVWXYZ".toCharArray()) + ", ");
  }
}

আউটপুট:

1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0
— কেভিন ক্রুইজসেন
সূত্র
@ টিমিডি হুঁ, তাই কখন বেড়ে ওঠে a > b, তবে কখন এবং এর a <= bপরিবর্তে ? ><
— কেভিন ক্রুইজসেন
@ টিমিমিডি ওকে, এটি ঠিক আছে, এমনকি 3 বাইটও সাশ্রয় করে। :)
— কেভিন ক্রুইজসেন
1
আপনি গ্রহণের জন্য আপনার পদ্ধতির পুনরায় সংজ্ঞা দিতে পারেন char[]যাতে আপনার ইনপুট স্ট্রিংটিকে চর অ্যারেতে রূপান্তর করতে হবে না। যে কয়েক বাইট সংরক্ষণ করা উচিত। PS: জাভা ftw!
— পিচ
1
আপনি সম্ভবত String s-> পরিবর্তন করার অর্থ দিয়েছিলেন char[]z?
1
আপনি কোনও মান truthyবা falseyমানটি ফিরিয়ে দিতে পারেন , সুতরাং আপনার পদ্ধতিটি ইনট করুন এবং 1 বা 0 :) ফিরতে পারেন .. আপনাকে 117 বাইটে নামিয়ে রাখে
— শন ওয়াইল্ড
3

পাওয়ারশেল ভি 2+, 83 বাইট

param($n)($a=-join(1..($n.Length-1)|%{+($n[$_-1]-lt$n[$_])}))-eq($a-replace'00|11')

কিছুটা আলাদা পন্থা। ইনপুট মাধ্যমে এই লুপ $n, প্রতিটি পুনরাবৃত্তির এইজন্য কিনা পূর্ববর্তী অক্ষরে $n[$_-1]হয় -lকানা অনুলিপি করুন tহান বর্তমান চরিত্র $n[$_], তারপর সঙ্গে একটি int- এ যে বুলিয়ান অপারেটরের ফলাফল ভোটদান +। সেগুলি -joinস্ট্রিংয়ে একত্রে সম্পাদিত হয় $a। তারপরে আমরা পরীক্ষা করে $aদেখি যে কোনও সাবস্ট্রিংগুলি -eqইউল হয়েছে কিনা বা সরানো হয়েছে।$a0011

— AdmBorkBork
সূত্র
3

পাইথন 2.7, 84 বাইট

s=input()
b=s[0]<s[1]
o=1
for i in range(len(s)-1):o&=(s[i]<s[i+1])==b;b^=1
print o

গাঁদা ফেলার জন্য 1, অন্যথায় 0 প্রদান করে

বিটওয়াইস এবং এবং with দিয়ে কিছু দুর্দান্ত জিনিস শিখেছে ^
বুলিয়ান বি প্রথম জোড়টিকে উপরের / নীচে হিসাবে সংজ্ঞায়িত করে শুরু হয়, তারপরে প্রতিটি নিম্নলিখিত জোড়ের জন্য পরীক্ষা করে এবং ফ্লিপ করে।
o পরীক্ষায় ব্যর্থ হলে এবং লাঠিপেটা মিথ্যাতে উল্টে।
ইনপুটের চারপাশে উদ্ধৃতিগুলি প্রয়োজন (কাঁচা ইনপুট জন্য +4 বাইট (যদি এটি কিছু নিয়ম ভঙ্গ করে))

এটা পরীক্ষা করো

— greyShift
সূত্র
3

05 এ বি 1 ই , 9 বাইট

SÇ¥0›¥_O_

ব্যাখ্যা

SÇ          # convert to list of ascii values
  ¥         # take delta's
   0›       # check if positive, giving a list of 1's and 0's
            # if they alternate, the word is bumpy
     ¥      # take delta's again, if we have any 0's in the list the word is not bumpy
      _     # logical negation, turning 0 into 1 and everything else to 0
       O    # sum, producing 0 for a bumpy word and 1 for a non-bumpy word
        _   # logical negation, inverting the previous 1 into 0 and vice versa

এটি অনলাইন চেষ্টা করুন!

— Emigna
সূত্র
2

পাইথন ২.7 (আবার, ৮৮ 83 বাইট)

def a(s):x=s[1:];return[cmp(s[0],x)]+a(x) if x else []
print len(set(a(input())))>1

বা, মুদ্রণ ছাড়াই 78 77 বাইট।

যাইহোক, উপরের by 56 বাইট পাইথন ২.7 উদাহরণটি বিরতি দেয়, উদাহরণস্বরূপ, "abbab"বা পুনরাবৃত্ত অক্ষরগুলির সাথে অন্য কোনও ইনপুট। কিছু মনে করবেন না, নির্দেশাবলী পড়েন না। পরিমার্জনা করেছেন বারবার।

ঠিক আছে, 83 এর নিচে। ত্রিগল যদিও ভাল।

— টিমোথি টেরেভেইনেন
সূত্র
ইয়া জন্য কিছু টিপস এখানে। 1. কিছু সাদা স্থান সরান a(x)if x else[]। ২. পরিবর্তে ল্যাম্বদা ব্যবহার করুন a=lambda s:[cmp(s[0],s[1:])]+a(s[1:])if s[1:]else[]৩. প্রিন্টিংয়ের পরিবর্তে শেষে ল্যাম্বডা ব্যবহার করুন। lambda s:len(set(a(s)))>14. যদি len(set(a(s)))1 এর চেয়ে বড় নয়, তুলনায় এটি ইতিমধ্যে falsy, তাই তুমি গ্রহণ করতে পারেন>1
— DJMcMayhem
2

সিজেম , 15 বাইট

l2ew::<2ew::^:*

এটি অনলাইন চেষ্টা করুন! (লাইনফিড-বিচ্ছিন্ন পরীক্ষা-স্যুট হিসাবে))

ব্যাখ্যা

l    e# Read input.
2ew  e# Get all (overlapping) pairs.
::<  e# Check whether each pair is strictly ascending (1) or not (0).
2ew  e# Get all (overlapping) pairs.
::^  e# Take the bitwise XOR of each pair, giving 1 if a rise and a fall alternate,
     e# and zero if there are two rises or two falls in succession.
:*   e# Product. Gives 1 only if the previous step yielded a list of 1s, meaning
     e# that any two consecutive rises/falls will turn this into a zero.
— মার্টিন ইন্ডার
সূত্র
2

পিএইচপি, 80 বাইট

$s=$argv[1];for($c=$s[0];$n=$s[++$i];$c=$n,$d=$e)if($d===$e=$n>$c)break;echo!$n;

অথবা

for($c=$argv[1][0];$n=$argv[1][++$i];$c=$n,$d=$e)if($d===$e=$n>$c)break;echo!$n;

1সত্য মিথ্যা জন্য খালি আউটপুট

বা হেডির পুনরাবৃত্তির পদ্ধতির পোর্ট করা হয়েছে এবং 70 বাইটের জন্য কিছুটা গল্ফ করা হয়েছে:

function f($s){return!$s[2]|$s[0]<$s[1]^$s[1]<$s[2]&&f(substr($s,1));}

প্রকৃতপক্ষে, এটি গণ্ডগোলপূর্ণ শব্দের জন্য অসীম পুনরাবৃত্তি করা উচিত, তবে তা হয় না!

— তিতাস
সূত্র
2

হাস্কেল, 30 37 বাইট

q f=tail>>=zipWith f;k=and.q(/=).q(>)

ব্যবহার:

Prelude> k <$> words "ABA ABB BAB BUMP BALD BALDY UPWARD EXAMINATION AZBYCXDWEVFUGTHSIRJQKPLOMN"
[True,True,True,True,True,True,True,True,True]

Prelude> k <$> words "AAA BBA ACE THE BUMPY BALDING ABCDEFGHIJKLMNOPQRSTUVWXYZ"
[False,False,False,False,False,False,False]
— BlackCap
সূত্র
এটি "টাক" গ্রহণ করে না, foldl1(/=)আপনি যা ভাবেন তা করেন না।
— খ্রিস্টান সিভর্স
@ ক্রিশ্চিয়ানসিভারস অচ, আপনি ঠিক বলেছেন।
— শীর্ষস্থানীয়দের
2

পিএইচপি 7, 137 118 বাইট

for($i=0;$i<strlen($argv[1])-2;$i++)if(((($s[$i]<=>$s[$i+1])<0)?1:0)==((($s[$i+1]<=>$s[$i+2])<0)?1:0)){echo"0";break;}

খাঁটি আউটপুট বাম্পির জন্য, নমনীয় 0নয় for

কোড গল্ফিংয়ের এটি আমার প্রথম প্রচেষ্টা এবং আমাকে অনেক উন্নতি করতে হবে, তবে আমার জন্য নতুন জিনিস শেখার একটি দুর্দান্ত পদ্ধতি ছিল। আমি খুব নতুন আকর্ষণীয় বলে মনে হচ্ছে নতুন পিএইচপি 7 স্পেসশিপ অপারেটর ব্যবহার করে সেই কাজটিতে নিজেকে চ্যালেঞ্জ করতে চেয়েছিলাম ।

যাইহোক আমি এটি সম্পর্কে সন্তুষ্ট নই, সবার আগে আমি if(isset($s[$i+2]))ভেরিয়েবলটি উপস্থিত কিনা তা পরীক্ষা করার জন্য আমাকে একটি অতিরিক্ত যুক্ত করতে হয়েছিল কারণ আমি সমস্যার আর কোনও সমাধান খুঁজে পাইনি, তবে এটি আপাতত এটি। (দ্রষ্টব্য: আমি ঠিক করেছি যে কেবল পরিবর্তন করে strlen($s)-1থেকে strlen($s)-2, আমি সত্যিই তার আগে দেখতে না পারে ...)।

পরীক্ষার কোড:

$as = array("ABA", "ABB", "BAB", "BUMP", "BALD", "BALDY", "UPWARD", 
            "EXAMINATION", "AZBYCXDWEVFUGTHSIRJQKPLOMN", "AAA", "BBA", 
            "ACE", "THE", "BUMPY", "BALDING", "ABCDEFGHIJKLMNOPQRSTUVWXYZ");

foreach ($as as $s) {
    for($i=0;$i<strlen($s)-2;$i++)if(((($s[$i]<=>$s[$i+1])<0)?1:0)==((($s[$i+1]<=>$s[$i+2])<0)?1:0)){echo"0";break;}
}

অনলাইন পরীক্ষা

— মারিও
সূত্র
হ্যালো, এবং পিপিসিজিতে আপনাকে স্বাগতম! দুর্দান্ত প্রথম পোস্ট!
— NoOneIs এখানে
পিপিসিজিতে আপনাকে স্বাগতম! সুন্দর প্রথম পোস্ট। কিছু অতিরিক্ত গল্ফিং পরামর্শের জন্য পিএইচপি- র টিপস দেখুন ।
— অ্যাডমবর্কবর্ক
1

জাভাস্ক্রিপ্ট ES6, 100 বাইট

d="charCodeAt";a=b=>{f=r=0;for(i=1;i<b.length;i++){if(b[d](i)<=b[d](i-1)){f=1}else{r=1}}return f&&r}

এটি এখানে চেষ্টা করুন: 

d="charCodeAt";a=b=>{f=r=0;for(i=1;i<b.length;i++){if(b[d](i)<=b[d](i-1)){f=1}else{r=1}}return f&&r}
alert(a(prompt()));
স্নিপেট প্রসারিত করুন

ওহ এসো দু'জন লোক ইতিমধ্যে আমাকে 40 বাইট দিয়ে মারল ... যাই হোক না কেন

— বাল্ড বান্থা
সূত্র
ইঙ্গিত "A"<"B":, সুতরাং আপনাকে চরগুলির চারকোডগুলি পাওয়ার দরকার নেই।
— ETH প্রোডাকশনগুলি
এছাড়াও, এটির 1জন্য BUMPY(বা অন্য কোনও কিছুতে উত্থান এবং পতন উভয়ই রয়েছে) এর জন্য ফেরত আসে ।
— ETH প্রোডাকশনস
এটি বেশ কার্যকর বলে মনে হচ্ছে না।
— অ্যাডমবর্কবার্ক
1

পাইথন 3, 148 139 127 বাইট

def _(w):*r,=map(lambda a,b:0>ord(a)-ord(b)and-1or 1,w,w[1:]);s=len(r)%2==0and r+[r[0]]or r;return sum(s)in(-1,1)and s==s[::-1]

পরীক্ষার কোড

positives = ('ABA', 'ABB', 'BAB', 'BUMP', 'BALD', 'BALDY', 'UPWARD', 'EXAMINATION', 'AZBYCXDWEVFUGTHSIRJQKPLOMN')
negatives = ('AAA', 'BBA', 'ACE', 'THE', 'BUMPY', 'BALDING', 'ABCDEFGHIJKLMNOPQRSTUVWXYZ')

for w in positives:
    print(_(w), w)
    assert _(w)

for w in negatives:
    print(_(w), w)
    assert not _(w)
— Jeffrey04
সূত্র
আমি সত্যিই এই # পৃষ্ঠার স্তন্যপান
— জেফ্রি04
পিপিসিজিতে আপনাকে স্বাগতম! পাইথনে গল্ফিংয়ের টিপস দেখুন এবং অন্যান্য উত্তরগুলি থেকে অনুপ্রেরণা নিন।
— অ্যাডমবর্কবার্ক
1

সি, 65 57 60 বাইট

 r;f(char*s){for(r=0;*++s&&(r=~r&1<<(*s>*(s-1))););return r;}

ঠিক করা হয়

r;f(char*s){for(;*++s&&(r=~r&1<<(*s>*(s-1))););return r;}

যা কেবলমাত্র একক ফাংশন কলে (যখন বৈশ্বিক ভেরিয়েবল rশূন্যে আরম্ভ হয়) তে কোনও ডেটা দিয়ে সঠিকভাবে কাজ করে ।

কিন্তু যাই হোক এই পূর্ববর্তী সমাধান (65 বাইটস) ব্যবহার করার কারণে তুলনায় খাটো forপরিবর্তে while। তবে পূর্ববর্তী (নিম্নলিখিতগুলি) বুঝতে খুব সহজ:

r;f(char*s){while(*++s)if(!(r=~r&1<<(*s>*(s-1))))break;return r;}

আমার সমাধান, bitwise উপর ভিত্তি করে তৈরি &উল্টানো পূর্ববর্তী ও বর্তমান অভিমুখ কোড, যেখানে দিক কোড হতে পারে 2( 1<<1) অক্ষর কোড বৃদ্ধি (জন্য *s > *(s-1)) অথবা 1( 1<<0) অন্যথায়। যদি আমরা পূর্ববর্তী এবং বর্তমানের মতো একই দিক নির্দেশক কোডটি ব্যবহার করি, যখন শব্দটি মোটা নয়।

হালনাগাদ:

পরীক্ষার জন্য কোড:

#include <stdio.h>
#include <string.h>

r;f(char*s){for(;*++s&&(r=~r&1<<(*s>*(s-1))););return r;}

int main(void)
{
    char * Truthy[] = { "ABA", 
                        "ABB", 
                        "BAB",
                        "BUMP",
                        "BALD",
                        "BALDY",
                        "UPWARD",
                        "EXAMINATION",
                        "AZBYCXDWEVFUGTHSIRJQKPLOMN" };
    char * Falsey[] = { "AAA",
                        "BBA",
                        "ACE",
                        "THE",
                        "BUMPY",
                        "BALDING",
                        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"};
    int posTestNum = sizeof(Truthy) / sizeof(char *);
    int negTestNum = sizeof(Falsey) / sizeof(char *);
    int i;
    int rate = 0;
    int tests = 0;
    int res = 0;
    printf("Truthy (%d tests):\n", posTestNum);
    for (i = 0; i < posTestNum; i++)
    {
        tests++;
        printf("%s - %s\n", Truthy[i], f(Truthy[i]) ? (rate++, "OK") : "Fail");
        r = 0;
    }
    printf("\nFalsey (%d tests):\n", negTestNum);
    for (i = 0; i < negTestNum; i++)
    {
        tests++;
        printf("%s - %s\n", Falsey[i], f(Falsey[i]) ? "Fail" : (rate++, "OK"));
        r = 0;
    }
    printf("\n%d of %d tests passed\n", rate, tests);
    return 0;
}
— Voland
সূত্র
প্রতি মেটা সম্মতিতে, ফাংশনগুলি পুনরায় ব্যবহারযোগ্য হতে হবে । তার মানে আপনি রিসেট করতে পারবেন না rকরার 0বিনামূল্যে জন্য কিন্তু ফাংশন মধ্যে থেকে তাই করতে হবে।
— ডেনিস
@ ডেনিস আপনি ঠিক বলেছেন, আরম্ভের প্রয়োজন হয় তবে কেবল বারবার কল করার জন্য। আসুন ধরে নেওয়া যাক যে কোনও একক কলের জন্য যা কোনও ডেটা নিয়ে কাজ করে কারণ সংকলক গ্লোবাল ভেরিয়েবলের জন্য সূচনা দেয়
— ভোলএন্ড
আমি মনে করি আপনার 60 বাইট সমাধানটি আপনার প্রধান একটি করা উচিত, যেহেতু 57 বাইট সংস্করণটি আমার উদ্ধৃত মেটা পোস্ট দ্বারা বৈধ নয়।
— ডেনিস
@ ডেনিস হয়ে গেছে! +3 বাইট
— ভোল এবং
1

পিএইচপি, 100 বাইট

for($s=$argv[1];$i<strlen($s)-1;$i++)$s[$i]=$s[$i+1]>$s[$i]?r:f;echo str_replace([rr,ff],'',$s)==$s;

একটি সহ STRING (শেষ এক স্পষ্টত ব্যতীত) প্রতিটি গৃহস্থালির কাজ প্রতিস্থাপিত rবৃদ্ধি জন্য অথবা একটি fপতনের এবং তারপর কিনা তা পরীক্ষা করার জন্য rrবা ffস্ট্রিং ঘটে থাকে। এটির সাথে শেষের অক্ষরটি হস্তক্ষেপ না করতে, ইনপুটটি অবশ্যই বড় হাতের অক্ষরে থাকা উচিত।

আমি লুপটির সাথে খুব সন্তুষ্ট নই, উদাহরণস্বরূপ আমার একটি অনুভূতি আছে যে লুপটিতে ব্যবহৃত $i++বেশ কয়েকটি $iগুলি এর মধ্যে একটি মিশ্রনের উপায় থাকতে হবে তবে আমি সেভাবে খুঁজে পাইনি to অন্য কেউ এটি দেখতে পারে।

(এ কারণেই আমি আমার কোডটি টিটাসের সুন্দর সমাধানের চেয়ে 20 (!) বাইট দীর্ঘ হওয়া সত্ত্বেও পোস্ট করেছি))

— Christallkeks
সূত্র
0

জাভা 8, 114 90 বাইট

(c,b)->{b=c[0]<c[1];for(int i=2;i<c.length;i++)if(c[i]>c[i-1]!=(b=!b))return 0;return 1;};

অসম্পূর্ণ পরীক্ষা প্রোগ্রাম

public static void main(String[] args) {
    BiFunction<char[], Boolean, Integer> func = (c, b) -> {
        b = c[0] < c[1];
        for (int i = 2; i < c.length; i++) {
            if (c[i] > c[i - 1] != (b = !b)) {
                return 0;
            }
        }
        return 1;
    };

    System.out.println(func.apply("ABCDEFG".toCharArray(), false));
    System.out.println(func.apply("AZBYCXDGEF".toCharArray(), false));
    System.out.println(func.apply("ZXZXZX".toCharArray(), false));
    System.out.println(func.apply("ZXCYZ".toCharArray(), false));
    System.out.println(func.apply("AAA".toCharArray(), false));
}
— শন ওয়াইল্ড
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.