fundo

Inspirado pela interpretação muito conveniente de Octave (e, por extensão, MATL) de matrizes de verdade / falsidade, Jelly obteve o átomo Ȧ ( tudo em estilo oitava ).

Ȧ pega uma matriz como entrada e retorna 1 se a matriz não estiver vazia e não contiver o número 0 (número inteiro, flutuante ou complexo) em qualquer lugar da estrutura da árvore ; caso contrário, ele retornará 0 .

Por exemplo, a matriz [[]] é verdadeira porque não está vazia e não contém zeros, mas [[0]] é falsa porque contém 0 no nível mais interno.

Tarefa

Em uma linguagem de programação de sua escolha, escreva um programa completo ou uma função que use uma matriz de números inteiros possivelmente vazia e possivelmente irregular como entrada e imprima ou retorne um valor verdadeiro ou falso que indica se return retornaria 1 ou 0 , respectivamente.

Seu envio deve obedecer às seguintes regras.

• Os valores truthy e falsy devem ser consistentes para todas as entradas , ou seja, todas as matrizes para as quais Ȧ retorna 1 devem ser mapeadas para o mesmo valor de verdade e todas as matrizes para as quais Ȧ retorna 0 devem ser mapeadas para o mesmo valor de falsy.

• Como os programas completos só podem receber representações de string de matrizes como entrada, isso é permitido. No entanto, você deve usar a representação canocical do seu idioma, retornada por reprou similar.

  Em particular, você não pode assumir que o primeiro elemento da matriz será precedido por um espaço.

• Se (e somente se) sua linguagem não puder representar matrizes irregulares nativamente, você poderá fazer uma representação em string da entrada, usando a sintaxe canônica de qualquer linguagem de programação pré-existente.

• Se o seu idioma tiver várias maneiras de representar matrizes irregulares (por exemplo, listas e tuplas), você precisará apenas oferecer suporte a uma delas.

• Se seu idioma possui um envio interno válido para esse desafio, você não pode usá-lo em sua resposta . Todos os outros built-ins são permitidos.

• Você é encorajado a postar respostas usando a manipulação de array e string, mesmo que uma seja significativamente menor que a outra.

• Todas as regras padrão de código de golfe se aplicam.

Que ganhe o menor código em bytes!

Casos de teste de verdade

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

Casos de teste de falsidade

[]
[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 bytes

ṭFẠ

F nivela a lista de entrada.

ṭ adere à lista de entrada original como um elemento, que é falso se e somente se estiver vazio.

Ạ depois verifica se algum elemento da lista nivelada ou da própria lista original é falso.

(Resposta original)

FẠ^Ṇ

Agradecemos a Dennis por encorajar a encontrar uma solução que corresponda à dele.

FẠfornece 0 se a entrada contiver um valor falso em qualquer profundidade, senão 1. É o que Ȧocorre, exceto as listas vazias.

Ṇ fornece 1 se a entrada for um valor falso, senão 0. A única lista de falsidade é a lista vazia.

XOR-ing os dois dá a resposta.

F;WẠ

Isso é muito parecido com o de Dennis F;LẠ, mas, em vez de Lcolocar um zero na lista quando a lista está vazia, ele usa Wpara colocar a lista vazia em si mesma (produzindo [[]]), fazendo com que ela contenha um elemento falso.

Retina , 10 bytes

A`\b0
^...

Experimente online!

Primeiro, removemos a entrada se ela contiver um zero. Tentamos corresponder pelo menos três caracteres desde o início da string (para garantir que a entrada não tenha sido eliminada no estágio anterior ou apenas []para começar).

Ruby, 25 24 23 18 16 bytes

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

Requer o -nsinalizador na linha de comando (+1 byte, -e-> -ne).

Experimente online!

Este é um programa completo que recebe entradas no formato de matriz canônica do Ruby no STDIN e nas saídas trueou falseno 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

Versão da função de 23 bytes :

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

Este é um processo que leva um argumento, a matriz a ser testada.

Obrigado a Martin Ender por um byte e a Ventero por dois bytes!

Gelatina , 4 bytes

FẠ_Ṇ

Experimente online!

Ȧproduz 0se a entrada estiver vazia ou contiver a 0, caso contrário, será 1.

FẠproduz 0se a entrada achatada contiver a 0, deixando apenas a caixa de borda de uma matriz vazia (desde que a entrada seja garantida como uma matriz).

Ṇé uma mônada lógica não-vetorizadora e, portanto, retorna 0para qualquer lista não-vazia e 1para a lista vazia. Como tal, isso pode simplesmente ser subtraído do resultado do FẠuso _.

05AB1E , 9 8 bytes

-1 bytes graças a Emigna

)Q¹˜0å~_

Explicação:

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

Experimente online!

Mathematica, 17 bytes

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

FreeQfaz a verificação contra 0nós, mas é claro que retornaria Truepara entrada {}, por isso precisamos verificar esse caso separadamente.

APL (Dyalog), 21 12 7 bytes

Golpeou 5 bytes graças a Adám usando garfos

⍬∘≡⍱0∊∊

Experimente online!

Esta é a minha primeira tentativa no Dyalog. Dicas de golfe são bem-vindas!

Explicação

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

Linguagem de script da operação Flashpoint , 199 188 bytes

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

Ligue para:

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

ou com:

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

Explicação:

Na linguagem de script do jogo, qualquer string que contenha código pode ser chamada. Os chavetas {}indicam o começo e o fim de uma corda. (As aspas também funcionam, mas isso fica confuso quando são aninhadas.) Portanto, A={...}atribui uma string à variável Ae a variável pode ser chamada como uma função com:<argument> call A . Basicamente, qualquer string pode ser tratada como um bloco de código.

Então, dentro da "função" A, definimos outra função f. privatedeclara as duas variáveis _ie _rlocal para funcionar f. O nome de uma variável local deve começar com um sublinhado.

while {} do {}é um loop, em que a primeira string (indicada por {}) contém o código para a condição do loop e a segunda para o corpo do loop.

_thisé o argumento que foi passado com a callfunção_thispode ser de qualquer tipo, mas aqui assumimos que é uma matriz.

No loop, o=_this select _iacessa o elemento _i: th da matriz e o atribui à variável o. if (o in [o])é um truque para determinar se oé outra matriz ou não. Se ofor um número (ou qualquer coisa que não seja uma matriz), o in [o]será avaliado como true, porque a infunção encontra um valor correspondente ona matriz [o]. Se ofor uma matriz, a expressão renderá false, porque inse recusa a comparar matrizes.

Se onão é uma matriz, verificamos se é igual a zero e, se o fizer, definiremos a variável _r, que usaremos como valor de retorno, como zero. Caso contrário, se ofor uma matriz, atribuímos _ro valor de retorno da chamada recursiva a fcom a nova matriz ocomo argumento.

Após o loop, no final da função f, avaliamos a expressão _r, que gera o valor de _r, e como esta é a última expressão a ser avaliada, é isso que a chamada à função fretorna.

Agora que definimos f( fnão precisa estar lá dentro A, mas dessa forma poderíamos tê-la declarado uma variável / função local (sem nenhuma diferença), Ase não desejássemos salvar alguns bytes), vamos voltar A. if (count _this == 0)verifica se Aa matriz de entrada está vazia e, se estiver, Aretorna 0. Caso contrário, a função fé chamada e seu valor de retorno será Ao valor de retorno.

Pode-se notar que parece que um ponto-e-vírgula estaria faltando em alguns lugares, mas esse não é o caso, porque um ponto-e-vírgula só é necessário após uma instrução se outra instrução a seguir dentro do mesmo bloco de código (ou seja, string).

Perl 5 , 15 bytes

Economizou 2 bytes usando a mesma técnica da resposta Ruby da maçaneta da porta .

14 bytes de código + -psinalizador

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

Experimente online!

/.../garante que a matriz não está vazia (isto irá corresponder a qualquer matriz mas [].
/\b0/só irá corresponder se houver um 0na matriz. (os \bassegura que o 0não é uma parte de um outro número, mas um número inteiro).

Haskell , 48 bytes

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

Experimente online!

Obrigado a Lynn pelos casos de teste e pelo x<"[]" truque.

A desigualdade externa precisa (x<"[]")ser Verdadeira (lista não vazia) e or[elem c"[,"|c:'0':_<-scanr(:)[]x]Falsa (sem zeros).

Os caracteres de 0são detectados como seguindo um ,ou [, em oposição a um número como 20. A expressão scanr(:)[]xgera todos os elementos suficientes le c:'0':_<-captura aqueles cujo segundo caractere é '0'. Em seguida, elem c"[,"verifica se o primeiro caractere é ,ou [.

Suponho aqui que as listas no estilo Haskell não tenham espaços, mas, se sim, ','podem ser substituídas por ' '.

Aqui está um método mais direto de 48 bytes, apesar de produzir 0's 1' e 's que não são Truthy / Falsey em Haskell.

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

Gelatina , 4 bytes

F;LẠ

Experimente online!

Como funciona

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.

Observe que o átomo be se comporta como o do Python alle, portanto, é bastante diferente do ned proibido.

JavaScript (ES6), 34 bytes

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

Casos de teste

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)

Isso cria uma função gque indica se be seria 1 ou 0 chamando uma função recursiva a. Para fazer um adequado a, usamos vários despachos:

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

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

A função allaceita um argumento de função, portanto, estamos chamando acada elemento da entrada. Em seguida, simplesmente definimos a função para o envio como

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

Basicamente, só precisamos, amas com uma verificação para lidar corretamente [].

Experimente online!

Grime , 16 14 11 bytes

Obrigado ao Zgarb por salvar 5 bytes.

e`s\0v#|!..

Experimente online!

O eGrime diz para tentar combinar com toda a entrada e imprimir 0ou 1dependendo se isso é possível.

O |!é efetivamente um operador "nenhum", porque x|!yé uma abreviação para (x|y)!. Portanto, garantimos que a entrada não contenha um zero precedido por um símbolo nem uma sequência de apenas dois caracteres ( []).

Uma observação sobre a segunda metade: P#corresponde a um retângulo que contém pelo menos uma correspondência de P. No entanto, no nosso caso, Pconsiste em ambos se, \0portanto, isso normalmente exigiria parênteses: (s\0)#(porque a precedência de #é muito alta). Mas o Grime tem um recurso realmente interessante, onde você pode modificar a precedência dos operadores com ^e v. Portanto, usando a v#menor #precedência, é menor que a de qualquer outro operador (incluindo concatenação), o que nos permite salvar um byte entre parênteses.

Pip , 12 bytes

#Va&`\b0`NIa

Toma a matriz como um argumento de linha de comando na forma de repr do Pip, como [1;[2;3]]. Retorna 1para verdade, 0para falsey. Experimente online ou verifique todos os casos de teste .

Explicação

              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

Resposta bônus, 12 bytes

Aqui está uma função que recebe uma lista:

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

Experimente online!

frecebe a entrada de seu fluxo como uma lista que pode conter outras listas e números inteiros. Retorna 1se aé verdade e nada mais. A função auxiliar gverifica se acontém zeros.

Explicação:

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

Uma solução que faça uso de expressões regulares muito provavelmente poderia ser mais curta.

Essa resposta poderia ter sido menor se fosse permitido retornar vários valores. Isso foi discutido em uma das minhas respostas antes e concluiu-se que nas regras padrão é permitido retornar valores diferentes de verdade e falsidade para entradas diferentes, mas, por algum motivo, o OP proíbe aqui e ali. :(

Maravilha , 15 bytes

@&#0! iO0flat#0

Uso:

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

Achate a entrada, obtenha todas as ocorrências de 0, NOT lógica, AND lógica com a entrada.

Haskell , 62 bytes

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

Experimente online!

Esta é uma função String -> Bool. As listas de Haskell são heterogêneas, portanto não há como incorporar listas como essa [0, [0]].

Python 2, 45 39 38 bytes

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

Try it online!

-6 thanks to @BenFrankel

previous version, without converting list to 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

As MATLAB (as well as Octave) does not allow these kind of nested arrays, we interpret it as a string.

First we replace all non-digit characters with a space. Then we use str2num to convert it to an (1D) array, on which we can apply all (which is allowed, as it does not completely solve this task by itself.)

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

egrep, 7+3=10 bytes

\<0|^.]

+3 bytes for the required -v flag to invert the result.

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
}