36

एक 'सम स्ट्रिंग' वह कोई भी स्ट्रिंग है जहां वर्णों के 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

जो स्पष्ट रूप से हमेशा बारी-बारी से नहीं होता है।

चुनौती

आपको या तो एक पूर्ण कार्यक्रम या एक फ़ंक्शन लिखना होगा जो इनपुट के लिए एक स्ट्रिंग को स्वीकार करता है और एक सत्य मान को आउटपुट करता है यदि स्ट्रिंग भी है, और एक मिथ्या मूल्य अन्यथा। आप किसी भी उचित प्रारूप में अपना इनपुट और आउटपुट ले सकते हैं, और आप यह मान सकते हैं कि इनपुट में केवल मुद्रण योग्य ASCII (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!

यदि आप किसी निश्चित परीक्षण-मामले के बारे में उत्सुक हैं, तो आप किसी भी तार का परीक्षण करने के लिए इस असंगठित समाधान का उपयोग कर सकते हैं ।

code-golf string

— DJMcMayhem
स्रोत

यह थोड़ा और अधिक पठनीय हो सकता है

— ASCII- केवल

1

क्या इनपुट लंबाई 1 हो सकती है? खाली करें?

— xnor

2

@xnor परीक्षण के मामलों में एक लंबाई -1 उदाहरण है, लेकिन खाली इनपुट एक अच्छा सवाल है।

— मार्टिन एंडर

परीक्षण मामले के रूप में एक और असमान स्ट्रिंग जोड़ें lno:।

— एड्रिएम्प

4

कार्यक्रम के लिए कोई भी बोनस अंक खुद भी एक स्ट्रिंग है?

— दाएरडेमन्ड्ट

20

MATL , 4 3 बाइट्स

कुछ बग्गियों को ठीक करने के लिए लुइस मेंडो को धन्यवाद और बाइट बचाने के लिए एमिग्ना को धन्यवाद । कोड:

doA

स्पष्टीकरण:

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

इसे ऑनलाइन आज़माएं!

— अदनान
स्रोत

1

मुझे लगता है कि MATL में 1 की सूची सही है, इसलिए आपको इसे हटाने में सक्षम होना चाहिए A।

— एमिगा

1

उदाहरण के लिए देखें यह पोस्ट, ऐसा बताते हुए :)

— एमिग्ना

3

इस मेटा प्रश्न को देखें । उच्चतम मतदान जवाब AMATL के ifकाम करने के तरीके के लिए धन्यवाद छोड़ने के लिए अनुमति देगा ।

— 1313

4

तुम भी बदल सकते हैं 2\ द्वारा o। और कोड बहुत अच्छा लगेगा ... अनिवार्य :-)

— लुइस मेंडो

6

4अभी भी नियमित है पार 4...

— AdmBorkBork

17

05AB1E , 5 4 बाइट्स

अदनान को 1 बाइट दिया ।

Ç¥ÉP

इसे ऑनलाइन आज़माएं!

व्याख्या

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

— Emigna
स्रोत

मेरा मानना है कि यह भी काम करता है: Ç¥ÉP:)

— अदनान

@ अदनान: लोल, बिल्कुल! धन्यवाद! :)

— एमिग्ना

13

जेली , 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

— मील की दूरी पर
स्रोत

मैं उसी जेली जवाब के साथ स्वतंत्र रूप से आया था, कुदोस

— स्टीवन एच।

1

आप एक बाइट बचा सकते हैं: %2→Ḃ

— लिन

@ लायन थैंक्स, मुझे लगा जैसे मॉड 2 के लिए एक बिलिन था, लेकिन मुझे यह नहीं मिला, मैं खोज कर रहा था mod।

— मील

8

पायथन 2, 54 बाइट्स

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

— कार्ल नेफ
स्रोत

7

गणितज्ञ, ५० 44 बाइट्स

वर्तमान संस्करण मूल रूप से सभी मार्टिन एंडर की खूबी है।

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

लौटाता है TrueयाFalse । कुछ भी बहुत चालाक नहीं है: लगातार ASCII कोड की प्रत्येक जोड़ी के मॉड -2 योग लेता है, और जाँचता है कि 0 कभी प्राप्त नहीं होता है।

पुराना संस्करण:

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

— ग्रेग मार्टिन
स्रोत

6

जावास्क्रिप्ट (ईएस 6), 60 50 46 बाइट्स

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

मैंने पुनरावृत्ति की कोशिश की, लेकिन 51 बाइट्स पर, यह काफी लायक नहीं लगता है:

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>

स्निपेट का विस्तार करें

— ETHproductions
स्रोत

Node.js में 41 अक्षर:s=>[...Buffer(s)].every(c=>p-(p=c&1),p=2)

— Mwr247

6

ब्रेन-फ्लैक , 138 114 112 84 + 3 = 87 बाइट्स

@ गोल्फ की मदद के लिए धन्यवाद ।

यह प्रोग्राम खाली इनपुट को एक नॉच स्ट्रिंग के रूप में मानता है।

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

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण (पुराना)

2 से मोड करते समय बाएं स्टैक से इनपुट को दाईं ओर शिफ्ट करता है। प्रत्येक आसन्न वर्ण के बीच अंतर को तब तक ढूँढता है जब तक कि सभी की जाँच नहीं हो जाती है या अंतर में से एक शून्य के बराबर होता है (जो केवल एक शून्य स्ट्रिंग में होता है)। यदि लूप एक बिना स्ट्रिंग के कारण समाप्त हो जाता है, तो बाएं स्टैक पर वापस जाएं और उस पर शेष मूल्य को पॉप करें। अन्यथा, सही स्टैक पर रहें और स्टैक पर शेष 1 के ऊपर शून्य पॉप करें।

— 0 '
स्रोत

अच्छा! मैं जा रहा था मैं इस पर एक bflack जवाब मिल जाएगा। खाली इनपुट अपरिभाषित है, इसलिए आप छोटे के साथ जा सकते हैं।

— DJMcMayhem

जब आप मॉड की गणना करते हैं तो स्टैक की ऊंचाई का उपयोग न करके आप 10 बाइट्स बचा सकते हैं। बस शुरुआत को बदल दें ([]){{}-> {और ([])पहले लूप के बंद होने से ठीक पहले हटा दें ।

— रिले

1

धन्यवाद @ रिले, मैं मॉड 2 के आकार को कम करने में देख रहा हूं और मुझे लगता है कि पूरी चीज को {({}(())){({}[()]<(()[{}])>)}{}({}<>)<>}<>(42 फीट) में बनाया जा सकता है । यह आपके मूल मापांक से लिया गया था। इसे अपने प्रोग्राम के साथ काम करने के लिए अतिरिक्त +1 निलाद को जोड़ना होगा:{({}(())){({}[()]<(()[{}])>)}{}({}()<>)<>}<>

— 0 '

मेरा मूल 95% विकी से था । आपने मुझे नए मॉड के साथ एक बाइट्स का एक टन बचाया। मुझे पता था कि एक बेहतर होना चाहिए, मेरे पास इसे खोजने का समय नहीं था। धन्यवाद!

— रिले

6

आर, 41 35 बाइट्स

संपादित करें: @JDL के diffबजाय उपयोग करके कुछ बाइट्स धन्यवाद को सहेजा गया rle।

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

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

व्याख्या

readline() इनपुट पढ़ें
utf8ToInt()%%2 एएससीआई मान और मॉड 2 में बदलें (आर-वेक्टर के रूप में स्टोर करें)
all(rle()==1)रन खोजने के लिए लंबाई एन्कोडिंग चलाते हैं। सभी रन 2 से एक या छोटे के बराबर होने चाहिए क्योंकि कोई भी रन नकारात्मक या 0 नहीं होता (एक बाइट को बचाता है ==)।

— Billywob
स्रोत

मुझे लगता है कि कुछ वर्णों को सहेजने के prod(...)बजाय उपयोग करना all(... == 1)।

— JDL

1

@JDL यकीन नहीं है कि आप क्या मतलब है। क्या यह हमेशा कुछ नहीं लौटाएगा >1?

— बिलीवोब

क्षमा करें, मैंने आपके समाधान को दूसरे के तरीके के साथ भ्रमित किया। किसी कारण से मुझे लगा कि अंदर की बात allपूरी तरह से शून्य और लोगों की थी।

— JDL

1

मुझे लगता है कि हम वास्तव में खाई rleऔर उपयोग करके बचा सकते हैं diff: all(diff(utf8ToInt(readline())%%2))(हमें एक चेतावनी मिलती है, लेकिन मुझे नहीं लगता कि यह अस्वीकृत है)

— JDL

मुझे लगता है कि यह करता है; लंबाई एक स्ट्रिंग के साथ, यह नीचे उबलता all(numeric(0))है TRUE, जिसकी लंबाई एक स्ट्रिंग के लिए वांछित उत्तर है। (मैंने परीक्षण किया, अगर यह मायने रखता है, तो आर-3.3.1 के खिलाफ)

— जेडीएल

5

पायथ ( कांटा ), 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)

— स्टीवन एच।
स्रोत

5

ब्रेकीलॉग , 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

— Fatalize
स्रोत

5

जावा 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 बाइट्स @Gobits का धन्यवाद ।

स्पष्टीकरण:

इसे ऑनलाइन आज़माएं।

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

— केविन क्रूज़सेन
स्रोत

1

Truthy मूल्यों के लिए मेटा आम सहमति का मतलब है कि आप एक लौटने किया जाना चाहिए booleanयहाँ (मैं जानता हूँ कि, यह बेकार है)। सबसे अच्छा मैं इसे इस तरह से प्राप्त कर सकता था (72) एक ध्वज- boolean c(char[]a){int i=3,b=1;for(int c:a)b=i==(i=c%2)?0:b;return b>0;}

— अंतर

4

ब्रेन-फ्लैक 155 151 141 121

-A के लिए +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
([]<(())>){((<{}{}>))}{}

— रिले
स्रोत

4

तारों से , 85 बाइट्स

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

इसे ऑनलाइन आज़माएं!

ध्यान दें कि चूंकि तारों के कार्यक्रम का कोई रास्ता नहीं है, जब मनमानी लंबाई का इनपुट समाप्त होता है, तो यह प्रोग्राम स्ट्रिंग के अंत को चिह्नित करने के लिए इनपुट में एक अनुगामी न्यूलाइन का उपयोग करता है। यदि आपको इसके बारे में एक अपरिष्कृत त्रुटि संदेश प्राप्त होता है और इसके लिए अपरिभाषित विधि होती है ord, nil:NilClassतो इनपुट एक अनुगामी न्यूलाइन याद कर रहा है।

व्याख्या

मूल कार्यनीति जो प्रोग्राम को नियोजित करती है, वह है वर्णों को एक-एक करके इनपुट से पढ़ती है और यदि वे एक नई पंक्ति (वर्ण 10) नहीं हैं, तो यह अक्षर के ASCII मान को 2 से मापता है और इसके और पूर्व में पढ़े गए वर्ण के बीच का अंतर खोजता है। यदि अंतर शून्य है तो प्रोग्राम समाप्त हो जाता है और प्रिंट 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

— 0 '
स्रोत

3

पर्ल, 24 + 1 ( `-p`) = 25 बाइट्स

-4 बाइट्स @ थॉन हास्पेल को धन्यवाद !

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

जरूरत है -pझंडा। आउटपुट 1 स्ट्रिंग है, यहां तक कि अन्यथा कुछ भी नहीं है। उदाहरण के लिए :

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

स्पष्टीकरण : प्रत्येक वर्ण को उसके मान mod 2 से बदल देता है (इसलिए स्ट्रिंग में केवल 0s और उसके बाद 1s शामिल हैं)। फिर 1 या 0 में से दो की खोज करें: यदि यह कुछ पाता है, तो स्ट्रिंग भी नहीं है, अन्यथा यह है।

— बापू
स्रोत

1

सही तरीका है लेकिन पूरी तरह से बाहर नहीं निकला है। s/./$&&v1/eg;$_=!/(.)\1/। PS के (ord$&)%2रूप में लिखा जा सकता था1&ord$&

— Ton Hospel

@ टॉन्होस्पेल धिक्कार है, मुझे खुशी है कि मैंने पाया कि ... लेकिन मैं स्ट्रिंग्स पर बिटवाइज़ ऑपरेशंस के बारे में भूल जाता हूं। बहुत बहुत धन्यवाद! :)

— दादा

@TonHospel, मैंने इसे आज़माया नहीं है, लेकिन क्या आप इसके बजाय स्वयं v1 का उपयोग करके एक बाइट को नहीं बचा सकते हैं v1?

— msh210

1

@ msh210 नहीं, आप नंगे शब्दों के रूप में केवल वैध पहचानकर्ता का उपयोग कर सकते हैं, और \x01नहीं

— टन इंजील

2

जे, 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

— मील की दूरी पर
स्रोत

2

विम, 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 लगातार "बिट्स" का समान मूल्य है। एक बैक-रेफरेंस की तुलना में तेज़।

आम तौर पर, विमगॉल्फ में, जब आप किसी मैक्रो के अंदर एक एक्सप्रेशन फंक्शन का उपयोग करते हैं, तो आपको मैक्रो को एक्सप्रेशन रजिस्टर पर ही करना चाहिए और टैब-कम्पलीट करने के लिए कुछ ट्रिकरी का उपयोग करना चाहिए। इस बार ज्यादा मुश्किल है। हो सकता है कि बाद में मुझे छोटा करने का रास्ता मिल जाए।

— udioica
स्रोत

2

रेटिना , 39 बाइट्स

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।

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

Mm`.¶.|^¶$
^0

सत्य के 1लिए आउटपुट और0 ।

इसे ऑनलाइन आज़माएं! (पहली पंक्ति एक लाइनफ़ीड-पृथक परीक्षण सूट को सक्षम करती है।)

व्याख्या

Mbomb007 के I केord() उत्तर से प्रेरित होकर मैंने हाल ही में रेटिना में एक यथोचित संक्षिप्त कार्यान्वयन विकसित किया है। यह काफी हद तक उस पर आधारित है, हालांकि मैं कुछ सरलीकरण करने में सक्षम था क्योंकि मुझे दशमलव परिणाम की आवश्यकता नहीं है क्योंकि मुझे केवल मुद्रण योग्य ASCII का समर्थन करने की आवश्यकता है (और मुझे केवल परिणाम की समता की परवाह है, इसलिए इसके साथ समाप्त एक मनमाना ऑफसेट ठीक है, भी)।

स्टेज 1: विभाजन

S_`

यह केवल खाली मैच के आसपास विभाजन करके और शुरुआत में और अंत में खाली परिणामों को छोड़ने के द्वारा इनपुट को अपने व्यक्तिगत पात्रों में विभाजित करता है _।

स्टेज 2: प्रतिस्थापित करें

%{2`
$`

%{रेटिना एक कहता है) जब तक स्ट्रिंग एक पूर्ण यात्रा के माध्यम से बदल रहा है बंद हो जाता है कि इस स्तर और अगले एक पाश में चला जाना चाहिए, और है कि इन दो चरणों प्रत्येक पंक्ति के लिए अलग से (यानी इनपुट के हर किरदार) लागू किया जाना चाहिए।

चरण ही इनपुट के पहले चरित्र को डुप्लिकेट करने के लिए मानक तकनीक है। हम खाली स्ट्रिंग से मेल खाते हैं (लेकिन केवल पहले दो मैचों को देखें) और उस मैच के उपसर्ग डालें। पहले मैच का उपसर्ग (स्ट्रिंग की शुरुआत में) खाली है, इसलिए यह कुछ भी नहीं करता है, और दूसरे मैच का उपसर्ग पहला चरित्र है, जिसे इसलिए दोहराया गया है।

चरण 3: अनुवादक

}T01`p`_o

}लूप के अंत का संकेत देता है। मंच ही एक लिप्यंतरण है। 01इंगित करता है कि इसे केवल स्ट्रिंग के पहले चरित्र पर लागू किया जाना चाहिए। pसभी मुद्रण योग्य ASCII वर्णों के लिए आशुलिपि है और _इसका अर्थ है "हटाएं"। इसलिए यदि हम इसका विस्तार करते हैं, तो लिप्यंतरण निम्न परिवर्तन करता है:

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

इसलिए रिक्त स्थान हटा दिए जाते हैं और अन्य सभी वर्णों को हटा दिया जाता है। इसका मतलब है कि, ये दो चरण एक साथ अंतरिक्ष से चरित्र को दिए गए चरित्र में बनाएंगे (क्योंकि वे दोहराएंगे और पहले वर्ण को तब तक हटा देंगे, जब तक कि वह ऐसा स्थान न बन जाए, जहां पर दोहराव और विलोपन रद्द हो जाए)।

इस श्रेणी की लंबाई का उपयोग चरित्र की समता निर्धारित करने के लिए किया जा सकता है।

चरण 4: प्रतिस्थापित करें

..

हम सभी वर्णों को छोड़ देते हैं। यह समान-लंबाई वाली रेखाओं को साफ़ करता है और विषम-लंबाई वाली रेखाओं को एक वर्ण (इनपुट वर्ण, वास्तव में, लेकिन वास्तव में कोई फर्क नहीं पड़ता) को कम करता है।

स्टेज 5: मैच

Mm`.¶.|^¶$

ऐसे इनपुट ढूंढना आसान है जो कि हैं भी नहीं , इसलिए हम दो क्रमिक खाली लाइनों या दो क्रमिक गैर-रिक्त लाइनों के मिलानों की संख्या की गणना करते हैं। हमें 0इनपुट्स और गैर-शून्य के लिए भी मिलना चाहिए ।

स्टेज 6: मैच

^0

जो कुछ बचा है वह परिणाम को पलटना है, जो हम इस रेगेक्स के मैचों की संख्या की गणना करके करते हैं, जो यह जांचता है कि इनपुट ए से शुरू होता है 0। यह केवल तभी संभव है जब पहले चरण का परिणाम था 0।

— मार्टिन एंडर
स्रोत

2

क्लोजर, 59 बाइट्स

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

स्ट्रिंग से सभी अनुक्रमिक जोड़े बनाता है nऔर जाँचता है कि क्या प्रत्येक जोड़ी राशि विषम है। यदि चींटियों का अनुक्रम एक उचित प्रारूप माना जाता है तो यह 50 बाइट्स है।

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

इसे ऑनलाइन देखें: https://ideone.com/USeSnk

— cliffroot
स्रोत

2

जूलिया, 55 53 बाइट्स

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

व्याख्या की

मैप चार्ट 0 से 1। और जांचें कि क्या परिणामस्वरूप स्ट्रिंग में "00" या "11" हैं, जो स्ट्रिंग को वैकल्पिक नहीं बनाता है।

— nyro_0
स्रोत

2

पायथन, 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

वैकल्पिक रूप से, एक पुनरावृत्त समाधान। इनपुट वर्णों पर Iterates, करंट और पिछले कैरेक्टर वैल्यू मॉड 2 को स्टोर करता है। रनिंग प्रॉडक्ट को अंतर से गुणा करता है, क्योंकि 0 (फाल्सी) केवल तब जब दो लगातार समानताएं बराबर होती हैं।

"पिछले" मान को 2 (या किसी भी मान 0 या 1) के लिए आरंभीकृत किया गया है ताकि पहला चरित्र काल्पनिक पिछले चरित्र के साथ समानता से मेल न खाए।

पायथन, 42 बाइट्स, एक्ज़िट कोड के माध्यम से आउटपुट

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

निर्गम कोड के माध्यम से आउटपुट। लगातार दो वर्ण समान होने पर, ZeroDivisionError के साथ टर्मिनेट करता है, अन्यथा सफाई से समाप्त हो जाता है।

— XNOR
स्रोत

2

हास्केल, 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 ने दो बाइट्स बचाए। धन्यवाद!

— nimi
स्रोत

मतभेद होने और जाँचने के लिए यह थोड़ा कम है कि क्या वे विषम हैं all odd.(zipWith(-)=<<tail).map fromEnum:।

— xnor

2

गणितज्ञ, ४१ ४० बाइट्स

And@@OddQ@Differences@ToCharacterCode@#&

-1 चरित्र, मार्टिन एंडर के लिए धन्यवाद

— celtschk
स्रोत

2

सी, 52 बाइट्स

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

पहले 2 वर्णों की समता की तुलना करता है, फिर से स्ट्रिंग के माध्यम से आगे बढ़ता है जब तक कि एक ही समता के साथ 2 वर्ण या 1 की लंबाई के साथ तार नहीं मिल जाता (s[1] == 0 )।

कुछ परीक्षण मामलों के साथ कोड

— AlexRacer
स्रोत

आप f(char*s){s=s[1]?(*s-s[1])%2?f(s+1):0:1;} इंट, रिटर्न या [0] की जरूरत नहीं है, यह बहुत कम कर सकते हैं

— Etaoin Shrdlu

ऐसा करके *++sदूसरे के बजाय s[1]आप बदल सकते हैं f(s+1)करने के लिए f(s)। इसके अलावा मेरी पिछली टिप्पणी कुल 39 को नीचे लाती है; मुझे यह भी जोड़ना चाहिए कि हटाने returnसे यह विचारधारा पर काम नहीं करता है, लेकिन यह अभी भी खिड़कियों पर जीसीसी के साथ काम करता है

— Etaoin Shrdlu

एक अंतिम ट्वीक के साथ मैंने आंतरिक टर्नरी को हटाकर इसे 38 तक लाया। f(char*s){s=s[1]?(*s-*++s)%2&&f(s):1;}मैं जाऊँगा, लेकिन यह

— एटाओइन शर्डलू

1

पाइके, 8 बाइट्स

m.o$2m%B

यहाँ यह कोशिश करो!

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

— नीला
स्रोत

1

सी #, 69 बाइट्स

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

परीक्षण मामलों के साथ पूरा कार्यक्रम:

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!"));
        }
    }
}

— adrianmp
स्रोत

अच्छा जवाब! +1 यह मज़ेदार है कि जब मैं आपके उत्तर को जावा 7 में पोर्ट करने की कोशिश करता हूं तो यह मेरे पास की तुलना में अधिक लंबा है। लेकिन जब मैं अपने उत्तर को C # में पोर्ट करने की कोशिश करता हूं तो यह आपके पास की तुलना में अधिक लंबा होता है। ;)

— केविन क्रूज़सेन

1

@KevinCruijssen धन्यवाद, लेकिन एक बग था, जिसे किसी भी परीक्षण के मामले में नहीं पकड़ा गया था :( मैं बाद में किसी अन्य विधि को खोजने की कोशिश करूंगा।

— एड्रिएम्प

1

PHP, 69 बाइट्स

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

रेगेक्स 81 बाइट्स के साथ समाधान

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

— जार्ग हुल्सरमन
स्रोत

1

PowerShell v2 +, 47 बाइट्स

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

( काफी नहीं कर सकते PowerShell के सामान्य प्रतियोगियों को पकड़ने ...)

$args[0]एक स्ट्रिंग के रूप में इनपुट लेता है , इसे एक char-रे के रूप में डालता है, इसके माध्यम से लूप करता है |%{...}, प्रत्येक पुनरावृत्ति को पाइपलाइन पर मोडुलो ( रूपांतरण के [char]लिए निहित [int]) के साथ रखता है । इन्हें पैरेंस में एनकैप्स किया जाता है और -joinएक स्ट्रिंग में एड किया जाता है, जिसे -notmatchऑपरेटर के बाएं हाथ में खिलाया जाता है, जिसके खिलाफ चेक करना ( 00या 11, Trueअगर 0एस वापस आता है)1 रों वैकल्पिक)। उस बूलियन परिणाम को पाइपलाइन पर छोड़ दिया गया है और आउटपुट निहित है।

परीक्षण के मामलों

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

— AdmBorkBork
स्रोत

1

> <> , 29 27 बाइट्स

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

आउटपुट 1 यदि शब्द सम है, तो यदि शब्द विषम है।

आप इसे ऑनलाइन आज़मा सकते हैं ।

संपादित करें: मार्टिन एंडर के लिए धन्यवाद दो बाइट्स सहेजे गए

— हारून
स्रोत

1

पर्ल 6 , 47 26 बाइट्स

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

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

विस्तारित:

# 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?
}

— ब्रैड गिल्बर्ट b2gills
स्रोत

1

स्काला, 54 बाइट्स

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

मुझे यकीन है कि इसमें सुधार किया जा सकता है।

— corvus_192
स्रोत

इवन-रिंग C ode - g ol! F

चुनौती

उदाहरण

MATL , 4 3 बाइट्स

05AB1E , 5 4 बाइट्स

जेली , 7 5 4 बाइट्स

व्याख्या

पायथन 2, 54 बाइट्स

गणितज्ञ, ५० 44 बाइट्स

जावास्क्रिप्ट (ईएस 6), 60 50 46 बाइट्स

टेस्ट स्निपेट

ब्रेन-फ्लैक , 138 114 112 84 + 3 = 87 बाइट्स

स्पष्टीकरण (पुराना)

आर, 41 35 बाइट्स

पायथ ( कांटा ), 9 बाइट्स

ब्रेकीलॉग , 17 बाइट्स

व्याख्या

जावा 8, 77 76 72 57 बाइट्स

ब्रेन-फ्लैक 155 151 141 121

तारों से , 85 बाइट्स

व्याख्या

एनोटेट प्रोग्राम

पर्ल, 24 + 1 ( -p) = 25 बाइट्स

जे, 15 बाइट्स

प्रयोग

व्याख्या

विम, 38 बाइट्स

रेटिना , 39 बाइट्स

व्याख्या

क्लोजर, 59 बाइट्स

जूलिया, 55 53 बाइट्स

पायथन, 52 बाइट्स

हास्केल, 42 40 बाइट्स

गणितज्ञ, ४१ ४० बाइट्स

सी, 52 बाइट्स

पाइके, 8 बाइट्स

सी #, 69 बाइट्स

PHP, 69 बाइट्स

PowerShell v2 +, 47 बाइट्स

परीक्षण के मामलों

> <> , 29 27 बाइट्स

पर्ल 6 , 47 26 बाइट्स

विस्तारित:

स्काला, 54 बाइट्स

पर्ल, 24 + 1 ( `-p`) = 25 बाइट्स