背景

受到Octave（以及扩展为MATL）对真/伪矩阵的非常方便的解释的启发，Jelly得到了Ȧ（所有八度音阶）原子。

Ȧ将数组作为输入，如果数组为非空并且在树结构中的任何位置都不包含数字0（整数，浮点数或复数），则返回1；否则，返回0。

例如，数组[[]]是真实的，因为它是非空的并且不包含零。而[[0]]是虚假的，因为它在最内层包含0。

任务

用您选择的编程语言编写一个完整的程序或函数，该函数或函数将可能为空的，可能是锯齿状的整数数组作为输入，并打印或返回一个真值或伪值，该值指示a 分别返回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。唯一的虚假列表是空列表。

将两者异或给出答案。

F;WẠ

这与Dennis的精神基本相同F;LẠ，但是L当列表为空时，它不是在列表中使用零，而是W将空列表放入自身（产生[[]]），从而使其包含虚假元素。

视网膜，10字节

A`\b0
^...

在线尝试！

首先，如果输入包含零，则将其删除。我们尝试从字符串开头至少匹配三个字符（以确保输入在上一阶段没有被消除，或者仅仅[]是从头开始）。

Ruby，25 24 23 18 16字节

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

-n在命令行上需要标志（+1字节，-e-> -ne）。

在线尝试！

这是一个全程序，它输入在上STDIN和输出Ruby的规范数组格式true或false上STDOUT。

 $_              # 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。

感谢Martin Ender提供一个字节，并感谢Ventero提供两个字节！

果冻，4字节

FẠ_Ṇ

在线尝试！

Ȧ产生0，如果输入是空的或包含一个0，否则是1。

FẠ0如果拼合的输入包含a 0，则产生，仅保留空数组的边缘情况（因为保证输入是数组）。

Ṇ是一个非向量化逻辑非monad，因此返回0任何非空列表和1空列表。这样此可以简单地从结果来subtraced FẠ使用_。

05AB1E，9 8字节

-1字节归功于Emigna

)Q¹˜0å~_

说明：

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

在线尝试！

Mathematica，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

操作Flashpoint脚本语言，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={...}将字符串分配给变量A，然后可以像下面的函数一样调用该变量：<argument> call A。基本上，任何字符串都可以视为代码块。

然后，在“函数”内部A，定义另一个函数f。private声明两个变量_i和_r函数的局部变量f。局部变量的名称必须以下划线开头。

while {} do {} 是一个循环，其中第一个字符串（由 {}）包含用于循环条件的代码，第二个用于循环主体。

_this是随call函数传递的参数。_this可以是任何类型，但是在这里我们假设它是一个数组。

在循环中，o=_this select _i访问数组的_i：th元素并将其分配给variable o。if (o in [o])这是确定o数组是否为另一个数组的技巧。If o是一个数字（或数组以外的任何东西），o in [o]将求值为true，因为该in函数o从array中找到一个匹配的值[o]。如果o为数组，则表达式产生false，因为in拒绝比较数组。

如果o不是数组，则检查它是否等于零，如果是，则将变量_r（用作返回值）设置为零。否则，如果o是一个数组，则将新数组分配给_r递归调用的返回值fo作为参数。

循环后，在函数末尾f，我们对expression求值，该表达式_r产生的值_r，并且由于这是要求值的最后一个表达式，因此这是对函数的调用f返回的结果。

既然我们已经定义了f（f不必在里面A，但是通过这种方式，我们可以将其声明为局部变量/函数（A如果我们不想保存一些字节，实际上没有区别）），让我们返回A。if (count _this == 0)检查A的输入数组是否为空，如果为空，则A返回0。否则f调用该函数，其返回值将为A返回值。

可能会注意到，似乎在某些地方会缺少分号，但事实并非如此，因为只有在同一条代码块（即字符串）中紧随另一条语句之后，才需要在一条语句后使用分号。

Perl 5、15个字节

使用与Doorknob的Ruby answer相同的技术节省了2个字节。

14个字节的代码+ -p标志

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

在线尝试！

/.../ 确保数组不为空（它将与任何数组匹配，但 []。
/\b0/仅0在数组中存在时才匹配。（\b确保the 0不是另一个数字的一​​部分，而是一个整数）。

哈斯克尔，48个字节

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

在线尝试！

感谢Lynn提供的测试用例和 x<"[]"技巧。

外部不等式要求(x<"[]")为True（非空列表），并且or[elem c"[,"|c:'0':_<-scanr(:)[]x]为False（无零）。

0检测到的字符在 ,或之后[，而不是像的数字20。该表达式scanr(:)[]x生成的所有满足l，并c:'0':_<-捕获第二个字符为的那些'0'。然后，elem c"[,"检查第一个字符是,还是[。

我在这里假设Haskell样式的列表没有空格，但是如果有的话，','可以将其替换为' '。

这里的一个更直接的48字节的方法，尽管它产生0的和1的哪些不是Truthy / Falsey Haskell中。

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.

请注意，Ạ原子的行为类似于Python的行为all，因此与被禁止的rather完全不同。

JavaScript（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检查一下即可正确处理[]。

在线尝试！

污垢，16 14 11字节

感谢Zgarb节省了5个字节。

e`s\0v#|!..

在线尝试！

该e告诉污秽物，试图匹配整个输入并打印0或1取决于是否这是可能的。

该|!实际上是一个“既不是”运营商，因为x|!y是速记(x|y)!。因此，我们要确保输入的内容既不包含以符号开头的零，也不是仅包含两个字符的字符串（[]）。

关于下半部分的注释：P#匹配一个矩形，该矩形至少包含一个匹配项P。但是，在我们的情况下P，两者都由s和组成，\0因此通常需要括号：（(s\0)#因为的优先级#太高）。但是Grime具有真正的功能，您可以使用^和修改运算符的优先级v。因此，通过使用v#Lower #的优先级，使其比任何其他运算符（包括串联）的优先级都低，这使我们可以在括号中保存一个字节。

点，12字节

#Va&`\b0`NIa

将数组作为Pip的repr形式的命令行参数（如）[1;[2;3]]。退货1真假，0假。在线尝试或验证所有测试用例。

说明

              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)

蒂奥

Röda，59 44字节

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

在线尝试！

f将其流中的输入作为一个列表，其中可以包含其他列表和整数。1如果a为真，则返回，否则为空。辅助功能g检查a包含零。

说明：

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禁止在此处和此处进行输入。:(

不可思议，15个字节

@&#0! iO0flat#0

用法：

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

拼合输入，获得所有出现的0，逻辑非，与输入的逻辑与。

Haskell，62个字节

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

在线尝试！

这是一个功能String -> Bool。Haskell的列表是异类的，因此没有内置方法来表示类似的列表[0, [0]]。

Python 2中，45个39 38字节

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

在线尝试！

-6感谢@BenFrankel

以前的版本，不将列表转换为字符串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|^.]

+3个字节用于-v反转结果。

Grep没有数组的任何概念，因此它使用问题中给出的字符串表示形式。从标准输入取一行输入，通过退出代码返回（忽略标准输出）。

（现在使用没有解释的版本，01并且类似，因为神的话就可以了）

原始bash / grep条目：

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

0在任何地方查找s（使用单词边界检查\<并\>打折诸如10或的东西a1）或整个字符串match []，然后反转匹配。

分解：

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个字符

适用于数组，返回值1或0：

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

测试：

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字节

i0Bu

说明

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 

如果需要输出结果...

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

先前的解决方案

在意识到基于堆栈的语言可能会将值作为输出形式保留在堆栈上之前，我已发布了此内容

i0B¿0oP?!¿o?

说明

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

哈斯克尔，45岁

正如Lynn和xnor所说，Haskell没有附带异构嵌套的列表类型。但是很容易将它们添加为自定义数据类型，然后让函数对该类型进行操作，这比对（urgh！）字符串进行操作更可取。

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

为了真正能够写出带有[1, [2]]语法的文字列表，您还需要一些typeclass fu。完整的测试案例：

{-# 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])

在线尝试！

Vim，23个字节

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

在线尝试！

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
}