„Łańcuch parzysty” to dowolny ciąg, w którym parzystość wartości ASCII znaków jest zawsze naprzemienna. Na przykład ciąg EvenSt-ring$!jest ciągiem parzystym, ponieważ wartości ASCII znaków to:

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

A parytety tych liczb to:

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

Co zmienia się na przemian przez całą drogę. Jednak łańcuch jak Hello world!to nie jeszcze ciąg ponieważ wartości ASCII są:

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

A parytety to:

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

Co oczywiście nie zawsze jest na przemian.

Wyzwanie

Musisz napisać pełny program lub funkcję, która akceptuje ciąg wejściowy i wyświetla prawdziwą wartość, jeśli ciąg jest parzysty, a w przeciwnym razie wartość fałsz. Możesz przyjmować dane wejściowe i wyjściowe w dowolnym rozsądnym formacie i możesz założyć, że dane wejściowe będą miały tylko drukowalny ASCII (zakres 32-127). Zdajesz nie muszą obsługiwać pusty wkład.

Przykłady

Oto kilka przykładów parzystych ciągów:

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

Wszystkie te przykłady nie są nawet łańcuchami:

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

Możesz także użyć tego niestosowanego rozwiązania do testowania dowolnych ciągów, jeśli jesteś ciekawy konkretnego przypadku testowego.

MATL , 4 3 bajty

Podziękowania dla Emigny za uratowanie bajtu i podziękowania dla Luisa Mendo za naprawienie niektórych błędów. Kod:

doA

Wyjaśnienie:

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

Wypróbuj online!

05AB1E , 5 4 bajtów

Zaoszczędzono 1 bajt dzięki Adnanowi .

Ç¥ÉP

Wypróbuj online!

Wyjaśnienie

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

Galaretka , 7 5 4 bajtów

OIḂẠ

Zaoszczędzono 2 bajty, używając pomysłu delta z @ Steven H.

Zapisano 1 bajt dzięki @ Lynn .

Wypróbuj online! lub Zweryfikuj wszystkie przypadki testowe.

Wyjaśnienie

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

Python 2, 54 bajtów

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

Mathematica, 50 44 bajtów

Obecna wersja jest w zasadzie wirtuozerią Martina Endera.

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

Zwraca Truelub False. Nic zbyt sprytnego: pobiera sumę mod-2 każdej pary kolejnych kodów ASCII i sprawdza, czy 0 nigdy nie jest uzyskiwane.

Stara wersja:

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

JavaScript (ES6), 60 50 46 bajtów

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

Próbowałem rekurencji, ale przy 51 bajtach nie wydaje się to warte:

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

Testowy fragment kodu

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 bajtów

Dzięki @Riley za pomoc w grze w golfa.

Ten program traktuje puste dane wejściowe jako ciąg nici.

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

Wypróbuj online!

Wyjaśnienie (nieaktualne)

Przesuwa dane wejściowe z lewego stosu w prawo podczas modowania o 2. Znajduje różnicę między każdym sąsiednim znakiem, aż wszystkie zostaną sprawdzone lub jedna z różnic będzie równa zero (co wystąpiłoby tylko w żadnym nieistniejącym ciągu). Jeśli pętla zakończy się z powodu nierównomiernego ciągu, przełącz się z powrotem na lewy stos i usuń pozostałą na nim wartość. W przeciwnym razie pozostań na właściwym stosie i wyzeruj zero powyżej 1 pozostającego na stosie.

R, 41 35 bajtów

EDYCJA: Zaoszczędź kilka bajtów dzięki @JDL, używając diffzamiast rle.

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

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

Wyjaśnienie

1. readline() odczytać wejście.
2. utf8ToInt()%%2 konwertuj na wartości ascii i mod 2 (zapisz jako wektor R)
3. all(rle()==1)kodowanie długości przebiegu w celu znalezienia przebiegów. Wszystkie przebiegi powinny być równe 1 lub mniejsze niż 2, ponieważ żadne przebiegi nie mogą być ujemne lub 0 (zapisuje jeden bajt zamiast ==).

Pyth ( widelec ), 9 bajtów

.A%R2.+CM

Brak linku Wypróbuj online, ponieważ rozwidlenie nie ma własnej wersji w tłumaczach internetowych.

Wyjaśnienie:

       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 bajtów

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

Wypróbuj online!

Wyjaśnienie

@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 bajtów

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

-4 bajty dzięki @Geobits .

Wyjaśnienie:

Wypróbuj online.

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

Zawiera +3 dla -a

Zaoszczędzono 30 bajtów dzięki 1000000000

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

Wyjście:
prawda : 1
fałsz : 0 na górze stosu

Wypróbuj online! (prawda)
Wypróbuj online! (falsy)

Lepsze wyjaśnienie nastąpi później (jeśli pamiętam, jak to działa po kilku godzinach ...)

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

Gwiaździsta , 85 bajtów

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

Wypróbuj online!

Zauważ, że ponieważ program Starry nie ma sposobu na określenie, kiedy kończy się wejście o dowolnej długości, program ten używa końcowego znaku nowej linii na wejściu, aby oznaczyć koniec łańcucha. Jeśli pojawi się komunikat o błędzie o tajemniczą i metody niezdefiniowanej ordprzez nil:NilClassto wejście brakuje końcowego znaku nowej linii.

Wyjaśnienie

Podstawową strategią stosowaną przez program jest czytanie znaków jeden po drugim z wejścia, a jeśli nie są one znakiem nowej linii (znak 10), modyfikuje wartość ASCII znaku o 2 i znajduje różnicę między nim a poprzednio odczytanym znakiem. Jeśli różnica wynosi zero, program kończy działanie i drukuje 0(falsey). W przeciwnym razie program zapętla się i wykonuje ten proces od nowa. Jeśli program odczytuje nowy wiersz, kończy się i drukuje 10(prawda).

Program z adnotacjami

 ,               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 bajtów

-4 bajty dzięki @Ton Hospel !

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

Potrzebuje -pflagi. Wyjścia 1 to ciąg parzysty, nic poza tym. Na przykład :

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

Objaśnienia : zastępuje każdy znak wartością mod 2 (więc ciąg zawiera tylko 0 i 1). Następnie wyszukaj dwa następujące 1 lub 0: jeśli znajdzie jakiś, to łańcuch nie jest parzysty, w przeciwnym razie jest.

J, 15 bajtów

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

Stosowanie

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

Wyjaśnienie

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 bajtów

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

Zakłada ciąg wejściowy w buforze i pusty "q. Wysyła binarne bzdury, jeśli jest to prawda, nic, jeśli jest to fałsz.

• s<C-R>=char2nr(@")%2<CR>: Zamienia znak na 1, jeśli nieparzysty, 0, jeśli parzysty. Makro to właśnie robi to dla każdego znaku w linii (bez względu na to, jak długo to trwa).
• :g/00\|11/d<CR>: Usuwa linię, jeśli 2 kolejne „bity” mają tę samą wartość. Szybciej niż referencje.

Zwykle w vimgolf, kiedy używasz funkcji wyrażenia wewnątrz makra, powinieneś zrobić to samo w rejestrze wyrażeń i użyć pewnych sztuczek, aby uzupełnić tabulatorami. Tym razem trudniej. Później znajdę sposób, aby to skrócić.

Siatkówka , 39 bajtów

Liczba bajtów zakłada kodowanie ISO 8859-1.

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

Mm`.¶.|^¶$
^0

Wyjścia 1dla prawdy i 0fałszu.

Wypróbuj online! (Pierwszy wiersz włącza pakiet testowy oddzielony od linii).

Wyjaśnienie

Zainspirowany odpowiedzią mbomb007 opracowałem ostatnio dość krótką ord()implementację w Retinie. Jest to w dużej mierze oparte na tym, chociaż udało mi się wprowadzić kilka uproszczeń, ponieważ nie potrzebuję wyniku dziesiętnego, ponieważ muszę tylko obsługiwać ASCII do wydruku (i zależy mi tylko na parzystości wyniku, więc kończę na dowolne przesunięcie również jest w porządku).

Etap 1: Podział

S_`

To po prostu dzieli dane wejściowe na poszczególne znaki, dzieląc je wokół pustego dopasowania i upuszczając puste wyniki na początku i na końcu _.

Etap 2: Wymień

%{2`
$`

%{Mówi Retina a) że etap ten i następny powinien być prowadzony w pętli aż łańcuch zatrzyma się zmienia przez pełną iteracji, i że te dwa etapy powinny być stosowane do każdej linii (każdy znak) na wejściu oddzielnie.

Sam etap jest standardową techniką powielania pierwszego znaku danych wejściowych. Dopasowujemy pusty ciąg (ale patrzymy tylko na pierwsze dwa dopasowania) i wstawiamy prefiks tego dopasowania. Prefiks pierwszego dopasowania (na początku łańcucha) jest pusty, więc nic to nie robi, a prefiks drugiego dopasowania jest pierwszym znakiem, który jest zatem duplikowany.

Etap 3: Transliteracja

}T01`p`_o

}wskazuje koniec pętli. Sama scena jest transliteracją. 01wskazuje, że należy go zastosować tylko do pierwszego znaku ciągu. pjest skrótem dla wszystkich drukowalnych znaków ASCII i _oznacza „usuń”. Jeśli więc to rozwiniemy, transliteracja wykona następującą transformację:

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

Spacje są usuwane, a wszystkie inne znaki są zmniejszane. Oznacza to, że te dwa etapy razem utworzą zakres postaci od spacji do danej postaci (ponieważ będą wielokrotnie duplikować i zmniejszać pierwszy znak, aż stanie się spacją, w której to miejsce anuluje się powielanie i usuwanie).

Długość tego zakresu można wykorzystać do ustalenia parzystości znaku.

Etap 4: Zamień

..

Po prostu upuszczamy wszystkie pary znaków. Czyści to linie o parzystej długości i redukuje linie o nieparzystej długości do jednego znaku (tak naprawdę znak wejściowy, ale to nie ma znaczenia).

Etap 5: mecz

Mm`.¶.|^¶$

Łatwiej jest znaleźć dane wejściowe, które nie są nawet równe, dlatego liczymy liczbę dopasowań dwóch kolejnych pustych linii lub dwóch kolejnych niepustych linii. Powinniśmy dostać 0za parzyste dane wejściowe, a w przeciwnym razie coś niezerowego.

Etap 6: Mecz

^0

Pozostało tylko odwrócić wynik, co robimy, licząc liczbę dopasowań tego wyrażenia regularnego, co sprawdza, czy dane wejściowe zaczynają się od 0. Jest to możliwe tylko wtedy, gdy wynik pierwszego etapu był 0.

Clojure, 59 bajtów

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

Generuje wszystkie sekwencyjne pary z łańcucha ni sprawdza, czy suma każdej pary jest nieparzysta. Jeśli sekwencja ints jest uważana za rozsądny format, to ma 50 bajtów.

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

Zobacz online: https://ideone.com/USeSnk

Julia, 55 53 bajtów

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

Wyjaśnił

Odwzoruj znaki na 0 | 1 i sprawdź, czy wynikowy ciąg zawiera „00” lub „11”, co powoduje, że ciąg nie jest na przemian.

Python, 52 bajty

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

Funkcja rekurencyjna. Daje 1 (lub True) dla parzystych ciągów, 0 dla nieparzystych. Mnoży parzystość różnicy pierwszych dwóch znaków przez wartość rekurencyjną reszty. Ciąg znaków składający się z jednego znaku daje wartość True, co jest sprawdzane przez to, że równa się jej pierwszy znak. Zakłada się, że dane wejściowe nie są puste; w przeciwnym razie potrzebny jest jeszcze jeden bajt dla s==s[:1]lub len(s)<2.

Python 2, 52 bajty

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

Alternatywnie, iteracyjne rozwiązanie. Iteruje nad znakami wejściowymi, przechowując bieżące i poprzednie wartości znaków mod 2. Mnoży działający produkt przez różnicę, która ponieważ 0 (Falsey) tylko wtedy, gdy dwa kolejne parzystości są równe.

Wartość „poprzednia” jest inicjowana na 2 (lub dowolną wartość inną niż 0 lub 1), dzięki czemu pierwszy znak nigdy nie pasuje do parzystości z fikcyjnym poprzednim znakiem.

Python, 42 bajty, generowany przez kod wyjścia

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

Dane wyjściowe za pośrednictwem kodu wyjścia. Kończy się z ZeroDivisionError, gdy dwa kolejne znaki mają te same parzystości, w przeciwnym razie kończy się czysto.

Haskell, 42 40 bajtów

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

Przykład użycia: all odd.(zipWith(-)=<<tail).map fromEnum $ "long"-> True.

Jak to działa:

               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

Edycja: @xnor zapisał dwa bajty. Dzięki!

Mathematica, 41 40 bajtów

And@@OddQ@Differences@ToCharacterCode@#&

-1 postać, dzięki Martinowi Enderowi

C, 52 bajty

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

Porównuje parzystość pierwszych 2 znaków, rekurencyjnie poruszając się po łańcuchu, aż znajdzie 2 znaki o tej samej parzystości lub łańcuch o długości 1 ( s[1] == 0).

Kod z niektórymi przypadkami testowymi

Pyke, 8 bajtów

m.o$2m%B

Wypróbuj tutaj!

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

C #, 69 bajtów

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

Pełny program z przypadkami testowymi:

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 bajtów

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

rozwiązanie z Regex 81 Bytes

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

PowerShell v2 +, 47 bajtów

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

(Nie można dość złapać zwykle konkurentów PowerShell za ...)

Zajmuje wejście $args[0]jako ciąg, rzuca go jako char-array, pętle przez niego |%{...}, każda iteracja umieszczenie modulo na rurociągu (z niejawna [char]do [int]konwersji). Są one kapsułkowane w pareny i przetwarzane -joinw ciąg znaków, który jest podawany do lewej strony -notmatchoperatora, sprawdzając względem 00lub 11(tj. Zwraca w Truekierunku 0s i1 e alternatywna). Ten wynik logiczny jest pozostawiany w potoku, a dane wyjściowe są niejawne.

Przypadki testowe

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 bajtów

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

Zwraca 1, jeśli słowo jest parzyste, 0, jeśli słowo jest nieparzyste.

Możesz spróbować online .

Edycja: zapisane dwa bajty dzięki Martinowi Enderowi

Perl 6 ,  47  26 bajtów

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

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

Rozszerzony:

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

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

Jestem pewien, że można to poprawić.