Четная строка - это любая строка, в которой четность значений символов 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 байта

Спас 1 байт благодаря Аднану .

Ç¥ÉP

Попробуйте онлайн!

объяснение

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

Желе , 7 5 4 байта

OIḂẠ

Сохранено 2 байта с использованием идеи дельт от @ Steven H.

Сохранено 1 байт благодаря @ Lynn .

Попробуйте онлайн!или Проверьте все контрольные примеры.

объяснение

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 байта

Текущая версия в основном вся виртуозность Мартина Эндера.

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 за помощь в игре в гольф.

Эта программа обрабатывает пустой ввод как непустую строку.

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

Попробуйте онлайн!

Объяснение (устарело)

Сдвигает ввод из левого стека вправо при изменении на 2. Находит разницу между каждым смежным символом до тех пор, пока все не будут проверены или одно из различий не станет равным нулю (что может произойти только в непустой строке). Если цикл завершился из-за нечетной строки, переключитесь обратно в левый стек и вытолкните оставшееся на нем значение. В противном случае, оставайтесь в правом стеке и вставьте ноль выше 1, оставшегося в стеке.

R, 41 35 байт

РЕДАКТИРОВАТЬ: Сохранено несколько байтов благодаря @JDL с использованием diffвместо 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)длина кодировки, чтобы найти прогоны. Все пробеги должны быть равны одному или меньше 2, поскольку никакие пробеги не могут быть отрицательными или 0 (сохраняет один байт вместо ==).

Pyth ( вилка ), 9 байт

.A%R2.+CM

Нет Ссылка Try It Online, потому что у форка нет собственной версии в онлайн-переводчиках.

Объяснение:

       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)

Брахилог , 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
([]<(())>){((<{}{}>))}{}

Звездный , 85 байт

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

Попробуйте онлайн!

Обратите внимание, что, поскольку программа Starry не может сообщить, когда заканчивается ввод произвольной длины, эта программа использует завершающий символ новой строки во вводе, чтобы отметить конец строки. Если вы получите загадочное сообщение об ошибке и неопределенный методord для, nil:NilClassто во вводе отсутствует завершающий символ новой строки.

объяснение

Основная стратегия, которую использует программа, заключается в том, что она читает символы один за другим из ввода и, если они не являются новой строкой (символ 10), она изменяет значение символа в ASCII на 2 и находит разницу между ним и ранее прочитанным символом. Если разница равна нулю, программа завершается и печатает0 (Falsey). В противном случае программа возвращается назад и повторяет процесс. Если программа читает новую 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>

Предполагает, что входная строка находится в буфере и пуста "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

Осталось только инвертировать результат, что мы и делаем, подсчитывая количество совпадений этого регулярного выражения, которое проверяет, что ввод начинается с 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...])))

Разъяснения

Сопоставьте символы с 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) только при равенстве двух последовательных четностей.

«Предыдущее» значение инициализируется значением 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 персонаж, спасибо Мартину Эндеру

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(т.е. возвращает, Trueесли0 и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/}

Expanded:

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

Я уверен, что это можно улучшить.