「偶数文字列」は、文字の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

全体が交互になっています。ただし、ASCII値は次のとおりであるため、次のような文字列Hello world!は偶数文字列ではありません。

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!

特定のテストケースに興味がある場合は、この未解決のソリューションを使用して文字列をテストすることもできます。

MATL、4 3バイト

バイトを保存してくれたエミグナと、いくつかのバグを修正してくれたルイス・メンドーに感謝します。コード：

doA

説明：

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

オンラインでお試しください！

05AB1E、5 4バイト

Adnanのおかげで1バイト節約されました。

Ç¥ÉP

オンラインでお試しください！

説明

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

ゼリー、7 5 4バイト

OIḂẠ

@ Steven Hのデルタアイデアを使用して2バイトを保存しました。

@ Lynnのおかげで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。あまり賢いものはありません。連続するASCIIコードの各ペアのmod-2の合計を取り、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>

脳フラック、138 114 112 84 + 3 = 87のバイト

ゴルフを手伝ってくれた@Rileyに感謝します。

このプログラムは、空の入力を不均等な文字列として扱います。

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

オンラインでお試しください！

説明（古い）

改造中に左スタックから右に入力を2シフトします。すべてのチェックが終了するか、差の1つがゼロに等しくなるまで（偶数でない文字列でのみ発生する）、隣接する文字間の差を見つけます。ループが不均等なストリングのために終了した場合、左のスタックに戻り、そのスタックに残っている値をポップします。そうでなければ、正しいスタックに留まり、スタックに残っている1の上にゼロをポップします。

R、41 35バイト

編集：のdiff代わりにを使用して、@ JDLのおかげで数バイトを節約しましたrle。

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)ランを見つけるためのランレングスエンコーディング。すべての実行は、1に等しいか、2より小さい必要があります。これは、負または0にならないためです（の代わりに1バイトを保存します==）。

Pyth（fork）、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;}

@Geobitsのおかげで-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

Brain-Flak 155 151 141 121

-aの+3を含む

1000000000のおかげで30バイト節約

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

出力：
truthy：1
falsy：スタックの先頭に0

オンラインでお試しください！（真実）
オンラインで試してみてください！（偽）

より良い説明は後で来る（数時間後にどのように機能するか覚えているなら...）

#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
([]<(())>){((<{}{}>))}{}

星空、85バイト

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

オンラインでお試しください！

Starryプログラムには、任意の長さの入力がいつ終了するかを知らせる方法がないため、このプログラムでは、入力の末尾の改行を使用して文字列の終わりをマークすることに注意してください。についての不可解なエラーメッセージと未定義のメソッドordを取得した場合nil:NilClass場合は、入力の末尾に改行がありません。

説明

プログラムが採用する基本的な戦略は、入力から文字を1つずつ読み取り、それらが改行（文字10）でない場合、文字のASCII値を2ずつ変更し、以前に読み取った文字との違いを見つけます。差がゼロの場合、プログラムは終了して印刷します0（false）。それ以外の場合、プログラムはループバックし、プロセスを再度実行します。プログラムが改行を読み取ると、プログラムは終了して印刷します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バイト

@Ton Hospelのおかげで-4バイト！

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

-pフラグが必要です。出力1は文字列が偶数であり、それ以外は何もありません。例えば ​​：

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

説明：各文字をmod 2という値に置き換えます（したがって、文字列にはその後に0と1のみが含まれます）。次に、1または0の後に続く2つを検索します。一部が見つかった場合、文字列は均等ではありません。それ以外の場合は均等です。

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

Vim、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をサポートするだけでよいため、10進数の結果を必要としないため、いくつかの単純化を行うことができました（そして、結果のパリティのみを気にして、任意のオフセットでも問題ありません）。

ステージ1：分割

S_`

これは、入力を空の一致の周りで分割し、最初と最後に空の結果をドロップすることにより、個々の文字に単純に分割します _。

ステージ2：交換

%{2`
$`

%{指示網膜A）文字列が完全反復を通じて変化停止し、これらの二つの段階は別々の入力の各行（すなわち、各文字）に適用されるべきであることまで、この段階および次ループで実行されるべきであること。

ステージ自体は、入力の最初の文字を複製するための標準的な手法です。空の文字列と一致します（ただし、最初の2つの一致のみを調べます）。その一致のプレフィックスを挿入します。最初の一致（文字列の先頭）のプレフィックスは空なので、これは何もしません。2番目の一致のプレフィックスは最初の文字であるため、重複します。

ステージ3：文字変換

}T01`p`_o

}ループの終わりを示します。ステージ自体は音訳です。01文字列の最初の文字にのみ適用されることを示します。pすべての印刷可能なASCII文字の省略形であり、_「削除」を意味します。したがって、これを展開すると、音訳は次の変換を行います。

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

したがって、スペースは削除され、他のすべての文字は減少します。つまり、これらの2つのステージは一緒にスペースから指定されたキャラクターまでのキャラクター範囲を作成します（複製と削除がキャンセルされるスペースになるまで最初のキャラクターを繰り返し複製および減分するため）。

この範囲の長さを使用して、文字のパリティを決定できます。

ステージ4：交換

..

単にすべての文字のペアをドロップします。これにより、偶数長の行がクリアされ、奇数長の行が1文字に削減されます（実際には入力文字ですが、それは実際には問題ではありません）。

ステージ5：試合

Mm`.¶.|^¶$

偶数でない入力を見つけるのは簡単なので、2つの連続した空行または2つの連続した空でない行の一致数をカウントします。0それ以外の場合は、偶数の入力とゼロ以外の値を取得する必要があります。

ステージ6：試合

^0

残っているのは結果を反転させることだけです。これは、この正規表現の一致数をカウントすることで行い0ます。これは、入力がで始まることを確認します。これは、最初のステージの結果がである場合にのみ可能です0。

Clojure、59バイト

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

文字列からすべてのシーケンシャルペアを生成し、すべてのnペアの合計が奇数かどうかを確認します。intのシーケンスが妥当な形式と見なされる場合、50バイトです。

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

オンラインで見る：https : //ideone.com/USeSnk

ジュリア、55 53バイト

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を生成します。最初の2文字の差のパリティに、残りの再帰値を乗算します。1文字の文字列は、最初の文字に等しいことを確認すると、Trueになります。これは、入力が空でないことを前提としています。それ以外の場合は、s==s[:1]またはにもう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を格納します。2つの連続したパリティが等しい場合のみ0（Falsey）であるため、実行中の製品に差を乗算します。

「previous」値は2（または0または1以外の任意の値）に初期化され、最初の文字が架空の前の文字とパリティを一致させないようにします。

Python、42バイト、終了コードによる出力

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

終了コードを介した出力。2つの連続する文字のパリティが同じ場合、ZeroDivisionErrorで終了します。それ以外の場合は、正常に終了します。

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は2バイトを保存しました。ありがとう！

Mathematica、41 40バイト

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）の文字列が見つかるまで、文字列を再帰的に移動します。

いくつかのテストケースのコード

パイク、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バイトを使用したソリューション

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]変換されます）。それらは、括弧内にカプセル化されている-joinの左側に供給される文字列の中に編-notmatchオペレータに対してチェック00または11（すなわち、戻りTrueIFF 0sおよび1 sが交互になった）。そのブール結果はパイプラインに残り、出力は暗黙的です。

テストケース

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を出力します。

オンラインで試すことができます。

編集：マーティン・エンダーのおかげで2バイト節約

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

Scala、54バイト

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

これは改善できると確信しています。