'Chuỗi chẵn' là bất kỳ chuỗi nào có tính chẵn lẻ của các giá trị ASCII của các ký tự luôn xen kẽ. Ví dụ: chuỗi EvenSt-ring$!là một chuỗi chẵn vì các giá trị ASCII của các ký tự là:

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

Và các chẵn lẻ của những con số này là:

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

Đó là xen kẽ toàn bộ cách. Tuy nhiên, một chuỗi như Hello world!là không một chuỗi thậm chí vì các giá trị ASCII là:

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

Và các chẵn lẻ là:

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

Mà rõ ràng không phải lúc nào cũng xen kẽ.

Các thách thức

Bạn phải viết hoặc là một chương trình đầy đủ hoặc một chức năng chấp nhận một chuỗi cho đầu vào và đầu ra một truthy giá trị nếu chuỗi là chẵn và một giá trị falsy khác. Bạn có thể lấy đầu vào và đầu ra của mình ở bất kỳ định dạng hợp lý nào và bạn có thể giả sử rằng đầu vào sẽ chỉ có ASCII có thể in được (phạm vi 32-127). Bạn không phải xử lý đầu vào trống.

Ví dụ

Dưới đây là một số ví dụ về chuỗi chẵn:

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

Và tất cả các ví dụ này thậm chí không phải là chuỗi:

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

Bạn cũng có thể sử dụng giải pháp vô căn cứ này để kiểm tra bất kỳ chuỗi nào nếu bạn tò mò về một trường hợp thử nghiệm nhất định.

MATL , 4 3 byte

Nhờ vào Emigna đã lưu một byte và cảm ơn Luis Mendo vì đã sửa một số lỗi. Mã số:

doA

Giải trình:

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

Hãy thử trực tuyến!

05AB1E , 5 4 byte

Đã lưu 1 byte nhờ Adnan .

Ç¥ÉP

Hãy thử trực tuyến!

Giải trình

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

Thạch , 7 5 4 byte

OIḂẠ

Đã lưu 2 byte bằng cách sử dụng ý tưởng deltas từ @ Steven H.

Đã lưu 1 byte nhờ @ Lynn .

Hãy thử trực tuyến!hoặc Xác minh tất cả các trường hợp thử nghiệm.

Giải trình

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

Python 2, 54 byte

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

Toán học, 50 44 byte

Phiên bản hiện tại về cơ bản là tất cả sự điêu luyện của Martin Ender.

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

Trả về True hoặc False. Không có gì quá thông minh: lấy tổng số mod-2 của mỗi cặp mã ASCII liên tiếp và kiểm tra 0 không bao giờ lấy được.

Phiên bản cũ:

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

JavaScript (ES6), 60 50 46 byte

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

Tôi đã thử đệ quy, nhưng ở mức 51 byte, nó dường như không hoàn toàn xứng đáng:

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

Kiểm tra đoạn

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 byte

Cảm ơn @Riley đã giúp chơi golf.

Chương trình này coi đầu vào trống là một chuỗi không đồng đều.

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

Hãy thử trực tuyến!

Giải thích (lỗi thời)

Chuyển đầu vào từ ngăn xếp bên trái sang bên phải trong khi sửa đổi bằng 2. Tìm sự khác biệt giữa từng ký tự liền kề cho đến khi tất cả đã được kiểm tra hoặc một trong những khác biệt bằng 0 (chỉ xảy ra trong một chuỗi không đều). Nếu vòng lặp kết thúc do một chuỗi không đều thì chuyển trở lại ngăn xếp bên trái và bật giá trị còn lại trên nó. Nếu không, hãy ở trên ngăn xếp bên phải và bật số 0 lên trên 1 còn lại trên ngăn xếp.

R, 41 35 byte

EDIT: Đã lưu một vài byte nhờ @JDL bằng cách sử dụng diffthay vì rle.

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

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

Giải trình

1. readline() đọc đầu vào.
2. utf8ToInt()%%2 chuyển đổi thành giá trị ascii và mod 2 (lưu trữ dưới dạng vector R)
3. all(rle()==1)chạy mã hóa chiều dài để tìm chạy. Tất cả các lần chạy phải bằng một hoặc nhỏ hơn 2 vì không có lần chạy nào không thể âm hoặc 0 (lưu một byte thay vì ==).

Pyth ( ngã ba ), 9 byte

.A%R2.+CM

Không có liên kết Dùng thử trực tuyến vì ngã ba không có phiên bản riêng trong trình thông dịch trực tuyến.

Giải trình:

       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 byte

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

Hãy thử trực tuyến!

Giải trình

@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 byte

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

-4 byte nhờ @Geobits .

Giải trình:

Hãy thử trực tuyến.

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

Bao gồm +3 cho -a

Đã lưu 30 byte nhờ 1000000000

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

Output:
truthy : 1
falsy : 0 trên đỉnh của ngăn xếp

Hãy thử trực tuyến! (sự thật)
Hãy thử trực tuyến! (giả)

Giải thích tốt hơn đến sau (nếu tôi có thể nhớ nó hoạt động như thế nào sau vài giờ ...)

#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 byte

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

Hãy thử trực tuyến!

Lưu ý rằng vì chương trình Starry không có cách nào để biết khi nào đầu vào có độ dài tùy ý kết thúc, chương trình này sử dụng một dòng mới ở đầu vào để đánh dấu kết thúc chuỗi. Nếu bạn nhận được một thông báo lỗi khó hiểu về và phương thức không xác định ordchonil:NilClass sau đó đầu vào là mất tích một ký tự dòng mới.

Giải trình

Chiến lược cơ bản mà chương trình sử dụng là đọc từng ký tự một từ đầu vào và nếu chúng không phải là một dòng mới (ký tự 10), chúng sẽ sửa đổi giá trị ASCII của ký tự bằng 2 và tìm thấy sự khác biệt giữa nó và ký tự đã đọc trước đó. Nếu chênh lệch bằng 0, chương trình chấm dứt và in 0(falsey). Nếu không, chương trình lặp lại và thực hiện lại quá trình. Nếu chương trình đọc một dòng mới, nó sẽ chấm dứt và in10 (trung thực).

Chương trình chú thích

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

-4 byte nhờ @TonMedel !

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

Cần -pcờ. Đầu ra 1 là chuỗi chẵn, không có gì khác. Ví dụ :

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

Giải thích : thay thế mỗi ký tự bằng giá trị mod 2 (vì vậy chuỗi chỉ chứa 0 và 1 sau đó). Sau đó tìm kiếm hai hoặc 1 sau: nếu nó tìm thấy một số, thì chuỗi không đồng đều, nếu không nó là.

J, 15 byte

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

Sử dụng

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

Giải trình

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

Vim, 38 byte

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

Giả sử chuỗi đầu vào trong bộ đệm và trống "q . Đầu ra nhị phân vô nghĩa nếu đúng, không có gì nếu sai.

• s<C-R>=char2nr(@")%2<CR>: Thay thế một ký tự bằng 1 nếu lẻ, 0 nếu chẵn. Macro này chỉ thực hiện điều này cho mọi nhân vật trong dòng (bất kể nó dài bao nhiêu).
• :g/00\|11/d<CR>: Xóa dòng nếu 2 "bit" liên tiếp có cùng giá trị. Nhanh hơn một tài liệu tham khảo ngược.

Thông thường, trong vimgolf, khi bạn sử dụng hàm biểu thức bên trong macro, bạn phải tự thực hiện macro trên thanh ghi biểu thức và sử dụng một số mẹo để hoàn thành tab. Lần đó khó khăn hơn. Tôi có thể tìm cách rút ngắn điều đó sau.

Võng mạc , 39 byte

Số lượng byte giả định mã hóa ISO 8859-1.

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

Mm`.¶.|^¶$
^0

Đầu ra 1cho sự thật và0 .

Hãy thử trực tuyến!(Dòng đầu tiên cho phép bộ kiểm tra được phân tách bằng nguồn cấp.)

Giải trình

Lấy cảm hứng từ một câu trả lời của mbomb007 của tôi gần đây đã phát triển một cách hợp lý ngắn ord()thực hiện trong Retina. Điều này phần lớn dựa trên điều đó, mặc dù tôi đã có thể thực hiện một vài đơn giản hóa vì tôi không cần kết quả thập phân vì tôi chỉ cần hỗ trợ ASCII có thể in được (và tôi chỉ quan tâm đến tính chẵn lẻ của kết quả, vì vậy kết thúc bằng một bù tùy ý là tốt, quá).

Giai đoạn 1: Chia nhỏ

S_`

Điều này chỉ đơn giản là phân tách đầu vào thành các ký tự riêng lẻ bằng cách chia nó xung quanh kết quả khớp trống và bỏ kết quả trống ở đầu và cuối _.

Giai đoạn 2: Thay thế

%{2`
$`

Các %{ nói với Retina a) rằng giai đoạn này và giai đoạn tiếp theo nên được chạy trong một vòng lặp cho đến khi chuỗi dừng thay đổi thông qua một lần lặp đầy đủ và hai giai đoạn này nên được áp dụng cho từng dòng (tức là mỗi ký tự) của đầu vào.

Bản thân giai đoạn là kỹ thuật tiêu chuẩn để nhân đôi ký tự đầu tiên của đầu vào. Chúng tôi khớp chuỗi trống (nhưng chỉ nhìn vào hai kết quả khớp đầu tiên) và chèn tiền tố của kết quả khớp đó. Tiền tố của trận đấu đầu tiên (ở đầu chuỗi) trống, do đó, điều này không làm gì cả và tiền tố của trận đấu thứ hai là ký tự đầu tiên, do đó được nhân đôi.

Giai đoạn 3: Chuyển ngữ

}T01`p`_o

}chỉ ra kết thúc của vòng lặp. Bản thân sân khấu là một phiên âm. 01chỉ ra rằng nó chỉ nên được áp dụng cho ký tự đầu tiên của chuỗi. plà viết tắt cho tất cả các ký tự ASCII có thể in và _có nghĩa là "xóa". Vì vậy, nếu chúng tôi mở rộng điều này, phiên âm thực hiện chuyển đổi sau:

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

Vì vậy, không gian được xóa và tất cả các ký tự khác được giảm. Điều đó có nghĩa là, hai giai đoạn này cùng nhau sẽ tạo ra một phạm vi ký tự từ không gian đến ký tự đã cho (bởi vì chúng sẽ lặp lại và nhân đôi ký tự đầu tiên cho đến khi nó trở thành khoảng trống tại đó điểm trùng lặp và xóa bị hủy).

Độ dài của phạm vi này có thể được sử dụng để xác định tính chẵn lẻ của nhân vật.

Giai đoạn 4: Thay thế

..

Chúng tôi chỉ đơn giản là thả tất cả các cặp nhân vật. Điều này xóa các dòng có độ dài chẵn và giảm các dòng có độ dài lẻ thành một ký tự (thực tế là ký tự đầu vào, nhưng điều đó không thực sự quan trọng).

Giai đoạn 5: Trận đấu

Mm`.¶.|^¶$

Việc tìm đầu vào không đồng đều dễ dàng hơn , vì vậy chúng tôi đếm số lượng trận đấu của hai dòng trống liên tiếp hoặc hai dòng không trống liên tiếp. Chúng ta nên nhận 0ngay cả đầu vào và một cái gì đó khác không.

Giai đoạn 6: Trận đấu

^0

Tất cả những gì còn lại là đảo ngược kết quả, điều chúng tôi làm bằng cách đếm số lượng trận đấu của biểu thức chính này, kiểm tra xem đầu vào bắt đầu bằng a 0. Điều này chỉ có thể nếu kết quả của giai đoạn đầu tiên là 0.

Clojure, 59 byte

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

Tạo tất cả các cặp tuần tự từ chuỗi nvà kiểm tra xem mỗi tổng số cặp là số lẻ. Nếu một chuỗi các số nguyên được coi là một định dạng hợp lý thì đó là 50 byte.

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

Xem trực tuyến: https://ideone.com/USeSnk

Julia, 55 53 byte

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

Giải thích

Ánh xạ ký tự thành 0 | 1 và kiểm tra xem chuỗi kết quả có chứa "00" hoặc "11", điều này làm cho chuỗi không xen kẽ.

Python, 52 byte

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

Một hàm đệ quy. Tạo 1 (hoặc True) cho các chuỗi chẵn, 0 cho các chuỗi lẻ. Nhân số chẵn lẻ của sự khác biệt của hai ký tự đầu tiên bằng giá trị đệ quy trên phần còn lại. Một chuỗi ký tự đơn cho True, khi được kiểm tra bằng chuỗi ký tự đầu tiên của nó. Điều này giả định đầu vào là không trống; khác, cần thêm một byte cho s==s[:1]hoặc len(s)<2.

Python 2, 52 byte

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

Ngoài ra, một giải pháp lặp đi lặp lại. Lặp lại các ký tự đầu vào, lưu trữ giá trị ký tự hiện tại và trước đó mod 2. Nhân số sản phẩm đang chạy bằng chênh lệch, bởi vì 0 (Falsey) chỉ khi hai chẵn lẻ liên tiếp bằng nhau.

Giá trị "trước" được khởi tạo thành 2 (hoặc bất kỳ giá trị nào không phải 0 hoặc 1) để ký tự đầu tiên không bao giờ khớp với chẵn lẻ với ký tự hư cấu trước đó.

Python, 42 byte, xuất ra thông qua mã thoát

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

Đầu ra thông qua mã thoát. Chấm dứt với ZeroDivisionError khi hai ký tự liên tiếp có cùng một chẵn lẻ, nếu không thì chấm dứt sạch sẽ.

Haskell, 42 40 byte

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

Ví dụ sử dụng: all odd.(zipWith(-)=<<tail).map fromEnum $ "long"-> True.

Làm thế nào nó hoạt động:

               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

Chỉnh sửa: @xnor đã lưu hai byte. Cảm ơn!

Toán học, 41 40 byte

And@@OddQ@Differences@ToCharacterCode@#&

-1 ký tự, nhờ Martin Ender

C, 52 byte

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

So sánh tính chẵn lẻ của 2 ký tự đầu tiên, di chuyển đệ quy qua chuỗi cho đến khi tìm thấy 2 ký tự có cùng mức chẵn hoặc chuỗi có độ dài 1 ( s[1] == 0).

Mã với một số trường hợp thử nghiệm

Pyke, 8 byte

m.o$2m%B

Hãy thử nó ở đây!

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

C #, 69 byte

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

Chương trình đầy đủ với các trường hợp thử nghiệm:

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 byte

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

giải pháp với Regex 81 Byte

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

PowerShell v2 +, 47 byte

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

(Có thể không khá bắt đối thủ cạnh tranh thông thường của PowerShell ...)

Đưa đầu vào $args[0]như là một chuỗi, phôi nó như là một char-array, vòng qua nó |%{...}, mỗi lần lặp đặt modulo trên đường ống (với ngầm [char]để [int]chuyển đổi). Những cái đó được gói gọn trong parens và -joined thành một chuỗi, được đưa vào bên trái của -notmatchtoán tử, kiểm tra lại 00hoặc 11(nghĩa là trả về Trueiff thay thế s 0và 1s). Kết quả Boolean đó được để lại trên đường ống và đầu ra là ẩn.

Các trường hợp thử nghiệm

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 byte

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

Xuất ra 1 nếu từ chẵn, 0 nếu từ lẻ.

Bạn có thể thử trực tuyến .

Chỉnh sửa: đã lưu hai byte nhờ Martin Ender

Perl 6 ,  47  26 byte

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

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

Mở rộng:

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

Scala, 54 byte

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

Tôi chắc chắn rằng điều này có thể được cải thiện.