ইভেনস্ট-রিং সি ওড - জি ওল! চ

Question

একটি 'এমনকি স্ট্রিং' এমন কোনও স্ট্রিং যেখানে অক্ষরের ASCII মানগুলির সমতা সর্বদা পরিবর্তিত হয়। উদাহরণস্বরূপ, স্ট্রিংটি EvenSt-ring$!একটি সম-স্ট্রিং কারণ অক্ষরের ASCII মানগুলি হ'ল:

69 118 101 110 83 116 45 114 105 110 103 36 33

এবং এই সংখ্যার অংশগুলি হ'ল:

Odd Even Odd Even Odd Even Odd Even Odd Even Odd Even Odd

যা পুরো পথকেই বদলে দিচ্ছে। যাইহোক, মত একটি স্ট্রিং Hello world!হয় না একটি এমনকি স্ট্রিং কারণ হওয়া ASCII মান হল:

72 101 108 108 111 32 87 111 114 108 100 33

এবং পক্ষগুলি হ'ল:

Even Odd Even Even Odd Even Odd Odd Even Even Even Odd

যা স্পষ্টভাবে সর্বদা পরিবর্তিত হয় না।

চ্যালেঞ্জ

আপনাকে অবশ্যই একটি সম্পূর্ণ প্রোগ্রাম বা একটি ফাংশন লিখতে হবে যা ইনপুটটির জন্য একটি স্ট্রিং গ্রহণ করে এবং স্ট্রিংটি সমান হলে সত্যবাদী মান এবং অন্যথায় একটি মিথ্যা মানকে আউটপুট করে। আপনি আপনার ইনপুট এবং আউটপুটটিকে যেকোন যুক্তিসঙ্গত ফর্ম্যাটে নিতে পারেন এবং আপনি ধরে নিতে পারেন যে ইনপুটটিতে কেবল প্রিন্টযোগ্য এএসসিআইআই (32-127 রেঞ্জ) থাকবে। আপনাকে খালি ইনপুট পরিচালনা করতে হবে না ।

উদাহরণ

এখানে এমনকি স্ট্রিং এর কয়েকটি উদাহরণ:

#define
EvenSt-ring$!
long
abcdABCD
3.141
~
0123456789
C ode - g ol!f
HatchingLobstersVexinglyPopulateJuvenileFoxglove

এবং এই সমস্ত উদাহরণ এমনকি স্ট্রিং নয়:

Hello World
PPCG
3.1415
babbage
Code-golf
Standard loopholes apply
Shortest answer in bytes wins
Happy golfing!

আপনি যদি কোনও নির্দিষ্ট টেস্ট-কেস সম্পর্কে আগ্রহী হন তবে কোনও স্ট্রিং টেস্ট করার জন্য আপনি এই অব্যক্ত সমাধানটিও ব্যবহার করতে পারেন ।

Comments

এই সামান্য বেশি পাঠযোগ্য হতে পারে

— হওয়া ASCII শুধুমাত্র

ইনপুট দৈর্ঘ্য 1 হতে পারে? খালি?

— xnor

@xnor পরীক্ষার ক্ষেত্রে একটি দৈর্ঘ্য -১ উদাহরণ রয়েছে, তবে খালি ইনপুটটি একটি ভাল প্রশ্ন।

— মার্টিন ইন্ডার

একটি পরীক্ষা কেস হিসাবে অন্য অমসৃণ স্ট্রিং যোগ করুন lno।

— অ্যাড্রিয়ান্প

প্রোগ্রামের জন্য কোনও বোনাস পয়েন্ট নিজেই একটি স্ট্রিং হচ্ছে?

— দেরডেম্যান্ড 18

Answer 1

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

বাইট সংরক্ষণের জন্য এমিগিনার ধন্যবাদ এবং কিছু বাগ ঠিক করার জন্য লুইস মেন্ডোকে ধন্যবাদ । কোড:

doA

ব্যাখ্যা:

d     # Difference between the characters
 o    # Mod 2
  A   # Matlab style all

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

Comments

আমি মনে করি এমএটিএল-তে 1 জনের একটি তালিকা সত্য, সুতরাং আপনার এটি অপসারণ করতে সক্ষম হওয়া উচিত A।

— এমিগানা

উদাহরণস্বরূপ এই পোস্টটি দেখুন, তাই উল্লেখ করে :)

— Emigna

দেখুন এই মেটা প্রশ্ন । সর্বাধিক ভোট দেওয়া উত্তর Aএমএটিএল এর যেভাবে ifকাজ করে তার জন্য ধন্যবাদ ছাড়ার অনুমতি দেয় ।

— Sanchises

আপনি এটি 2\ দ্বারা প্রতিস্থাপন করতে পারেন o। এবং কোডটি খুব ... আবশ্যক :-) দেখাবে

— লুইস মেন্ডো

ক্রস আউট 4এখনও নিয়মিত 4...

— অ্যাডমবর্কবার্ক

Answer 2

05 এ বি 1 ই , 5 4 বাইট

সংরক্ষণ 1 বাইট ধন্যবাদ আদনান ।

Ç¥ÉP

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

ব্যাখ্যা

Ç       # convert to ascii values 
 ¥      # compute delta's
  É     # mod by 2
   P    # product

Comments

আমি বিশ্বাস করি এটি কাজ করে: Ç¥ÉP:)

— আদনান

@ আদনান: লোল, অবশ্যই! ধন্যবাদ! :)

— এমিগানা

Answer 3

জেলি , 7 5 4 বাইট

OIḂẠ

@ স্টিভেন এইচ এর ডেল্টাস আইডিয়া ব্যবহার করে 2 বাইট সংরক্ষণ করা হয়েছে

@ লিনকে 1 টি বাইট সংরক্ষণ করা হয়েছে ।

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

ব্যাখ্যা

OIḂẠ  Input: string S
O     Ordinal
 I    Increments
  Ḃ   Mod 2
   Ạ  All, 0 if it contains a falsey value, else 1

Comments

আমি স্বাধীনভাবে একই জেলি উত্তর নিয়ে এসেছি, বুথ

— স্টিভেন এইচ।

আপনি একটি বাইট সংরক্ষণ করতে পারেন: %2→Ḃ

— লিন

@ লিন থ্যাঙ্কস, আমার মনে হয়েছে যে মড 2 এর জন্য একটি বিল্টিন রয়েছে তবে আমি এটি খুঁজে পেলাম না, ব্যবহার করে অনুসন্ধান করছিলাম mod।

— মাইল

Answer 4

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

lambda s:all((ord(x)-ord(y))%2for x,y in zip(s,s[1:]))

Answer 5

ম্যাথামেটিকাল, 50 44 বাইট

বর্তমান সংস্করণটি মূলত মার্টিন ইন্ডারের সমস্ত পুণ্য।

Differences@ToCharacterCode@#~Mod~2~FreeQ~0&

রিটার্নস True বা False। খুব চতুর কিছু নয়: পর পরের ASCII কোডগুলির প্রতিটি জোড়ার Mod-2 যোগফল নেয় এবং 0 টি কখনও পাওয়া যায় না তা চেক করে।

পুরনো সংস্করণ:

Union@Mod[Most[a=ToCharacterCode@#]+Rest@a,2]=={1}&

Answer 6

জাভাস্ক্রিপ্ট (ES6), 60 50 46 বাইট

s=>[...s].every(c=>p-(p=c.charCodeAt()%2),p=2)

আমি পুনরাবৃত্তি চেষ্টা করেছিলাম, তবে ৫১ বাইটে, এটি যথেষ্ট উপযুক্ত বলে মনে হচ্ছে না:

f=([c,...s],p=2)=>c?p-(p=c.charCodeAt()%2)&f(s,p):1

পরীক্ষার স্নিপেট

f=s=>[...s].every(c=>p-(p=c.charCodeAt()%2),p=2)

<input id=I value="Evenst-ring"><button onclick="console.log(f(I.value))">Run</button>

Comments

নোড.জেএস-এ 41 অক্ষর:s=>[...Buffer(s)].every(c=>p-(p=c&1),p=2)

— Mwr247

Answer 7

ব্রেন-ফ্লাক , 138 114 112 84 + 3 = 87 বাইট

গল্ফিং সাহায্যের জন্য @ রিলেকে ধন্যবাদ

এই প্রোগ্রামটি খালি ইনপুটটিকে অদৃশ্য স্ট্রিং হিসাবে বিবেচনা করে।

{({}(())){({}[()]<(()[{}])>)}{}(({})<>[[]{}]()){{}(<>)}{}({}<>)<>}<>(([])[()]){<>}{}

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

ব্যাখ্যা (পুরানো)

২ দ্বারা সংশোধন করার সময় বাম স্ট্যাক থেকে ডানদিকে ইনপুটটি স্থানান্তরিত করে সমস্ত পরীক্ষিত না হওয়া বা পার্থক্যের একটির শূন্যের সমান না হওয়া অবধি প্রতিটি পার্শ্ববর্তী চরিত্রের মধ্যে পার্থক্য সন্ধান করে (যা কেবলমাত্র একটি অলৌকিক স্ট্রাইনে ঘটবে)। যদি কোনও অজানা স্ট্রিংয়ের কারণে লুপটি সমাপ্ত হয় তবে বাম স্ট্যাকটিতে ফিরে যান এবং এর মধ্যে থাকা মানটি পপ করুন। অন্যথায়, ডান স্ট্যাকের কাছে থাকুন এবং স্ট্যাকের বাকি 1 টির উপরে শূন্যটি পপ করুন।

Comments

নিস! আমি যাচ্ছিলাম আমি এই একটি উপর একটি bflack উত্তর পেতে হবে। খালি ইনপুটটি সংজ্ঞায়িত, তাই আপনি সংক্ষিপ্তর সাথে যেতে পারেন।

— ডিজেএমসিএমহেম

আপনি যখন মোড 2 গণনা করবেন তখন স্ট্যাকের উচ্চতা ব্যবহার না করে আপনি 10 বাইট সংরক্ষণ করতে পারবেন Just কেবল শুরুটি পরিবর্তন করুন ([]){{}-> {এবং ([])প্রথম লুপটি বন্ধ হওয়ার ঠিক আগে থেকে সরিয়ে ফেলুন ।

— রিলে

ধন্যবাদ @ রিলে, আমি মোড 2 এর আকার হ্রাস করার চেষ্টা করছি এবং আমি মনে করি পুরো জিনিসটি {({}(())){({}[()]<(()[{}])>)}{}({}<>)<>}<>(42 বাইট) তৈরি করা যেতে পারে । এটি আপনার মূল মডুলাস থেকে প্রাপ্ত। আপনার প্রোগ্রামটি এটিকে কাজ করতে অতিরিক্ত +1 নীলাদ যুক্ত করা দরকার:{({}(())){({}[()]<(()[{}])>)}{}({}()<>)<>}<>

— 0 '

আমার আসলটির 95% ছিল from উইকি । আপনি নতুন মড 2 দিয়ে আমাকে একটি টন বাইট সংরক্ষণ করেছেন। আমি জানতাম আরও ভাল হওয়া উচিত, এটি সন্ধান করার আমার কাছে সময় ছিল না। ধন্যবাদ!

— রিলে

Answer 8

আর, 41 35 বাইট

সম্পাদনা: এর diffপরিবর্তে ব্যবহার করে @ জেডিএলকে কয়েকটি বাইট সংরক্ষণ করা হয়েছে rle।

all(diff(utf8ToInt(readline())%%2))

---

all(rle(utf8ToInt(readline())%%2)[[1]]<2)

ব্যাখ্যা

1. readline() ইনপুট পড়ুন।
2. utf8ToInt()%%2 আসকি মানগুলিতে রূপান্তর করুন এবং মোড 2 (আর-ভেক্টর হিসাবে সঞ্চয় করুন)
3. all(rle()==1)রান খুঁজতে দৈর্ঘ্যের এনকোডিং চালান। সমস্ত রান 2 এর সমান বা 2 এর সমান হওয়া উচিত কারণ কোনও রানই নেতিবাচক বা 0 হয় না (পরিবর্তে একটি বাইট সংরক্ষণ করে)== )।

Comments

আমি মনে করি prod(...)পরিবর্তে all(... == 1)কয়েক অক্ষর সংরক্ষণ করে ।

— জেডিএল

@ জেডিএল নিশ্চিত নয় যে আপনি কী বলছেন। এটি কি সবসময় কিছু ফেরত দেবে না >1?

— বিলিওব

দুঃখিত, আমি আপনার সমাধানটিকে অন্য একটির পদ্ধতির সাথে বিভ্রান্ত করেছি। কিছু কারণে আমি ভেবেছিলাম ভিতরে থাকা জিনিসটি allসম্পূর্ণ শূন্য এবং একই।

— জেডিএল

আমি মনে করি আমরা খাঁজ করে rleএবং ব্যবহার করে আরও বেশি সঞ্চয় করতে পারি diff: all(diff(utf8ToInt(readline())%%2))(আমরা একটি সতর্কতা পেয়েছি, তবে আমি তা অস্বীকার করি না বলে মনে করি)

— জেডিএল

আমি মনে করি এটি করে; একটি দৈর্ঘ্যের একটি স্ট্রিং সহ, এটি একে একে নীচে ফুটায় all(numeric(0))যা TRUEএকটি দৈর্ঘ্যের এক স্ট্রিংয়ের জন্য পছন্দসই উত্তর। (আমি যদি পরীক্ষার চেষ্টা করি তবে এটি আর

— -৩.৩.১. এর

Answer 9

পাইথ ( কাঁটাচামচ ), 9 বাইট

.A%R2.+CM

অনলাইনে এটি অনুবাদ করুন অনলাইনে লিঙ্কটি নেই কারণ অনলাইন দোভাষীগুলিতে কাঁটাচামার নিজস্ব সংস্করণ নেই।

ব্যাখ্যা:

       CM       Map characters to their ASCII codes.
     .+         Get deltas (differences between consecutive character codes)
  %R2           Take the modulo of each base 2
.A              all are truthy (all deltas are odd)

Answer 10

ব্র্যাচল্যাগ , 17 বাইট

@c:{:2%}a@b:{l1}a

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

ব্যাখ্যা

@c                   Input to a list of char codes
  :{:2%}a            Apply X mod 2 for each X in the list of char codes
         @b          Split the list into a list of lists where each sublist elements are the
                       same, e.g. turn [1,0,1,1,0,0] into [[1],[0],[1,1],[0,0]]
           :{l1}a    The length of each sublist must be 1

Answer 11

জাভা 8, 77 76 72 57 বাইট

a->{int i=2,b=1;for(int c:a)b=i==(i=c%2)?0:b;return b>0;}

-4 বাইটস @ জিওবিটসকে ধন্যবাদ ।

ব্যাখ্যা:

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

a->{               // Method with character-array parameter and boolean return-type
  int i=2,         //  Integer `i`, starting at any integer not 0 or 1
      b=1;         //  Flag-integer `b`, starting at 1
  for(int c:a)     //  Loop over the input-array
    b=i==(i=c%2)?  //   If two adjacent characters were both odd or even:
       0           //    Set the flag-integer `b` to 0
      :            //   Else:
       b;          //    The flag-integer `b` remains the same
  return b>0;}     //  Return if the flag-integer `b` is still 1

Comments

Truthy মানের জন্য মেটা ঐক্যমত্য উপায়ে আপনি একটি ফেরার দিতে হবে booleanএখানে (আমি জানি, এটি sucks)। আমি এইভাবে সবচেয়ে ভালভাবে পেলাম (72) হ'ল ফ্ল্যাগ-ইন ব্যবহার করে:boolean c(char[]a){int i=3,b=1;for(int c:a)b=i==(i=c%2)?0:b;return b>0;}

— জিওবিটস

Answer 12

মস্তিষ্ক-ফ্লাক 155 151 141 121

-3 এর জন্য +3 অন্তর্ভুক্ত

1000000000 ধন্যবাদ 30 বাইট সংরক্ষণ করা

{({}(())){({}[()]<(()[{}])>)}{}({}()<>)<>}<>{({}[({})]<(())>){((<{}{}>))}{}({}[()]<>)<>}<>{{}}([]<(())>){((<{}{}>))}{}

আউটপুট:
সত্যবাদী : 1
মিথ্যা : 0 স্ট্যাকের উপরে

এটি অনলাইন চেষ্টা করুন! (সত্যবাদী)
অনলাইনে চেষ্টা করে দেখুন! (falsy)

---

পরে আরও ভাল ব্যাখ্যা আসবে (যদি আমি বুঝতে পারি যে এটি কয়েক ঘন্টা পরে কীভাবে কাজ করে ...)

#compute ((mod 2) + 1) and put on other stack
{({}(())){({}[()]<(()[{}])>)}{}({}()<>)<>}<>

#compare top two (remove top 1) push on other stack (-1 for different 0 for same)
{({}[({})]<(())>){((<{}{}>))}{}({}[()]<>)<>}<>

#remove all of the top -1s
{{}}

#take the logical not of the stack height
([]<(())>){((<{}{}>))}{}

Answer 13

স্টারি , 85 বাইট

 ,       +    *   ` , +               + * ' +  ' `       +    * +   + *   '     +  `.

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

নোট করুন যেহেতু স্টারারি প্রোগ্রামের বলার উপায় নেই যখন স্বেচ্ছাসেবী দৈর্ঘ্যের একটি ইনপুট শেষ হয় তাই এই প্রোগ্রামটি স্ট্রিংয়ের শেষ চিহ্নিত করতে ইনপুটটিতে একটি ট্রেলিং নিউলাইন ব্যবহার করে। আপনি যদি কোনও ক্রিপ্টিক ত্রুটি বার্তা এবং এর জন্য অপরিজ্ঞাত পদ্ধতি ordপানnil:NilClass তবে ইনপুটটিতে একটি অনুমানযোগ্য নতুন লাইন অনুপস্থিত।

ব্যাখ্যা

প্রোগ্রামটি যে মূল কৌশলটি নিয়োগ করে তা হ'ল এটি হ'ল অক্ষরগুলি ইনপুট থেকে একের পর এক পড়ে এবং যদি সেগুলি একটি নতুন লাইন (অক্ষর 10) না হয় তবে তারা 2 দ্বারা অক্ষরের মান ASCII মোড করে এবং এটি এবং পূর্বে পড়া অক্ষরের মধ্যে পার্থক্য খুঁজে পায় finds পার্থক্যটি শূন্য হলে প্রোগ্রামটি সমাপ্ত হয় এবং মুদ্রণ 0(মিথ্যা)। অন্যথায় প্রোগ্রামটি পিছনে ফিরে আসে এবং আবার প্রক্রিয়াটি করে। প্রোগ্রামটি যদি কোনও নিউলাইন পড়ে তবে এটি শেষ হয় এবং প্রিন্ট করে 10(সত্যবাদী)।

স্বীকৃত প্রোগ্রাম

 ,               Push the first character
       +         Push 2
    *            Replace the first character and 2 with the first character mod 2
   `             Label 3 <--------------------------------------------------------\
 ,               Push the next the character                                      |
 +               Push a duplicate of it                                           |
               + Push 10                                                          |
 *               Replace the 10 and the duplicate with their difference           |
 '               Pop and if not zero (the read char is not 10) goto label 1 >-\   |
 +               Push a duplicate of the character which must be newline (10) |   |
  '              Pop and goto label 2 >---------------------------------------+-\ |
 `               Label 1 <----------------------------------------------------/ | |
       +         Push 2                                                         | |
    *            Replace the character and 2 with the character mod 2           | |
 +               Duplicate it ^                                                 | |
   +             Roll the top three items on the stack. The top goes to         | |
                   the bottom. The top three items are now                      | |
                   (from top to bottom) the current character, the previous     | |
                   character, the current character (all modded by 2).          | |
 *               Replace the current character and previous character           | |
                   with their difference                                        | |
   '             Pop if nonzero goto label 3 >----------------------------------+-/
     +           Push zero                                                      |
  `              Label 2 <------------------------------------------------------/
.                Print out the number on top of the stack
                    0 if we came by not following the goto label 3
                   10 if we came by going to label 2

Answer 14

পার্ল, 24 + 1 ( -p) = 25 বাইট

@ টন হসপেলকে -4 বাইট ধন্যবাদ !

s/./$&&v1/eg;$_=!/(.)\1/

-pপতাকা প্রয়োজন । আউটপুট 1 হ'ল স্ট্রিং সমান, অন্যথায় কিছু নয়। এই ক্ষেত্রে :

perl -pe 's/./$&&v1/eg;$_=!/(.)\1/' <<< "#define
Hello World"

ব্যাখ্যা : প্রতিটি অক্ষরকে এর মান মোড 2 দ্বারা প্রতিস্থাপন করে (সুতরাং স্ট্রিংয়ের পরে কেবল 0 সে এবং 1 সেকেন্ড থাকে)। তারপরে নিম্নলিখিত 1 বা 0 এর জন্য দুটি অনুসন্ধান করুন: যদি এটি কিছু খুঁজে পায় তবে স্ট্রিংটি সমান নয়, অন্যথায় এটি।

Comments

সঠিক পদ্ধতি কিন্তু পুরোপুরি গল্ফড নয়। s/./$&&v1/eg;$_=!/(.)\1/। পিএস (ord$&)%2হিসাবে লেখা যেতে পারে1&ord$&

— টন হসপেল

টনহোস্পেল ড্যাম, আমি খুশি যে আমি পেয়েছি ... তবে আমি স্ট্রিংগুলিতে বিটওয়াইজ অপারেশনগুলি ভুলে যেতে চাইছি T অনেক ধন্যবাদ! :)

— দাদা

@ টনহোপেল, আমি এটি চেষ্টা করে দেখিনি, তবে আপনি v1কী পরিবর্তে ভি 1 ব্যবহার করে একটি বাইট সংরক্ষণ করতে পারবেন না ?

— এমএস 210

@ এমএস 210 না, আপনি কেবল খালি শব্দ হিসাবে বৈধ সনাক্তকারী ব্যবহার করতে পারেন, এবং \x01তা নয়

— টন হসপেল ২el

Answer 15

জে, 15 বাইট

0=1#.2=/\2|3&u:

ব্যবহার

   f =: 0=1#.2=/\2|3&u:
   f 'C ode - g ol!f'
1
   f 'Code-golf'
0

ব্যাখ্যা

0=1#.2=/\2|3&u:  Input: string S
           3&u:  Get ordinals of each char
         2|      Take each modulo 2
     2  \        For each pair of values
      =/           Test if they are equal, 1 if true else 0
  1#.            Treat the list of integers as base 1 digits and convert to decimal
                 This is equivalent to taking the sum
0=               Is it equal to 0, 1 if true else 0, and return

Answer 16

ভিম, 38 বাইট

qqs<C-R>=char2nr(@")%2<CR><Esc>l@qq@q:g/00\|11/d<CR>

বাফারে ইনপুট স্ট্রিং এবং খালি ধরে "q। যদি সত্য হয় তবে বাইনারি আজেবাজে আউটপুট দেয়, মিথ্যা হলে কিছুই নয়।

• s<C-R>=char2nr(@")%2<CR>: বিজোড় হলে 1 এর সাথে একটি অক্ষর প্রতিস্থাপন করে, 0 এমনকি যদি হয়। এই ম্যাক্রোটি কেবল লাইনের প্রতিটি চরিত্রের সাথে এটি করে (এটি যত দীর্ঘ হোক না কেন)।
• :g/00\|11/d<CR>: টানা 2 "বিট" এর একই মান থাকলে লাইনটি মুছে দেয়। একটি পিছনের রেফারেন্স চেয়ে দ্রুত।

সাধারণত, ভিমগল্ফে, আপনি যখন ম্যাক্রোর অভ্যন্তরে কোনও এক্সপ্রেশন ফাংশন ব্যবহার করেন, তখন আপনাকে ম্যাক্রোটি এক্সপ্রেশন রেজিস্ট্রারে নিজেই করা উচিত এবং ট্যাব-সম্পূর্ণ করার জন্য কিছু কৌশল ব্যবহার করা উচিত। এবার আরও বেশি কষ্টকর। আমি এটি পরে ছোট করার কোনও উপায় খুঁজে পেতে পারি।

Answer 17

রেটিনা , 39 বাইট

বাইট গণনাটি আইএসও 8859-1 এনকোডিং ধরেছে।

S_`
%{2`
$`
}T01`p`_p
..

Mm`.¶.|^¶$
^0

1সত্য এবং মিথ্যা জন্য আউটপুট 0।

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

ব্যাখ্যা

Mbomb007 এর উত্তরে অনুপ্রাণিত হয়ে আমি সম্প্রতিord() রেটিনায় একটি যুক্তিসঙ্গত সংক্ষিপ্ত বাস্তবায়ন বিকাশ করেছি । এটি মূলত এর উপর ভিত্তি করেই, যদিও আমি কয়েকটি সরলিকরণ করতে পেরেছিলাম যেহেতু আমার কেবল দশমিক ফলাফলের প্রয়োজন নেই কারণ আমাকে কেবল প্রিন্টযোগ্য এএসসিআই সমর্থন করতে হবে (এবং আমি কেবল ফলাফলের সামঞ্জস্য সম্পর্কে যত্নশীল, তাই শেষ পর্যন্ত একটি স্বেচ্ছাসেবক অফসেট খুব ভাল)।

মঞ্চ 1: বিভক্ত

S_`

এটি খালি ম্যাচের চারপাশে বিভক্ত করে এবং খালি ফলাফলগুলি শুরুতে এবং শেষে দিয়ে এটিকে পৃথক অক্ষরগুলিতে সহজেই ইনপুটটি বিভক্ত করে _।

দ্বিতীয় পর্যায়: প্রতিস্থাপন করুন

%{2`
$`

দ্য %{রেটিনা একটি বলে) পর্যন্ত স্ট্রিং একটি পূর্ণ পুনরাবৃত্তির মাধ্যমে পরিবর্তন স্টপ যে এই পর্যায়ে এবং পরবর্তী একটি লুপ চালানোর করা উচিত, এবং যে এই দুই পর্যায়ে প্রতিটি লাইনে আলাদাভাবে (অর্থাত ইনপুট প্রতিটি চরিত্র) প্রয়োগ করতে হবে।

মঞ্চটি নিজেই ইনপুটটির প্রথম চরিত্রটিকে নকল করার মানক কৌশল। আমরা খালি স্ট্রিংটি মেলে (তবে কেবল প্রথম দুটি ম্যাচ দেখি) এবং সেই ম্যাচের উপসর্গ সন্নিবেশ করি। প্রথম ম্যাচের উপসর্গটি (স্ট্রিংয়ের শুরুতে) খালি রয়েছে, সুতরাং এটি কিছুই করে না এবং দ্বিতীয় ম্যাচের উপসর্গটি প্রথম অক্ষর, যা অনুলিপিযুক্ত।

পর্যায় 3: লিপি প্রতিলিপি

}T01`p`_o

}লুপের শেষ নির্দেশ করে। মঞ্চটি নিজেই একটি লিখিত প্রতিবেদন। 01ইঙ্গিত করে যে এটি কেবল স্ট্রিংয়ের প্রথম অক্ষরে প্রয়োগ করা উচিত। pসমস্ত মুদ্রণযোগ্য ASCII অক্ষরগুলির শর্টহ্যান্ড এবং এর _অর্থ "মোছা"। সুতরাং আমরা যদি এটি প্রসারিত করি তবে প্রতিবর্ণীকরণটি নিম্নলিখিত রূপান্তরটি করে:

from:   !"#$%...
to:    _ !"#$...

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

এই ব্যাপ্তির দৈর্ঘ্যটি চরিত্রের সমতা নির্ধারণ করতে ব্যবহার করা যেতে পারে।

পর্যায় 4: প্রতিস্থাপন করুন

..

আমরা কেবল সমস্ত জোড় অক্ষর ফেলেছি। এটি সম-দৈর্ঘ্যের রেখাগুলি সাফ করে এবং একক অক্ষরে বিজোড়-দৈর্ঘ্যের রেখাগুলি হ্রাস করে (ইনপুট চরিত্রটি আসলে, তবে এটি আসলে গুরুত্বপূর্ণ নয়)।

মঞ্চ 5: ম্যাচ

Mm`.¶.|^¶$

এমনকি সমান নয় এমন ইনপুটগুলি সন্ধান করা সহজ , সুতরাং আমরা দুটি ক্রমাগত খালি লাইন বা দুটি ধারাবাহিক অ-খালি রেখার মিলগুলির সংখ্যা গণনা করি। আমাদের 0এমনকি ইনপুট এবং অন্যথায় শূন্য কিছু না পাওয়া উচিত ।

মঞ্চ 6: ম্যাচ

^0

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

Answer 18

Clojure, 59 বাইট

#(every?(fn[p](odd?(apply + p)))(partition 2 1(map int %)))

স্ট্রিং থেকে সমস্ত ক্রমিক nজোড় উত্পন্ন করে এবং প্রতি জোড়ের যোগ বিজোড় হয় কিনা তা পরীক্ষা করে। Ints এর ক্রম যদি যুক্তিসঙ্গত ফর্ম্যাট হিসাবে বিবেচনা করা হয় তবে এটি 50 বাইট।

#(every?(fn[p](odd?(apply + p)))(partition 2 1 %))

এটি অনলাইনে দেখুন: https://ideone.com/USeSnk

Answer 19

জুলিয়া, 55 53 বাইট

f(s)=!ismatch(r"00|11",join(map(x->Int(x)%2,[s...])))

ব্যাখ্যা

মানচিত্রটি 0 | 1-তে অক্ষর করে এবং ফলাফলটি স্ট্রিংয়ে "00" বা "11" রয়েছে কিনা তা পরীক্ষা করুন, যা স্ট্রিংটিকে বিকল্প হিসাবে না করে তোলে।

Answer 20

পাইথন, 52 বাইট

f=lambda s:s==s[0]or(ord(s[0])-ord(s[1]))%2*f(s[1:])

একটি পুনরাবৃত্তি ফাংশন। এমনকি স্ট্রিংয়ের জন্য 1 (বা সত্য) উত্পাদন করে, বিজোড়দের জন্য 0 করে। প্রথমটিতে দুটি অক্ষরের পার্থক্যের পার্থক্যটিকে অবশিষ্টাংশে পুনরাবৃত্ত মান দ্বারা গুণ করে। একটি একক-অক্ষরযুক্ত স্ট্রিং সত্য দেয়, এটির দ্বারা এটির প্রথম অক্ষরের সমান হিসাবে পরীক্ষা করা হয়েছে। এটি ধরে নেয় ইনপুটটি খালি নয়; অন্যথায়, s==s[:1]বা আরও একটি বাইট প্রয়োজন len(s)<2।

---

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

p=r=2
for c in input():x=ord(c)%2;r*=p-x;p=x
print r

বিকল্পভাবে, একটি পুনরাবৃত্তি সমাধান। বর্তমান এবং পূর্ববর্তী অক্ষরের মানগুলিকে সংরক্ষণ করে ইনপুট অক্ষরগুলির উপর পরিবেশন করা হয় 2. চলমান পণ্যটিকে পার্থক্য অনুযায়ী গুণ করে, কারণ 0 (ফ্যালসি) কেবল যখন দুটি পর পর দুটি অংশ সমান হয়।

"পূর্ববর্তী" মানটি 2 (বা কোনও মান 0 বা 1 নয়) তে আরম্ভ করা হয় যাতে প্রথম চরিত্রটি কখনই কাল্পনিক আগের অক্ষরের সাথে সমতা মেলে না।

---

পাইথন, 42 বাইট, প্রস্থান কোডের মাধ্যমে আউটপুট

p=2
for c in input():x=ord(c)%2;p=x/(p!=x)

প্রস্থান কোড মাধ্যমে আউটপুট। একটি জিরো ডিভিশনআরারের সাথে সমাপ্ত হয় যখন পরপর দুটি অক্ষরের সমতা থাকে, অন্যথায় পরিষ্কারভাবে শেষ হয়।

Answer 21

হাস্কেল, 42 40 বাইট

all odd.(zipWith(-)=<<tail).map fromEnum

ব্যবহারের উদাহরণ: all odd.(zipWith(-)=<<tail).map fromEnum $ "long"-> True।

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

               map fromEnum         -- turn into a list of ascii values
    (zipWith(/=)=<<tail)            -- build a list of neighbor differences
all odd                             -- check if all differences are odd

সম্পাদনা: @ xnor দুটি বাইট সংরক্ষণ করেছে। ধন্যবাদ!

Comments

পার্থক্য নিতে এবং সেগুলি বিজোড় হয় কিনা তা পরীক্ষা করা কিছুটা ছোট all odd.(zipWith(-)=<<tail).map fromEnum।

— এক্সনোর

Answer 22

গণিত, 41 40 বাইট

And@@OddQ@Differences@ToCharacterCode@#&

-1 চরিত্র, মার্টিন ইন্ডারকে ধন্যবাদ

Answer 23

C, 52 bytes

int f(char*s){return s[1]?(s[0]-s[1])%2?f(s+1):0:1;}

Compares the parity of first 2 characters, recursively moving through the string until it finds 2 characters with the same parity or the string with the length of 1 (s[1] == 0).

Code with some of the test cases

Comments

you can shorten this quite a bit by doing f(char*s){s=s[1]?(*s-s[1])%2?f(s+1):0:1;} you don't need the int, return or [0]

— Etaoin Shrdlu

by doing *++s instead of the second s[1] you can change f(s+1) to f(s). that plus my previous comment bring the total down to 39; I should also add that removing return makes it not work on ideone, but it still works with gcc on windows

— Etaoin Shrdlu

with one final tweak I brought it down to 38 by removing the inner ternary. f(char*s){s=s[1]?(*s-*++s)%2&&f(s):1;} I'd go on but it's 5 am and I have wake up in 3 hours lmao

— Etaoin Shrdlu

Answer 24

Pyke, 8 bytes

m.o$2m%B

Try it here!

m.o      -    map(ord, input)
   $     -   delta(^)
    2m%  -  map(> % 2, ^) 
       B - product(^)

Answer 25

C#, 69 bytes

s=>{int i=1,e=0;for(;i<s.Length;)e+=(s[i-1]+s[i++]+1)%2;return e<1;};

Full program with test cases:

using System;

namespace EvenStrings
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<string,bool>f= s=>{int i=1,e=0;for(;i<s.Length;)e+=(s[i-1]+s[i++]+1)%2;return e<1;};

            Console.WriteLine(f("lno")); //false

            //true:
            Console.WriteLine(f("#define"));
            Console.WriteLine(f("EvenSt-ring$!"));
            Console.WriteLine(f("long"));
            Console.WriteLine(f("abcdABCD"));
            Console.WriteLine(f("3.141"));
            Console.WriteLine(f("~"));
            Console.WriteLine(f("0123456789"));
            Console.WriteLine(f("C ode - g ol!f"));
            Console.WriteLine(f("HatchingLobstersVexinglyPopulateJuvenileFoxglove"));

            //false:
            Console.WriteLine(f("Hello World"));
            Console.WriteLine(f("PPCG"));
            Console.WriteLine(f("3.1415"));
            Console.WriteLine(f("babbage"));
            Console.WriteLine(f("Code-golf"));
            Console.WriteLine(f("Standard loopholes apply"));
            Console.WriteLine(f("Shortest answer in bytes wins"));
            Console.WriteLine(f("Happy golfing!"));
        }
    }
}

Comments

Nice answer! +1 It's funny that when I try to port your answer to Java 7 it's longer than the one I have. But when I try to port my answer to C# it's longer than what you have. ;)

— Kevin Cruijssen

@KevinCruijssen Thanks, but there was a bug, which was not caught by any test case :( I'll try to find some other method later.

— adrianmp

Answer 26

PHP, 69 Bytes

for(;$i<strlen($s=$argv[1])-1;)$d+=1-ord($s[$i++]^$s[$i])%2;echo$d<1;

solution with Regex 81 Bytes

for(;$i<strlen($s=$argv[1]);)$t.=ord($s[$i++])%2;echo 1-preg_match("#00|11#",$t);

Answer 27

PowerShell v2+, 47 bytes

-join([char[]]$args[0]|%{$_%2})-notmatch'00|11'

(Can't quite catch PowerShell's usual competitors ...)

Takes input $args[0] as a string, casts it as a char-array, loops through it |%{...}, each iteration placing the modulo on the pipeline (with implicit [char] to [int] conversion). Those are encapsulated in parens and -joined into a string, which is fed into the left-hand of the -notmatch operator, checking against 00 or 11 (i.e., returns True iff the 0s and 1s alternate). That Boolean result is left on the pipeline and output is implicit.

Test Cases

PS C:\Tools\Scripts\golfing> '#define','EvenSt-ring$!','long','abcdABCD','3.141','~','0123456789','C ode - g ol!f','HatchingLobstersVexinglyPopulateJuvenileFoxglove'|%{"$_ --> "+(.\evenst-ring-c-ode-g-olf.ps1 $_)}
#define --> True
EvenSt-ring$! --> True
long --> True
abcdABCD --> True
3.141 --> True
~ --> True
0123456789 --> True
C ode - g ol!f --> True
HatchingLobstersVexinglyPopulateJuvenileFoxglove --> True

PS C:\Tools\Scripts\golfing> 'Hello World','PPCG','3.1415','babbage','Code-golf','Standard loopholes apply','Shortest answer in bytes wins','Happy golfing!'|%{"$_ --> "+(.\evenst-ring-c-ode-g-olf.ps1 $_)}
Hello World --> False
PPCG --> False
3.1415 --> False
babbage --> False
Code-golf --> False
Standard loopholes apply --> False
Shortest answer in bytes wins --> False
Happy golfing! --> False

Answer 28

><>, 29 27 bytes

i2%\0 n;n 1<
0:i/!?-}:%2^?(

Outputs 1 if the word is even, 0 if the word is odd.

You can try it online.

Edit : saved two bytes thanks to Martin Ender

Answer 29

Perl 6,  47  26 bytes

{?all .ords.rotor(2=>-1).map({(.[0]+^.[1])%2})}

{[~](.ords X%2)!~~/(.)$0/}

Expanded:

# bare block lambda with implicit parameter $_
{
  [~](             # reduce using concatenation operator ( no space chars )
    .ords X[%] 2   # the ordinals cross modulus with 2 ( 1 or 0 )
  # ^-- implicit method call on $_
  )

  ![~~]            # negating meta operator combined with smartmatch operator

  / ( . ) $0 /     # is there a character followed by itself?
}

Answer 30

Scala, 54 bytes

(_:String)sliding 2 map(t=>t(0)%2!=t(1)%2)reduce(_&&_)

I'm sure this can be improved.