Kürzlich gab es ein paar ASCII Pet Snake Challenges (zB hier )

            0 0               
  0        0 0 000            
00 0     00       000 0      0
    000 0            0 0   00 
       0                000   

Diese Herausforderung besteht darin, eine zufällig erzeugte horizontale Haustierschlange (Höhe von fünf Linien, Länge von 30) zu nehmen und zu überprüfen, dass:

• Jede Spalte hat nur eine 0
• Jedes 0ist mit dem 0Vorher und Nachher "verbunden" (vertikal nur durch 0 oder 1 Zeile getrennt)

Die fertige Ausgabe kann trueoder 1wenn die Schlange gültig ist, oder falseoder , 0wenn die Schlange ist ungültig

Bearbeiten - Erläuterung

Angenommen, die Eingabe:

• Ist eine Zeichenfolge
• Enthält nur '', '0' und '\ n'
• Hat genau 30 Zeichen pro Zeile
• Hat genau 5 Zeilen

Dh vergewissern Sie sich, dass die Schlange verbunden ist und keine streunenden Zeichen vorhanden sind. Die "Leinwand", auf der die Schlange gedruckt ist, muss nicht validiert werden.

JavaScript (ES2018), 62 54 Bytes

s=>!/0(.{30}|.{60,62}(.{31})*)0|( .{30}){4} /s.test(s)

Die Eingabe ist eine einzelne Zeichenfolge:

• ohne neue Zeile zu folgen
• Enthält nur Leerzeichen, '0' und '\ n'
• 30 Zeichen pro Zeile, 5 Zeilen, insgesamt 154 Zeichen

Flag sbedeutet eine Punktübereinstimmung (einschließlich '\ n'). Diese Funktion wird derzeit von Chrome 63+, Opera 50+, Safari 11.1+ unterstützt und basiert auf der Kompatibilitätstabelle . Sie können diese Funktion mit diesem unterstützten Browser testen. Sie erhalten eine Ausnahme beim Laden der Seite, wenn Ihr Browser diese Funktion nicht unterstützt.

Wie es funktioniert:

• Keine Spalte mit nein 0:
  • nicht übereinstimmen /( .{30}){4} /
• Keine zwei 0s in einer Spalte:
  • nicht übereinstimmen /0.{30}(.{31})*0/
• Nein, 0nicht mit seinen Nachbarn verbinden:
  • passen nicht zusammen /0.{60}(.{31})*0/,/0.{62}(.{31})*0/

Füge all diese regulären Ausdrücke zusammen und du erhältst endlich diese.

f =

s=>!/0(.{30}|.{60,62}(.{31})*)0|( .{30}){4} /s.test(s)

<textarea id=i style="width:100%;height:100px">            0 0               
  0        0 0 000            
00 0     00       000 0      0
    000 0            0 0   00 
       0                000   </textarea>
<button onclick="o.value=f(i.value.slice(0,154))">Validate</button>
Result: <output id=o></output>

Dank Martin Enders darauf hinweisen, dass ein einzelner !Operator 8 Bytes einsparen kann.

SnakeEx , 51 Bytes

Dies ist natürlich die richtige Sprache für die Aufgabe. : ^ D

s:({c<L>}{c<R>}0[(<R> <L>)(<L> <R>)_?])%{30}
c:0 *$

Entspricht der gesamten Eingabe, wenn es sich um eine gültige Schlange handelt. stimmt nicht überein, wenn dies nicht der Fall ist. Probieren Sie es hier aus!

Erläuterung

SnakeEx ist eine 2-D-Pattern-Matching-Sprache . Ein Programm besteht aus einer Liste von Definitionen für "Schlangen", die die eingegebenen übereinstimmenden Zeichen durchsuchen, die Richtung ändern und andere Schlangen erzeugen. In unserem Programm definieren wir zwei Schlangen sund c.

Wir fangen damit an, cweil es einfacher ist. Die Definition ist 0 *$, was gut lesbar sein sollte, wenn Sie Regex kennen: match 0, gefolgt von null oder mehr Leerzeichen, gefolgt von der Kante des Gitters. Das Wichtigste dabei: Dieses Matching kann in jede Richtung gehen. Wir werden csowohl aufwärts als auch abwärts von der Schlange aus verwenden, um zu überprüfen, ob 0in jeder Spalte keine zusätzlichen s enthalten sind.

Nun zur Hauptschlange s. Es hat die Form (...)%{30}, was bedeutet, dass "der Inhalt der Klammern 30-mal übereinstimmt" - einmal für jeden 0in der Schlange. So weit, ist es gut. Was steht in Klammern?

{c<L>}

Dies bringt eine neue cSchlange hervor, die um 90 Grad nach links gedreht wurde. Die Richtung ist relativ zur Richtung der sSchlange, sodass sich die neue Schlange nach oben im Gitter bewegt (die Hauptschlange bewegt sich nach rechts). Die cSchlange überprüft, ob die aktuelle Gitterzelle eine ist 0und ob jede Zelle darüber ein Leerzeichen ist. Wenn dies fehlschlägt, schlägt die gesamte Übereinstimmung fehl. Wenn es gelingt, machen wir weiter

{c<R>}

was dasselbe tut, nur nach rechts gedreht (zum unteren Rand des Gitters).

Beachten Sie, dass diese Spawns die Position des Matchzeigers in der Hauptschlange nicht beeinflussen. Sie sind ein bisschen wie Lookaheads in Regex. (Vielleicht können wir sie hier als "Lookbesides" bezeichnen?) Nachdem wir überprüft haben, dass wir auf a zeigen 0und der Rest der Spalte nur Leerzeichen enthält, müssen wir tatsächlich die 0folgenden Kriterien erfüllen :

0

Jetzt befindet sich der Übereinstimmungszeiger auf dem Zeichen rechts von der 0. Wir müssen drei verschiedene Optionen ankreuzen: die Schlangenwinkel nach unten, die Schlangenwinkel nach oben oder die Schlange geht geradeaus. Hierfür können wir einen OR-Ausdruck verwenden:

[...]

In unserem OP haben wir drei Möglichkeiten:

(<R> <L>)

Drehe dich nach rechts, finde ein Feld und drehe dich erneut nach links (Schlangenwinkel nach unten).

(<L> <R>)

Drehe dich nach links, finde ein Feld und drehe dich erneut nach rechts (Schlangenwinkel nach oben).

_?

Stimmen Sie mit 0 oder 1 Unterstrichen überein. Da die Eingabe keine Unterstriche enthält, handelt es sich immer um eine leere Übereinstimmung (Snake geht geradeaus).

Nachdem Sie eine der drei oben genannten Optionen ausgewählt haben, sollte der Übereinstimmungszeiger 0auf die nächste Spalte zeigen, damit der Ausdruck in Klammern erneut übereinstimmt.

CJam , 35 34 Bytes

{z_{'0e=1=}%:*\'0f#2ew::-[W0X]-!*}

Probieren Sie es online! Die Eingabe ist eine rechteckige Anordnung von Zeichenanordnungen. Nimmt an, dass die Eingabe nur und enthält 0.

Erläuterung:

{z_{'0e=1=}%:*\'0f#2ew::-[W0X]-!*}   Function taking a character matrix:
 z                                      Transpose.
   {      }%                            Consider whether each row
      e=                                  contains
        1=                                exactly one
    '0                                    of the character '0'.
            :*                            This must be true for every row.
                  #                     Next, find the position
               '0                         of the character '0'
                 f                        at every row
  _           \                           in the original input.
                       :-               Find the differences between
                      :                   each
                   2                      pair
                    ew                    of adjacent elements (in other words, compute
                                            the increments).
                                        For the snake to be valid, this array of increments
                                            must only contain {0, 1, -1}, so
                              -         Remove from this list
                         [   ]            the elements
                          W                 -1,
                           0                0,
                            X               and 1,
                               !          and then check whether the array is empty.
                                *       The previous code tested two different properties
                                          of the matrix; they both must be true for a
                                          valid snake.

05AB1E , 18 Bytes

ζDε0k}¥Ä2‹sεþg}ìPΘ

Probieren Sie es online!

Erläuterung

ζ                    # transpose
 D                   # duplicate
  ε  }               # for each row in the first copy (column of input)
   0k                # get the index of the first 0
      ¥Ä             # calculate absolute delta's
        2‹           # check that each is less than 2
          sε  }      # for each row in the second copy (column of input)
            þg       # calculate the length of the string with non-digits removed
               ì     # concatenate the lists
                P    # calculate product
                 Θ   # truthify (turn false values to 0)

Schale , 12 Bytes

Je nach Regelklärung können dies 11 Bytes oder 13 Bytes sein .

±Λ=;1Ẋ×≈mηfT

Probieren Sie es online!

Die Eingabe ist eine Liste von Zeilen, die nur Leerzeichen und Nullen enthalten. Wenn eine einzelne Zeichenfolge erforderlich ist, stellen Sie ¶diese dem Programm voran , um sie in Zeilen aufzuteilen. Die TIO-Verbindung tut dies aus Gründen der Übersichtlichkeit bereits. Ausgang ist 0 oder 1; Wenn falsche und wahrheitsgemäße Werte in Ordnung sind, ±können diese entfernt werden.

Erläuterung

±Λ=;1Ẋ×≈mηfT  Implicit input: a list of lines.
           T  Transpose into list of columns.
        m     For each column,
         ηf   get list of indices of truthy elements.
              In Husk, whitespace characters are falsy and other are truthy,
              so this gets us the indices of 0s on each column.
     Ẋ        For each adjacent pair of these index lists,
      ×       for all pairs drawn from the two lists,
       ≈      give 1 if they differ by at most 1, otherwise 0.
              For each adjacent pair, this produces a list of 1s and 0s.
 Λ            Do all of these lists
  =;1         equal [1]? Return either 0 or 30 (length of the outer list + 1).
±             Signum; convert to 0 or 1.

Damit soll ×≈sichergestellt werden, dass (a) alle Spalten genau eine 0 enthalten und (b) sich ihre Positionen um höchstens eine unterscheiden. Betrachten Sie als Beispiel die 8-Spalten-Eingabe

0  0  0 
 000 0  
  00   0

Zuerst mηfTwandelt sie in die Liste der Indexlisten

[[1],[2],[2,3],[1,2,3],[],[2],[1],[3]]

Dann Ẋ×≈gibt

[[1],[1,1],[1,1,0,1,1,1],[],[],[1],[0]]

Jedes 1entspricht einem Paar von Indizes, die sich um höchstens 1 unterscheiden, und jedes 0entspricht einem Paar, das dies nicht tut. Jedes Ergebnis ist [1]genau gleich , wenn beide Listen einen Index haben und sich die Indizes um höchstens 1 unterscheiden.

Python 2 , 71 Bytes

f=lambda s:s[1]<' 'or'0'in s[::31]in' %s '%s[1::31]in'%6s'%0*2*f(s[1:])

Probieren Sie es online!

Übernimmt die Eingabe als mehrzeilige Zeichenfolge. Testet Koffer von Bubbler .

Die erste Spalte wird als s[::31]und die zweite als extrahiert und s[1::31]auf Gültigkeit geprüft. Wir wiederholen das sEntfernen des ersten Zeichens, wodurch aufeinanderfolgende Spaltenpaare überprüft werden.

Die Prüfung für zwei Spalten verwendet Pythons Vergleichsverkettung, inum mehrere Prüfungen zu kombinieren:

• '0'in s[::31] Überprüft, ob die erste Spalte mindestens eine enthält 0
• s[::31]in' %s '%s[1::31]prüft, ob die erste Spalte eine Teilzeichenfolge der zweiten Spalte ist, die sich zwischen zwei Leerzeichen befindet, wodurch sichergestellt wird, dass sich die Position von 0höchstens um ein Leerzeichen verschoben hat
• ' %s '%s[1::31]in'%6s'%0*2prüft, ob die zweite Spalte höchstens eine enthält 0.

Das Ende *f(s[1:])zwingt auch den rekursiven Fall, wahr zu sein.

C (gcc) ,246 245 232 215 212 Bytes

#define F)exit(1);
#define L for(i=l=0;i<30;i++)
#define X b[7][i]
char b[8][31];k,j,l;main(i){for(;j++<5;){gets(b);L{if(i[*b]>47){if(X++F memset(b[j+1]+i-1,l=1,3);}else if(!X&b[j][i]F}k+=!!l;}if(k<5 F L if(!X F}

Probieren Sie es online!

Dachte mir, ich würde meine Lieblingssprache dazu nehmen (auch wenn ich aus den vielen anderen, kleineren Einträgen ersehen kann, dass es für diese Art von Herausforderung wahrscheinlich alles andere als ideal ist) und C, was ich schaffen könnte. Die Herangehensweise des Programms an das Problem ist relativ unkompliziert, nur mit viel Byte-Penny-Pinching. es nimmt die Schlange auf stdin und gibt ihr Ergebnis in den Rückgabewert von main (also den Exit-Code;Wie im Problem angefordert, bedeutet 0 eine ungültige Schlange und 1 eine gültige, auch wenn der Exit-Code seltsam istwie für Exit-Codes typisch 0 ist eine gültige Schlange und 1 ist eine ungültige Schlange). Mit den erweiterten Makros und ein paar schönen Leerzeichen sieht es ungefähr so ​​aus:

char b[8][31];l,j,k;                           //Declares a buffer to work in, initialized all to 0; l j and k default to int and as globals are init to 0
main(i) {                                      //This is run no-args, so argc is 1 and the undeclared type defaults to int.
  for (; j++ < 5;) {                           //Iterating over each row, 1-indexed for convenience accessing the buffer
    gets(b);                                   //Reads into b[0] because of stack array decl layout
    for (i = l = 0; i < 30; i++) {             //j and l both init each time we begin this overall loop
      if (i[*b] > 47) {                        //Did we read a zero?
        if(b[7][i]++) exit(1);                 //If the snake already had a zero in this column, fail out
        memset(b[j+1] + i-1, l = 1, 3);        //Expect them on the next row in the columns left and right of this one (also set l)
      } else if (!b[7][i] & b[j][i]) exit(1);  //If we didn't read a zero, and we had reason to expect one this row, and there wasn't already a zero in this column, fail out
    }
    k+=!!l;                                    //Adds 1 to k iff l is nonzero 
  } if (k < 5) exit(1);                        //If less than 5 rows had zeroes in them, fail out
  for(i = l = 0 ; i < 30; i++) {               //l isn't relevant in this loop but saves some bytes when sharing a macro with the other horizontal loop
    if(!b[7][i]) exit(1);                      //If any columns didn't have zeroes, fail out
  }                                            //Else, snake is valid. main default returns 0.
}

Eingabezeilen werden in die erste Zeile des Puffers eingelesen, die nächsten fünf dienen zum Verfolgen, an welchen Stellen nach jeder aktuellen Null Nullen erwartet werden (read: must), und die letzte dient zum Verfolgen, ob bereits eine Null vorhanden ist wurde in einer bestimmten Spalte in einer beliebigen Zeile gelesen. Das Programm verarbeitet nacheinander jede Zeile.

Es ist überhaupt nicht robust ( gets()ist nur der Anfang) und die Eingabe muss alle relevanten Leerzeichen enthalten (z. B. kein abschließendes Leerzeichen), und gcc gibt Warnungen und Hinweise zur implizit deklarierten stdlib-Funktionalität aus und so weiter, aber C das Leben.

Es wird auch vorausgesetzt, dass sich der Schlangenkopf nicht in der mittleren Reihe befinden muss und dass eine gültige Schlange mindestens eine Null in jeder Reihe haben muss (dh keine Reihen aller Leerzeichen in den 5 Eingangsreihen). Wenn letzteres keine Anforderung ist, kann es etwas kürzer gemacht werden - alles, was mit kund lim Programm zu tun hat , kann in diesem Fall durch weniger Code-Bytes ersetzt werden.

Dank an user202729 für ca. 26 Bytes gespeichert.

MATL , 18 17 Bytes

32>&fun30=wd|2<vA

Die Eingabe ist ein 2D-Zeichen-Array. Für die Schlange kann jedes beliebige Nicht-Leerzeichen verwendet werden.

Probieren Sie es online!

Erläuterung

32>      % Implicit input. Transform non-space into 1, space into 0
&f       % Push vector of row indices and vector of column indices of nonzeros
u        % Unique: vector of deduplicated entries
n        % Length
30=      % Does it equal 30? (*)
w        % Swap. Moves vector of row indices to top
d|       % Absolute consecutive differences
2<       % Is each value less than 2? (**)
v        % Concatenate results (*) and (**) vertically
A        % All: true if all entries are nonzero. Implicit display

Beleg , 28 Bytes

((\|/)?0(<(?| *$^)<){2}){30}

Teste es hier.

Jelly , 19 Bytes

Zn⁶T€L€=1$$;FIỊ$$$Ạ

Probieren Sie es online!

-2 Bytes dank Mr. Xcoder

Erläuterung

Zn⁶T€L€=1$$;FIỊ$$$Ạ  Main Link
Z                    Transpose the matrix of characters
                         (string -> list of chars in Jelly)
 n⁶                  != " " (vectorizing)
   T€                For each column, get (row) indices of snake parts
     L€=1$$          For each index list, is its length 1? (that is, exactly one snake part per column)
           ;     $   Append (helper part)
            FIỊ$$    helper part:
            F        flatten index list
             I       get increments/forward differences
              Ị      are the values insignificant? (|z| <= 1)
                  Ạ  Are these all true?

Die Eingabe erfolgt als Liste von Zeichenfolgen

Jelly , (14? *) 13 Bytes

Zn⁶T€z-IỊ0-¦Ȧ

Eine monadische Verknüpfung, die eine Liste mit fünf Zeichenfolgen * mit einer Länge von jeweils 30 aus Leerzeichen und anderen Zeichen (z. B. 0s) erstellt und eine Ganzzahl zurückgibt (1, wenn eine Schlange definiert ist, 0, sonst).

* Wenn die Eingabe eine einzelne Zeichenfolge (Liste von Zeichen) sein muss, stellen Sie a voran Ỵ, um die Zeichenfolge bei Zeilenvorschüben zu teilen.

Probieren Sie es online!

Wie?

Zn⁶T€z-IỊ0-¦Ȧ - Link: list of lists of characters, Lines
Z             - transpose the lines -> columns
  ⁶           - literal space character
 n            - not equal? -> 0 where there were spaces and 1 where there were "0"s
   T€         - truthy indices for each -> e.g. [0,0,1,0,0] -> [3] or [0,1,1,0,0] -> [2,3]
              -                           note: [0,0,0,0,0] -> []
      -       - literal minus one
     z        - transpose with filler (-1) -> {valid: a single list of heights {top:1,...,bottom:5}
              -                              invalid: list of >1 lists, some of which contain -1
              -                                       ...OR an empty list (no 0s in the input at all)}
       I      - differences -> {up:-1; down:1; flat:0; invalid:-6,-5,...,-2,2,...4}
        Ị     - insignificant (abs(z)<=1) -? {up/down/flat:1; invalid:0}
           ¦  - sparse application///
         0    - ...action: literal zero
          -   - ...to indices: [-1] -> make penultimate list into a zero (when one exists)
            Ȧ - any & all -> when flattened:{empty or contains a 0:0; otherwise:1}

Stax , 20 Bytes ^CP437

Å┴m▐◘5)ît╢V¼≥+╝╜►º½ê

24 Bytes beim Auspacken,

LM{'0|Ic%vChm:-{Jh!f%29=

Online ausführen und debuggen!

Vielleicht nicht der beste Golfspieler, aber ich finde die Methode neu und interessant.

Erläuterung

LM                          Load the input string as a 2d array of characters, and transpose it

  {         m               Map array with block
   '0|I                     Get all indices of substring "0"
       c%vC                 Map to nothing if the indices are not unique
           h                Otherwise map to the unique index

             :-             Take pairwise difference

               {   f        Filter array with block
                Jh!         Only keep 0, 1 and -1

                    %29=    Check whether the final array has exactly 29 elements

J , 38, 37, 30 Bytes

-8 Bytes dank FrownyFrog

[:($e.~[:(-:*)2-/\])@:I.'0'=|:

Probieren Sie es online!

Gelee , 16 Bytes

Zµi€”0IỊ;ċ€⁶=4ƊẠ

Probieren Sie es online!

Es wird davon ausgegangen, dass die Eingabezeichenfolge immer nur Leerzeichen und Nullen enthält. Nimmt Eingaben als Liste von Zeichenfolgen (jede stellt eine Zeile dar) und gibt 1 aus, wenn dies wahr ist, andernfalls 0 .

Erläuterung

Zµi€”0IỊ;ċ€⁶=4ƊẠ | Monadic full program.
Z                | Transpose.
 µ               | Start a new monadic chain.
  i€”0           | Retrieve the first index of 0 in each column.
      IỊ         | Check whether their increments are insignificant (element-wise).
        ;     Ɗ  | Append the result of the following:
         ċ€⁶     | In each list of characters, count the occurrences of a space.
            =4   | Check whether they equal 4 (returns a boolean array).
               Ạ | All. Check whether all the elements are truthy.

Python 2 , 141 Bytes

lambda g:(lambda a:all(map(len,a)+[-2<x-y<2 for b in[sum(a,[])]for x,y in zip(b,b[1:])]))([[i for i in range(5)if"0"==r[i]]for r in zip(*g)])

Probieren Sie es online!

Die Eingabe ist ein Zeichenraster.

Python 2 und Python 3 , 122 120 119 Bytes

lambda s:s.count('0')<31and all(s[i-31*(i>30):31*(i<124)-~i:31].strip(' ')for i,x in enumerate(s,1)if' '<x)and' '<s[62]

Probieren Sie es online!

Das Eingabeformat ist eine Zeichenfolge mit der Länge 154 (5 x 30 Zeichen, 4 Zeilenumbrüche):

'''
            0 0               
  0        0 0 000            
00 0     00       000 0      0
    000 0            0 0   00 
       0                000   '''[1:] # to exclude starting newline

Wenn der Kopf nicht die mittlere Reihe sein muss

Die Anforderung für den Kopf der mittleren Reihe war in der ursprünglichen Herausforderung enthalten, aber ich stellte fest, dass dies hier nicht der Fall ist (zumindest wird dies nicht explizit erwähnt).

Python 2 und Python 3 , 124 123 Bytes

lambda s:s.count('0')<31and all(s[i-31*(i>30):31*(i<124)-~i:31].strip(' ')for i,x in enumerate(s,1)if' '<x)and'0'in s[::31]

Probieren Sie es online!

Bearbeiten:

• Reduziert 2 Bytes durch Ändern von equals ( ==) in Ungleichungen für jeden Code.
• In der weniger einschränkenden Version wurden Fehler gefunden und überarbeitet. (Zum Glück ist es nicht zu schrecklich, so dass ich alle Versionen in der Länge ähnlich halten kann.) Sie können zusätzliche Testfälle in den letzten beiden TIO-Links sehen.
• In Py2-Lösungen wurde ein Dangling-Byte gefunden, wodurch der all()Trick in Py3 bedeutungslos wurde. Daher wurden beide Versionen zusammengeführt.

Excel (VBA), 68 Byte

Verwenden des Direktfensters Cell[A6]als Ausgabe.

[A1:AD5]="=CHOOSE(ROUND(RAND()+1,),0,"""")":[A6]="=COUNT(A1:AD5)=30"

Schnecken , 18 Bytes

\0!(ud.,\0)raa7)30

Probieren Sie es online!

Schmutz , 30 26 23 Bytes

Vielen Dank an Zgarb für das Speichern von 7 Bytes und das Hinweisen auf einen Fehler.

e`" 0/0 "oO|#29ddv&d#1+

Probieren Sie es online!

Ruby , 93 Bytes

->x{x.transpose.map{|x|x.count(?0)<2&&x.index(?0)}.each_cons(2).all?{|x,y|x&&y&&(x-y).abs<2}}

Probieren Sie es online!

JavaScript (Node.js) , 128 126 Bytes

Bearbeitet nach der Eingabeerklärung, in der angegeben wird, dass die Eingabe "eine Zeichenfolge" ist.

F=(a,l=29,r=0,t=/^( *)0 *$/.exec(a.split`
`.map(p=>p[l]).join``),q=t&&~t[1].length)=>q&&(s=q-(r=r||q))>-2&s<2?l?F(a,l-1,q):1:0

Probieren Sie es online!

Python 3 , 197 185 Bytes

In der Eingabeaufforderung tun verify.py<snake.txtoder in der Bash tuncat snake.txt | python verify.py . Wo snake.txtist eine Datei mit einer zu überprüfenden Schlange?

Wenn die Schlange korrekt ist, wird nichts ausgegeben. Wenn es nicht korrekt ist, wird Python einen Indexfehler auslösen.

import sys
s=sys.stdin.read().split("\n")
x=0
exec('t,y="",0\nwhile y<5:t+=s[y][x];y+=1\ns+=[t];x+=1;'*30)
s=list(map(lambda l:len(l.rstrip()),s))
while y<35:"ee"[abs(s[y]-s[y+1])];y+=2