“偶数字符串”是字符的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!

如果您对某个测试用例感到好奇，也可以使用这种非解决方案来测试任何字符串。

MATL，4 3字节

感谢Emigna节省了一个字节，也感谢Luis Mendo修复了一些错误。码：

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的deltas思想节省了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之上。

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矢量）
3. all(rle()==1)运行长度编码，以查找运行。所有游程都应等于1或小于2，因为任何游程都不能为负或0（节省一个字节而不是==）。

Pyth（fork），9个字节

.A%R2.+CM

没有“在线尝试”链接，因为fork在联机解释器中没有自己的版本。

说明：

       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

脑高射炮155 151 141 121

包括-a的+3

由于1000000000，节省了30个字节

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

输出：
真值：1
错误：堆栈顶部为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则输入缺少尾随换行符。

说明

该程序采用的基本策略是从输入中逐个读取字符，如果它们不是换行符（字符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

Vim，38个字节

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

假设输入字符串在buffer中，并且为empty "q。如果为true，则输出二进制废话，如果为false，则不输出任何东西。

• s<C-R>=char2nr(@")%2<CR>：如果一个字符为奇数，则将其替换为1；如果是偶数，则将其替换为0。它所在的宏只会对行中的每个字符执行此操作（无论它有多长）。
• :g/00\|11/d<CR>：如果两个连续的“位”具有相同的值，则删除该行。比向后引用更快。

通常，在vimgolf中，当您在宏内使用表达式函数时，应该在表达式寄存器上执行宏本身，并使用一些技巧来制表符补全。这次更加困难。我可能会在以后找到缩短它的方法。

视网膜，39字节

字节数假定为ISO 8859-1编码。

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

Mm`.¶.|^¶$
^0

输出1为真和0为假。

在线尝试！（第一行启用换行分隔的测试套件。）

说明

受mbomb007答案的启发，我最近ord()在Retina中开发了一个相当短的实现。这主要基于此，尽管我可以进行一些简化，因为我不需要十进制结果，因为我只需要支持可打印的ASCII（而且我只关心结果的奇偶性，所以最终任意偏移量也可以）。

阶段1：拆分

S_`

只需将输入拆分为空字符，只需将输入拆分为空字符，然后将空结果放在开头和结尾处即可_。

阶段2：更换

%{2`
$`

的%{讲述视网膜a）在这一阶段和下一个应在一个循环直到停止串通过全迭代改变运行，并且这两个阶段应该输入的（即，每个字符）分别被施加到每一行。

舞台本身是复制输入的第一个字符的标准技术。我们匹配空字符串（但仅查看前两个匹配项）并插入该匹配项的前缀。第一个匹配项的前缀（在字符串的开头）为空，因此不执行任何操作，第二个匹配项的前缀为第一个字符，因此重复。

阶段3：音译

}T01`p`_o

}指示循环结束。舞台本身就是音译。01指示仅应将其应用于字符串的第一个字符。p是所有可打印ASCII字符的简写，_表示“删除”。因此，如果我们对此进行扩展，音译将进行以下转换：

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

因此，空格将被删除，所有其他字符都将减少。这意味着，这两个阶段将共同创建一个从空格到给定字符的字符范围（因为它们将重复复制并递减第一个字符，直到它成为一个空间，复制和删除都会在此取消）。

此范围的长度可用于确定字符的奇偶性。

阶段4：更换

..

我们只是丢弃所有对字符。这样可以清除偶数行并将奇数行减少为一个字符（实际上是输入字符，但这并不重要）。

阶段5：比赛

Mm`.¶.|^¶$

这是比较容易找到它的投入是不是就算了，所以我们算要么两个连续的空行或两个连续的非空行的匹配的数目。我们应该获取0偶数输入，否则获取非零值。

阶段6：比赛

^0

剩下的就是反转结果，这是通过计算此正则表达式的匹配数来完成的，该正则表达式检查输入是否以开头0。仅当第一阶段的结果为时，才有可能0。

Clojure，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

朱莉娅，55 53字节

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

讲解

将char映射为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

或者，迭代解决方案。遍历输入字符，存储当前和先前的字符值mod2。将乘积乘以差异，这是因为仅当两个连续的奇偶校验相等时才为0（假）。

“上一个”值初始化为2（或任何非0或1的值），以便第一个字符永远不会与虚构的前一个字符匹配奇偶校验。

Python，42字节，通过退出代码输出

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

通过退出代码输出。当两个连续的字符具有相同的奇偶校验时，以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保存了两个字节。谢谢！

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）的字符串。

用一些测试用例编写代码

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;

正则表达式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（即，返回True当且仅当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。

您可以在线尝试。

编辑：感谢马丁·恩德节省了两个字节

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(_&&_)

我相信这可以改善。