Di recente ci sono state un paio di sfide con il serpente per animali domestici ASCII (ad es. Qui )

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

Questa sfida consiste nel prendere un serpente domestico orizzontale generato casualmente (altezza di cinque linee, lunghezza di 30) e verificare che:

• Ogni colonna ne ha solo una 0
• Ognuno 0è "connesso" al 0precedente e al successivo (spaziato verticalmente solo da 0 o 1 linea)

L'output finale può essere trueo 1se il serpente è valido falseo 0se il serpente non è valido

Edit-Chiarimento

Assumi l'input:

• È una stringa
• Contiene solo '', '0' e '\ n'
• Ha esattamente 30 caratteri per riga
• Ha esattamente 5 righe

Vale a dire se il serpente è collegato e che non ci sono caratteri vaganti. Non è necessario convalidare la "tela" su cui è stampato il serpente.

JavaScript (ES2018), 62 54 byte

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

L'input è una singola stringa:

• senza seguire la nuova riga
• contiene solo spazio, '0' e '\ n'
• 30 caratteri per riga, 5 righe, 154 caratteri in totale

Flag sindica che un punto corrisponde a qualsiasi cosa (incluso '\ n'). Questa funzione è attualmente supportata da Chrome 63+, Opera 50+, Safari 11.1+, in base alla tabella di compatibilità . È possibile testare questa funzione con questi browser supportati. Otterrai un'eccezione durante il caricamento della pagina se il tuo browser non supporta questa funzione.

Come funziona:

• Nessuna colonna senza 0:
  • non corrispondono /( .{30}){4} /
• Non ci sono due 0secondi in una colonna:
  • non corrispondono /0.{30}(.{31})*0/
• No 0non connettersi ai suoi vicini:
  • non abbinare /0.{60}(.{31})*0/,/0.{62}(.{31})*0/

Unisci tutti questi regex e finalmente otterrai questo.

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>

Grazie a Martin Ender sottolinea che un singolo !operatore può risparmiare 8 byte.

SnakeEx , 51 byte

Questa è ovviamente la lingua giusta per l'attività. : ^ D

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

Corrisponde all'intero input se è un serpente valido; non riesce a corrispondere se non lo è. Provalo qui!

Spiegazione

SnakeEx è un linguaggio di corrispondenza del modello 2D . Un programma consiste in un elenco di definizioni per "serpenti", che strisciano attorno ai caratteri corrispondenti all'input, cambiando direzione e generando altri serpenti. Nel nostro programma, definiamo due serpenti se c.

Inizieremo cperché è più semplice. La sua definizione è 0 *$, che dovrebbe essere abbastanza leggibile se conosci regex: match 0, seguito da zero o più spazi, seguito dal bordo della griglia. Il principale vantaggio qui: questa corrispondenza può procedere in qualsiasi direzione. Useremo csia verso l'alto che verso il basso dal serpente, per verificare che non ci siano messaggi extra 0in ogni colonna.

Ora, per il serpente principale s. Prende la forma (...)%{30}, che significa "abbina il contenuto delle parentesi 30 volte" - una volta per ciascuna 0nel serpente. Fin qui tutto bene. Cosa c'è tra parentesi?

{c<L>}

Questo genera un nuovo cserpente, girato a sinistra di 90 gradi. La direzione è relativa alla sdirezione del serpente, quindi il nuovo serpente si sposta verso la parte superiore della griglia (il serpente principale si sta muovendo verso destra). Il cserpente verifica che la cella della griglia corrente sia una 0e che ogni cella sopra di essa sia uno spazio. Se fallisce, l'intera partita fallisce. Se ci riesce, continuiamo con

{c<R>}

che fa la stessa cosa, solo girato a destra (verso il fondo della griglia).

Nota che queste spawn non influiscono sulla posizione del puntatore della partita nel serpente principale. Sono un po 'come lookaheads in regex. (Forse qui potremmo chiamarli "lookbesides"?) Quindi, dopo aver verificato che stiamo puntando a 0e il resto della colonna contiene solo spazi, dobbiamo effettivamente abbinare 0:

0

Ora il puntatore della partita si trova sul personaggio a destra del 0. Dobbiamo controllare tre diverse opzioni: il serpente si inclina verso il basso, il serpente si inclina verso l'alto o il serpente va dritto. Per questo, possiamo usare un'espressione OR:

[...]

All'interno del nostro OR, abbiamo tre possibilità:

(<R> <L>)

Gira a destra, abbina uno spazio e gira di nuovo a sinistra (angoli di serpente verso il basso).

(<L> <R>)

Gira a sinistra, abbina uno spazio e gira di nuovo a destra (angoli del serpente in alto).

_?

Abbina zero o un trattino basso. Poiché non ci sono caratteri di sottolineatura nell'input, questa sarà sempre una corrispondenza vuota (il serpente va dritto).

Dopo aver abbinato una delle tre opzioni precedenti, il puntatore di corrispondenza dovrebbe puntare alla 0colonna successiva, pronto per abbinare nuovamente l'espressione tra parentesi.

CJam , 35 34 byte

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

Provalo online! L'input è una matrice rettangolare di matrici di caratteri. Presuppone che l'input contenga solo e 0.

Spiegazione:

{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 byte

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

Provalo online!

Spiegazione

ζ                    # 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)

Buccia , 12 byte

A seconda dei chiarimenti sulle regole, possono essere 11 byte o 13 byte .

±Λ=;1Ẋ×≈mηfT

Provalo online!

L'input è un elenco di righe che contiene solo spazi e 0; se è richiesta una singola stringa, anteporre ¶al programma per suddividere in righe. Il link TIO lo fa già per chiarezza. L'output è 0 o 1; se qualsiasi valore di falsità e verità va bene, ±può essere rimosso.

Spiegazione

±Λ=;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.

L'idea è quella ×≈di garantire che (a) tutte le colonne contengano esattamente uno 0, e (b) le loro posizioni differiscano al massimo di uno. Ad esempio, considerare l'input a 8 colonne

0  0  0 
 000 0  
  00   0

Innanzitutto, lo mηfTtrasforma nell'elenco degli elenchi di indici

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

Quindi Ẋ×≈dà

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

Ciascuno 1corrisponde a una coppia di indici che differiscono al massimo per 1 e ciascuno 0corrisponde a una coppia che non lo fa. Ogni risultato è uguale [1]esattamente quando entrambe le liste hanno un indice e gli indici differiscono al massimo da 1.

Python 2 , 71 byte

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

Provalo online!

Accetta l'input come stringa multilinea. Test case di Gorgogliatore .

La prima colonna viene estratta come s[::31]e la seconda come s[1::31]e vengono verificate la validità. Facciamo riferimento alla srimozione del primo carattere, causando il controllo di coppie successive di colonne.

Il controllo per due colonne utilizza il concatenamento di confronto di Python per incombinare più controlli:

• '0'in s[::31] controlla che la prima colonna ne abbia almeno una 0
• s[::31]in' %s '%s[1::31]verifica che la prima colonna sia una sottostringa dei sandwich della seconda colonna tra due spazi, il che garantisce che la posizione della si 0sia spostata al massimo di uno spazio
• ' %s '%s[1::31]in'%6s'%0*2verifica che la seconda colonna contenga al massimo una 0.

Il finale *f(s[1:])forza anche il caso ricorsivo per essere vero.

C (gcc) ,246 245 232 215 212 byte

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

Provalo online!

Ho pensato che avrei portato la mia lingua preferita in questo (anche se, come posso vedere da molte altre voci più piccole, è probabilmente tutt'altro che ideale per questo tipo di sfida) e C quello che potrei gestire. L'approccio del programma al problema è relativamente semplice, solo con un pizzico di byte; prende il serpente su stdin e dà il suo risultato nel valore di ritorno di main (quindi il codice di uscita;come richiesto nel problema 0 indica un serpente non valido e 1 valido anche se per un codice di uscita stranocome tipico per i codici di uscita 0 è un serpente valido e 1 è un serpente non valido). Con le macro espanse e alcuni spazi bianchi è più simile al seguente:

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.
}

Le righe di input vengono lette nella prima riga del buffer, le cinque successive sono per tracciare quali luoghi dovrebbero (leggi: devono) avere zero nella riga dopo ciascuno di quelli correnti, e l'ultimo è per tracciare se uno zero ha già stato letto in una determinata colonna, in qualsiasi riga. Il programma elabora ogni riga a turno.

Non è affatto robusto ( gets()è solo l'inizio) e l'input deve contenere tutti gli spazi rilevanti (nessuno spazio vuoto finale lasciato per esempio), e gcc emette avvisi e note sulla funzionalità stdlib lasciati implicitamente dichiarati e così via, ma, C la vie.

Presuppone inoltre che la testa del serpente non debba trovarsi nella riga centrale e che un serpente valido debba avere almeno uno zero in ogni riga (ovvero nessuna riga di tutti gli spazi nelle 5 righe di input). Se quest'ultimo non è un requisito, può essere reso un po 'più breve - tutto ciò che ha a che fare con ke lnel programma può essere eliminato o sostituito con meno byte di codice in quel caso.

Grazie all'utente202729 per ca. 26 byte salvati.

MATL , 18 17 byte

32>&fun30=wd|2<vA

L'input è un array di caratteri 2D. Qualsiasi personaggio non spaziale può essere usato per il serpente.

Provalo online!

Spiegazione

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

Slittamento , 28 byte

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

Provalo qui.

Gelatina , 19 byte

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

Provalo online!

-2 byte grazie a Mr. Xcoder

Spiegazione

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?

L'input è come un elenco di stringhe

Jelly , (14? *) 13 byte

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

Un collegamento monadico che prende un elenco di cinque stringhe *, ciascuna della lunghezza 30 costituita da spazi e qualsiasi altro carattere (ad es. 0S), e che restituisce un numero intero (1 se definito da un serpente, 0 altrimenti)

* Se l'input deve essere una singola stringa (elenco di caratteri), anteporre a Ỵper dividere la stringa nei feed di riga.

Provalo online!

Come?

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 byte ^CP437

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

24 byte quando decompresso,

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

Esegui ed esegui il debug online!

Potrebbe non essere il migliore, ma penso che il metodo sia nuovo e interessante.

Spiegazione

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 byte

-8 byte grazie a FrownyFrog

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

Provalo online!

Gelatina , 16 byte

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

Provalo online!

Presuppone che la stringa di input conterrà sempre solo spazi e zeri. Prende l'input come un elenco di stringhe (ognuna delle quali rappresenta una riga) e genera 1 se vero, 0 altrimenti.

Spiegazione

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 byte

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)])

Provalo online!

L'input è una griglia di caratteri.

Python 2 e Python 3 , 122 120 119 byte

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]

Provalo online!

Il formato di input è una stringa di lunghezza 154 (5 caratteri x 30, 4 righe):

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

Se la testa non deve essere la fila centrale

Il requisito della fila centrale era nella sfida originale, ma ho scoperto che non è il caso qui (almeno non è esplicitamente menzionato).

Python 2 e Python 3 , 124 123 byte

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]

Provalo online!

Modificare:

• Ridotto 2 byte modificando equals ( ==) in disuguaglianze per ciascun codice.
• Trovato errori nella versione meno limitante e rivisto. (Fortunatamente non è troppo terribile, quindi ho potuto mantenere tutte le versioni simili per lunghezza.) Puoi vedere ulteriori casi di test negli ultimi due link TIO.
• Trovato un byte penzolante nelle soluzioni Py2, rendendo all()insignificante il trucco in Py3, quindi ho unito entrambe le versioni.

Excel (VBA), 68 byte

Utilizzando la finestra immediata, Cell[A6]come output.

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

Lumache , 18 byte

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

Provalo online!

Grime , 30 26 23 byte

Grazie a Zgarb per aver salvato 7 byte e segnalato un bug.

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

Provalo online!

Rubino , 93 byte

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

Provalo online!

JavaScript (Node.js) , 128 126 byte

Modificato dopo il chiarimento dell'input affermando che l'input è "una stringa".

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

Provalo online!

Python 3 , 197 185 byte

Nel prompt dei comandi do verify.py<snake.txto in bash do cat snake.txt | python verify.py. Dove si snake.txttrova un file contenente un serpente da verificare.

Se il serpente è corretto, non verrà emesso nulla. Se non è corretto, Python genererà un errore di indice.

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