sfondo

Ispirato dall'interpretazione molto conveniente di Octave (e, per estensione, di MATL) delle matrici verità / falsa, Jelly ottenne l'atomo Ȧ (stile ottava tutto ).

Ȧ accetta un array come input e restituisce 1 se l'array non è vuoto e non contiene il numero 0 (intero, float o complesso) in qualsiasi punto della struttura ad albero ; in caso contrario, restituisce 0 .

Ad esempio, l'array [[]] è vero perché non è vuoto e non contiene zero, ma [[0]] è falso perché contiene uno 0 al livello più interno.

Compito

In un linguaggio di programmazione a tua scelta, scrivi un programma completo o una funzione che accetta un array di numeri interi eventualmente vuoto, eventualmente frastagliato come input e stampa o restituisce un valore di verità o falsità che indica se Ȧ restituirà rispettivamente 1 o 0 .

La tua richiesta deve rispettare le seguenti regole.

• I valori di verità e falsità devono essere coerenti per tutti gli input , ovvero tutti gli array per i quali Ȧ restituisce 1 devono essere associati allo stesso valore di verità e tutti gli array per i quali Ȧ restituisce 0 devono essere associati allo stesso valore di falsità.

• Poiché i programmi completi possono accettare solo rappresentazioni di stringhe di matrici come input, ciò è consentito. Tuttavia, è necessario utilizzare la rappresentazione canocica della propria lingua, come restituita repro simile.

  In particolare non si può presumere che il primo elemento dell'array sarà preceduto da uno spazio.

• Se (e solo se) il tuo linguaggio non può rappresentare nativamente array frastagliati, puoi prendere una rappresentazione in stringa dell'input, usando la sintassi canonica di qualsiasi linguaggio di programmazione preesistente.

• Se la tua lingua ha diversi modi di rappresentare array frastagliati (ad es. Elenchi e tuple), devi solo supportarne uno.

• Se la tua lingua ha un built-in che è esso stesso un valido contributo a questa sfida, non puoi utilizzarlo nella tua risposta . Sono ammessi tutti gli altri built-in.

• Siete incoraggiati a pubblicare risposte usando sia la manipolazione di array che di stringhe, anche se una è significativamente più corta dell'altra.

• Si applicano tutte le regole standard del code-golf .

Che vinca il codice più breve in byte!

Casi di prova veritieri

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

Casi di prova falsi

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

Gelatina, 3 byte

ṭFẠ

F appiattisce l'elenco di input.

ṭ considera l'elenco di input originale come elemento, che è falso se e solo se è vuoto.

Ạ quindi controlla se qualche elemento nell'elenco appiattito o nell'elenco originale stesso è errato.

(Risposta originale)

FẠ^Ṇ

Grazie a Dennis per aver incoraggiato a trovare una soluzione corrispondente alla sua.

FẠdà 0 se l'input contiene un valore di falsy a qualsiasi profondità, altrimenti 1. Questo è ciò che Ȧfa, tranne per gli elenchi vuoti.

Ṇ dà 1 se l'input è un valore falso, altrimenti 0. L'unica lista falsa è la lista vuota.

XOR-ing i due dà la risposta.

F;WẠ

Questo è molto simile a quello di Dennis F;LẠ, ma invece di usare Lper mettere uno zero nella lista quando la lista è vuota, usa Wper mettere la lista vuota in se stessa (producendo [[]]), facendola contenere un elemento falso.

Retina , 10 byte

A`\b0
^...

Provalo online!

Innanzitutto rimuoviamo l'input se contiene uno zero. Cerchiamo di abbinare almeno tre caratteri dall'inizio della stringa (per garantire che l'input non sia stato eliminato nella fase precedente o fosse solo []per cominciare).

Rubino, 25 24 23 18 16 byte

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

Richiede il -nflag sulla riga di comando (+1 byte, -e-> -ne).

Provalo online!

Questo è un programma completo che accetta input nel formato di array canonico di Ruby su STDIN e output trueo falsesu 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

Versione con funzione a 23 byte :

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

Questo è un proc che accetta un argomento, l'array da testare.

Grazie a Martin Ender per un byte e a Ventero per due byte!

Gelatina , 4 byte

FẠ_Ṇ

Provalo online!

Ȧproduce 0se l'input è vuoto o contiene un 0, altrimenti lo è 1.

FẠproduce 0se l'input appiattito contiene a 0, lasciando solo il caso limite di un array vuoto (poiché si garantisce che l'input sia un array).

Ṇè una logica non monarchica non monade, e quindi ritorna 0per qualsiasi elenco non vuoto e 1per l'elenco vuoto. Come tale, questo può semplicemente essere sottratto al risultato FẠdell'uso _.

05AB1E , 9 8 byte

-1 byte grazie a Emigna

)Q¹˜0å~_

Spiegazione:

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

Provalo online!

Mathematica, 17 byte

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

FreeQfa il check contro 0per noi, ma ovviamente ritornerebbe Trueper input {}, quindi dobbiamo controllare quel caso separatamente.

APL (Dyalog), 21 12 7 byte

Golfato 5 byte grazie ad Adám usando le forcelle

⍬∘≡⍱0∊∊

Provalo online!

Questo è il mio primo tentativo a Dyalog. I consigli sul golf sono i benvenuti!

Spiegazione

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

Operazione linguaggio di scripting Flashpoint , 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}}

Chiama con:

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

o con:

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

Spiegazione:

Nel linguaggio di scripting del gioco, è possibile chiamare qualsiasi stringa contenente codice. Le parentesi graffe {}indicano l'inizio e la fine di una stringa. (Virgolette lavoro troppo, ma che diventa disordinato quando sono annidati.) Quindi, A={...}assegna una stringa alla variabile A, e la variabile può quindi essere chiamato come una funzione con: <argument> call A. Fondamentalmente qualsiasi stringa può essere trattata come un blocco di codice.

Quindi, all'interno della "funzione" A, definiamo un'altra funzione f. privatedichiara le due variabili _ie _rlocale per funzionare f. Il nome di una variabile locale deve iniziare con un trattino basso.

while {} do {}è un ciclo, in cui la prima stringa (indicata da {}) contiene il codice per la condizione del ciclo e la seconda per il corpo del ciclo.

_thisè l'argomento che è stato passato con la callfunzione. _thispuò essere di qualsiasi tipo, ma qui assumiamo che sia un array.

Nel ciclo o=_this select _iaccede all'elemento _i: th dell'array e lo assegna alla variabile o. if (o in [o])è un trucco per determinare se oè un altro array o no. If oè un numero (o qualsiasi cosa diversa da un array), o in [o]valuterà a true, perché la infunzione trova un valore corrispondente odall'array [o]. Se oè un array, l'espressione produce false, perché inrifiuta di confrontare gli array.

Se onon è un array, controlliamo se è uguale a zero e, in caso affermativo, impostiamo la variabile _r, che useremo come valore di ritorno, su zero. Altrimenti, se oè un array, assegniamo al _rvalore restituito della chiamata ricorsiva fcon il nuovo array ocome argomento.

Dopo il ciclo, alla fine della funzione f, valutiamo l'espressione _r, che produce il valore di _r, e poiché questa è l'ultima espressione da valutare, questo è ciò che frestituisce la chiamata alla funzione .

Ora che abbiamo definito f( fnon è necessario essere all'interno A, ma in questo modo avremmo potuto dichiararlo una variabile / funzione locale (nessuna differenza in realtà) Ase non volessimo salvare alcuni byte), torniamo indietro A. if (count _this == 0)controlla se Ala matrice di input è vuota e, se lo è, Arestituisce 0. In caso contrario, la funzione fviene chiamata e il suo valore restituito sarà Ail valore restituito.

Si potrebbe notare che sembra che manchi un punto e virgola in alcuni punti, ma non è così, perché un punto e virgola è necessario solo dopo un'istruzione se un'altra istruzione lo segue all'interno dello stesso blocco di codice (cioè stringa).

Perl 5 , 15 byte

Hai salvato 2 byte usando la stessa tecnica della risposta Ruby di Doorknob .

14 byte di codice + -pflag

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

Provalo online!

/.../assicura che l'array non sia vuoto (corrisponderà a qualsiasi array ma [].
/\b0/corrisponderà solo se è presente un 0array ( \bassicura che 0non sia parte di un altro numero ma un numero intero).

Haskell , 48 byte

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

Provalo online!

Grazie a Lynn per i casi di test e il x<"[]"trucco.

La disuguaglianza esterna richiede (x<"[]")di essere Vero (elenco non vuoto) e or[elem c"[,"|c:'0':_<-scanr(:)[]x]di essere Falso (nessuno zero).

I caratteri di 0vengono rilevati come segue a ,o [, a differenza di un numero simile 20. L'espressione scanr(:)[]xgenera tutti i sufficienti le c:'0':_<-cattura quelli il cui secondo carattere è '0'. Quindi, elem c"[,"controlla se il primo carattere è ,o [.

Suppongo che gli elenchi in stile Haskell non abbiano spazi, ma in tal caso ','possono essere semplicemente sostituiti da ' '.

Ecco un metodo più diretto a 48 byte, sebbene produca 0"e 1" che non sono Truthy / Falsey in Haskell.

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

Gelatina , 4 byte

F;LẠ

Provalo online!

Come funziona

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.

Nota che l'atomo Ạ si comporta come quello di Python alle quindi è piuttosto diverso da quello bandito Ȧ.

JavaScript (ES6), 34 byte

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

Casi test

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 byte

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

Questo crea una funzione gche indica se Ȧ sarebbe 1 o 0 chiamando una funzione ricorsiva a. Per renderlo idoneo a, utilizziamo la spedizione multipla:

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

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

La funzione allaccetta un argomento di funzione, quindi stiamo invocando aogni elemento dell'input. Quindi definiamo semplicemente la funzione per l'invio come

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

Fondamentalmente abbiamo solo bisogno ama con un controllo per gestire correttamente [].

Provalo online!

Grime , 16 14 11 byte

Grazie a Zgarb per aver salvato 5 byte.

e`s\0v#|!..

Provalo online!

Questo edice a Grime di provare a far corrispondere l'intero input e la stampa 0o a 1seconda che sia possibile.

Il |!è effettivamente un operatore di "nè", perché x|!yè una scorciatoia per (x|y)!. Quindi ci assicuriamo che l'ingresso non contenga uno zero preceduto da un simbolo né una stringa di soli due caratteri ( []).

Una nota sulla seconda metà: P#corrisponde a un rettangolo che contiene almeno una corrispondenza di P. Tuttavia, nel nostro caso è Pcostituito da entrambi se \0quindi ciò richiederebbe normalmente parentesi: (s\0)#(perché la precedenza di #è troppo alta). Ma Grime ha una funzionalità davvero ordinata in cui è possibile modificare la precedenza degli operatori con ^e v. Quindi, usando v#abbassiamo #la precedenza in modo che sia inferiore a quella di qualsiasi altro operatore (inclusa la concatenazione), che ci consente di salvare un byte tra parentesi.

Pip , 12 byte

#Va&`\b0`NIa

Prende l'array come argomento della riga di comando nella forma repr di Pip, come [1;[2;3]]. Ritorna 1per la verità, 0per la falsità. Provalo online o verifica tutti i casi di test .

Spiegazione

              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

Risposta bonus, 12 byte

Ecco una funzione che prende invece un elenco:

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

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

Provalo online!

fprende l'input dal suo flusso come un elenco che può contenere altri elenchi e numeri interi. Restituisce 1se aè vero e niente altrimenti. La funzione helper gverifica se acontiene zeri.

Spiegazione:

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

Una soluzione che utilizza regex potrebbe molto probabilmente essere più breve.

Questa risposta avrebbe potuto essere più breve se fosse stato permesso di restituire più valori. Questo è stato discusso in una delle mie risposte in precedenza e si è concluso che nelle regole predefinite è consentito restituire valori di verità e falsità diversi per input diversi, ma per qualche motivo OP lo ha proibito qua e là. :(

Meraviglia , 15 byte

@&#0! iO0flat#0

Uso:

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

Appiattisci input, ottieni tutte le occorrenze di 0, NOT logico, AND logico con input.

Haskell , 62 byte

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

Provalo online!

Questa è una funzione String -> Bool. Gli elenchi di Haskell sono eterogenei, quindi non esiste un modo integrato per rappresentare elenchi come [0, [0]].

Python 2 , 45 39 38 byte

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

Provalo online!

-6 grazie a @BenFrankel

versione precedente, senza convertire l'elenco in repr stringa, 68 byte:

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

MATLAB, 49 byte

Poiché MATLAB (così come Octave) non consente questo tipo di array nidificati, lo interpretiamo come una stringa.

Per prima cosa sostituiamo tutti i caratteri non digitati con uno spazio. Quindi usiamo str2numper convertirlo in un array (1D), sul quale possiamo applicare all(il che è consentito, in quanto non risolve completamente questo compito da solo.)

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

egrep, 7 + 3 = 10 byte

\<0|^.]

+3 byte per il necessario -v flag per invertire il risultato.

Grep non ha alcun concetto di array, quindi utilizza una rappresentazione di stringhe come indicato nella domanda. Prende input su una riga da stdin, ritorna tramite il codice di uscita (ignora stdout).

(Ora usando una versione che non tiene conto 01e simili, poiché la parola di Dio è che va bene)

Voce bash / grep originale:

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

Trova 0s ovunque (usando i controlli al contorno della parola \<e \>per scartare cose come 10o a1), o un'intera stringa corrispondente [], quindi inverte la corrispondenza.

Abbattersi:

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 caratteri

Funziona con array, restituisce 1o 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 byte

i0Bu

Spiegazione

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 

Se il risultato deve essere emesso ...

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

Soluzione precedente

Avevo pubblicato questo prima di rendermi conto che le lingue basate sullo stack potevano lasciare il valore nello stack come una forma di output

i0B¿0oP?!¿o?

Spiegazione

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 anni

Come hanno osservato Lynn e xnor , Haskell non ha un tipo di elenco annidato in modo eterogeneo. Ma è facile aggiungerli come un tipo di dati personalizzato e lasciare che la funzione di operare su quel tipo, e questo è molto più preferibile per operare su (urgh!) Le stringhe .

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

Per essere effettivamente in grado di scrivere elenchi come letterali con [1, [2]]sintassi, è necessario anche un po 'di fu. Caso di prova completo:

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

Provalo online!

Vim, 23 byte

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

Provalo online!

Emette una stringa vuota per false o 1per true. Questo potrebbe essere più breve se riesco a produrre una stringa vuota o [] per falso (entrambi sono valori falsi in vim).

Impilato , 20 byte

:size\flat,0 eq none

Provalo online!

In alternativa, usando una stringa:

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

Provalo online!

Lithp , 74 byte

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

Provalo online!

Bene, questo è risultato più lungo di quanto sperassi. Il []caso mi ha fatto scattare e ha aggiunto alcuni byte. Semplicemente appiattisce l'elenco e fa una piega rimasta su di esso, e se trova uno 0 imposta l'accumulatore su 0.

Rubino , 24 22 byte

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

Provalo online!

Sì, lo so che c'è una soluzione migliore in Ruby, ma volevo trovarne una che prendesse l'array in input anziché una stringa.

tinylisp , 70 64 byte

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

L'ultima riga è una funzione lambda senza nome che accetta un elenco e restituisce 1"verità-sotto-Ȧ" e 0falsità. Provalo online!

Ungolfed

(load library)

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

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

La funzione di supporto ricorsivo _Ȧsvolge gran parte del lavoro. Se il suo argomento è un elenco, torniamo map _Ȧai suoi elementi e ritorniamo 1se sono allveritieri, 0se ne esistono falsi. (Convenientemente, allrestituisce 1quando viene fornito l'elenco vuoto.) In caso contrario, l'argomento deve essere un numero intero; lo restituiamo così com'è (0 è falso e tutti gli altri numeri interi sono veri in tinylisp).

La funzione principale Ȧcontrolla se l'elenco è vuoto. In tal caso, chiama _Ȧ; in caso contrario, ritorna 0.

La versione golfizzata sfrutta un comportamento indefinito: piuttosto che usare (e(type X)List)per testare se Xè un numero intero o un elenco, lo fa (c()X), che tenta di cons(anteporre) l'elenco vuoto su X. Se Xè un elenco, questo si traduce in un elenco non vuoto, il che è vero. Se Xè un numero intero, tinylisp genera un messaggio di errore e restituisce un elenco vuoto, che è falso. Poiché stderr viene ignorato, questo approccio è valido.

PHP, 63 54 byte

9 byte salvati da @ user63956

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

accetta un array come input; ritorna trueo false: Se $anon è vuoto,
controlla se l' print_routput contiene un 0valore.

soluzione array, 83 byte

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

ritorna la funzione ricorsiva 1o 0.

abbattersi

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
}