Hintergrund

Inspiriert von Octaves (und, im weiteren Sinne, MATLs) sehr praktischer Interpretation von Wahrheits- / Falschmatrizen, erhielt Jelly das Ȧ- Atom (Octave-style all ).

Ȧ nimmt ein Array als Eingabe und gibt 1 zurück, wenn das Array nicht leer ist und an keiner Stelle in der Baumstruktur die Zahl 0 (Integer, Float oder Complex) enthält . Andernfalls wird 0 zurückgegeben .

Beispielsweise ist das Array [[]] wahr, weil es nicht leer ist und keine Nullen enthält, aber [[0]] ist falsch, weil es auf der innersten Ebene eine 0 enthält .

Aufgabe

Schreiben Sie in einer Programmiersprache Ihrer Wahl ein vollständiges Programm oder eine Funktion, die ein möglicherweise leeres, möglicherweise gezacktes Array von Ganzzahlen als Eingabe verwendet und einen wahren oder falschen Wert ausgibt oder zurückgibt , der angibt, ob Ȧ 1 oder 0 zurückgeben würde .

Ihr Beitrag muss den folgenden Regeln entsprechen.

• Die Wahrheits- und Falschwerte müssen für alle Eingaben konsistent sein , dh alle Arrays, für die Ȧ 1 zurückgibt, müssen demselben Wahrheitswert zugeordnet sein, und alle Arrays, für die Ȧ 0 zurückgibt, müssen demselben Falschwert zugeordnet sein.

• Da vollständige Programme nur Zeichenfolgendarstellungen von Arrays als Eingabe verwenden können, ist dies zulässig. Sie müssen jedoch die kanokische Darstellung Ihrer Sprache verwenden, wie sie von reproder ähnlich zurückgegeben wurde.

  Insbesondere können Sie nicht davon ausgehen, dass vor dem ersten Element des Arrays ein Leerzeichen steht.

• Wenn (und nur wenn) Ihre Sprache keine gezackten Arrays nativ darstellen kann, können Sie eine Zeichenfolgendarstellung der Eingabe unter Verwendung der kanonischen Syntax einer vorhandenen Programmiersprache vornehmen.

• Wenn Ihre Sprache über mehrere Darstellungsmöglichkeiten für gezackte Arrays verfügt (z. B. Listen und Tupel), müssen Sie nur eines davon unterstützen.

• Wenn Ihre Sprache über eine integrierte Funktion verfügt, die selbst eine gültige Vorlage für diese Herausforderung darstellt, können Sie sie in Ihrer Antwort möglicherweise nicht verwenden . Alle anderen Einbauten sind erlaubt.

• Es wird empfohlen, Antworten sowohl mit Array- als auch mit String-Manipulation zu veröffentlichen, auch wenn eine deutlich kürzer ist als die andere.

• Es gelten alle gängigen Code-Golf- Regeln.

Möge der kürzeste Code in Bytes gewinnen!

Wahrheitstestfälle

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

Falsche Testfälle

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

Gelee, 3 Bytes

ṭFẠ

F verflacht die Eingabeliste.

ṭ die ursprüngliche Eingabeliste als Element anheftet, was genau dann falsch ist, wenn es leer ist.

Ạ prüft dann, ob ein Element in der reduzierten Liste oder die ursprüngliche Liste selbst falsch ist.

(Originalantwort)

FẠ^Ṇ

Vielen Dank an Dennis für die Anregung, eine zu ihm passende Lösung zu finden.

FẠGibt 0, wenn die Eingabe einen falschen Wert in einer beliebigen Tiefe enthält, andernfalls 1. Dies ist Ȧ, mit Ausnahme von leeren Listen, der Fall.

Ṇ Gibt 1, wenn die Eingabe ein falscher Wert ist, andernfalls 0. Die einzige falsche Liste ist die leere Liste.

XOR-Verknüpfung der beiden gibt die Antwort.

F;WẠ

Dies entspricht in etwa dem von Dennis F;LẠ, aber anstatt Leine Null in die Liste einzufügen, wenn die Liste leer ist, wird Wdie leere Liste in sich selbst [[]]eingefügt (produziert ), sodass sie ein falsches Element enthält.

Retina , 10 Bytes

A`\b0
^...

Probieren Sie es online!

Zuerst entfernen wir die Eingabe, wenn sie eine Null enthält. Wir versuchen, mindestens drei Zeichen vom Anfang des Strings an abzugleichen (um sicherzustellen, dass die Eingabe in der vorherigen Phase nicht beseitigt wurde oder nur []von Anfang an erfolgte).

Ruby, 25 24 23 18 16 Bytes

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

Benötigt das -nFlag in der Kommandozeile (+1 Byte, -e-> -ne).

Probieren Sie es online!

Dies ist ein vollständiges Programm, das Eingaben in Rubys kanonischem Array-Format für STDIN und Ausgaben trueoder falsefür STDOUT akzeptiert.

 $_              # 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 Byte Funktionsversion:

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

Dies ist ein Prozess, der ein Argument akzeptiert, das zu testende Array.

Danke an Martin Ender für ein Byte und an Ventero für zwei Byte!

Gelee , 4 Bytes

FẠ_Ṇ

Probieren Sie es online!

Ȧergibt, 0wenn die Eingabe leer ist oder a enthält 0, sonst ist es 1.

FẠErgibt, 0wenn die abgeflachte Eingabe a enthält 0, und lässt nur den Kantenfall eines leeren Arrays (da garantiert wird, dass die Eingabe ein Array ist).

Ṇist eine nicht vektorisierende logische Nicht-Monade und gibt daher 0für jede nicht leere Liste und 1für die leere Liste zurück. Als solches kann dies einfach vom Ergebnis der FẠVerwendung abgezogen werden _.

05AB1E , 9 8 Bytes

-1 Bytes dank Emigna

)Q¹˜0å~_

Erläuterung:

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

Probieren Sie es online!

Mathematica, 17 Bytes

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

FreeQprüft 0für uns gegen , aber natürlich würde es Truezur Eingabe zurückkehren {}, also müssen wir diesen Fall separat prüfen.

APL (Dyalog), 21 12 7 Bytes

Golf 5 Bytes dank Adám mit Gabeln

⍬∘≡⍱0∊∊

Probieren Sie es online!

Dies ist mein erster Versuch bei Dyalog. Golftipps sind willkommen!

Erläuterung

⍬∘≡                   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

Operation Flashpoint- Skriptsprache, 199 188 Byte

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}}

Rufen Sie an mit:

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

oder mit:

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

Erläuterung:

In der Skriptsprache des Spiels kann jeder String mit Code aufgerufen werden. Die geschweiften Klammern {}kennzeichnen den Anfang und das Ende einer Zeichenfolge. (Anführungszeichen funktionieren auch, aber das wird chaotisch, wenn sie verschachtelt sind.) Weist der Variablen also A={...}eine Zeichenfolge zu A, und die Variable kann dann wie eine Funktion mit den folgenden Befehlen aufgerufen werden:<argument> call A . Grundsätzlich kann jede Zeichenfolge als Codeblock behandelt werden.

Dann Adefinieren wir innerhalb der "Funktion" eine andere Funktion f. privatedeklariert die beiden Variablen _iund _rlocal zu functionf . Der Name einer lokalen Variablen muss mit einem Unterstrich beginnen.

while {} do {} ist eine Schleife, in der der erste String (bezeichnet mit {} ) den Code für die Schleifenbedingung und die zweite den Code für den Schleifenkörper enthält.

_thisist das Argument, das mit der callFunktion übergeben wurde._thiskann von jedem Typ sein, aber hier nehmen wir an, dass es sich um ein Array handelt.

o=_this select _iGreift in der Schleife auf das Element _i: th des Arrays zu und weist es der Variablen zu o. if (o in [o])ist ein Trick, um festzustellen, ob oes sich um ein anderes Array handelt oder nicht. Wenn oes sich um eine Zahl (oder etwas anderes als ein Array) handelt, o in [o]wird trueder inWert auf ausgewertet , da die Funktion einen Wert findet, der mit odem Array übereinstimmt [o]. Wenn oes sich um ein Array handelt, liefert der Ausdruck false, da der inVergleich von Arrays verweigert wird.

Wenn oes sich nicht um ein Array handelt, prüfen wir, ob es gleich Null ist. Wenn dies der Fall ist, setzen wir die Variable _r, die wir als Rückgabewert verwenden, auf Null. Andernfalls oweisen wir , wenn es sich um ein Array handelt, _rden Rückgabewert des rekursiven Aufrufs fmit dem neuen Array zuo als Argument zu.

Nach der Schleife wird am Ende der Funktion fder Ausdruck ausgewertet _r, der den Wert von ergibt. Da _rdies der letzte auszuwertende Ausdruck ist, gibt der Funktionsaufruf diesen fzurück.

Nachdem wir definiert haben f( fmüssen nicht drinnen sein A, aber auf diese Weise hätten wir es als lokale Variable / Funktion deklarieren können (kein Unterschied), Awenn wir nicht einige Bytes speichern wollten), gehen wir zurück A. if (count _this == 0)prüft, ob Adas Eingabearray leer ist und Agibt ansonsten 0 zurück. Andernfalls wird die Funktion faufgerufen und ihr Rückgabewert wirdA Rückgabewert.

Man könnte bemerken, dass an einigen Stellen ein Semikolon fehlen würde, aber dies ist nicht der Fall, da ein Semikolon nur nach einer Anweisung benötigt wird, wenn eine andere Anweisung innerhalb desselben Codeblocks (dh einer Zeichenfolge) darauf folgt.

Perl 5 , 15 Bytes

Mit derselben Technik wie bei der Ruby-Antwort von Doorknob wurden 2 Byte gespeichert .

14 Byte Code + -pFlag

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

Probieren Sie es online!

/.../sichergestellt , dass das Array nicht leer ist (es wird auf jedem Array entsprechen aber [].
/\b0/wird übereinstimmen nur , wenn es eine ist , 0in der Anordnung. (Die \bsichergestellt , dass die 0nicht ein Teil einer anderen Zahl , sondern eine ganze Zahl ist).

Haskell , 48 Bytes

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

Probieren Sie es online!

Vielen Dank an Lynn für die Testfälle und den x<"[]"Trick.

Die äußere Ungleichung muss (x<"[]")True (nicht leere Liste) und or[elem c"[,"|c:'0':_<-scanr(:)[]x]False (keine Nullen) sein.

Zeichen von 0werden als nach ,oder stehend erkannt [, im Gegensatz zu einer Zahl wie 20. Der Ausdruck scanr(:)[]xgeneriert alle ausreichen lund c:'0':_<-erfasst diejenigen, deren zweites Zeichen ist '0'. elem c"[,"Überprüft dann, ob das erste Zeichen ,oder ist [.

Ich gehe hier davon aus, dass Listen im Haskell-Stil keine Leerzeichen enthalten, sondern ','nur durch ersetzt werden können ' '.

Hier ist ein direktes 48-Byte - Verfahren, obwohl es produziert 0‚s und 1‘ s, die nicht truthy / Falsey in Haskell.

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

Gelee , 4 Bytes

F;LẠ

Probieren Sie es online!

Wie es funktioniert

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.

Beachten Sie, dass sich das Ạ-Atom wie das von Python verhält allund sich daher stark von dem verbotenen Ȧ unterscheidet.

JavaScript (ES6), 34 Byte

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

Testfälle

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

Julia, 45 Bytes

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

Dadurch wird eine Funktion erstellt g, die durch Aufrufen einer rekursiven Funktion angibt, ob Ȧ 1 oder 0 ist a. Um ein passendes zu machen a, verwenden wir mehrere Versandarten:

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

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

Die Funktion allnimmt ein Funktionsargument an, also rufen wir aufa jedes Element der Eingabe auf. Dann definieren wir einfach die Funktion für die Einreichung als

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

Grundsätzlich brauchen wir nur a aber mit einem Scheck richtig umgehen [].

Probieren Sie es online!

Schmutz , 16 14 11 Bytes

Vielen Dank an Zgarb für das Speichern von 5 Bytes.

e`s\0v#|!..

Probieren Sie es online!

Das eweist Grime an, zu versuchen, die gesamte Eingabe abzugleichen und 0oder zu drucken1 je nachdem, ob dies möglich ist.

Das |!ist quasi ein "Keinen" Operator, weil x|!yes eine Abkürzung für ist (x|y)!. Wir stellen also sicher, dass die Eingabe weder eine Null mit vorangestelltem Symbol enthält, noch eine Zeichenfolge mit nur zwei Zeichen ( []) ist.

Ein Hinweis zur zweiten Hälfte: P#Stimmt mit einem Rechteck überein, das mindestens eine Übereinstimmung von enthält P. In unserem Fall Pbesteht es jedoch aus beidem sund \0das würde normalerweise Klammern erfordern: (s\0)#(weil die Priorität von #zu hoch ist). Aber Grime hat eine wirklich nette Funktion, mit der Sie die Priorität von Operatoren mit ^und ändern können v. Wenn Sie also die Priorität von v#wir #verringern, ist sie niedriger als die eines anderen Operators (einschließlich Verkettung), wodurch wir ein Byte in den Klammern speichern können.

Pip , 12 Bytes

#Va&`\b0`NIa

Nimmt das Array als Befehlszeilenargument in Pips Repr-Form wie [1;[2;3]]. Returns 1für truthy, 0für Falsey. Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung

              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

Bonusantwort, 12 Bytes

Hier ist eine Funktion, die stattdessen eine Liste annimmt:

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

Röda , 59 44 Bytes

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

Probieren Sie es online!

fNimmt die Eingabe aus seinem Stream als Liste, die andere Listen und ganze Zahlen enthalten kann. Es kehrt zurück, 1wenn aes wahr ist und sonst nichts. Die Hilfsfunktion gprüft, ob aNullen enthalten sind.

Erläuterung:

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) */

Eine Lösung, die reguläre Ausdrücke verwendet, könnte sehr wahrscheinlich kürzer sein.

Diese Antwort hätte kürzer sein können, wenn mehrere Werte zurückgegeben werden könnten . Dies wurde bereits in einer meiner Antworten besprochen , und es wurde der Schluss gezogen, dass es in den Standardregeln zulässig ist, unterschiedliche wahrheitsgemäße und falsche Werte für unterschiedliche Eingaben zurückzugeben, aber aus irgendeinem Grund verbietet OP dies hier und da. :(

Wunder , 15 Bytes

@&#0! iO0flat#0

Verwendung:

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

Eingabe reduzieren, alle Vorkommen von 0, logisches NICHT, logisches UND mit Eingabe abrufen.

Haskell , 62 Bytes

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

Probieren Sie es online!

Dies ist eine Funktion String -> Bool. Haskells Listen sind heterogen, so dass es keine eingebaute Möglichkeit gibt, Listen wie diese darzustellen [0, [0]].

Python 2 , 45 39 38 Bytes

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

Probieren Sie es online!

-6 danke an @BenFrankel

Vorgängerversion, ohne Konvertierung der Liste in String Repr, 68 Bytes:

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

MATLAB, 49 Bytes

Da MATLAB (wie auch Octave) diese Art von verschachtelten Arrays nicht zulässt, interpretieren wir es als String.

Zuerst ersetzen wir alle nichtstelligen Zeichen durch ein Leerzeichen. Dann str2numkonvertieren wir es in ein (1D) -Array, auf das wir anwenden können all(was erlaubt ist, da es diese Aufgabe nicht vollständig alleine löst.)

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

egrep, 7 + 3 = 10 Bytes

\<0|^.]

+3 Bytes für das erforderliche -vFlag zum Invertieren des Ergebnisses.

Grep kennt kein Array-Konzept, daher wird eine in der Frage angegebene Zeichenfolgendarstellung verwendet. Übernimmt die Eingabe in einer Zeile von stdin und kehrt über den Exit-Code zurück (ignoriere stdout).

(Jetzt mit einer Version, die nicht berücksichtigt 01 und ähnlich ist, da Gottes Wort ist, dass es in Ordnung ist)

Ursprünglicher bash / grep Eintrag:

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

Findet 0s überall (mit den Wortbegrenzungsprüfungen \<und\> um Dinge wie zu diskontieren10 odera1 ) oder eine ganze Zeichenfolge, die übereinstimmt[] abzuwerten und invertiert die Übereinstimmung.

Nervenzusammenbruch:

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 Zeichen

Funktioniert mit Array, Retouren 1oder 0:

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

Prüfung:

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

Erläuterung

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 

Wenn das Ergebnis ausgegeben werden muss ...

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

Vorherige Lösung

Ich hatte dies gepostet, bevor mir klar wurde, dass stapelbasierte Sprachen den Wert als Ausgabeform auf dem Stapel belassen können

i0B¿0oP?!¿o?

Erläuterung

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

Wie Lynn und xnor bemerkten, wird Haskell nicht mit einem heterogen verschachtelten Listentyp geliefert . Es ist jedoch einfach, sie als benutzerdefinierten Datentyp hinzuzufügen und die Funktion auf diesen Typ anwenden zu lassen. Dies ist der Verwendung von (urgh!) - Zeichenfolgen weitaus vorzuziehen .

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

Um solche Listen tatsächlich als Literale mit [1, [2]]Syntax ausschreiben zu können , benötigen Sie auch Typeclass Fu. Vollständiger Testfall:

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

Probieren Sie es online!

Vim, 23 Bytes

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

Probieren Sie es online!

Gibt eine leere Zeichenfolge für false oder 1true aus. Dies kann kürzer sein, wenn ich eine leere Zeichenfolge ausgeben kann oder [] falsch (beides sind falsche Werte in vim).

Gestapelt , 20 Bytes

:size\flat,0 eq none

Probieren Sie es online!

Alternativ können Sie eine Zeichenfolge verwenden:

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

Probieren Sie es online!

Lithp , 74 Bytes

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

Probieren Sie es online!

Nun, das war länger, als ich gehofft hatte. Der []Fall löste mich aus und fügte ein paar Bytes hinzu. Die Liste wird einfach geglättet und es wird ein Fold darüber ausgeführt. Wenn eine 0 gefunden wird, wird der Akku auf 0 gesetzt.

Ruby , 24 22 Bytes

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

Probieren Sie es online!

Ja, ich weiß, es gibt eine bessere Lösung in Ruby, aber ich wollte eine finden, die das Array in der Eingabe anstelle einer Zeichenfolge verwendet.

tinylisp , 70 64 Bytes

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

Die letzte Zeile ist eine unbenannte Lambda-Funktion, die eine Liste aufnimmt und 1für "truthy under Ȧ" und 0für "falsey" zurückgibt. Probieren Sie es online!

Ungolfed

(load library)

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

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

Die rekursive Hilfsfunktion _Ȧerledigt den größten Teil der Arbeit. Wenn sein Argument eine Liste ist, map _Ȧkehren wir zu seinen Elementen zurück und prüfen, ob 1sie allwahr sind oder ob sie falsch 0sind. (Praktischerweiseall zurückkehrt , 1wenn die leere Liste angegeben.) Ansonsten müssen ganzzahlig sein; wir geben es so zurück, wie es ist (0 ist falsch und alle anderen ganzen Zahlen sind in tinylisp wahr).

Die Hauptfunktion Ȧ prüft, ob die Liste nicht leer ist. Wenn ja, ruft es an _Ȧ; Wenn nicht, kehrt es zurück0 .

Die Golf-Version nutzt ein undefiniertes Verhalten: Anstatt (e(type X)List)zu testen, ob Xes sich um eine Ganzzahl oder eine Liste handelt (c()X), versucht sie, consdie leere Liste voranzustellenX . Wenn Xes sich um eine Liste handelt, wird eine nicht leere Liste erstellt, die der Wahrheit entspricht. Wenn Xes sich um eine Ganzzahl handelt, gibt tinylisp eine Fehlermeldung aus und gibt eine leere Liste zurück, die falsch ist. Da stderr ignoriert wird, ist dieser Ansatz gültig.

PHP, 63 54 Bytes

9 Bytes gespeichert von @ user63956

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

nimmt ein Array als Eingabe; gibt zurück trueoder false: Wenn $anicht leer ist,
überprüfen Sie, ob die print_rAusgabe a enthält0 Wert .

Array-Lösung, 83 Bytes

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

rekursive Funktion gibt zurück 1 oder zurück 0.

Nervenzusammenbruch

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
}