Pegue uma matriz que consiste em números ou matrizes, produza se ela contiver apenas 2s.

A saída deve ser um valor verdadeiro ou falso (desculpe se isso destrói as respostas)

Casos de teste de verdade

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

Casos de Teste Falsey

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

As brechas padrão são proibidas.

Regras de E / S padrão se aplicam.

Código de golfe, menos bytes ganha!

MATL , 3 bytes

2=p

Experimente online!

Tecnicamente, isso poderia ser apenas

2=

Como uma matriz que contém quaisquer elementos zero é falsa, mas isso parece barato.

Python 2 , 43 40 bytes

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

Experimente online!

No momento da publicação desta resposta, ainda era permitido, por esse meta consenso, gerar um erro / não um erro. Portanto, esta resposta em 26 bytes era válida:

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

Experimente online!

Prolog (SWI) , 43 33 bytes

Eu cheiro... recursão .

Graças a Emigna e Leaky Nun por salvar 10 bytes!

Código

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

Experimente online!ou Verifique todos os casos de teste!

Explicação:

Para usuários não-Prolog, uma lista é formatado da seguinte maneira: [Head | Tail].

O Headé o primeiro elemento da lista e tail é a lista restante. Teste aqui! . Um caso importante aqui é que a cauda de uma lista com 1 elemento é igual a []. Você pode testar isso aqui .

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

Gelatina , 4 bytes

F;2E

Experimente online!

Como funciona

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

Oitava, 13 bytes

@(x)~any(x-2)

Verifique todos os casos de teste.

Esta é uma função anônima que recebe um argumento de entrada x,. Ele subtrai 2de todos os elementos, verifica se existem elementos diferentes de zero. Ele anula a saída truepara casos onde todos os valores são zero.

Isso funciona porque x-2funciona para matrizes de todos os tamanhos, incluindo a matriz vazia [],.

x-2 seria suficiente se não pudesse haver matrizes vazias na entrada.

Matemática , 28 bytes

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

Experimente online!

Retina , 13 10 bytes

Obrigado ao Kritixi Lithos por salvar 3 bytes.

\W|\b2

^$

Experimente online!

05AB1E , 4 bytes

˜YQP

Experimente online!

Explicação

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

Teste-o

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]

Também funciona em matemática. Experimente online!

APL (Dyalog) , 5 bytes

∧/2=∊

Experimente online!

Explicação

∧/                         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&

Função pura retornando Trueou False. Após Flattendigitar a matriz aninhada e chamá-la t, Cases[t,2]retorna a lista de elementos que correspondem ao "padrão" 2e ==tverifica se essa é a lista inteira.

Mathematica, 29 bytes

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

Não é tão curto, mas mais divertido. A partir da entrada #, duas regras de substituição são aplicadas até que o resultado pare de mudar ( //.): primeiro, todos os 2s são substituídos por {}s; e qualquer lista cujas entradas sejam todos conjuntos vazios ( {{}..}) será substituída (repetidamente) por conjuntos vazios. Se o resto for um conjunto vazio ( =={}), vencemos.

Haskell , 36 bytes

Uma função anônima, pega a Stringe retorna a Bool.

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

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

Experimente online!

Como funciona

• Haskell não possui listas de tipos mistos embutidas, então usamos uma string como argumento.
• scanr(:)[] gera uma lista de todos os sufixos da sequência.
• (reads=<<)tenta analisar um número no início de cada sufixo, combinando os sucessos em uma lista de tuplas (n,restOfString).
• all((==2).fst)verifica se todos os números analisados ​​são 2.

Python 2 , 38 bytes

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

Experimente online!

Pega uma string sem espaços, gera um bool.

Verifica se a remoção de todos os caracteres '[],2'de lfornece a sequência vazia. Também verifica que 22não é uma substring - se for, a entrada lé usada no lugar da cadeia vazia para comparar com o resultado da remoção e que sempre falha.

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

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

Apesar de o "achatamento" ser muito longo, ainda é mais curto que as soluções baseadas em regex ou coisas recursivas que precisam resgatar erros no caso base. A combinação embutida de conjuntos e matrizes de Ruby, no entanto, às vezes é incrivelmente útil.

JavaScript (ES6), 26 bytes

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

Test cases

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~

Try it online!

Breakdown:

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

Well, outgolfed. But I'm keeping this, since I'm quite happy I managed this all on my own (even though the task is super simple).

R, 28 bytes

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

unlist(x) turns a (nested) list into a vector. Then 2 is subtracted from that vector. any converts (with a warning) numeric to logical and checks if there are any TRUEs. This is inverted with ! and output.

This works with nested lists because unlist by default works recursively to unlist all list entries of the initial list.

This also works with empty lists, because unlist(list()) becomes numeric(), an empty numerical vector. Coercion by any makes it logical(), which is interpreted as FALSE by any, and then reversed to TRUE by !.

Python 3, 55 bytes

No cheating. Uses nested list as input.

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

Try it online!

Jelly, 4 bytes

F=2Ạ

Try it online!

Slightly different than Leaky's algorithm.

Explanation:

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)+$

Try it online!

05AB1E, 4 bytes

2‚˜Ë

Try it online!

JavaScript (ES6), 53 50 48 bytes

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

Saved 5 bytes, thanks to @Shaggy!

Test Cases :

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

Try it online! or Try All 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 bytes

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

Port of @KritixiLithos's amazing Retina answer, excluding the ^...$, since String#matches always matches the entire String and adds the ^...$ implicitly.

-2 bytes thanks to @Jakob for reminding me of ^...$ isn't necessary for String#matches.

Try it here.

Python 2, 44 43 42 bytes

Takes x as the string representation of the list. This also assumes like in the example the representations have no spaces.

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

Try it online!

Explanation

Both of these take the characters in the string representation of the input and determine if any characters other than [], 2 are in it. They do this by casting to a set and comparing to the set of just those characters. However this fails if we have a number other than 2 which has only digits of 2 (e.g. 22 or 222), in order to patch this case we multiply the string used to create the set by the negation of whether or not x contains "22". If it contains it this will be the empty set, otherwise it will be the same as before.

Ohm, 6 bytes

∙e]Å2N

Uses CP-437 encoding.

Explanation:

∙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

Input as as string array JSON encoded

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

PHP<7.0, 42 Bytes

use the deprecated function ereg

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

PHP, 50 Bytes

prints 1 for true and nothing for false

-1 Byte for other wise remove !

or + 1 Byte for true 1, false 0 add + before !

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

Try it online!

Pyth, 6 bytes

!-.nQ2

Very similar to my CJam answer. I'm still new to Pyth, so please tell me if there's anything I can golf off.

Explanation:

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