Tome una matriz que consta de números o matrices, salida si solo contiene 2s.

La salida debe ser un valor verdadero o falso (lo siento si esto destruye las respuestas)

Casos de prueba de la verdad

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

Casos de prueba de Falsey

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

Las lagunas estándar están prohibidas.

Se aplican las reglas IO predeterminadas .

Code-golf, Fewest bytes gana!

MATL , 3 bytes

2=p

Pruébalo en línea!

Técnicamente, esto podría ser

2=

Dado que una matriz que contiene elementos cero es falsa, pero esto parece barato.

Python 2 , 43 40 bytes

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

Pruébalo en línea!

Al momento de publicar esta respuesta, todavía se permitía que este meta consenso llegara a través de lanzar un error / no arrojar un error. Por lo tanto, esta respuesta a 26 bytes era válida:

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

Pruébalo en línea!

Prólogo (SWI) , 43 33 bytes

Huelo ... recursión .

¡Gracias a Emigna y Leaky Nun por guardar 10 bytes!

Código

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

Pruébalo en línea! o Verifique todos los casos de prueba!

Explicación:

Para los usuarios no-Prolog, una lista tiene el formato de la siguiente manera: [Head | Tail].

El Heades el primer elemento de la lista, y tail es la lista restante. ¡Pruébalo aquí! . Un caso importante aquí es que la cola de una lista con 1 elemento es igual a []. Puedes probar eso aquí .

% 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).

Jalea , 4 bytes

F;2E

Pruébalo en línea!

Cómo funciona

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

Octava, 13 bytes

@(x)~any(x-2)

Verifique todos los casos de prueba.

Esta es una función anónima teniendo un argumento de entrada, x. Resta 2de todos los elementos, verifica si hay elementos distintos de cero. Niega la salida para obtener truecasos donde todos los valores son cero.

Esto funciona porque x-2funciona para matrices de todos los tamaños, incluyendo la matriz vacía, [].

x-2 sería suficiente si no pudiera haber matrices vacías en la entrada.

Matemáticas , 28 bytes

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

Pruébalo en línea!

Retina , 13 10 bytes

Gracias a Kritixi Lithos por guardar 3 bytes.

\W|\b2

^$

Pruébalo en línea!

05AB1E , 4 bytes

˜YQP

Pruébalo en línea!

Explicación

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

JavaScript (ES6), 22 19 23 22 bytes

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

Pruébalo

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 bytes

FreeQ[x_/;x!=2]

También funciona en matemáticas. Pruébalo en línea!

APL (Dyalog) , 5 bytes

∧/2=∊

Pruébalo en línea!

Explicación

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

Mathematica, 24 bytes

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

Función pura que vuelve Trueo False. Después Flattende ingresar la matriz anidada y llamarla t, Cases[t,2]devuelve la lista de elementos que coinciden con el "patrón" 2y==t comprueba si esa es la lista completa.

Mathematica, 29 bytes

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

No tan corto, pero más divertido. A partir de la entrada #, se aplican dos reglas de reemplazo hasta que el resultado deja de cambiar ( //.): primero, todas las 2s se reemplazan por {}s; y luego cualquier lista cuyas entradas son todos conjuntos vacíos ( {{}..}) son reemplazados (repetidamente) por conjuntos vacíos. Si el resto es un conjunto vacío ( =={}), ganamos.

Haskell , 36 bytes

Una función anónima, toma un Stringy devuelve unBool .

Usar como (all((==2).fst).(reads=<<).scanr(:)[]) "[2,2,2,1]"

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

Pruébalo en línea!

Cómo funciona

• Haskell no tiene listas integradas de tipo mixto, por lo que tomamos una cadena como argumento.
• scanr(:)[] genera una lista de todos los sufijos de la cadena.
• (reads=<<)intenta analizar un número al comienzo de cada sufijo, combinando los éxitos en una lista de tuplas (n,restOfString).
• all((==2).fst)comprueba si todos los números analizados son 2.

Python 2 , 38 bytes

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

Pruébalo en línea!

Toma una cadena sin espacios, emite un bool.

Comprueba si eliminar todos los caracteres '[],2'de lda la cadena vacía. También verifica que 22no sea una subcadena: si lo es, la entrada lse usa en lugar de la cadena vacía para comparar con el resultado de la eliminación, y eso siempre falla.

Ruby, 28 23 22 bytes - 5 bytes guardados por GB

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

A pesar de que "aplanar" es realmente largo, aún es más corto que las soluciones basadas en expresiones regulares o cosas recursivas que tienen que rescatar errores en el caso base. Sin embargo, la combinación de conjuntos y matrices incorporada de Ruby es increíblemente útil a veces.

JavaScript (ES6), 26 bytes

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

Casos de prueba

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 bytes

2-a~

Pruébalo en línea!

Descompostura:

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

Bueno, outgolfed . Pero me quedo con esto, ya que estoy bastante feliz de haberlo logrado todo por mi cuenta (aunque la tarea es muy simple).

R, 28 bytes

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

unlist(x)convierte una lista (anidada) en un vector. Luego 2se resta de ese vector. anyconvierte (con una advertencia) numérico a lógico y comprueba si hay algún TRUEs. Esto se invierte con !y salida.

Esto funciona con listas anidadas porque, unlistde forma predeterminada, funciona de forma recursiva para eliminar todas las entradas de la lista inicial.

Esto también funciona con listas vacías, porque se unlist(list())convierte en numeric()un vector numérico vacío. La coacción por lo anyhace logical(), que se interpreta como FALSEpor any, y luego se invierte a TRUEpor !.

Python 3 , 55 bytes

Sin trampas. Utiliza la lista anidada como entrada.

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

Pruébalo en línea!

Jalea , 4 bytes

F=2Ạ

Pruébalo en línea!

Ligeramente diferente al algoritmo de Leaky.

Explicación:

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

Retina , 14 11 bytes

^(\W|2\b)+$

Pruébalo en línea!

05AB1E , 4 bytes

2‚˜Ë

Pruébalo en línea!

JavaScript (ES6), 53 50 48 bytes

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

¡Guardado 5 bytes, gracias a @Shaggy!

Casos de prueba :

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 bytes

˜DOsg·Q

Pruébalo en línea! o prueba todas las pruebas!

˜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 bytes

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

Puerto de la sorprendente respuesta de Retina de @KritixiLithos , excluyendo el^...$ , ya que String#matchessiempre coincide con toda la cadena y agrega ^...$implícitamente.

-2 bytes gracias a @Jakob por recordarme ^...$ no es necesario String#matches.

Pruébalo aquí

Python 2 , 44 43 42 bytes

Toma xcomo la representación de cadena de la lista. Esto también supone que, como en el ejemplo, las representaciones no tienen espacios.

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

Pruébalo en línea!

Explicación

Ambos toman los caracteres en la representación de cadena de la entrada y determinan si hay otros caracteres que no [], 2estén en ella. Lo hacen al elegir un conjunto y compararlo con el conjunto de esos personajes. Sin embargo, esto falla si tenemos un número distinto de 2 que solo tiene dígitos de 2 (por ejemplo, 22 o 222), para parchear este caso multiplicamos la cadena utilizada para crear el conjunto por la negación de si xcontiene o no "22". Si lo contiene, este será el conjunto vacío, de lo contrario será el mismo que antes.

Ohm, 6 bytes

∙e]Å2N

Utiliza CP-437codificación.

Explicación:

∙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 bytes

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

PHP <7.0, 29 bytes

Entrada como codificación JSON de matriz de cadenas

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

PHP <7.0, 42 bytes

usar la función obsoleta ereg

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

PHP, 50 bytes

imprime 1 para verdadero y nada para falso

-1 Byte para otro sabio eliminar !

o + 1 Byte para verdadero 1, falso 0 agregar +antes!

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

Pruébalo en línea!

Pyth, 6 bytes

!-.nQ2

Muy similar a mi respuesta CJam. Todavía soy nuevo en Pyth, así que dígame si hay algo que pueda jugar al golf.

Explicación:

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