"Рядний рядок" - це будь-який рядок, де парність значень 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 байти

Дякуємо Еміньї за збереження байта і спасибі Луїсу Мендо за виправлення деяких помилок. Код:

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

Пітон 2, 54 байти

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

Математика, 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>

Мозг-Флак , 138 114 112 84 + 3 = 87 байт

Дякуємо @Riley за допомогу в гольфі .

Ця програма розглядає порожній вхід як нерівний рядок.

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

Спробуйте в Інтернеті!

Пояснення (застаріле)

Зсуває вхід з лівого стека вправо під час модифікації на 2. Знаходить різницю між кожним суміжним символом до тих пір, поки всі не будуть перевірені або одна з різниць не дорівнює нулю (що відбудеться лише в нерівномірному рядку). Якщо цикл завершився через нерівномірний рядок, тоді перемкніть назад на лівий стек і вставте значення, що залишилося на ньому. В іншому випадку тримайтеся на правій стеці та висуньте нуль вище 1, що залишився на стеку.

R, 41 35 байт

EDIT: Збережено кілька байт завдяки @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

Немає посилання "Спробуйте в Інтернеті", оскільки вилка не має власної версії в онлайн-перекладачах.

Пояснення:

       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

Мозок-Флак 155 151 141 121

Включає +3 для -а

Збережено 30 байт завдяки 1000000000

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

Вихід:
truthy : 1
falsy : 0 на вершині стека

Спробуйте в Інтернеті! (truthy)
Спробуйте в Інтернеті! (помилково)

Краще пояснення надійде пізніше (якщо я можу згадати, як це працює через кілька годин ...)

#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 (truthy).

Анотована програма

 ,               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 (тому рядок містить лише 0s та 1s після цього). Потім знайдіть два наступних 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>: Видаляє рядок, якщо два послідовних "біта" мають однакове значення. Швидше, ніж зворотний посилання.

Зазвичай, у vimgolf, коли ви використовуєте функцію вираження всередині макросу, ви повинні робити сам макрос в регістрі виразів і використовувати певну хитрість для завершення вкладки. Цього разу складніше. Можливо, я знайду спосіб скоротити це пізніше.

Сітківка , 39 байт

Кількість байтів передбачає кодування ISO 8859-1.

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

Mm`.¶.|^¶$
^0

Вихідні дані 1для правди і 0для помилки .

Спробуйте в Інтернеті! (Перший рядок включає тестовий набір, відокремлений виведенням ліній.)

Пояснення

Натхненний відповіддю mbomb007, нещодавно я розробив досить коротку ord()реалізацію в Retina. Це багато в чому ґрунтується на цьому, хоча мені вдалося зробити декілька спрощень, оскільки мені не потрібен десятковий результат, оскільки мені потрібно лише підтримувати друкований ASCII (і мені цікаво лише паритет результату, і в кінцевому підсумку довільне зміщення теж добре).

1 етап: Спліт

S_`

Це просто розбиває вхід на окремі символи, розділяючи його навколо порожнього збігу та видаляючи порожні результати на початку та в кінці _.

2 етап: замінити

%{2`
$`

Повідомляє %{Retina 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...])))

Пояснив

Зіставте символи на 0 | 1 і перевірте, чи містить отриманий рядок "00" або "11", завдяки чому рядок не чергується.

Пітон, 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 зберегло два байти. Спасибі!

Математика, 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(тобто повертає Trueiff 0і 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, якщо слово непарне.

Ви можете спробувати в Інтернеті .

Редагувати: збережено два байти завдяки Мартіну Ендеру

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

Я впевнений, що це можна покращити.