Prenez un tableau composé de nombres ou de tableaux, sortez s'il ne contient que 2s.

La sortie doit être une valeur true ou falsey (Désolé si cela détruit les réponses)

Cas de test authentiques

[2]
[2,2]
[[2],[2,2],2]
[]
[[],[]]

Cas de test Falsey

[1]
[22]
[2,2,2,1]
[[1,2],2]

Les échappatoires standard sont interdites.

Les règles d' E / S par défaut s'appliquent.

Code-golf, le moins d'octets gagne!

MATL , 3 octets

2=p

Essayez-le en ligne!

Techniquement, cela pourrait simplement être

2=

Puisqu'un tableau contenant des éléments nuls est faux, mais cela semble bon marché.

Python 2 , 43 40 octets

f=lambda l:l>=[]and all(map(f,l))or l==2

Essayez-le en ligne!

Au moment de publier cette réponse, il était toujours autorisé par ce méta-consensus de produire via le lancement d'une erreur / le non-lancement d'une erreur. Par conséquent, cette réponse à 26 octets était valide:

f=lambda l:l==2or map(f,l)

Essayez-le en ligne!

Prolog (SWI) , 43 33 octets

Je sens ... la récursivité .

Merci à Emigna et Leaky Nun pour avoir économisé 10 octets!

Code

a([]).
a([X|T]):-(X=2;a(X)),a(T).

Essayez-le en ligne! ou Vérifiez tous les cas de test!

Explication:

Pour les utilisateurs non-Prolog, une liste est formatée de la manière suivante: [Head | Tail].

Le Headest le premier élément de la liste et la queue est la liste restante. Testez-le ici! . Un cas important ici est que la queue d'une liste avec 1 élément est égale à []. Vous pouvez le tester ici .

% State that an empty array is truthy.
a([]).

% If the list is not empty (covered by the previous line), we need to check
% whether the Head is equal to 2 or whether the head is truthy.
% After that, we only need to check if the remaining list is truthy.
a([Head | Tail]) :- (Head = 2; a(Head)), a(Tail).

Gelée , 4 octets

F;2E

Essayez-le en ligne!

Comment ça fonctionne

F;2E
F    flatten
 ;2  append 2
   E all elements are equal

Octave, 13 octets

@(x)~any(x-2)

Vérifiez tous les cas de test.

Ceci est une fonction anonyme avec un argument d'entrée, x. Il soustrait 2de tous les éléments, vérifie s'il y a des éléments non nuls. Il annule la sortie pour obtenir truedes cas où toutes les valeurs sont nulles.

Cela fonctionne parce que les x-2travaux pour les matrices de toutes tailles, y compris la matrice vide, [].

x-2 serait suffisant s'il ne pouvait pas y avoir de matrices vides dans l'entrée.

Mathématiques , 28 octets

Select[Flatten@#,#!=2&]=={}&

Essayez-le en ligne!

Rétine , 13 10 octets

Merci à Kritixi Lithos pour avoir économisé 3 octets.

\W|\b2

^$

Essayez-le en ligne!

05AB1E , 4 octets

˜YQP

Essayez-le en ligne!

Explication

˜      # flatten list
 YQ    # check each element for equality to 2
   P   # product of list

JavaScript (ES6), 22 19 23 22 octets

a=>!/[^2,]|22/.test(a)

Essaye-le

f=
a=>!/[^2,]|22/.test(a)
console.log(" "+f([2])+": "+JSON.stringify([2]))
console.log(" "+f([2,2])+": "+JSON.stringify([2,2]))
console.log(" "+f([[2],[2,2],2])+": "+JSON.stringify([[2],[2,2],2]))
console.log(" "+f([])+": "+JSON.stringify([]))
console.log(" "+f([[],[]])+": "+JSON.stringify([[],[]]))
console.log(f([1])+": "+JSON.stringify([1]))
console.log(f([22])+": "+JSON.stringify([22]))
console.log(f([2,2,2,1])+": "+JSON.stringify([2,2,2,1]))
console.log(f([[1,2],2])+": "+JSON.stringify([[1,2],2]))

Mathematica, 15 octets

FreeQ[x_/;x!=2]

Il fonctionne également en mathématiques. Essayez-le en ligne!

APL (Dyalog) , 5 octets

∧/2=∊

Essayez-le en ligne!

Explication

∧/                         Only
  2=                       2s are equal to
    ∊                      any of the elements in the enlisted form of the right argument

Mathematica, 24 octets

Cases[t=Flatten@#,2]==t&

Fonction pure retournant Trueou False. Après avoir Flattening le tableau imbriqué et l'avoir appelé t, Cases[t,2]retourne la liste des éléments qui correspondent au "modèle" 2et ==tvérifie s'il s'agit de la liste entière.

Mathematica, 29 octets

(#//.{2->{},{{}..}->{}})=={}&

Pas aussi court, mais plus amusant. À partir de l'entrée #, deux règles de remplacement sont appliquées jusqu'à ce que le résultat cesse de changer ( //.): tout d'abord, tous les 2s sont remplacés par des {}s; puis toute liste dont les entrées sont toutes des ensembles vides ( {{}..}) est remplacée (à plusieurs reprises) par des ensembles vides. Si le reste est un ensemble vide ( =={}), nous gagnons.

Haskell , 36 octets

Une fonction anonyme, prend a Stringet retourne a Bool.

Utilisé comme (all((==2).fst).(reads=<<).scanr(:)[]) "[2,2,2,1]"

all((==2).fst).(reads=<<).scanr(:)[]

Essayez-le en ligne!

Comment ça fonctionne

• Haskell n'a pas de listes intégrées de type mixte, nous prenons donc une chaîne comme argument.
• scanr(:)[] génère une liste de tous les suffixes de la chaîne.
• (reads=<<)essaie d'analyser un nombre au début de chaque suffixe, en combinant les succès dans une liste de tuples (n,restOfString).
• all((==2).fst)vérifie si tous les nombres analysés le sont 2.

Python 2 , 38 octets

lambda l:l.strip('[],2')==l*('22'in l)

Essayez-le en ligne!

Prend une chaîne sans espaces, génère un booléen.

Vérifie si la suppression de tous les caractères '[],2'de ldonne la chaîne vide. Vérifie également qu'il 22ne s'agit pas d'une sous-chaîne - si c'est le cas, l'entrée lest utilisée à la place de la chaîne vide pour se comparer au résultat de la suppression, et cela échoue toujours.

Ruby, 28 23 22 octets - 5 octets économisés par Go

->x{x.flatten-[2]==[]}

Bien que "aplatir" soit vraiment long, il est toujours plus court que les solutions basées sur l'expression régulière ou les trucs récursifs qui doivent sauver les erreurs dans le cas de base. Cependant, la fusion intégrée de Ruby des ensembles et des tableaux est parfois incroyablement utile.

JavaScript (ES6), 26 octets

f=a=>a.map?a.every(f):a==2

Cas de test

f=a=>a.map?a.every(f):a==2

console.log(f([2]))
console.log(f([2,2]))
console.log(f([[2],[2,2],2]))
console.log(f([]))
console.log(f([[],[]]))

console.log(f([1]))
console.log(f([22]))
console.log(f([2,2,2,1]))
console.log(f([[1,2],2]))

MATL , 4 octets

2-a~

Essayez-le en ligne!

Panne:

           % Implicit input
2-         % Push 2 to the stack, and subtract from input
  a        % Any non-zero elements?
    ~      % Negate to get true for cases where all elements are zero.

Eh bien, hors - golf . Mais je garde ça, car je suis assez content d'avoir tout fait par moi-même (même si la tâche est super simple).

R, 28 octets

function(x)!any(unlist(x)-2)

unlist(x)transforme une liste (imbriquée) en vecteur. 2Est ensuite soustrait de ce vecteur. anyconvertit (avec un avertissement) numérique en logique et vérifie s'il y a des TRUEs. Ceci est inversé avec !et en sortie.

Cela fonctionne avec les listes imbriquées car, unlistpar défaut, fonctionne de manière récursive pour annuler la liste de toutes les entrées de liste de la liste initiale.

Cela fonctionne également avec des listes vides, car unlist(list())devient numeric(), un vecteur numérique vide. La contrainte par le anyfait logical(), ce qui est interprété comme FALSEpar any, puis inversé en TRUEpar !.

Python 3 , 55 octets

Pas de tricherie. Utilise la liste imbriquée comme entrée.

f=lambda a:all(type(x)!=int and f(x)for x in a if x!=2)

Essayez-le en ligne!

Gelée , 4 octets

F=2Ạ

Essayez-le en ligne!

Légèrement différent de l'algorithme de Leaky.

Explication:

F=2Ạ
F    Flatten
 =2  Check if equal to 2 (vectorizes)
   Ạ Check if there isn't any falsey value

Rétine , 14 11 octets

^(\W|2\b)+$

Essayez-le en ligne!

05AB1E , 4 octets

2‚˜Ë

Essayez-le en ligne!

JavaScript (ES6), 53 50 48 octets

_=>(_+"").split`,`.map(c=>!c?2:c).every(c=>c==2)

5 octets enregistrés grâce à @Shaggy!

Cas de test:

let f =

_=>(_+"").split`,`.map(c=>!c?2:c).every(c=>c==2)

console.log(f([2]))
console.log(f([2,2]))
console.log(f([[2],[2,2],2]))
console.log(f([]))
console.log(f([[],[]]))

console.log(f([1]))
console.log(f([22]))
console.log(f([2,2,2,1]))
console.log(f([[1,2],2]))

05AB1E , 7 octets

˜DOsg·Q

Essayez-le en ligne! ou essayez tous les tests!

˜D      # Flatten and duplicate
  O     # Sum one copy
   sg·  # Get double the length of the other copy
      Q # Check if they are equal

Java 8, 126 55 27 octets

s->s.matches("(\\W|2\\b)+")

Port de @KritixiLithos 's étonnante réponse Retina , excluant le ^...$, car String#matchescorrespond toujours à la chaîne entière et ajoute ^...$implicitement.

-2 octets merci à @Jakob de me le rappeler ^...$n'est pas nécessaire pour String#matches.

Essayez-le ici.

Python 2 , 44 43 42 octets

Prend xcomme représentation sous forme de chaîne de la liste. Cela suppose également que dans l'exemple les représentations n'ont pas d'espaces.

lambda x:set(x)<=set("[],2"*0**("22"in x))

Essayez-le en ligne!

Explication

Les deux prennent les caractères dans la représentation sous forme de chaîne de l'entrée et déterminent s'il [], 2existe des caractères autres que ceux -ci. Ils le font en lançant un ensemble et en le comparant à l'ensemble de ces personnages uniquement. Cependant, cela échoue si nous avons un nombre autre que 2 qui n'a que des chiffres de 2 (par exemple 22 ou 222), afin de corriger ce cas, nous multiplions la chaîne utilisée pour créer l'ensemble par la négation de s'il xcontient ou non "22". S'il le contient, ce sera l'ensemble vide, sinon ce sera le même qu'avant.

Ohm, 6 octets

∙e]Å2N

Les usages CP-437 encodage.

Explication:

∙e]Å2E
∙e           ■Evaluate the input to form an array
   Å         ■any(              ,             )
  ]          ■    flatten(input)
    2N       ■                   lambda x:x!=2
             ■implict end of any and print

PHP, 46 octets

<?=!preg_match('/:"(?!2")/',serialize($_GET));

PHP <7,0, 29 octets

Entrée sous forme de tableau de chaînes codé JSON

<?=!ereg("22|[013-9]",$argn);

PHP <7,0, 42 octets

utiliser la fonction obsolète ereg

<?=!ereg("22|[013-9]",json_encode($_GET));

PHP, 50 octets

imprime 1 pour vrai et rien pour faux

-1 octet pour les autres suppressions !

ou + 1 octet pour vrai 1, faux 0 ajouter +avant!

<?=!preg_match('#22|[013-9]#',json_encode($_GET));

Essayez-le en ligne!

Pyth, 6 octets

!-.nQ2

Très similaire à ma réponse CJam. Je suis encore nouveau sur Pyth, alors dites-moi s'il y a quelque chose que je peux jouer au golf.

Explication:

    Q   Input:     [[[], [2]], [1]]
  .n    Flatten:   [2, 1]
 -   2  Remove 2s: [1]
!       Not:       False