배경

Jelly는 Octave (및 확장에 의해 MATL)의 진실 / 거짓 행렬에 대한 매우 편리한 해석에서 영감을 받아 Ȧ (옥타브 스타일의 모든 ) 원자를 얻었습니다 .

Ȧ 배열을 입력으로 취하고 배열이 비어 있지 않고 트리 구조의 어느 곳에도 숫자 0 (정수, 부동 소수점 또는 복소수)을 포함하지 않으면 1을 반환 합니다. . 그렇지 않으면 0 을 반환합니다 .

예를 들어, [[]] 배열 은 비어 있지 않고 0을 포함하지 않기 때문에 진실입니다 . 그러나 [[0]] 은 가장 안쪽 레벨에 0 을 입니다.

태스크

A의 프로그래밍 언어 선택의, 전체 프로그램이나의 비어있을 가능성 가변 배열받는 함수 쓰기 정수 를 입력으로하고 인쇄 또는 리턴한다 truthy 또는 falsy ȧ가 반환 여부를 나타내는 값 1 또는 0을 각각을,.

제출은 다음 규칙을 준수해야합니다.

• 진리와 허위 값 은 모든 입력에 대해 일관성이 있어야합니다 . 즉, Ȧ 1을 반환하는 모든 배열 은 동일한 진리 값에 매핑되어야 하고 Ȧ이 0을 반환하는 모든 배열 은 동일한 거짓 값에 매핑되어야합니다.

• 전체 프로그램은 배열의 문자열 표현 만 입력으로 사용할 수 있으므로 허용됩니다. 그러나 다음과 같이 반환 된 언어의 표준 표현을 사용해야합니다.repr 또는 유사한 .

  특히 배열의 첫 번째 요소 앞에 공백이 있다고 가정 할 수 없습니다.

• 언어가 기본적으로 들쭉날쭉 한 배열을 나타낼 수없는 경우 기존 프로그래밍 언어의 표준 구문을 사용하여 입력의 문자열 표현을 사용할 수 있습니다.

• 언어에 들쭉날쭉 한 배열 (예 : 목록 및 튜플)을 나타내는 여러 가지 방법이있는 경우 그 중 하나만 지원하면됩니다.

• 귀하의 언어에이 과제에 대한 유효한 제출물 인 빌트인이있는 경우 귀하 의 답변 에 해당 언어를 사용할 수 없습니다 . 다른 모든 내장 기능이 허용됩니다.

• 하나는 다른 것보다 상당히 짧은 경우에도 배열과 문자열 조작을 사용하여 답변을 게시하는 것이 좋습니다.

• 모든 표준 코드 골프 규칙이 적용됩니다.

가장 짧은 바이트 단위의 코드가 이길 수 있습니다!

확실한 테스트 사례

[1]
[10]
[[]]
[[[[1]]]]
[[], [1], [1, 2]]
[[1], [1, [2]], [1, [2, [3]]]]
[[8], [8, [9]], [8, [9, [10]]]]

거짓 테스트 사례

[]
[0]
[0, -1]
[-1, 0]
[[[[0]]]]
[[0], [1, 2], [3, 4, 5]]
[[8], [8, [9]], [8, [9, [1, 0]]]]
[-1, 0, 0, 0]

젤리, 3 바이트

ṭFẠ

F 입력 목록을 평평하게합니다.

ṭ 원래 입력 목록에서 요소로 압정하며, 비어있는 경우에만 거짓입니다.

Ạ 그런 다음 병합 된 목록의 요소 또는 원래 목록 자체가 허위인지 확인합니다.

(원래 답변)

FẠ^Ṇ

자신에게 맞는 솔루션을 찾도록 격려해 주신 Dennis에게 감사합니다.

FẠ 입력에 깊이에 잘못된 값이 포함되어 있으면 0을, 그렇지 않으면 1을 제공합니다. Ȧ 합니다. 빈 목록을 제외하고 ?

Ṇ 입력이 잘못된 값이면 1을, 그렇지 않으면 0을 제공합니다. 유일한 잘못된 목록은 빈 목록입니다.

이 두 가지를 XOR하면 답을 얻을 수 있습니다.

F;WẠ

이것은 Dennis와 같은 정신 F;LẠ이지만 L목록이 비어있을 때 목록에 0을 넣는 대신 W빈 목록을 자체에 넣고 (생산하는 [[]]) 잘못된 요소를 포함시킵니다.

레티 나 , 10 바이트

A`\b0
^...

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

먼저 입력에 0이 있으면 입력을 제거합니다. 우리는 문자열의 시작 부분에서 최소 3 개의 문자를 일치 시키려고 시도합니다 (이전 단계에서 입력이 제거되지 않았거나 []시작 만되었는지 확인하기 위해 ).

루비, 25 24 23 18 16 바이트

p$_!~/\D0|^..$/

-n명령 행에 플래그가 필요합니다 (+1 바이트, -e-> -ne).

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

STDIN 및 출력 true또는 falseSTDOUT 에서 Ruby의 정식 배열 형식으로 입력을받는 전체 프로그램입니다 .

 $_              # line of input that was read automatically (-n)
   !~/        /  # does not match the regex...
      \D0        #   a non-digit followed by a 0
         |       #   or...
          ^..$   #   a 2-length string (which must be [], the empty array)
p                # output the result

23 바이트 기능 버전 :

->a{"#{a}"!~/\D0|^..$/}

이것은 테스트 할 배열 인 하나의 인수를 취하는 proc입니다.

1 바이트는 Martin Ender , 2 바이트는 Ventero 에게 감사 합니다!

젤리 , 4 바이트

FẠ_Ṇ

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

Ȧ0입력이 비어 있거나을 포함 하면을 생성 하고 0, 그렇지 않으면을 생성합니다 1.

FẠ수율 0평탄화 입력이 포함되어있는 경우 0(입력이 배열이 보장되기 때문에) 빈 배열의 경우 에지를 남겨.

Ṇ벡터화되지 않은 논리 모나드가 0아니므로 비어 있지 않은 목록과 빈 목록에 대해 반환 1합니다. 따라서 이것은 FẠ사용 결과에서 단순히 하위 추적 될 수 있습니다 _.

05AB1E , 9 8 바이트

Emigna 덕분에 -1 바이트

)Q¹˜0å~_

설명:

)Q        Is the length of the input 0?
  ~    _  ... NOR ... (just for you, Dennis) 
   ¹˜     Input deep flattened
     0å   Contains 0

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

매스 매 티카, 17 바이트

#!={}&&#~FreeQ~0&

FreeQ0우리 를 위해 검사를 하지만, 물론 Trueinput을 반환 할 {}것이므로 그 경우를 별도로 검사해야합니다.

APL (Dyalog), 21 12 7 바이트

포크를 사용하여 Adám 덕분에 5 바이트 골프

⍬∘≡⍱0∊∊

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

이것은 Dyalog에서 처음 시도한 것입니다. 골프 팁을 환영합니다!

설명

⍬∘≡                   Fork; Is the argument a null set
   ⍱                  Nor
    0∊∊               0 belongs to the enlisted form of the argument
                      For example, (1 (2 (3 (0)))) would become
                      1 2 3 0 using the ∊ monad
                      Then we check if zero belongs to this vector

인화점 스크립팅 언어, 199 188 바이트

A={f={private["_i","_r"];_r=1;_i=0;while{_i<count _this}do{o=_this select _i;if(o in [o])then{if(o==0)then{_r=0}}else{_r=o call f};_i=_i+1};_r};if(count _this==0)then{0}else{_this call f}}

전화 :

[3,6,4,[4,6],[3,6,[],[2,4,[0],3]]] call A

또는 함께 :

hint format["%1", [3,6,4,[4,6],[3,6,[],[2,4,[0],3]]] call A]

설명:

게임의 스크립팅 언어에서 코드가 포함 된 문자열을 호출 할 수 있습니다. 중괄호 {}는 문자열의 시작과 끝을 나타냅니다. (따옴표도 작동하지만 중첩 될 때 지저분합니다.) 따라서 A={...}string을 variable에 할당하면 A다음과 같은 함수로 변수를 호출 할 수 있습니다 <argument> call A. 기본적으로 모든 문자열은 코드 블록으로 취급 될 수 있습니다.

그런 다음 "function"안에 A다른 함수를 정의합니다 f. private두 개의 변수를 선언 _i하고 _rlocal을 function에 선언합니다 f. 지역 변수의 이름은 밑줄로 시작해야합니다.

while {} do {}는 루프이며 여기서 첫 번째 문자열 (로 표시됨 {})에는 루프 조건에 대한 코드가 포함 되고 두 번째 문자열 에는 루프 본문에 대한 코드가 포함됩니다.

_this 함께 전달 된 인수입니다 call함수 . _this모든 유형이 될 수 있지만 여기서는 배열이라고 가정합니다.

루프 o=_this select _i에서 배열의 _i : th 요소에 액세스하여 variable에 지정합니다 o. if (o in [o])가 o다른 배열 인지 아닌지를 결정하는 요령 입니다. 경우 o다수 (또는 배열 이외)이다 o in [o]으로 평가할 것이다 true때문에 in함수 값 일치 발견 o어레이에서를 [o]. 경우 o배열, 표현의 수익률이다 false(가) 때문에, in배열을 비교 거부합니다.

경우 o배열이 아닌이 0 인 경우에, 우리는 확인하고는 않는 경우, 우리는 변수를 설정합니다 _r우리는 제로로, 반환 값으로 사용합니다. 그렇지 않으면 o배열 인 경우 , 새 배열 을 인수로 사용하여 _r재귀 호출의 반환 값을 할당합니다 .fo

루프가 끝나면 function의 끝 f에서 expression을 평가하여 _r의 값을 산출합니다.이 값은 _r마지막으로 평가할 표현식이므로 이것이 함수 호출입니다.f 리턴합니다.

이제 우리는 정의했습니다 f ( f내부 A에 있을 필요는 없지만 , 이렇게하면 A바이트를 저장하지 않으려 는 경우 로컬 변수 / 함수 (실제로 차이가 없음)로 선언 할 수 있음)으로 돌아가 봅시다 A. 의 입력 배열이 비어 if (count _this == 0)있는지 확인하고 A비어 있으면 A0을 반환합니다. 그렇지 않으면 함수 f가 호출되고 반환 값은 A의 반환 값이됩니다.

세미콜론은 몇 군데에서 누락 된 것으로 보이지만, 다른 명령문이 동일한 코드 블록 (예 : 문자열) 내에서 뒤에 오는 경우에만 명령문 뒤에 세미콜론이 필요하기 때문에 그렇지 않습니다.

펄 5 , 15 바이트

Doorknob의 Ruby answer 와 동일한 기술을 사용하여 2 바이트를 절약했습니다 .

14 바이트의 코드 + -p플래그

$_=!/\b0|^..$/

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

/.../배열이 비어 있지 보장은 (그것은 어떤 배열에 일치하지만 것입니다 [].
/\b0/A가있을 경우에만 일치합니다 0배열.합니다 ( \b(가) 보장 0다른 번호하지만 정수)의 일부가 아닙니다.

하스켈 , 48 바이트

f x=or[elem c"[,"|c:'0':_<-scanr(:)[]x]<(x<"[]")

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

테스트 사례에 대해 Lynn에게 감사하고 x<"[]" 트릭에 .

외적 불평등은 (x<"[]")참 (빈 목록)이어야하고or[elem c"[,"|c:'0':_<-scanr(:)[]x] False (0이 아님) 여야합니다.

의 문자는와 같은 숫자가 0아니라 다음과 같이 ,또는 로 감지됩니다 . 식은 모든 접미사를 생성 하고, 그 제 문자들을 캡처 . 그런 다음 첫 문자가 또는 인지 확인합니다 .[20scanr(:)[]xlc:'0':_<-'0'elem c"[,",[

여기서는 Haskell 스타일 목록에 공백이 없지만 그렇게 ','하면 그냥 바꿀 수 있다고 가정합니다 ' '.

여기가 생성하지만,보다 직접적인 48 바이트 메소드의 0집과 1의 하스켈 Truthy / Falsey되지 않은.

f"[]"=0
f(c:'0':_)|elem c"[,"=0
f(_:t)=f t
f _=1

젤리 , 4 바이트

F;LẠ

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

작동 원리

F;LẠ  Main link. Argument: A (array)

F     Flatten A.
  L   Yield A's length.
 ;    Concatenate.
   Ạ  All; Tell if all elements of the resulting 1D array are truthy.

Ạ 원자는 파이썬처럼 행동 all하므로 금지 된 Ȧ와는 조금 다릅니다.

자바 스크립트 (ES6), 34 바이트

a=>a.length&&+!~`,${a}`.search`,0`

테스트 사례

let f =

a=>a.length&&+!~`,${a}`.search`,0`

console.log('Truthy:')
console.log(f([1]))
console.log(f([10]))
console.log(f([[]]))
console.log(f([[[[1]]]]))
console.log(f([[], [1], [1, 2]]))
console.log(f([[1], [1, [2]], [1, [2, [3]]]]))
console.log(f([[8], [8, [9]], [8, [9, [10]]]]))

console.log('Falsy:')
console.log(f([]))
console.log(f([0]))
console.log(f([0, -1]))
console.log(f([-1, 0]))
console.log(f([[[[0]]]]))
console.log(f([[0], [1, 2], [3, 4, 5]]))
console.log(f([[8], [8, [9]], [8, [9, [1, 0]]]]))

줄리아, 45 바이트

a(x)=all(a,x);a(x::Int)=x!=0;g(x)=x!=[]&&a(x)

g재귀 함수를 호출하여 Ȧ이 1인지 0인지를 나타내는 함수 를 만듭니다 a. 적합 a하도록 여러 디스패치를 ​​사용합니다.

# A method for scalar values
a(x::Int) = x != 0

# A recursive fallback for arrays
a(x) = all(a, x)

함수 all는 함수 인수를 취하므로 a입력의 각 요소를 호출 합니다. 그런 다음 제출을위한 함수를 다음과 같이 간단히 정의합니다.

g(x) = x != [] && a(x)

기본적으로 우리는 필요 a하지만 올바르게 처리하기 위해 점검해야합니다.[] .

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

Grime , 16 14 11 바이트

5 바이트를 절약 한 Zgarb에게 감사합니다.

e`s\0v#|!..

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

은 e시도하고 전체 입력에 맞게 인쇄 할 피부를 깨끗하게 지시 0또는 1그 가능 여부에 따라.

가 |!있기 때문에, 효과적으로 "도"연산자 x|!y에 대한 속기입니다 (x|y)!. 따라서 입력 앞에 0이없고 기호가없고 두 문자 ( []) 만 포함하지 않아야 합니다.

후반부에 대한 메모 :의 P#일치 항목이 하나 이상 포함 된 사각형과 일치합니다 P. 그러나 우리의 경우에 P모두 구성 s하고 \0수 있도록 일반적으로 괄호를 요구한다 : (s\0)#(의 우선 순위가 있기 때문에 #너무 높다). 그러나 피부를 깨끗하게은 당신이 운영자의 우선 순위를 수정할 수있는 정말 깔끔한 기능을 가지고 ^와 v. 따라서 v#우리는 #우선 순위를 낮추어 다른 연산자 (연결 포함)보다 낮으므로 괄호에 바이트를 저장할 수 있습니다.

핍 , 12 바이트

#Va&`\b0`NIa

배열을 Pip repr 형식의 명령 줄 인수로 사용합니다 (예 :) [1;[2;3]]. 반환 1truthy를 들어, 0falsey합니다. 온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 .

설명

              a is 1st cmdline arg (implicit)
 Va            Eval a (converting from a string to a list)
#              Take the length (0 if empty, nonzero if nonempty)
   &          Logical AND
    `\b0`      Regex pattern: word boundary followed by 0 (avoids things like 10)
         NIa   Not in a (0 if `\b0` matches in a, 1 if it doesn't)
              Autoprint

보너스 답변, 12 바이트

대신 목록을 가져 오는 함수가 있습니다.

#_>0=0N_Js^s

#_            Len(arg)
  >0          is greater than 0
    =         which also equals the following (comparison operators chain like Python's):
     0N       Count of 0's in
       _Js^s  arg, joined on space and then split on space (a hacky way to flatten)

TIO

로다 , 59 44 바이트

f a{[1]if{g(a)[[]!=a]}}g a{[a!=0];try a|g _}

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

f스트림의 입력을 다른 목록과 정수를 포함 할 수있는 목록으로 가져옵니다. 그것은 반환 1경우 atruthy 아무것도 그렇지 않으면이다. 도우미 함수 g는 a0 이 포함되어 있는지 확인합니다 .

설명:

f a{[1]if{g(a)[[]!=a]}}
f a{                  } /* Function declaration */
          g(a)          /* Call g -> pushes some booleans to the stream */
              [[]!=a]   /* Push value []!=a to the stream */
       if{           }  /* If all booleans in the stream are true: */
    [1]                 /*   Push 1 to the stream */
                        /* Otherwise return nothing */

g a{[a!=0];try a|g _}   /* Helper function */
g a{                }   /* Function declaration */
    [a!=0];             /* Push value a!=0 to the output stream */
           try          /* Ignore errors in the following if a is not a list */
               a        /* Push values in a to the stream */
                |g _    /* Pull values from the stream and */
                        /*   call g for each of them */
                        /*   (pushes boolean values to the output stream) */

정규식을 사용하는 솔루션은 훨씬 짧을 수 있습니다.

이 값은 여러 값을 반환하도록 허용 된 경우 더 짧을 수 있습니다 . 이것은 이전의 답변 중 하나 에서 논의되었으며 기본 규칙에서 다른 입력에 대해 다른 진실성 및 허위 값을 반환하는 것이 허용되지만 어떤 이유로 OP가 여기저기서 금지한다는 결론을 내 렸습니다. :(

Wonder , 15 바이트

@&#0! iO0flat#0

용법:

(@&#0! iO0flat#0)[1;2;3;[8;9;0]]

입력을 평평하게하고, 모든 발생을 0, 논리적 NOT, 논리적 AND로 입력하십시오.

하스켈 , 62 바이트

import Data.List
(%)=isInfixOf
f x=not(",0"%x||"[0"%x)&&x<"[]"

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

이것은 기능 String -> Bool입니다. Haskell의 목록은 이기종이므로 ​​목록을 나타내는 기본 제공 방법은 없습니다 [0, [0]].

파이썬 2 , 45 39 38 바이트

lambda a:(a>[])^(' 0'in`a`or'[0'in`a`)

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

@BenFrankel 덕분에 -6

리스트를 문자열 repr, 68 바이트로 변환하지 않은 이전 버전 :

lambda a:(len(a)and g(a))*1
g=lambda b:all(map(g,b))if b>[]else b!=0

MATLAB, 49 바이트

MATLAB (및 Octave)은 이러한 종류의 중첩 배열을 허용하지 않기 때문에이를 문자열로 해석합니다.

먼저 숫자가 아닌 모든 문자를 공백으로 바꿉니다. 그런 다음 str2num(1D) 배열로 변환하여 적용 할 수 있습니다 all(이 작업 자체를 완전히 해결하지 못하므로 허용됩니다).

s=input('');s(s<45|s>57)=32;disp(all(str2num(s)))

egrep, 7 + 3 = 10 바이트

\<0|^.]

-v결과를 반전시키는 데 필요한 플래그에 +3 바이트

Grep doesn't have any concept of arrays, so this uses a string representation as given in the question. Takes input on one line from stdin, returns via the exit code (ignore stdout).

(Now using a version which doesn't account for 01 and similar, since word-of-god is that it's OK)

Original bash/grep entry:

grep -Ev '\<0+\>|^.]'

Finds 0s anywhere (using the word boundary checks \< and \> to discount things like 10 or a1), or a whole string matching [], then inverts the match.

Breakdown:

grep
     -E \    # extended regular expression syntax
     -v \    # invert match
     \<0+\>  # a number of 0s with alphanumeric boundaries on both sides
     |^.\]   # or ']' as the second character (implies '[]')

Javascript ES6, 24 chars

Works with array, returns 1 or 0:

a=>!!a[0]&!/\b0/.test(a)

Test:

f=a=>!!a[0]&!/\b0/.test(a)

console.log([
  [1],
  [10],
  [[]],
  [[[[1]]]],
  [[], [1], [1, 2]],
  [[1], [1, [2]], [1, [2, [3]]]],
  [[8], [8, [9]], [8, [9, [10]]]],
].every(x => f(x)===1))

console.log([
  [],
  [0],
  [0, -1],
  [-1, 0],
  [[[[0]]]],
  [[0], [1, 2], [3, 4, 5]],
  [[8], [8, [9]], [8, [9, [1, 0]]]],
].every(x => f(x)===0))

√ å ı ¥ ® Ï Ø ¿ , 12 4 bytes

i0Bu

Explanation

i            › Take input as a list and automatically flatten it. If empty, push 0.
 0           › Push 0 to the stack
  B          › Pop 0 and push the number of times it appears
   u         › convert top value to its boolean 

If result needs to be outputted ...

i0Buo        › same as above; o outputs the top value on the stack

Previous solution

I had posted this before realising that stack based languages could leave the value on the stack as a form of output

i0B¿0oP?!¿o?

Explanation

i            › Take input as a list and automatically flatten it. If empty, push 0.
 0           › Push 0 to the stack
  B          › Pop 0 and push the number of times it appears
   ¿         › If the top value is true ...
    0        › Push 0
     o       › Output the top value on the stack
      P      › Pop the top value from the stack
       ?     › End if statement
        !    › Boolean opposite of top value
         ¿   › If the top value is true ...
          o  › Output the top value
           ? › End if statement

Haskell, 45

As Lynn and xnor remarked, Haskell does not come with a heterogeneously-nested list type. But it's easy to add them as a custom data type and let the function operate on that type, and this is much preferrable to operating on (urgh!) strings.

data L=L Int|T[L]
f(L n)=n/=0
f(T l)=all f l

To actually be able to write out such lists as literals with [1, [2]] syntax, you also need some typeclass fu. Full test case:

{-# LANGUAGE OverloadedLists, TypeFamilies #-}
import GHC.Exts (IsList(..))

instance Num L where
  fromInteger = L . fromInteger
  negate (L n) = L $ negate n
instance IsList L where
  type Item L = L
  fromList = T
main = mapM_ (print . f) (
                    [ [1]
                    , [[[[0]]]]
                    , [[8], [8, [9]], [8, [9, [1, 0]]]]
                    ] :: [L])

Try it online!

Vim, 23 bytes

:g/0\|^..$/d
:s/.\+/1/<CR>

Try it online!

Outputs an empty string for false, or 1 for true. This could be shorter if I can output an empty string or [] for false (both of which are falsy values in vim).

Stacked, 20 bytes

:size\flat,0 eq none

Try it online!

Alternatively, using a string:

:tostr'\d+'match'0'has¬\size¬>

Try it online!

Lithp, 74 bytes

(def f #L::((foldl(flatten L)(?(>(length L)0)1 0)#N,A::((?(== N 0)0 A)))))

Try it online!

Well, this turned out longer than I'd hoped. The [] case tripped me up and added a few bytes. It simply flattens the list and does a fold left over it, and if it finds a 0 it sets the accumulator to 0.

Ruby, 24 22 bytes

->a{a[0]&&a*?!!~/\b0/}

Try it online!

Yes I know there's a better solution in Ruby but I wanted to find one taking the array in input instead of a string.

tinylisp, 70 64 bytes

(load library
(d _(q((X)(i(c()X)(all(map _ X))X
(q((L)(i L(_ L)0

The last line is an unnamed lambda function that takes a list and returns 1 for "truthy-under-Ȧ" and 0 for falsey. Try it online!

Ungolfed

(load library)

(def _Ȧ
 (lambda (val)
  (if (equal? (type val) List)
   (all (map _Ȧ val))
   val)))

(def Ȧ
 (lambda (ls)
  (if ls
   (_Ȧ ls)
   0)))

The recursive helper function _Ȧ does most of the work. If its argument is a list, we map _Ȧ to its elements and return 1 if they are all truthy, 0 if any are falsey. (Conveniently, all returns 1 when given the empty list.) Otherwise, the argument must be an integer; we return it as-is (0 is falsey and all other integers are truthy in tinylisp).

The main function Ȧ checks if the list is nonempty. If so, it calls _Ȧ; if not, it returns 0.

The golfed version takes advantage of some undefined behavior: rather than using (e(type X)List) to test whether X is an integer or a list, it does (c()X), which attempts to cons (prepend) the empty list onto X. If X is a list, this results in a nonempty list, which is truthy. If X is an integer, tinylisp outputs an error message and returns an empty list, which is falsey. Since stderr is ignored, this approach is valid.

PHP, 63 54 bytes

9 bytes saved by @user63956

function a($a){return$a&&!strpos(print_r($a,1)," 0");}

takes an array as input; returns true or false: If $a is not empty,
check if print_r output contains a 0 value.

array solution, 83 bytes

function b($a,$r=0){$r|=$a;foreach($a as$v)$r|=is_array($v)?b($v,1):!!$v;return$r;}

recursive function returns 1 or 0.

breakdown

function b($a,$r=0)
{
    $r|=$a;         # if $a is not empty, set $r (no effect in recursion)
    foreach($a as$v)    # loop through elements:    
        $r&=is_array($v)    # 2. if test failed, clear $r
            ?b($v,1)        # 1. if array, recurse
            :!!$v;          #    else test element <>0
    return$r;           # return $r
}