Arka fon

Octave'in (ve ek olarak MATL'nin), truthy / falsy matrislerinin çok rahat bir şekilde yorumlanmasından esinlenen Jelly, Octa (Octave tarzı hepsi ) atomunu aldı.

Ȧ dizi boşsa ve dizi boş değilse ve ağaç yapısının herhangi bir yerinde 0 sayısını (tam sayı, kayan nokta veya karmaşık) içermiyorsa 1 değerini döndürür ; Aksi takdirde, 0 döndürür .

Örneğin, [[]] dizisi boş çünkü boş değil ve sıfır içermiyor, ancak [[0]] sahtedir, çünkü en iç düzeyde 0 içerir .

Görev

Seçtiğiniz bir programlama dilinde , tam bir program veya girdi olarak muhtemel olarak boş, muhtemelen pürüzlü bir tamsayı dizisi alan ve Ȧ'nin sırasıyla 1 veya 0 değerini döndürüp döndürmeyeceğini belirten bir gerçeği veya sahte değeri döndüren bir işlev yazın .

Gönderiminiz aşağıdaki kurallara uymalıdır.

• Truthy ve falsy değerleri tüm girdiler için tutarlı olmalıdır; yani, Ȧ 1 döndüren tüm diziler aynı truthy değerine eşlenmeli ve Ȧ 0 döndüren tüm diziler aynı falsy değerine eşlenmelidir.

• Tam programlar dizilerin yalnızca girdi olarak dizgi gösterimlerini alabildiğinden, buna izin verilir. Bununla birlikte, dilin reprveya benzerinin döndürdüğü gibi, kanosik gösterimini kullanmanız gerekir .

  Özellikle, dizinin ilk öğesinin bir boşluktan önce geleceğini varsayamazsınız.

• Diliniz (ve yalnızca) diliniz doğal olarak tırtıklı dizileri temsil edemezse, önceden var olan herhangi bir programlama diline ait kanonik sözdizimini kullanarak girişin bir dize gösterimini alabilirsiniz.

• Dilinizde tırtıklı dizileri (örneğin listeler ve tuples) temsil etmenin birkaç yolu varsa, bunlardan yalnızca birini desteklemeniz gerekir.

• Dilinizde yerleşik olan, bu zorluğa dahil olan geçerli bir başvuru ise, cevabınızda kullanamazsınız . Diğer tüm yapılara izin verilir.

• Biri diğerinden önemli ölçüde kısa olsa bile, hem dizi hem de dize manipülasyonunu kullanarak cevap göndermeniz teşvik edilir.

• Tüm standart kod golf kuralları geçerlidir.

Bayt cinsinden en kısa kod kazanabilir!

Truthy test durumları

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

Sahte test durumları

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

Jöle, 3 bayt

ṭFẠ

F giriş listesini düzleştirir.

ṭ Orijinal giriş listesinde, boşsa ve sadece boşsa, sahte olan bir öğe olarak uyarlar.

Ạ daha sonra düzleştirilmiş listedeki herhangi bir öğenin veya orijinal listenin kendisinin sahte olup olmadığını kontrol eder.

(Orijinal cevap)

FẠ^Ṇ

Dennis'e, onunla eşleşen bir çözüm bulmayı teşvik ettiği için teşekkürler.

FẠgiriş, herhangi bir derinlikte sahte bir değer içeriyorsa, 0 değerini verir, aksi takdirde 1 Ȧ.

Ṇ giriş bir sahte değer ise 1 verir, yoksa 0 olur. Tek sahte liste boş listedir.

İki XOR-in cevap verir.

F;WẠ

Bu, Dennis'le aynı ruhta F;LẠ, ancak Lliste boşken listeye sıfıra Wkoymak yerine, boş listeyi kendi içine koymak için kullanıyor (üreten [[]]), sahte bir öğe içeriyor.

Retina , 10 bayt

A`\b0
^...

Çevrimiçi deneyin!

İlk önce sıfır içeriyorsa girişi kaldırırız. Dizenin başından itibaren en az üç karakterle eşleşmeye çalışırız (girişin önceki aşamada kaldırılmadığından veya yalnızca []başlayacağından emin olmak için).

Ruby, 25 24 23 18 16 bayt

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

-nBayrak komut satırında gerektirir (+1 bayt, -e-> -ne).

Çevrimiçi deneyin!

Bu, Ruby'nin kanonik dizi biçiminde STDIN'de ve çıktılarda trueveya STDOUT'da girdi alan tam bir programdır false.

 $_              # 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 bayt işlev sürümü:

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

Bu, test edilecek bir argüman olan bir işlemdir.

Bir bayt için Martin Ender'e ve iki bayt için Ventero'ya teşekkürler !

Jöle , 4 bayt

FẠ_Ṇ

Çevrimiçi deneyin!

Ȧ0giriş boşsa veya a içeriyorsa, sonuç verir 0; aksi halde doğrudur 1.

FẠ0Düzleştirilmiş giriş a içeriyorsa 0, verim yalnızca boş bir dizinin kenar büyüklüğünü bırakır (girişin bir dizi olması garanti edildiğinden).

Ṇmonad olmayan bir vektörleştirici mantıktır ve bu nedenle 0boş olmayan herhangi bir liste ve boş liste için döner 1. Bu itibarla bu basitçe sonucundan subtraced edilebilir FẠkullanarak _.

05AB1E , 9 8 bayt

Emigna sayesinde -1 bayt

)Q¹˜0å~_

Açıklama:

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

Çevrimiçi deneyin!

Mathematica, 17 bayt

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

FreeQÇek 0bizim için aleyhtedir, fakat elbette Truegirdi için geri dönecektir {}, bu yüzden bu durumu ayrı ayrı kontrol etmemiz gerekir.

APL (Dyalog), 21 12 7 bayt

Adám sayesinde çatal kullanarak 5 bayt golf oynadı

⍬∘≡⍱0∊∊

Çevrimiçi deneyin!

Bu benim Dyalog'daki ilk denemem. Golf ipuçları açıktır!

açıklama

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

İşlem Flashpoint kodlama dili, 199 188 bayt

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

İle ara:

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

veya:

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

Açıklama:

Oyunun kodlama dilinde, kod içeren herhangi bir dize çağrılabilir. Kıvrımlı kaşlı ayraçlar {}bir dizenin başlangıcını ve sonunu belirtir. (Tırnak işaretleri de çalışır, ancak yuvalandıklarında dağınık olur.) Bu nedenle, A={...}değişkene bir dize atar Ave değişken daha sonra: ile bir işlev gibi çağrılabilir <argument> call A. Temel olarak herhangi bir dize bir kod bloğu olarak değerlendirilebilir.

Sonra, "fonksiyon" içinde Abaşka bir fonksiyon tanımlarız f. privateiki değişkeni _ive _ryerel işlevi bildirir f. Bir yerel değişkenin adı bir alt çizgi ile başlamalıdır.

while {} do {}bu, birinci dizginin (ile gösterilen {}), döngü koşulu için kodu ve döngü gövdesi için ikincisini içerdiği bir döngüdür.

_thiscallişlevle iletilen argümandır ._thisherhangi bir türde olabilir, ancak burada bir dizi olduğunu varsayıyoruz.

Döngüde, o=_this select _idizisi ve değişkene atar bunu th eleman: _I kere o. başka bir dizi if (o in [o])olup olmadığını belirlemek için bir hiledir o. Eğer obir numara (ya da bir dizi başka bir şey) olup, o in [o]değerlendirecek trueiçin, infonksiyon değeri eşleşen bulur odiziden [o]. Bir odizi ise, ifade false, indizileri karşılaştırmayı reddettiği için verir .

Bir odizi değilse, sıfıra eşit olup olmadığını kontrol ederiz ve eğer öyleyse _r, dönüş değeri olarak kullanacağımız değişkeni sıfıra ayarlarız . Aksi takdirde, obir dizi _rise, özyinelemeli çağrının dönüş değerine fyeni dizi ile atarız.o argüman olarak .

Döngüden sonra, fonksiyonun sonunda f , biz ekspresyonunu değerlendirmek _rdeğerini verir, _rve bu da değerlendirilecek son sentezleme olduğu gibi, bu işlev, ne çağrı fgetiri.

Şimdi tanımladığımıza göre f( fiçeride olmamız gerekmiyor A, ancak bu şekilde onu bir Abayt kaydetmek istemiyorsak yerel bir değişken / işlev (gerçekten bir fark yok) olarak açıklayabilirdik , geri dönelim A. if (count _this == 0)eğer kontrol ederAgiriş dizisinin boş ve eğer öyleyse A0 döndürür. Aksi takdirde, işlev fçağrılır ve dönüş değeriA dönüş değeri olur.

Bir noktalı virgülün birkaç yerden kaybolacağı görülebilir, ancak durum böyle değildir, çünkü bir noktalı virgül yalnızca bir deyimden sonra aynı kod bloğunun (dize) içindeki başka bir deyim izlerse gerekli olur.

Perl 5 , 15 bayt

Doorknob'un Ruby cevabı ile aynı tekniği kullanarak 2 bayt kurtardı .

14 bayt kod + -pbayrak

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

Çevrimiçi deneyin!

/.../Dizi boş olmadığından emin olmasını sağlar (herhangi dizisinde eşleşen ancak edecektir [].
/\b0/Bir varsa sadece eşleşir 0dizideki. ( \bsağlamaktadır 0başka bir numaraya ama bir tam sayı) bir parçası değildir.

Haskell , 48 bayt

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

Çevrimiçi deneyin!

Test vakaları için Lynn'e ve x<"[]" numara ederim.

Dış eşitsizlik (x<"[]")Doğru (boş olmayan liste) ve or[elem c"[,"|c:'0':_<-scanr(:)[]x]Yanlış (sıfır) olmamalıdır.

Karakterleri, 0a ,veya [, gibi bir sayının aksine olarak algılanır 20. İfade scanr(:)[]x, bunların tüm yeterliliklerini üretir lve c:'0':_<-ikinci karakteri olanları yakalar '0'. Ardından, elem c"[,"ilk karakterin ,veya olup olmadığını kontrol eder [.

Burada, Haskell tarzı listelerin boşluk içermediğini, ancak varsa ','bunun yerine kullanılabileceğini varsayıyorum ' '.

Burada ürettiği olsa daha doğrudan 48 bayt yöntemidir 0'ın ve 1' s Haskell Truthy / Falsey yapılmaz.

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

Jöle , 4 bayt

F;LẠ

Çevrimiçi deneyin!

Nasıl çalışır

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.

Atomun Python'ın gibi davrandığını allve bu nedenle yasaklanmış olandan different farklı olduğunu unutmayın.

JavaScript (ES6), 34 bayt

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

Test durumları

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 bayt

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

Bu, gözyinelemeli bir işlev çağırarak Ȧ'nın 1 mi yoksa 0 mı olacağını belirten bir işlev oluşturur a. Uygun hale getirmek aiçin çoklu gönderim kullanıyoruz:

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

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

İşlev allbir işlev argümanı alır, bu yüzden agirişin her bir elemanını çağırıyoruz . Daha sonra sadece gönderim işlevini tanımlarız.

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

Temelde sadece ihtiyacımız var a ama doğru şekilde ele almak için bir çekle [].

Çevrimiçi deneyin!

Grime , 16 14 11 bayt

Zgarb'a 5 byte tasarruf ettiğin için teşekkürler.

e`s\0v#|!..

Çevrimiçi deneyin!

eDenemek ve tüm girdi eşleşmesi ve yazdırmak için kiri söyler 0ya 1bu mümkün olmadığına bağlı.

|!Çünkü etkili bir "ne" operatörüdür x|!yiçin kısaltmadır (x|y)!. Bu nedenle, girişin bir sembolden önce gelen bir sıfır içermediğinden ve yalnızca iki karakterden oluşan bir dize ( []) olmadığından emin oluruz .

A note about the second half: P# matches a rectangle that contains at least one match of P. However, in our case P consists of both s and \0 so that would normally require parentheses: (s\0)# (because the precedence of # is too high). But Grime has a really neat feature where you can modify the precedence of operators with ^ and v. So by using v# we lower #'s precedence so that it's lower than that of any other operator (including concatenation), which lets us save a byte on the parentheses.

Pip, 12 bytes

#Va&`\b0`NIa

Takes the array as a command-line argument in Pip's repr form, like [1;[2;3]]. Returns 1 for truthy, 0 for falsey. Try it online or verify all test cases.

Explanation

              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

Bonus answer, 12 bytes

Here's a function that takes a list instead:

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

Try it online!

f takes the input from its stream as a list that can contain other lists and integers. It returns 1 if a is truthy and nothing otherwise. The helper function g checks if a contains zeros.

Explanation:

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

A solution that makes use of regexes could very likely be shorter.

This answer could have been shorter if it were allowed to return multiple values. This has been discussed in one of my answers before, and it was concluded that it is allowed in the default rules to return different truthy and falsy values for different inputs, but for some reason OP forbid it here and there. :(

Wonder, 15 bytes

@&#0! iO0flat#0

Usage:

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

Flatten input, get all occurrences of 0, logical NOT, logical AND with input.

Haskell, 62 bytes

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

Try it online!

This is a function String -> Bool. Haskell’s lists are heterogenous, so there’s no built-in way to represent lists like [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
}