Eine 'gerade Zeichenfolge' ist eine beliebige Zeichenfolge, bei der sich die Parität der ASCII-Werte der Zeichen immer abwechselt. Die Zeichenfolge EvenSt-ring$!ist beispielsweise eine gerade Zeichenfolge, da die ASCII-Werte der Zeichen wie folgt lauten:

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

Und die Paritäten dieser Zahlen sind:

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

Welches wechselt den ganzen Weg. Ein String wie Hello world!ist jedoch kein gerader String, da die ASCII-Werte wie folgt lauten:

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

Und die Paritäten sind:

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

Was sich natürlich nicht immer abwechselt.

Die Herausforderung

Sie müssen entweder ein vollständiges Programm oder eine Funktion schreiben, die eine Zeichenfolge zur Eingabe akzeptiert und einen Wahrheitswert ausgibt , wenn die Zeichenfolge gerade ist, und ansonsten einen falschen Wert. Sie können Ihre Eingaben und Ausgaben in jedem vernünftigen Format vornehmen und davon ausgehen, dass die Eingabe nur druckbares ASCII (Bereich 32-127) enthält. Sie müssen keine leeren Eingaben verarbeiten.

Beispiele

Hier sind einige Beispiele für gerade Zeichenfolgen:

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

Und all diese Beispiele sind nicht einmal Strings:

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

Sie können diese Lösung auch zum Testen von Zeichenfolgen verwenden, wenn Sie auf einen bestimmten Testfall neugierig sind.

MATL , 4 3 Bytes

Vielen Dank an Emigna für das Speichern eines Bytes und an Luis Mendo für das Beheben einiger Fehler. Code:

doA

Erläuterung:

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

Probieren Sie es online!

05AB1E , 5 4 Bytes

Dank Adnan 1 Byte gespeichert .

Ç¥ÉP

Probieren Sie es online!

Erläuterung

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

Jelly , 7 5 4 Bytes

OIḂẠ

2 Bytes mit der Delta-Idee von @ Steven H. gespeichert

1 Byte dank @ Lynn gespeichert .

Probieren Sie es online! oder Überprüfen Sie alle Testfälle.

Erläuterung

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

Python 2, 54 Bytes

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

Mathematica, 50 44 Bytes

Die aktuelle Version ist im Grunde genommen die ganze Virtuosität von Martin Ender.

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

Rückgabe Trueoder False. Nichts allzu Schlaues: Nimmt die Mod-2-Summe jedes Paares aufeinanderfolgender ASCII-Codes und prüft, ob niemals eine 0 erhalten wird.

Alte Version:

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

JavaScript (ES6), 60 50 46 Bytes

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

Ich habe es mit Rekursion versucht, aber bei 51 Bytes scheint es sich nicht wirklich zu lohnen:

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

Testschnipsel

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 Bytes

Vielen Dank an @Riley für die Hilfe beim Golfen.

Dieses Programm behandelt leere Eingaben als ungeraden String.

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

Probieren Sie es online!

Erklärung (veraltet)

Verschiebt die Eingabe vom linken Stapel nach rechts, während Sie um 2 modifizieren. Ermittelt den Unterschied zwischen den benachbarten Zeichen, bis alle überprüft wurden oder einer der Unterschiede gleich Null ist (was nur in einer ungeraden Zeichenfolge auftreten würde). Wenn die Schleife aufgrund einer ungeraden Zeichenfolge beendet wurde, wechseln Sie zurück zum linken Stapel, und geben Sie den verbleibenden Wert ein. Andernfalls bleiben Sie auf dem rechten Stapel und platzieren die Null über der 1 auf dem Stapel.

R 41 35 Bytes

BEARBEITEN: Sparte dank @JDL ein paar Bytes mit diffanstelle von rle.

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

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

Erläuterung

1. readline() Eingabe lesen.
2. utf8ToInt()%%2 In ASCII-Werte und Mod 2 konvertieren (als R-Vektor speichern)
3. all(rle()==1)Lauflängencodierung von zu findenden Läufen. Alle Läufe sollten gleich oder kleiner als 2 sein, da keine Läufe negativ oder 0 sein können (spart ein Byte statt ==).

Pyth ( Gabel ), 9 Bytes

.A%R2.+CM

Kein Try It Online-Link, da die Gabel keine eigene Version in den Online-Dolmetschern hat.

Erläuterung:

       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 Bytes

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

Probieren Sie es online!

Erläuterung

@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 Bytes

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

-4 Bytes dank @Geobits .

Erläuterung:

Probieren Sie es online aus.

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

Beinhaltet +3 für -a

30 Bytes gespart dank 1000000000

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

Ausgabe:
wahr : 1
falsch : 0 oben auf dem Stapel

Probieren Sie es online! (ehrlich)
Probieren Sie es online! (falsch)

Bessere Erklärung kommt später (wenn ich mich erinnern kann, wie es nach ein paar Stunden funktioniert ...)

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

Sternenklar , 85 Bytes

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

Probieren Sie es online!

Da ein Starry-Programm nicht erkennen kann, wann eine Eingabe beliebiger Länge endet, markiert dieses Programm das Ende der Zeichenfolge mit einem nachgestellten Zeilenumbruch in der Eingabe. Wenn Sie eine kryptische Fehlermeldung und nicht definierte Methode erhalten ordfür nil:NilClassdann wird die Eingabe eines Newline fehlt.

Erläuterung

Die grundlegende Strategie, die das Programm anwendet, besteht darin, die Zeichen einzeln von der Eingabe zu lesen. Wenn es sich nicht um eine neue Zeile handelt (Zeichen 10), ändert es den ASCII-Wert des Zeichens um 2 und findet den Unterschied zwischen diesem und dem zuvor gelesenen Zeichen. Wenn die Differenz Null ist, wird das Programm beendet und gedruckt 0(falsey). Andernfalls springt das Programm zurück und führt den Vorgang erneut durch. Wenn das Programm eine neue Zeile liest, bricht es ab und druckt 10(wahrheitsgemäß).

Kommentiertes Programm

 ,               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 Bytes

-4 Bytes dank @Ton Hospel !

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

Benötigt -pFlagge. Outputs 1 ist der String ist gerade, sonst nichts. Zum Beispiel :

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

Erklärungen : Ersetzt jedes Zeichen durch seinen Wert mod 2 (der String enthält danach nur noch 0s und 1s). Dann suchen Sie nach zwei folgenden 1 oder 0: Wenn es einige findet, dann ist die Zeichenfolge nicht gerade, sonst ist es.

J, 15 Bytes

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

Verwendung

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

Erläuterung

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 Bytes

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

Nimmt an, dass die Eingabezeichenfolge im Puffer und leer ist "q. Gibt binären Unsinn aus, wenn wahr, nichts, wenn falsch.

• s<C-R>=char2nr(@")%2<CR>: Ersetzt ein Zeichen durch 1, wenn ungerade, 0, wenn gerade. Das Makro, in dem dies ist, bewirkt dies für jedes Zeichen in der Zeile (egal wie lang es ist).
• :g/00\|11/d<CR>: Löscht die Zeile, wenn 2 aufeinanderfolgende "Bits" den gleichen Wert haben. Schneller als ein Rückverweis.

Wenn Sie in Vimgolf eine Ausdrucksfunktion innerhalb eines Makros verwenden, sollten Sie das Makro normalerweise selbst im Ausdrucksregister ausführen und einige Tricks verwenden, um die Tabulatoren zu vervollständigen. Diesmal ist es schwieriger. Vielleicht finde ich später einen Weg, das zu verkürzen.

Retina , 39 Bytes

Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus.

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

Mm`.¶.|^¶$
^0

Ausgänge 1für wahr und 0für falsch.

Probieren Sie es online! (Die erste Zeile aktiviert eine durch Zeilenvorschub getrennte Testsuite.)

Erläuterung

Inspiriert von einer Antwort von mbomb007 habe ich kürzlich eine relativ kurze ord()Implementierung in Retina entwickelt. Dies basiert größtenteils darauf, obwohl ich einige Vereinfachungen vornehmen konnte, da ich kein Dezimalergebnis benötige, da ich nur druckbares ASCII unterstützen muss (und mich nur um die Parität des Ergebnisses kümmere, was letztendlich dazu führt, dass ein beliebiger Versatz ist auch in Ordnung).

Stufe 1: Split

S_`

Dies teilt die Eingabe einfach in ihre einzelnen Zeichen auf, indem es um die leere Übereinstimmung herum aufgeteilt wird und die leeren Ergebnisse am Anfang und Ende mit gelöscht werden _.

Stufe 2: Ersetzen

%{2`
$`

Das %{teilt Retina a) mit, dass diese und die nächste Stufe in einer Schleife ausgeführt werden sollen, bis sich die Zeichenfolge durch eine vollständige Iteration nicht mehr ändert, und dass diese beiden Stufen für jede Zeile (dh für jedes Zeichen) der Eingabe separat angewendet werden sollen.

Die Bühne selbst ist die Standardtechnik zum Duplizieren des ersten Zeichens der Eingabe. Wir passen die leere Zeichenfolge an (sehen uns aber nur die ersten beiden Übereinstimmungen an) und fügen das Präfix dieser Übereinstimmung ein. Das Präfix der ersten Übereinstimmung (am Anfang der Zeichenfolge) ist leer, dies macht also nichts, und das Präfix der zweiten Übereinstimmung ist das erste Zeichen, das daher dupliziert wird.

Stufe 3: Transliterieren

}T01`p`_o

}zeigt das Ende der Schleife an. Die Bühne selbst ist eine Transliteration. 01Gibt an, dass es nur auf das erste Zeichen der Zeichenfolge angewendet werden soll. pist eine Abkürzung für alle druckbaren ASCII-Zeichen und _bedeutet "Löschen". Wenn wir dies erweitern, führt die Transliteration die folgende Transformation durch:

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

Leerzeichen werden gelöscht und alle anderen Zeichen werden dekrementiert. Das bedeutet, dass diese beiden Stufen zusammen einen Zeichenbereich vom Leerzeichen bis zum angegebenen Zeichen erzeugen (da sie das erste Zeichen wiederholt duplizieren und dekrementieren, bis es ein Leerzeichen wird, an dem das Duplizieren und Löschen abgebrochen wird).

Die Länge dieses Bereichs kann verwendet werden, um die Parität des Zeichens zu bestimmen.

Stufe 4: Ersetzen

..

Wir lassen einfach alle Zeichenpaare fallen. Dies löscht Zeilen mit gerader Länge und reduziert Zeilen mit ungerader Länge auf ein einzelnes Zeichen (das Eingabezeichen, aber das ist eigentlich egal).

Stufe 5: Match

Mm`.¶.|^¶$

Es ist einfacher, Eingaben zu finden, die ungerade sind , daher zählen wir die Anzahl der Übereinstimmungen von entweder zwei aufeinanderfolgenden leeren Zeilen oder zwei aufeinanderfolgenden nicht leeren Zeilen. Wir sollten 0für gerade Eingaben und sonst etwas ungleich Null bekommen.

Stufe 6: Match

^0

Jetzt müssen wir nur noch das Ergebnis invertieren, indem wir die Anzahl der Übereinstimmungen dieses regulären Ausdrucks zählen, wodurch überprüft wird, ob die Eingabe mit a beginnt 0. Dies ist nur möglich, wenn das Ergebnis der ersten Stufe war 0.

Clojure, 59 Bytes

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

Erzeugt alle sequentiellen Paare aus einem String nund prüft, ob jede Paarsumme ungerade ist. Wenn eine Folge von Ints als vernünftiges Format angesehen wird, sind es 50 Bytes.

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

Sehen Sie es online: https://ideone.com/USeSnk

Julia, 55 53 Bytes

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

Erklärt

Ordnen Sie Zeichen 0 | 1 zu und prüfen Sie, ob die resultierende Zeichenfolge "00" oder "11" enthält, wodurch die Zeichenfolge nicht abwechselt.

Python, 52 Bytes

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

Eine rekursive Funktion. Erzeugt 1 (oder True) für gerade Zeichenfolgen, 0 für ungerade Zeichenfolgen. Multipliziert die Parität der Differenz der ersten beiden Zeichen mit dem rekursiven Wert im Rest. Eine Zeichenfolge mit nur einem Zeichen gibt True an, wenn dies mit dem ersten Zeichen gleichgesetzt wird. Dies setzt voraus, dass die Eingabe nicht leer ist. Andernfalls wird ein weiteres Byte für s==s[:1]oder benötigt len(s)<2.

Python 2, 52 Bytes

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

Alternativ eine iterative Lösung. Iteriert über die eingegebenen Zeichen und speichert die aktuellen und vorherigen Zeichenwerte Mod. 2. Multipliziert das laufende Produkt mit der Differenz, die wegen 0 (Falsch) nur dann besteht, wenn zwei aufeinanderfolgende Paritäten gleich sind.

Der "vorherige" Wert wird mit 2 (oder einem beliebigen Wert ungleich 0 oder 1) initialisiert, so dass das erste Zeichen niemals mit der Parität des fiktiven vorherigen Zeichens übereinstimmt.

Python, 42 Byte, wird über den Exit-Code ausgegeben

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

Ausgänge über Exit-Code. Wird mit einem ZeroDivisionError beendet, wenn zwei aufeinanderfolgende Zeichen die gleichen Paritäten aufweisen, andernfalls wird der Befehl ordnungsgemäß beendet.

Haskell, 42 40 Bytes

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

Anwendungsbeispiel: all odd.(zipWith(-)=<<tail).map fromEnum $ "long"-> True.

Wie es funktioniert:

               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

Edit: @xnor speicherte zwei Bytes. Vielen Dank!

Mathematica, 41-40 Bytes

And@@OddQ@Differences@ToCharacterCode@#&

-1 Charakter, danke an Martin Ender

C, 52 Bytes

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

Vergleicht die Parität der ersten zwei Zeichen und durchläuft die Zeichenfolge rekursiv, bis 2 Zeichen mit der gleichen Parität oder die Zeichenfolge mit der Länge 1 ( s[1] == 0) gefunden werden.

Code mit einigen Testfällen

Pyke, 8 Bytes

m.o$2m%B

Probieren Sie es hier aus!

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

C #, 69 Bytes

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

Volles Programm mit Testfällen:

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 Bytes

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

Lösung mit Regex 81 Bytes

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

PowerShell v2 +, 47 Byte

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

(Kann die üblichen Konkurrenten von PowerShell nicht ganz einfangen ...)

Nimmt Eingaben $args[0]als Zeichenfolge, charwandelt sie als -array um und durchläuft sie |%{...}. Bei jeder Iteration wird das Modulo in der Pipeline platziert (implizit [char]für die [int]Konvertierung). Diese werden in Parens eingekapselt und -joinzu einem String zusammengefasst, der in die linke Hand des -notmatchOperators eingespeist wird und gegen 00oder prüft 11(dh, Truewenn 0s und 1s alternieren). Dieses boolesche Ergebnis verbleibt in der Pipeline und die Ausgabe ist implizit.

Testfälle

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 Bytes

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

Gibt 1 aus, wenn das Wort gerade ist, 0, wenn das Wort ungerade ist.

Sie können es online ausprobieren .

Edit: Zwei Bytes dank Martin Ender gespeichert

Perl 6 ,  47  26 Bytes

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

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

Erweitert:

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

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

Ich bin sicher, dass dies verbessert werden kann.