'Even string' คือสตริงใด ๆ ที่พาริตี้ของค่า 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

และ parities คือ:

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

ซึ่งเห็นได้ชัดว่าไม่สลับกันเสมอไป

ความท้าทาย

คุณต้องเขียนทั้งโปรแกรมเต็มรูปแบบหรือฟังก์ชั่นที่ยอมรับสตริงสำหรับการป้อนข้อมูลและผลที่truthyค่าถ้าสตริงเป็นได้และค่า falsy มิฉะนั้น คุณสามารถใช้อินพุทและเอาท์พุทของคุณในรูปแบบที่เหมาะสมและคุณสามารถสันนิษฐานได้ว่าอินพุตนั้นจะมีเฉพาะ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!

คุณอาจใช้วิธีแก้ปัญหาที่ไม่ได้จดสิทธิบัตรนี้เพื่อทดสอบสตริงใด ๆ หากคุณสงสัยเกี่ยวกับกรณีทดสอบ

MATL , 4 3 ไบต์

ขอบคุณEmignaสำหรับการบันทึกไบต์และขอบคุณLuis Mendoสำหรับการแก้ไขข้อบกพร่องบางอย่าง รหัส:

doA

คำอธิบาย:

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

ลองออนไลน์!

05AB1E , 5 4 ไบต์

ที่บันทึกไว้ 1 ไบต์ขอบคุณที่Adnan

Ç¥ÉP

ลองออนไลน์!

คำอธิบาย

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

เยลลี่ , 7 5 4 ไบต์

OIḂẠ

บันทึก 2 ไบต์โดยใช้แนวคิด deltas จาก @ Steven H.

ที่บันทึกไว้ 1 ขอบคุณไบต์ @ ลินน์

ลองออนไลน์! หรือตรวจสอบกรณีทดสอบทั้งหมด

คำอธิบาย

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

Python 2, 54 ไบต์

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

Mathematica, 50 44 ไบต์

รุ่นปัจจุบันนั้นเป็นความสามารถพิเศษของ Martin Ender

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

ผลตอบแทนหรือTrue Falseไม่มีอะไรที่ฉลาดเกินไป: รับผลรวม mod-2 ของแต่ละรหัส ASCII ที่ต่อเนื่องกันและตรวจสอบว่าไม่เคยได้รับ 0

เวอร์ชั่นเก่า:

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

JavaScript (ES6), 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>

Brain-Flak , 138 114 112 84 + 3 = 87 ไบต์

ขอบคุณ@Rileyสำหรับความช่วยเหลือในการเล่นกอล์ฟ

โปรแกรมนี้ใช้อินพุตที่ว่างเปล่าเป็นสตริงที่ไม่สม่ำเสมอ

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

ลองออนไลน์!

คำอธิบาย (ล้าสมัย)

เลื่อนอินพุตจากสแต็กซ้ายไปทางขวาในขณะที่ modding โดย 2 ค้นหาความแตกต่างระหว่างอักขระแต่ละตัวที่อยู่ติดกันจนกว่าจะได้รับการตรวจสอบทั้งหมดหรือหนึ่งในความแตกต่างเท่ากับศูนย์ (ซึ่งจะเกิดขึ้นในสตริงที่ไม่สม่ำเสมอเท่านั้น) หากการวนซ้ำถูกยกเลิกเนื่องจากสตริงที่ไม่สม่ำเสมอให้สลับกลับไปที่สแต็กด้านซ้ายและป๊อปอัพค่าที่เหลืออยู่ มิฉะนั้นให้อยู่บนสแต็กด้านขวาและวางศูนย์เหนือ 1 ที่เหลือบนสแต็ก

R, 41 35 ไบต์

แก้ไข: บันทึกไว้ไม่กี่ไบต์ขอบคุณที่ @JDL โดยใช้แทนdiffrle

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

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

คำอธิบาย

1. readline() อ่านอินพุต
2. utf8ToInt()%%2 แปลงเป็นค่า ascii และ mod 2 (เก็บเป็น R-vector)
3. all(rle()==1)ใช้การเข้ารหัสความยาวของเพื่อค้นหาการวิ่ง การเรียกใช้ทั้งหมดควรเท่ากับหนึ่งหรือน้อยกว่า 2 เนื่องจากไม่มีการรันใด ๆ ที่ไม่สามารถลบได้หรือ 0 (บันทึกหนึ่งไบต์แทน==)

Pyth ( ทางแยก ), 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)

Brachylogขนาด 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

Java 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 ไบต์ขอบคุณที่@Geobits

คำอธิบาย:

ลองออนไลน์

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

Brain-Flak 155 151 141 121

รวม +3 สำหรับ -a

บันทึก 30 ไบต์ต้องขอบคุณ1000000000

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

เอาท์พุท: ความ
จริง : 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
([]<(())>){((<{}{}>))}{}

Starryขนาด 85 ไบต์

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

ลองออนไลน์!

โปรดทราบว่าเนื่องจากโปรแกรม Starry ไม่มีวิธีบอกเมื่ออินพุตของความยาวโดยพลการสิ้นสุดลงโปรแกรมนี้ใช้บรรทัดขึ้นบรรทัดใหม่ต่อท้ายในอินพุตเพื่อทำเครื่องหมายจุดสิ้นสุดของสตริง ถ้าคุณได้รับข้อผิดพลาดเกี่ยวกับความลับและวิธีการที่ไม่ได้กำหนด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

Perl, 24 + 1 ( -p) = 25 ไบต์

-4 ไบต์ขอบคุณ@Ton Hospel !

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

ต้องการ-pแฟล็ก เอาท์พุท 1 คือสตริงที่เป็นเลขคู่ ตัวอย่างเช่น

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

คำอธิบาย : แทนที่อักขระแต่ละตัวด้วยค่า mod 2 (ดังนั้นสตริงจะมีเพียง 0 วินาทีและ 1 วินาทีหลังจากนั้น) จากนั้นค้นหาสองรายการต่อไปนี้ 1 หรือ 0 หากพบบางรายการสตริงจะไม่เท่ากันมิฉะนั้นจะเป็น

J, 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

เป็นกลุ่ม, 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 บิต "ต่อเนื่อง" มีค่าเท่ากัน เร็วกว่าการอ้างอิงย้อนกลับ

โดยปกติใน vimgolf เมื่อคุณใช้ฟังก์ชั่นการแสดงออกภายในแมโครคุณควรจะทำแมโครเองบนนิพจน์รีจิสเตอร์และใช้กลอุบายเพื่อแท็บที่สมบูรณ์ คราวนี้ยากกว่ากันมาก ฉันอาจหาทางย่อให้สั้นลงในภายหลัง

เรติน่า 39 ไบต์

จำนวนไบต์ถือว่าการเข้ารหัส ISO 8859-1

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

Mm`.¶.|^¶$
^0

เอาท์พุท1สำหรับความจริงและความ0เท็จ

ลองออนไลน์! (บรรทัดแรกเปิดใช้งานชุดทดสอบที่แยกบรรทัดด้วยฟีด)

คำอธิบาย

ได้รับแรงบันดาลใจจากคำตอบของ mbomb007 ฉันเพิ่งพัฒนาการord()ใช้งานสั้น ๆ อย่างมีเหตุผลใน Retina สิ่งนี้ขึ้นอยู่กับว่าแม้ว่าฉันจะสามารถสร้างความเรียบง่ายไม่กี่อย่างเนื่องจากฉันไม่ต้องการผลทศนิยมเนื่องจากฉันต้องสนับสนุน ASCII ที่พิมพ์ได้เท่านั้น (และฉันสนใจเฉพาะความเสมอกันของผลลัพธ์ดังนั้นจึงจบลงด้วย การชดเชยโดยพลการก็ดีเช่นกัน)

ด่าน 1: แยก

S_`

_นี้ก็แยกการป้อนข้อมูลที่เป็นตัวอักษรของแต่ละบุคคลโดยแยกมันรอบการแข่งขันที่ว่างเปล่าและวางผลว่างเปล่าที่จุดเริ่มต้นและจบลงด้วยการ

ขั้นตอนที่ 2: แทนที่

%{2`
$`

%{บอก Retina) ที่เวทีนี้และต่อไปควรจะทำงานในวงสตริงจนกว่าจะหยุดการเปลี่ยนผ่านซ้ำเต็มรูปแบบและว่าทั้งสองขั้นตอนที่ควรจะนำไปใช้กับแต่ละบรรทัด (เช่นตัวละครแต่ละตัว) ของการป้อนข้อมูลแยกต่างหาก

สเตจนั้นเป็นเทคนิคมาตรฐานสำหรับการทำซ้ำอักขระแรกของอินพุต เราจับคู่สตริงว่าง (แต่ดูที่การจับคู่สองรายการแรกเท่านั้น) และใส่ส่วนนำหน้าของการจับคู่นั้น คำนำหน้าของการจับคู่ครั้งแรก (ที่จุดเริ่มต้นของสตริง) ว่างเปล่าดังนั้นสิ่งนี้จะไม่ทำอะไรเลยและคำนำหน้าของการจับคู่ที่สองคืออักขระตัวแรกซึ่งซ้ำกันดังนั้น

ด่าน 3: ถอดเสียง

}T01`p`_o

}หมายถึงจุดสิ้นสุดของลูป ตัวเวทีเองเป็นคำทับศัพท์ 01ระบุว่าควรใช้กับอักขระตัวแรกของสตริงเท่านั้น pย่อสำหรับอักขระ ASCII ที่พิมพ์ได้ทั้งหมดและ_หมายถึง "ลบ" ดังนั้นถ้าเราขยายสิ่งนี้การถอดเสียงจะทำการแปลงดังต่อไปนี้:

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

ดังนั้นช่องว่างจะถูกลบและตัวละครอื่น ๆ จะลดลง ซึ่งหมายความว่าสองขั้นตอนเหล่านี้ร่วมกันจะสร้างช่วงของอักขระจากช่องว่างไปยังอักขระที่กำหนด (เพราะจะซ้ำกันซ้ำ ๆ และลดอักขระตัวแรกจนกว่าจะกลายเป็นช่องว่างที่จะยกเลิกการคัดลอกและลบ)

ความยาวของช่วงนี้สามารถใช้เพื่อกำหนดความเท่าเทียมกันของตัวละคร

ขั้นตอนที่ 4: แทนที่

..

เราเพียงแค่วางตัวละครทุกคู่ วิธีนี้จะล้างเส้นที่มีความยาวเท่ากันและลดบรรทัดที่มีความยาวคี่ให้เหลือเพียงตัวอักษรเดียว (อันที่จริงแล้วเป็นอักขระอินพุต

ด่าน 5: การแข่งขัน

Mm`.¶.|^¶$

การค้นหาอินพุตที่ไม่ได้ง่ายกว่านั้นเราจึงนับจำนวนการแข่งขันของทั้งสองบรรทัดว่างต่อเนื่องหรือสองบรรทัดต่อเนื่องที่ไม่ว่างเปล่า เราควรจะได้รับ0แม้แต่อินพุตและบางอย่างที่ไม่ใช่ศูนย์

ด่าน 6: การแข่งขัน

^0

สิ่งที่เหลือคือการกลับผลซึ่งเราทำโดยการนับจำนวนของการแข่งขันของ regex 0นี้ซึ่งการตรวจสอบว่าการป้อนข้อมูลเริ่มต้นด้วย 0นี้เป็นไปได้เฉพาะในกรณีที่ผลของขั้นตอนแรกคือ

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

Julia, 55 53 Bytes

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

อธิบาย

แมปตัวอักษรเป็น 0 | 1 และตรวจสอบว่าสตริงผลลัพธ์ประกอบด้วย "00" หรือ "11" ซึ่งทำให้สตริงไม่สลับกันหรือไม่

Python ขนาด 52 ไบต์

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

ฟังก์ชั่นวนซ้ำ ผลิต 1 (หรือ True) สำหรับสตริงคู่ 0 สำหรับสตริงคี่ คูณพาริตีของความแตกต่างของอักขระสองตัวแรกด้วยค่าซ้ำในส่วนที่เหลือ สตริงอักขระตัวเดียวจะให้ True ตามที่ตรวจสอบโดยเท่ากับอักขระตัวแรก สิ่งนี้ถือว่าอินพุตไม่ว่างเปล่า อื่นอีกหนึ่งไบต์เป็นสิ่งจำเป็นสำหรับหรือs==s[:1]len(s)<2

Python 2, 52 ไบต์

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

อีกวิธีหนึ่งคือการแก้ปัญหาซ้ำ วนซ้ำอักขระอินพุตและการจัดเก็บค่าอักขระปัจจุบันและก่อนหน้า mod 2 คูณผลิตภัณฑ์ที่รันตามความแตกต่างซึ่งเนื่องจาก 0 (Falsey) เฉพาะเมื่อสอง parities ต่อเนื่องเท่ากัน

ค่า "ก่อนหน้า" ถูกเตรียมใช้งานเป็น 2 (หรือค่าใด ๆ ที่ไม่ใช่ 0 หรือ 1) เพื่อให้อักขระตัวแรกไม่ตรงกับพาริตี้กับอักขระก่อนหน้าสมมติ

Python ขนาด 42 ไบต์ส่งสัญญาณออกผ่านรหัสทางออก

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

ส่งออกผ่านรหัสทางออก สิ้นสุดด้วย ZeroDivisionError เมื่ออักขระสองตัวที่ต่อเนื่องกันมี parities เหมือนกันมิฉะนั้นจะสิ้นสุดอย่างสมบูรณ์

Haskell, 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 บันทึกสองไบต์ ขอบคุณ!

Mathematica, 41 40 Bytes

And@@OddQ@Differences@ToCharacterCode@#&

อักขระ 1 ตัวต้องขอบคุณ Martin Ender

C, 52 ไบต์

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

เปรียบเทียบพาริตีของอักขระ 2 ตัวแรกโดยเลื่อนผ่านสตริงซ้ำจนกระทั่งพบอักขระ 2 ตัวที่มีพาริตีเดียวกันหรือสตริงที่มีความยาว 1 ( s[1] == 0)

รหัสที่มีบางกรณีทดสอบ

Pyke 8 ไบต์

m.o$2m%B

ลองที่นี่!

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

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

PHP, 69 ไบต์

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

วิธีแก้ปัญหาด้วย Regex 81 Bytes

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

PowerShell v2 +, 47 ไบต์

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

(ไม่สามารถค่อนข้างจับสินค้าปกติ PowerShell ของ ... )

รับอินพุต$args[0]เป็นสตริง, ปลดเปลื้องมันเป็นchar-array, วน|%{...}ซ้ำไปเรื่อย ๆ, การวนซ้ำแต่ละครั้งจะวางโมดูโลบนไพพ์ไลน์ (โดยนัย[char]ถึง[int]การแปลง) สิ่งเหล่านั้นถูกห่อหุ้มใน parens และ-joined เป็นสตริงซึ่งป้อนเข้าทางด้านซ้ายของ-notmatchโอเปอเรเตอร์ตรวจสอบกับ00หรือ11(เช่นส่งคืนTrueiff 0s และ1s อื่น) ผลลัพธ์บูลีนนั้นถูกทิ้งไว้บนไพพ์ไลน์และเอาต์พุตนั้นเป็นนัย

กรณีทดสอบ

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

> <> , 29 27 ไบต์

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

ส่งออก 1 ถ้าคำเป็นเลขคู่, 0 ถ้าคำนั้นเป็นเลขคี่

คุณสามารถลองออนไลน์ได้

แก้ไข: บันทึกสองไบต์ด้วย Martin Ender

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

สกาลา 54 ไบต์

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

ฉันแน่ใจว่าสิ่งนี้สามารถปรับปรุงได้