숫자 또는 배열로 구성된 배열을 취하고 2s 만 포함 된 경우 출력합니다 .

결과는 진실 또는 거짓 값이어야합니다 (응답이 파괴되면 죄송합니다)

확실한 테스트 사례

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

팔시 테스트 사례

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

표준 허점 은 금지되어 있습니다.

기본 IO 규칙이 적용됩니다.

코드 골프, Fewest 바이트가 승리합니다!

MATL , 3 바이트

2=p

온라인으로 사용해보십시오!

기술적으로, 이것은 단지

2=

제로 요소를 포함하는 배열은 거짓이므로 저렴합니다.

파이썬 2 , 43 40 바이트

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

온라인으로 사용해보십시오!

이 답변을 게시 할 때이 메타 합의에 따라 오류 발생 / 오류 발생 없음을 통해 출력 하는 것이 여전히 허용되었습니다 . 따라서 26 바이트에서의이 응답은 유효합니다.

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

온라인으로 사용해보십시오!

프롤로그 (SWI) , 43 33 바이트

나는 냄새가 ... 재귀 .

10 바이트를 절약 한 Emigna 와 Leaky Nun 에게 감사드립니다 !

암호

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

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오!

설명:

프롤로그가 아닌 사용자의 경우 목록 형식은 다음과 같습니다 [Head | Tail]..

는 Head리스트의 첫 번째 요소이며, 꼬리 나머지 목록이다. 여기에서 테스트하십시오! . 여기서 중요한 경우는 1 개의 요소를 가진리스트 의 꼬리 가 같다는 것 []입니다. 여기서 테스트 할 수 있습니다 .

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

젤리 , 4 바이트

F;2E

온라인으로 사용해보십시오!

작동 원리

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

옥타브, 13 바이트

@(x)~any(x-2)

모든 테스트 사례를 확인하십시오.

이것은 하나의 입력 인수를 취하는 익명 함수 x입니다. 2모든 요소에서 빼고 0이 아닌 요소가 있는지 확인합니다. true모든 값이 0 인 경우 출력을 무효화합니다 .

이것은 x-2빈 행렬을 포함하여 모든 크기의 행렬에서 작동하기 때문에 작동합니다 [].

x-2 입력에 빈 행렬이 없으면 충분합니다.

수학 , 28 바이트

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

온라인으로 사용해보십시오!

망막 , 13 10 바이트

3 바이트를 절약 한 Kritixi Lithos에게 감사합니다.

\W|\b2

^$

온라인으로 사용해보십시오!

05AB1E , 4 바이트

˜YQP

온라인으로 사용해보십시오!

설명

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

자바 스크립트 (ES6), 22 19 23 22 바이트

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

그것을 테스트

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 바이트

FreeQ[x_/;x!=2]

또한 수학에서도 작동합니다. 온라인으로 사용해보십시오!

APL (Dyalog) , 5 바이트

∧/2=∊

온라인으로 사용해보십시오!

설명

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

Mathematica, 24 바이트

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

순수 함수 반환 True또는 False. 후 Flatten중첩 된 배열을 보내고 그것을 호출 t, Cases[t,2]은 "패턴"과 일치하는 요소의 목록을 반환 2하고, ==t그 전체 목록 여부를 확인합니다.

매스 매 티카, 29 바이트

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

짧지는 않지만 더 재미 있습니다. 입력에서 시작 #하여 결과 변경이 중지 될 때까지 두 개의 대체 규칙이 적용됩니다 ( //.) : 먼저 모든 2s가 s로 바뀝니다 {}. 그런 다음 항목이 모두 빈 세트 ( {{}..}) 인 목록은 빈 세트 로 (반복적으로) 바뀝니다. 나머지가 빈 세트 ( =={})이면 승리합니다.

하스켈 , 36 바이트

익명 함수는 a를 가져와 a String를 반환합니다 Bool.

로 사용 (all((==2).fst).(reads=<<).scanr(:)[]) "[2,2,2,1]"

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

온라인으로 사용해보십시오!

작동 원리

• Haskell에는 기본 제공 혼합 유형 목록이 없으므로 문자열을 인수로 사용합니다.
• scanr(:)[] 문자열의 모든 접미사 목록을 생성합니다.
• (reads=<<)각 접미사 시작 부분에서 숫자를 구문 분석하여 성공을 튜플 목록으로 결합합니다 (n,restOfString).
• all((==2).fst)파싱 ​​된 숫자가 모두인지 확인합니다 2.

Python 2, 38 bytes

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

Try it online!

Takes in a string without spaces, outputs a bool.

Checks if removing all the characters '[],2' of l gives the empty string. Also checks that 22 is not a substring -- if it is, the input l is used in place of the empty string to compare to the result of removal, and that always fails.

Ruby, 28 23 22 bytes - 5 bytes saved by G B

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

Despite "flatten" being really long, it's still shorter than regex based solutions or recursive stuff that has to rescue errors in the base case. Ruby's built-in conflation of sets and arrays, however, is amazingly useful sometimes.

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