Fondo

Inspirado por la interpretación muy conveniente de Octave (y, por extensión, MATL) de las matrices de verdad / falsedad, Jelly obtuvo el átomo Ȧ (Octave- all all ).

Ȧ toma una matriz como entrada y devuelve 1 si la matriz no está vacía y no contiene el número 0 (entero, flotante o complejo) en ninguna parte de la estructura de árbol ; de lo contrario, devuelve 0 .

Por ejemplo, la matriz [[]] es verdadera porque no está vacía y no contiene ceros, pero [[0]] es falsa porque contiene un 0 en el nivel más interno.

Tarea

En el lenguaje de programación que elija, escriba un programa completo o una función que tome una matriz de enteros posiblemente vacía y posiblemente irregular como entrada e imprima o devuelva un valor verdadero o falso que indica si Ȧ devolvería 1 o 0 , respectivamente.

Su presentación debe cumplir con las siguientes reglas.

• Los valores verdadero y falso deben ser consistentes para todas las entradas , es decir, todas las matrices para las cuales Ȧ devuelve 1 deben mapearse al mismo valor de verdad, y todas las matrices para las cuales Ȧ devuelve 0 deben mapearse al mismo valor de falsedad.

• Dado que los programas completos solo pueden tomar representaciones de cadenas de matrices como entrada, esto está permitido. Sin embargo, debe utilizar la representación canocical de su idioma, tal como lo devuelve repro similar.

  En particular, no puede suponer que el primer elemento de la matriz estará precedido por un espacio.

• Si (y solo si) su lenguaje no puede representar matrices irregulares de forma nativa, puede tomar una representación en cadena de la entrada, utilizando la sintaxis canónica de cualquier lenguaje de programación preexistente.

• Si su idioma tiene varias formas de representar matrices irregulares (por ejemplo, listas y tuplas), solo debe admitir una de ellas.

• Si su idioma tiene incorporado un envío válido para este desafío, no puede usarlo en su respuesta . Todos los demás elementos integrados están permitidos.

• Se le recomienda que publique respuestas utilizando tanto la manipulación de matrices como la de cadenas, incluso si una es significativamente más corta que la otra.

• Se aplican todas las reglas estándar de código de golf .

¡Que gane el código más corto en bytes!

Casos de prueba de verdad

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

Casos de prueba de falsa

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

Jalea, 3 bytes

ṭFẠ

F aplana la lista de entrada.

ṭ se agrega a la lista de entrada original como un elemento, que es falso si y solo si está vacío.

Ạ luego comprueba si algún elemento en la lista aplanada, o la lista original en sí, es falso.

(Respuesta original)

FẠ^Ṇ

Gracias a Dennis por alentar a encontrar una solución que coincida con la suya.

FẠda 0 si la entrada contiene un valor falso a cualquier profundidad, de lo contrario 1. Esto es lo que Ȧhace, excepto las listas vacías.

Ṇ da 1 si la entrada es un valor falso, de lo contrario 0. La única lista falsa es la lista vacía.

XOR-ing los dos da la respuesta.

F;WẠ

Esto tiene el mismo espíritu que Dennis F;LẠ, pero en lugar de usar Lpara poner un cero en la lista cuando la lista está vacía, se usa Wpara poner la lista vacía en sí misma (produciendo [[]]), haciendo que contenga un elemento falso.

Retina , 10 bytes

A`\b0
^...

Pruébalo en línea!

Primero eliminamos la entrada si contiene un cero. Intentamos hacer coincidir al menos tres caracteres desde el comienzo de la cadena (para asegurarnos de que la entrada no se haya eliminado en la etapa anterior, o que solo fuera []para comenzar).

Rubí, 25 24 23 18 16 bytes

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

Requiere la -nbandera en la línea de comando (+1 byte, -e-> -ne).

Pruébalo en línea!

Este es un programa completo que toma la entrada en formato de matriz canónica de Ruby en STDIN y salidas trueo falseen 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

Versión de función de 23 bytes :

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

Este es un proceso que toma un argumento, la matriz a probar.

¡Gracias a Martin Ender por un byte y a Ventero por dos bytes!

Jalea , 4 bytes

FẠ_Ṇ

Pruébalo en línea!

Ȧproduce 0si la entrada está vacía o contiene un 0, de lo contrario es1 .

FẠproduce 0si la entrada aplanada contiene un0 , dejando solo el caso de borde de una matriz vacía (ya que se garantiza que la entrada sea una matriz).

Ṇes una no mónada lógica no vectorizadora y, por lo tanto, devuelve 0para cualquier lista no vacía y 1para la lista vacía. Como tal, esto simplemente se puede restar del resultado del FẠuso _.

05AB1E , 9 8 bytes

-1 bytes gracias a Emigna

)Q¹˜0å~_

Explicación:

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

Pruébalo en línea!

Mathematica, 17 bytes

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

FreeQhace el chequeo en contra 0de nosotros, pero por supuesto volvería Truepara la entrada {}, por lo que debemos verificar ese caso por separado.

APL (Dyalog), 21 12 7 bytes

Golfó 5 bytes gracias a Adám utilizando horquillas

⍬∘≡⍱0∊∊

Pruébalo en línea!

Este es mi primer intento en Dyalog. ¡Los consejos de golf son bienvenidos!

Explicación

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

Lenguaje de script Operation 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}}

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

Explicación:

En el lenguaje de programación del juego, se puede llamar a cualquier cadena que contenga código. Las llaves {}indican el principio y el final de una cadena. (Las comillas trabajan también, pero que se complica cuando se anidan.) Por lo tanto, A={...}asigna una cadena a la variable A, y la variable a continuación, se puede llamar como una función con: <argument> call A. Básicamente, cualquier cadena se puede tratar como un bloque de código.

Luego, dentro de la "función" A, definimos otra función f. privatedeclara las dos variables _iy _rlocal para funcionar f. El nombre de una variable local tiene que comenzar con un guión bajo.

while {} do {} es un bucle, donde la primera cadena (denotada por {} ) contiene el código para la condición del bucle y la segunda para el cuerpo del bucle.

_thises el argumento que se pasó con la callfunción_thispuede ser de cualquier tipo, pero aquí asumimos que es una matriz.

En el bucle, o=_this select _iaccede al elemento _i: th de la matriz y lo asigna a variable o. if (o in [o])Es un truco para determinar si oes otra matriz o no. Si oes un número (o cualquier otra cosa que no sea una matriz), o in [o]se evaluará a true, porque la infunción encuentra un valor que coincide ocon la matriz [o]. Si oes una matriz, la expresión produce false, porque elin niega a comparar matrices.

Si ono es una matriz, verificamos si es igual a cero, y si lo hace, estableceremos la variable _r, que usaremos como valor de retorno, en cero. De lo contrario, si oes una matriz, asignamos al _rvalor de retorno de la llamada recursiva af la nueva matrizo como argumento.

Después del ciclo, al final de la función f, evaluamos la expresión _r, que produce el valor de _r, y como esta es la última expresión que se evaluará, esto es lo que fdevuelve la llamada a la función .

Ahora que hemos definido f(f no es necesario que esté dentro A, pero de esta manera podríamos haberlo declarado una variable / función local (realmente no hay diferencia) Asi no quisiéramos guardar algunos bytes), regresemos A. if (count _this == 0)comprueba si Ala matriz de entrada está vacía y, si lo está, Adevuelve 0. De lo contrario, fse llama a la función y su valor de retorno seráA el valor de retorno.

Uno podría notar que parece que faltaría un punto y coma en algunos lugares, pero este no es el caso, porque un punto y coma solo se necesita después de una declaración si otra declaración lo sigue dentro del mismo bloque de código (es decir, cadena).

Perl 5 , 15 bytes

Ahorró 2 bytes usando la misma técnica que la respuesta Ruby de Doorknob .

14 bytes de código + -pbandera

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

Pruébalo en línea!

/.../asegura que la matriz no esté vacía (coincidirá con cualquier matriz pero [].
/\b0/solo coincidirá si hay una 0en la matriz. (esto \basegura que 0no sea parte de otro número sino de un número entero).

Haskell , 48 bytes

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

Pruébalo en línea!

Gracias a Lynn por los casos de prueba y la x<"[]" truco.

La desigualdad externa requiere (x<"[]")ser Verdadero (lista no vacía) y or[elem c"[,"|c:'0':_<-scanr(:)[]x]Falso (sin ceros).

Los caracteres de 0se detectan siguiendo a ,o [, a diferencia de un número como 20. La expresión scanr(:)[]xgenera todos los suficientes ly c:'0':_<-captura a aquellos cuyo segundo carácter es '0'. Luego, elem c"[,"comprueba si el primer carácter es ,o [.

Asumo aquí que las listas de estilo Haskell no tienen espacios, pero si es así ',', solo se pueden reemplazar por ' '.

Aquí hay un método más directo de 48 bytes, aunque produce 0's 1' y 's que no son Truthy / Falsey en Haskell.

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

Jalea , 4 bytes

F;LẠ

Pruébalo en línea!

Cómo 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.

Tenga en cuenta que el átomo Ạ se comporta como el de Python ally, por lo tanto, es bastante diferente del ban prohibido.

JavaScript (ES6), 34 bytes

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

Casos de prueba

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)

Esto crea una función gque indica si Ȧ sería 1 o 0 llamando a una función recursiva a. Para hacer un adecuado a, utilizamos despacho múltiple:

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

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

La función alltoma un argumento de función, por lo que estamos llamando aa cada elemento de la entrada. Luego simplemente definimos la función para el envío como

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

Básicamente solo necesitamos apero con un cheque para manejar correctamente[] .

Pruébalo en línea!

Suciedad , 16 14 11 bytes

Gracias a Zgarb por guardar 5 bytes.

e`s\0v#|!..

Pruébalo en línea!

El ele dice a Grime que intente hacer coincidir toda la entrada e imprimir 0o 1dependiendo de si eso es posible.

El |!es efectivamente un operador "ninguno", porque x|!yes la abreviatura de (x|y)!. Por lo tanto, nos aseguramos de que la entrada no contenga un cero precedido por un símbolo ni sea una cadena de solo dos caracteres ([] ).

Una nota sobre la segunda mitad: P#coincide con un rectángulo que contiene al menos una coincidencia de P. Sin embargo, en nuestro caso Pconsta de ambos sy\0 eso normalmente requeriría paréntesis: (s\0)#(porque la precedencia de #es demasiado alta). Pero Grime tiene una característica realmente ordenada donde puede modificar la precedencia de los operadores con ^y v. Entonces, mediante el uso v#, disminuimos #la precedencia para que sea más baja que la de cualquier otro operador (incluida la concatenación), lo que nos permite guardar un byte en los paréntesis.

Pip , 12 bytes

#Va&`\b0`NIa

Toma la matriz como un argumento de línea de comandos en la forma repr de Pip, como [1;[2;3]]. Vuelve 1por la verdad, 0por falsey.Pruébalo en línea o verifique todos los casos de prueba .

Explicación

              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

Respuesta extra, 12 bytes

Aquí hay una función que toma una lista en su lugar:

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

Pruébalo en línea!

ftoma la entrada de su flujo como una lista que puede contener otras listas y enteros. Regresa 1si aes verdad y nada más. La función auxiliar gcomprueba sia contiene ceros.

Explicación:

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 solución que utiliza expresiones regulares podría muy probablemente ser más corta.

Esta respuesta podría haber sido más corta si se le permitiera devolver múltiples valores. Esto se ha discutido en una de mis respuestas anteriormente, y se concluyó que está permitido en las reglas predeterminadas devolver diferentes valores de verdad y falsedad para diferentes entradas, pero por alguna razón OP lo prohíbe aquí y allá. :(

Maravilla , 15 bytes

@&#0! iO0flat#0

Uso:

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

Acoplar la entrada, obtener todas las apariciones de 0, NOT lógico, AND lógico con entrada.

Haskell , 62 bytes

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

Pruébalo en línea!

Esta es una función String -> Bool. Las listas de Haskell son heterogéneas, por lo que no hay una forma integrada de representar listas como [0, [0]].

Python 2 , 45 39 38 bytes

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

Pruébalo en línea!

-6 gracias a @BenFrankel

versión anterior, sin convertir la lista a cadena 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

Como MATLAB (así como Octave) no permite este tipo de matrices anidadas, lo interpretamos como una cadena.

Primero reemplazamos todos los caracteres que no son dígitos con un espacio. Luego, lo usamos str2numpara convertirlo en una matriz (1D), en la que podemos aplicar all(lo cual está permitido, ya que no resuelve completamente esta tarea por sí mismo).

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

egrep, 7 + 3 = 10 bytes

\<0|^.]

+3 bytes para el requerido -v indicador para invertir el resultado.

Grep no tiene ningún concepto de matrices, por lo que utiliza una representación de cadena como se indica en la pregunta. Toma información en una línea desde stdin, regresa a través del código de salida (ignore stdout).

(Ahora usando una versión que no tiene en cuenta 01y similar, ya que la palabra de Dios es que está bien)

Entrada original de bash / grep:

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

Encuentra 0s en cualquier lugar (usando las verificaciones de límites de palabras \<y \>para descartar cosas como 10o a1), o una coincidencia de cadena completa [], luego invierte la coincidencia.

Descompostura:

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 caracteres

Funciona con matriz, devoluciones 1o 0:

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

Prueba:

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

Explicación

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 

Si el resultado necesita ser emitido ...

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

Solución previa

Había publicado esto antes de darme cuenta de que los idiomas basados ​​en la pila podrían dejar el valor en la pila como una forma de salida

i0B¿0oP?!¿o?

Explicación

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

Como comentaron Lynn y xnor , Haskell no viene con un tipo de lista heterogéneamente anidada. Pero es fácil agregarlos como un tipo de datos personalizado y dejar que la función opere en ese tipo, y esto es mucho más preferible que operar en cadenas (¡urgh!) .

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

Para poder escribir tales listas como literales con [1, [2]]sintaxis, también necesita un tipo de clase fu. Caso de prueba 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])

Pruébalo en línea!

Vim, 23 bytes

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

Pruébalo en línea!

Emite una cadena vacía para falso o 1verdadero. Esto podría ser más corto si puedo generar una cadena vacía o [] para falso (los cuales son valores falsos en vim).

Apilado , 20 bytes

:size\flat,0 eq none

Pruébalo en línea!

Alternativamente, usando una cadena:

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

Pruébalo en línea!

Lithp , 74 bytes

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

Pruébalo en línea!

Bueno, esto resultó más de lo que esperaba. El []caso me hizo tropezar y agregó algunos bytes. Simplemente aplana la lista y hace un doblez sobre ella, y si encuentra un 0, establece el acumulador en 0.

Ruby , 24 22 bytes

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

Pruébalo en línea!

Sí, sé que hay una mejor solución en Ruby, pero quería encontrar una que tome la matriz en la entrada en lugar de una cadena.

tinylisp , 70 64 bytes

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

La última línea es una función lambda sin nombre que toma una lista y regresa 1para "truthy-under-Ȧ" y 0para falsey. Pruébalo en línea!

Sin golf

(load library)

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

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

La función auxiliar recursiva _Ȧhace la mayor parte del trabajo. Si su argumento es una lista, vamos map _Ȧa sus elementos y regresamos si 1son allverdaderos, 0si alguno es falso. (Convenientemente, allregresa 1cuando se le da la lista vacía). De lo contrario, el argumento debe ser un número entero; lo devolvemos tal cual ( 0es falsey y todos los demás enteros son verdaderos en tinylisp).

La función principal Ȧverifica si la lista no está vacía. Si es así, llama _Ȧ; si no, vuelve 0.

La versión de golf aprovecha un comportamiento indefinido: en lugar de usar (e(type X)List)para probar si Xes un entero o una lista, lo hace (c()X), lo que intenta cons(anteponer) la lista vacía X. Si Xes una lista, esto da como resultado una lista no vacía, que es verdadera. Si Xes un número entero, tinylisp genera un mensaje de error y devuelve una lista vacía, que es falsey. Como se ignora stderr, este enfoque es válido.

PHP, 63 54 bytes

9 bytes guardados por @ user63956

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

toma una matriz como entrada; devuelve trueo false: si $ano está vacío,
verifique si la print_rsalida contiene un 0valor.

solución de matriz, 83 bytes

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

la función recursiva devuelve 1o 0.

Descompostura

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
}