Contexte

Inspirée par l'interprétation très pratique d'Octave (et, par extension, de MATL) des matrices véridiques / fausses, Jelly a obtenu l' atome Ȧ ( tout style Octave ).

Ȧ prend un tableau en entrée et renvoie 1 si le tableau n'est pas vide et ne contient le numéro 0 (entier, flottant ou complexe) nulle part dans la structure arborescente ; sinon, il renvoie 0 .

Par exemple, le tableau [[]] est véridique car il n'est pas vide et ne contient pas de zéros, mais [[0]] est faux car il contient un 0 au niveau le plus intérieur.

Tâche

Dans un langage de programmation de votre choix, écrivez un programme complet ou une fonction qui prend en entrée un tableau d' entiers éventuellement vide, peut-être dentelé, et imprime ou retourne une valeur vraie ou fausse qui indique si Ȧ retournerait 1 ou 0 , respectivement.

Votre soumission doit respecter les règles suivantes.

• Les valeurs véridiques et fausses doivent être cohérentes pour toutes les entrées , c'est-à-dire que tous les tableaux pour lesquels Ȧ renvoie 1 doivent correspondre à la même valeur véridique, et tous les tableaux pour lesquels Ȧ renvoie 0 doivent correspondre à la même valeur falsifiée.

• Étant donné que les programmes complets ne peuvent prendre que des représentations de chaînes de tableaux en entrée, cela est autorisé. Cependant, vous devez utiliser la représentation canocale de votre langue, telle que renvoyée par reprou similaire.

  En particulier, vous ne pouvez pas supposer que le premier élément du tableau sera précédé d'un espace.

• Si (et seulement si) votre langage ne peut pas représenter nativement des tableaux irréguliers, vous pouvez prendre une représentation sous forme de chaîne de l'entrée, en utilisant la syntaxe canonique de tout langage de programmation préexistant.

• Si votre langue a plusieurs façons de représenter des tableaux irréguliers (par exemple, des listes et des tuples), vous n'avez qu'à prendre en charge l'un d'eux.

• Si votre langue a une fonction intégrée qui est elle-même une soumission valide à ce défi, vous ne pouvez pas l'utiliser dans votre réponse . Tous les autres éléments intégrés sont autorisés.

• Nous vous encourageons à publier des réponses en utilisant à la fois la manipulation de tableaux et de chaînes, même si l'une est beaucoup plus courte que l'autre.

• Toutes les règles de code-golf standard s'appliquent.

Que le code le plus court en octets gagne!

Cas de test authentiques

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

Cas de test de falsification

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

Gelée, 3 octets

ṭFẠ

F aplatit la liste d'entrée.

ṭ punaises sur la liste d'entrée d'origine en tant qu'élément, ce qui est faux si et seulement s'il est vide.

Ạ vérifie ensuite si un élément de la liste aplatie, ou la liste d'origine elle-même, est faux.

(Réponse originale)

FẠ^Ṇ

Merci à Dennis d'avoir encouragé la recherche d'une solution correspondant à la sienne.

FẠdonne 0 si l'entrée contient une valeur falsifiée à n'importe quelle profondeur, sinon 1. C'est ce que Ȧfait, sauf pour les listes vides.

Ṇ donne 1 si l'entrée est une valeur falsifiée, sinon 0. La seule liste falsifiée est la liste vide.

XOR-ing les deux donne la réponse.

F;WẠ

C'est beaucoup dans le même esprit que Dennis F;LẠ, mais au lieu d'utiliser Lpour mettre un zéro dans la liste lorsque la liste est vide, il utilise Wpour mettre la liste vide en elle-même (production [[]]), en la faisant contenir un élément falsifié.

Retina , 10 octets

A`\b0
^...

Essayez-le en ligne!

Nous supprimons d'abord l'entrée si elle contient un zéro. Nous essayons de faire correspondre au moins trois caractères depuis le début de la chaîne (pour garantir que l'entrée n'a pas été éliminée à l'étape précédente, ou ne devait que []commencer).

Rubis, 25 24 23 18 16 octets

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

Nécessite le -ndrapeau sur la ligne de commande (+1 octet, -e-> -ne).

Essayez-le en ligne!

Il s'agit d'un programme complet qui prend les entrées au format de tableau canonique de Ruby sur STDIN et les sorties trueou falsesur 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

Version de la fonction 23 octets :

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

Il s'agit d'un proc qui prend un argument, le tableau à tester.

Merci à Martin Ender pour un octet et à Ventero pour deux octets!

Gelée , 4 octets

FẠ_Ṇ

Essayez-le en ligne!

Ȧdonne 0si l'entrée est vide ou contient un 0, sinon c'est le cas 1.

FẠdonne 0si l'entrée aplatie contient un 0, ne laissant que le cas de bord d'un tableau vide (puisque l'entrée est garantie d'être un tableau).

Ṇest une logique non vectorisante non monade, et retourne donc 0pour toute liste non vide et 1pour la liste vide. En tant que tel, cela peut simplement être retracé du résultat de l' FẠutilisation _.

05AB1E , 9 8 octets

-1 octets grâce à Emigna

)Q¹˜0å~_

Explication:

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

Essayez-le en ligne!

Mathematica, 17 octets

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

FreeQvérifie 0pour nous, mais bien sûr, il reviendrait Truepour entrée {}, nous devons donc vérifier ce cas séparément.

APL (Dyalog), 21 12 7 octets

Golfé 5 octets grâce à Adám en utilisant des fourches

⍬∘≡⍱0∊∊

Essayez-le en ligne!

Ceci est mon premier essai chez Dyalog. Les conseils de golf sont les bienvenus!

Explication

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

Langage de script Operation Flashpoint , 199 188 octets

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

Appeler avec:

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

ou avec:

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

Explication:

Dans le langage de script du jeu, n'importe quelle chaîne contenant du code peut être appelée. Les accolades {}représentent le début et la fin d'une chaîne. (Les guillemets fonctionnent aussi, mais cela devient compliqué lorsqu'ils sont imbriqués.) Donc, A={...}affecte une chaîne à la variableA , et la variable peut ensuite être appelée comme une fonction avec:<argument> call A . Fondamentalement, n'importe quelle chaîne peut être traitée comme un bloc de code.

Ensuite, à l'intérieur de la "fonction" A, nous définissons une autre fonction f. privatedéclare les deux variables _iet _rlocal pour fonctionner f. Le nom d'une variable locale doit commencer par un trait de soulignement.

while {} do {} est une boucle, où la première chaîne (notée par {} ) contient le code de la condition de boucle et la seconde du corps de la boucle.

_thisest l'argument transmis avec la callfonction._thispeut être de tout type, mais ici nous supposons qu'il s'agit d'un tableau.

Dans la boucle, o=_this select _iaccède à l'élément _i: th du tableau et l'affecte à la variable o. if (o in [o])est une astuce pour déterminer s'il os'agit d'un autre tableau ou non. Si oest un nombre (ou autre chose qu'un tableau), o in [o]sera évalué à true, car la infonction trouve une valeur correspondant oau tableau [o]. Si oest un tableau, l'expression donne false, car lein refuse de comparer les tableaux.

Si on'est pas un tableau, nous vérifions s'il est égal à zéro, et si c'est le cas, nous définirons la variable _r, que nous utiliserons comme valeur de retour, à zéro. Sinon, si oest un tableau, nous attribuons à _rla valeur de retour de l'appel récursif favec le nouveau tableauo comme argument.

Après la boucle, à la fin de la fonction f, nous évaluons l'expression _r, qui donne la valeur de _r, et comme c'est la dernière expression à évaluer, c'est ce que l'appel à la fonctionf renvoie .

Maintenant que nous avons défini f( fpas besoin d'être à l'intérieur A, mais de cette façon, nous aurions pu le déclarer variable / fonction locale (pas de différence vraiment) Asi nous ne voulions pas enregistrer quelques octets), revenons A. if (count _this == 0)vérifie si Ale tableau d'entrée est vide et s'il l'est, Aretourne 0. Sinon, la fonction fest appelée et sa valeur de retour seraA la valeur de retour de.

On pourrait remarquer qu'il semble qu'un point-virgule serait absent de quelques endroits, mais ce n'est pas le cas, car un point-virgule n'est nécessaire qu'après une instruction si une autre instruction le suit à l'intérieur du même bloc de code (c'est-à-dire une chaîne).

Perl 5 , 15 octets

Enregistré 2 octets en utilisant la même technique que la réponse Ruby de Doorknob .

14 octets de code + -pindicateur

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

Essayez-le en ligne!

/.../garantit que le tableau n'est pas vide (il correspondra à n'importe quel tableau mais [].
/\b0/ne correspondra que s'il y a un 0dans le tableau. (le \bgarantit qu'il 0ne fait pas partie d'un autre numéro mais d'un nombre entier).

Haskell , 48 octets

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

Essayez-le en ligne!

Merci à Lynn pour les cas de test et les x<"[]" astuce.

L'inégalité externe doit (x<"[]")être True (liste non vide) et or[elem c"[,"|c:'0':_<-scanr(:)[]x]False (pas de zéros).

Les caractères de 0sont détectés comme suivant un ,ou [, par opposition à un nombre comme 20. L'expression scanr(:)[]xgénère tous les suffixes de let c:'0':_<-capture ceux dont le deuxième caractère est '0'. Ensuite, elem c"[,"vérifie si le premier caractère est ,ou[ .

Je suppose ici que les listes de style Haskell n'ont pas d'espaces, mais si c'est le cas, elles ','peuvent simplement être remplacées par' ' .

Voici une méthode plus directe de 48 octets, bien qu'elle produise des 0«et 1» qui ne sont pas Truthy / Falsey dans Haskell.

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

Gelée , 4 octets

F;LẠ

Essayez-le en ligne!

Comment ça marche

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.

Notez que l'atome Ạ se comporte comme Python allet est donc assez différent du anned interdit.

JavaScript (ES6), 34 octets

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

Cas de 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 octets

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

Cela crée une fonction gqui indique si Ȧ serait 1 ou 0 en appelant une fonction récursivea . Pour faire un convenable a, nous utilisons l'envoi multiple:

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

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

La fonction all prend un argument de fonction, nous appelons donc achaque élément de l'entrée. Ensuite, nous définissons simplement la fonction pour la soumission comme

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

Fondamentalement, nous avons juste besoin a mais avec un chèque pour gérer correctement[] .

Essayez-le en ligne!

Grime , 16 14 11 octets

Merci à Zgarb d'avoir économisé 5 octets.

e`s\0v#|!..

Essayez-le en ligne!

Le edit à Grime d'essayer de faire correspondre la totalité de l'entrée et d'imprimer0 ou 1selon que cela est possible.

L' |!opérateur est en fait un "ni", car il x|!yest un raccourci pour(x|y)! . Nous nous assurons donc que l'entrée ne contient ni zéro précédé d'un symbole ni une chaîne de deux caractères seulement ([] ).

Une note sur la seconde moitié: P#correspond à un rectangle qui contient au moins une correspondance de P. Cependant, dans notre cas se Pcompose des deux set \0donc cela nécessiterait normalement des parenthèses: (s\0)#(car la priorité de #est trop élevée). Mais Grime a une fonctionnalité vraiment intéressante où vous pouvez modifier la priorité des opérateurs avec ^et v. Donc, en utilisant v#nous réduisons #la priorité de sorte qu'elle soit inférieure à celle de tout autre opérateur (y compris la concaténation), ce qui nous permet de sauvegarder un octet sur les parenthèses.

Pip , 12 octets

#Va&`\b0`NIa

Prend le tableau comme argument de ligne de commande dans la forme de repr de Pip, comme [1;[2;3]]. Retourne 1pour véridique, 0pour falsey. Essayez-le en ligne ou vérifiez tous les cas de test .

Explication

              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

Réponse bonus, 12 octets

Voici une fonction qui prend une liste à la place:

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

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

Essayez-le en ligne!

fprend l'entrée de son flux comme une liste qui peut contenir d'autres listes et entiers. Il revient 1si aest véridique et rien d'autre. La fonction d'assistance gvérifie si acontient des zéros.

Explication:

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

Une solution qui utilise des expressions rationnelles pourrait très probablement être plus courte.

Cette réponse aurait pu être plus courte si elle avait été autorisée à renvoyer plusieurs valeurs. Cela a été discuté dans l' une de mes réponses auparavant, et il a été conclu qu'il est autorisé dans les règles par défaut de renvoyer différentes valeurs de vérité et de fausse pour différentes entrées, mais pour une raison quelconque, OP l'interdit ici et là. :(

Wonder , 15 octets

@&#0! iO0flat#0

Usage:

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

Aplatissez l'entrée, obtenez toutes les occurrences de 0, NON logique, ET logique avec entrée.

Haskell , 62 octets

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

Essayez-le en ligne!

Ceci est une fonction String -> Bool. Les listes de Haskell sont hétérogènes, il n'y a donc aucun moyen intégré de représenter des listes comme [0, [0]].

Python 2 , 45 39 38 octets

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

Essayez-le en ligne!

-6 grâce à @BenFrankel

version précédente, sans convertir la liste en chaîne repr, 68 octets:

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

MATLAB, 49 octets

Comme MATLAB (ainsi qu'Octave) n'autorise pas ce type de tableaux imbriqués, nous l'interprétons comme une chaîne.

Tout d'abord, nous remplaçons tous les caractères non numériques par un espace. Ensuite, nous utilisons str2numpour le convertir en un tableau (1D), sur lequel nous pouvons appliquer all(ce qui est autorisé, car il ne résout pas complètement cette tâche par lui-même.)

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

egrep, 7 + 3 = 10 octets

\<0|^.]

+3 octets pour le requis -v indicateur pour inverser le résultat.

Grep n'a pas de concept de tableaux, donc cela utilise une représentation sous forme de chaîne comme indiqué dans la question. Prend l'entrée sur une ligne de stdin, retourne via le code de sortie (ignore stdout).

(Maintenant, en utilisant une version qui ne tient pas compte 01et similaire, car la parole de Dieu est que c'est OK)

Entrée bash / grep d'origine:

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

Trouve 0s n'importe où (en utilisant le mot vérification des limites \<et \>pour actualiser des choses comme 10ou a1), ou une correspondance de chaîne entière [], puis inverse la correspondance.

Panne:

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 caractères

Fonctionne avec tableau, renvoie 1ou 0:

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

Tester:

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
}