Récemment, il y a eu quelques défis de serpent de compagnie ASCII (par exemple ici )

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

Ce défi consiste à prendre un serpent de compagnie horizontal généré aléatoirement (hauteur de cinq lignes, longueur de 30) et vérifier que:

• Chaque colonne n'en a qu'une 0
• Chacun 0est "connecté" à l' 0avant et à la suite (espacés verticalement de 0 ou 1 ligne uniquement)

La sortie finale peut être trueou 1si le serpent est valide, ou falseou 0si le serpent n'est pas valide

Modifier — Clarification

Supposons l'entrée:

• Est une chaîne
• Contient uniquement '', '0' et '\ n'
• A exactement 30 caractères par ligne
• A exactement 5 lignes

C'est à dire vérifier si le serpent est connecté, et qu'il n'y a pas de caractères errants. Pas besoin de valider la "toile" sur laquelle le serpent est imprimé.

JavaScript (ES2018), 62 54 octets

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

L'entrée est une chaîne unique:

• sans nouvelle ligne de fuite
• contiennent uniquement de l'espace, '0' et '\ n'
• 30 caractères par ligne, 5 lignes, 154 caractères au total

Flag ssignifie qu'un point correspond à n'importe quoi (y compris '\ n'). Cette fonctionnalité est actuellement prise en charge par Chrome 63+, Opera 50+, Safari 11.1+, basé sur compat-table . Vous pouvez tester cette fonction avec ces navigateurs pris en charge. Vous obtiendrez une exception lors du chargement de la page si votre navigateur ne prend pas en charge cette fonctionnalité.

Comment ça marche:

• Pas de colonne sans 0:
  • ne correspondent pas /( .{30}){4} /
• Pas deux 0s dans une colonne:
  • ne correspondent pas /0.{30}(.{31})*0/
• Non 0pas se connecter à ses voisins:
  • ne correspondent pas /0.{60}(.{31})*0/,/0.{62}(.{31})*0/

Fusionnez tous ces regex, et vous obtiendrez enfin celui-ci.

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>

Merci à Martin Ender de souligner que faire un seul !opérateur peut économiser 8 octets.

SnakeEx , 51 octets

C'est évidemment le bon langage pour la tâche. : ^ D

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

Correspond à l'entrée entière s'il s'agit d'un serpent valide; ne correspond pas si ce n'est pas le cas. Essayez-le ici!

Explication

SnakeEx est un langage de correspondance de motifs 2D . Un programme se compose d'une liste de définitions de «serpents», qui rampent autour des caractères correspondants en entrée, changent de direction et engendrent d'autres serpents. Dans notre programme, nous définissons deux serpents, set c.

Nous allons commencer par c parce que c'est plus simple. Sa définition est 0 *$, ce qui devrait être assez lisible si vous connaissez regex: match 0, suivi de zéro ou plusieurs espaces, suivi du bord de la grille. Le principal hic ici: cet appariement peut se faire dans n'importe quelle direction. Nous allons utiliser à la cfois vers le haut et vers le bas à partir du serpent, pour vérifier qu'il n'y a pas de supplément0 s dans chaque colonne.

Maintenant pour le serpent principal, s . Il prend la forme (...)%{30}, ce qui signifie «faire correspondre le contenu des parenthèses 30 fois» - une fois pour chacune 0chez le serpent. Jusqu'ici tout va bien. Qu'y a-t-il entre les parenthèses?

{c<L>}

Cela engendre un nouveau cserpent, tourné à gauche de 90 degrés. La direction est relative à las direction du serpent, donc le nouveau serpent se déplace vers le haut de la grille (le serpent principal se déplace vers la droite). Le cserpent vérifie que la cellule de grille actuelle est un 0et que chaque cellule au-dessus est un espace. S'il échoue, la correspondance entière échoue. S'il réussit, nous continuons avec

{c<R>}

qui fait la même chose, seulement tourné à droite (vers le bas de la grille).

Notez que ces apparitions n'affectent pas la position du pointeur de correspondance dans le serpent principal. Ils sont un peu comme des lookaheads en regex. (Peut-être que nous pourrions les appeler ici "lookbesides"?) Donc, après avoir vérifié que nous pointons sur un 0et que le reste de la colonne ne contient que des espaces, nous devons réellement faire correspondre le0 :

0

Maintenant, le pointeur de correspondance se trouve sur le caractère à droite de la 0 . Nous devons vérifier trois options différentes: le serpent s'incline vers le bas, le serpent s'incline vers le haut ou le serpent va droit. Pour cela, nous pouvons utiliser une expression OR:

[...]

À l'intérieur de notre salle d'opération, nous avons trois possibilités:

(<R> <L>)

Tournez à droite, faites correspondre un espace et tournez à gauche à nouveau (angles de serpent vers le bas).

(<L> <R>)

Tournez à gauche, faites correspondre un espace et tournez à nouveau à droite (angles de serpent vers le haut).

_?

Faites correspondre zéro ou un trait de soulignement. Puisqu'il n'y a pas de soulignement dans l'entrée, ce sera toujours une correspondance vide (le serpent va droit).

Après avoir correspondu à l'une des trois options ci-dessus, le pointeur de correspondance doit pointer vers 0dans la colonne suivante, prêt à correspondre à nouveau à l'expression entre parenthèses.

CJam , 35 34 octets

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

Essayez-le en ligne! L'entrée est un tableau rectangulaire de tableaux de caractères. Suppose que l'entrée ne contient et0 .

Explication:

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

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

Essayez-le en ligne!

Explication

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

Husk , 12 octets

Selon les clarifications des règles, peut être de 11 octets ou 13 octets .

±Λ=;1Ẋ×≈mηfT

Essayez-le en ligne!

L'entrée est une liste de lignes contenant uniquement des espaces et des 0; si une seule chaîne est requise, ajoutez-la ¶au programme pour la diviser en lignes. Le lien TIO le fait déjà pour plus de clarté. La sortie est 0 ou 1; si des valeurs fausses et véridiques sont correctes,± peuvent être supprimées.

Explication

±Λ=;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'idée est d'utiliser ×≈pour garantir que (a) toutes les colonnes contiennent précisément un 0, et (b) leurs positions diffèrent d'au plus un. À titre d'exemple, considérons l'entrée à 8 colonnes

0  0  0 
 000 0  
  00   0

Tout d'abord, le mηfTtransforme en liste de listes d'index

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

Ẋ×≈Donne ensuite

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

Chacun 1correspond à une paire d'indices qui diffèrent d'au plus 1, et chacun 0correspond à une paire qui ne le fait pas. Chaque résultat est égal [1]précisément lorsque les deux listes ont un indice et que les indices diffèrent d'au plus 1.

Python 2 , 71 octets

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

Essayez-le en ligne!

Prend l'entrée comme une chaîne multiligne. Cas de test de Bubbler .

La première colonne est extraite en tant que s[::31]et la seconde en tant que s[1::31], et leur validité est vérifiée. Nous recurse surs suppression du premier caractère, provoquant la vérification des paires de colonnes successives.

La vérification pour deux colonnes utilise le chaînage de comparaison de Python pour incombiner plusieurs vérifications:

• '0'in s[::31] vérifie que la première colonne a au moins un 0
• s[::31]in' %s '%s[1::31]vérifie que la première colonne est une sous-chaîne des sandwichs de la deuxième colonne entre deux espaces, ce qui garantit que la position de la 0a décalé au plus d'un espace
• ' %s '%s[1::31]in'%6s'%0*2vérifie que la deuxième colonne en contient au plus un 0.

La fin *f(s[1:])force également le cas récursif à être vrai.

C (gcc) ,246 245 232 215 212 octets

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

Essayez-le en ligne!

Je pensais que j'apporterais ma langue préférée à cela (même si comme je peux le voir dans les nombreuses autres entrées plus petites, c'est probablement loin d'être idéal pour ce genre de défi) et C ce que je pourrais gérer. L'approche du programme au problème est relativement simple, juste avec beaucoup de pincement de penny d'octet; il prend le serpent sur stdin et donne son résultat dans la valeur de retour de main (donc le code de sortie;comme demandé dans le problème 0 indique un serpent invalide et 1 valide même si pour un code de sortie qui est bizarrecomme pour les codes de sortie, 0 est un serpent valide et 1 est un serpent invalide). Avec les macros étendues et de beaux espaces, cela ressemble plus à ce qui suit:

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

Les lignes d'entrée sont lues dans la première ligne de la mémoire tampon, les cinq suivantes servent à suivre les endroits qui doivent (lire: doivent) avoir des zéros dans la ligne après chaque courant, et le dernier est pour suivre si un zéro a déjà été lu dans une colonne donnée, dans une ligne. Le programme traite tour à tour chaque ligne.

Ce n'est pas du tout robuste (ce gets()n'est que le début) et l'entrée doit contenir tous les espaces pertinents (pas d'espace blanc de fin laissé par exemple), et gcc émet des avertissements et des notes sur la fonctionnalité stdlib laissés implicitement déclarés et ainsi de suite, mais, C la vie.

Il suppose également que la tête de serpent n'a pas besoin d'être dans la ligne centrale et qu'un serpent valide doit avoir au moins un zéro dans chaque ligne (c'est-à-dire aucune ligne de tous les espaces dans les 5 lignes d'entrée). Si ce dernier n'est pas une exigence, il peut être un peu plus court - tout ce qui concerne ket ldans le programme peut être analysé ou remplacé par moins d'octets de code dans ce cas.

Merci à l'utilisateur 202729 pour env. 26 octets enregistrés.

MATL , 18 17 octets

32>&fun30=wd|2<vA

L'entrée est un tableau de caractères 2D. Tout caractère non spatial peut être utilisé pour le serpent.

Essayez-le en ligne!

Explication

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

Slip , 28 octets

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

Testez-le ici.

Gelée , 19 octets

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

Essayez-le en ligne!

-2 octets grâce à M. Xcoder

Explication

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'entrée est une liste de chaînes

Gelée , (14? *) 13 octets

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

Un lien monadique prenant une liste de cinq chaînes *, chacune de longueur 30 composée d'espaces et de tout autre caractère (par exemple 0 s), et retournant un entier (1 si un serpent tel que défini, 0 sinon)

* Si l'entrée doit être une seule chaîne (liste de caractères), ajoutez un Ỵpour séparer la chaîne au niveau des sauts de ligne.

Essayez-le en ligne!

Comment?

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

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

24 octets une fois déballés,

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

Exécutez et déboguez en ligne!

Ce n'est peut-être pas le meilleur golfeur mais je pense que la méthode est nouvelle et intéressante.

Explication

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 octets

-8 octets grâce à FrownyFrog

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

Essayez-le en ligne!

Gelée , 16 octets

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

Essayez-le en ligne!

Suppose que la chaîne d'entrée ne contiendra toujours que des espaces et des zéros. Prend l'entrée comme une liste de chaînes (chacune représentant une ligne), et sort 1 si vrai, 0 sinon.

Explication

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 octets

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

Essayez-le en ligne!

L'entrée est une grille de caractères.

Python 2 et Python 3 , 122 120 119 119 octets

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]

Essayez-le en ligne!

Le format d'entrée est une chaîne de longueur 154 (5 x 30 caractères, 4 sauts de ligne):

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

Si la tête ne doit pas être la rangée centrale

L'exigence de la ligne centrale était dans le défi d'origine, mais j'ai trouvé que ce n'était pas le cas ici (au moins, ce n'est pas explicitement mentionné).

Python 2 et Python 3 , 124 123 octets

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]

Essayez-le en ligne!

Modifier:

• Réduction de 2 octets en changeant égal (== ) en inégalités pour chaque code.
• A trouvé des erreurs dans la version moins limitative et l'a révisée. (Heureusement, ce n'est pas trop terrible, donc j'ai pu garder toutes les versions de même longueur.) Vous pouvez voir des cas de test supplémentaires dans les deux derniers liens TIO.
• Trouvé un octet pendant dans les solutions Py2, rendant l' all()astuce vide de sens dans Py3, a donc fusionné les deux versions.

Excel (VBA), 68 octets

Utilisation de la fenêtre immédiate, Cell[A6]en sortie.

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

Escargots , 18 octets

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

Essayez-le en ligne!

Grime , 30 26 23 octets

Merci à Zgarb pour avoir économisé 7 octets et signalé un bug.

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

Essayez-le en ligne!

Rubis , 93 octets

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

Essayez-le en ligne!

JavaScript (Node.js) , 128 126 octets

Modifié après clarification de l'entrée indiquant que l'entrée est "une chaîne".

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

Essayez-le en ligne!

Python 3 , 197 185 octets

Dans l'invite de commande do verify.py<snake.txtou dans bash do cat snake.txt | python verify.py. Où se snake.txttrouve un fichier contenant un serpent à vérifier.

Si le serpent est correct, rien ne sera émis. S'il n'est pas correct, Python déclenchera une erreur d'index.

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