Задний план

Вдохновленный очень удобной интерпретацией Octave (и, как следствие, MATL) матриц истина / ложь, Jelly получил атом Ȧ ( все в стиле Octave ).

Ȧ принимает массив в качестве входных данных и возвращает 1, если массив не пустой и не содержит числа 0 (целое число, число с плавающей запятой или комплексное) где-либо в древовидной структуре ; в противном случае возвращается 0 .

Например, массив [[]] является правдивым, потому что он не пуст и не содержит нулей, но [[0]] является ложным, потому что он содержит 0 на самом внутреннем уровне.

задача

На выбранном вами языке программирования напишите полную программу или функцию, которая принимает в качестве входных данных возможно пустой, возможно зубчатый массив целых чисел и печатает или возвращает истинное или ложное значение, указывающее, вернет ли Ȧ 1 или 0 соответственно.

Ваша заявка должна соответствовать следующим правилам.

• Значения достоверности и ложности должны быть согласованы для всех входных данных , т. Е. Все массивы, для которых Ȧ возвращает 1, должны отображаться на одно и то же значение истинности, а все массивы, для которых Ȧ возвращает 0, должны отображаться на одно и то же значение ложных значений.

• Поскольку полные программы могут принимать только строковые представления массивов в качестве входных данных, это разрешено. Тем не менее, вы должны использовать каноническое представление вашего языка, возвращенное reprили подобное.

  В частности, вы не можете предполагать, что первому элементу массива будет предшествовать пробел.

• Если (и только если) ваш язык не может представлять неровные массивы изначально, вы можете взять строковое представление ввода, используя канонический синтаксис любого ранее существовавшего языка программирования.

• Если у вашего языка есть несколько способов представления зубчатых массивов (например, списков и кортежей), вам нужно поддерживать только один из них.

• Если на вашем языке есть встроенная программа, которая сама по себе является действительным предложением для этого задания, вы не можете использовать ее в своем ответе . Все остальные встроенные модули разрешены.

• Вам предлагается публиковать ответы, используя манипуляции с массивами и строками, даже если один из них значительно короче другого.

• Действуют все стандартные правила игры в гольф .

Пусть победит самый короткий код в байтах!

Правдивые тесты

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

Ложные тесты

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

Желе, 3 байта

ṭFẠ

F выравнивает список ввода.

ṭ привязывает исходный список ввода как элемент, который ложен тогда и только тогда, когда он пуст.

Ạ затем проверяет, является ли какой-либо элемент в плоском списке или сам исходный список ложным.

(Оригинальный ответ)

FẠ^Ṇ

Спасибо Деннису за поддержку в поиске решения, соответствующего его.

FẠдает 0, если вход содержит ложное значение на любой глубине, иначе 1. Это то Ȧ, что делает, за исключением пустых списков.

Ṇ дает 1, если вход является ложным значением, иначе 0. Единственный ложный список - пустой список.

XOR-IN два дает ответ.

F;WẠ

Это во многом в том же духе, что и у Денниса F;LẠ, но вместо того, Lчтобы ставить ноль в списке, когда список пуст, он использует Wдля помещения пустого списка в себя (создания [[]]), в результате чего он содержит ложный элемент.

Сетчатка , 10 байт

A`\b0
^...

Попробуйте онлайн!

Сначала мы удаляем вход, если он содержит ноль. Мы пытаемся сопоставить не менее трех символов в начале строки (чтобы гарантировать, что ввод не был исключен на предыдущем этапе или был только []для начала).

Рубин, 25 24 23 18 16 байт

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

Требуется -nфлаг в командной строке (+1 байт, -e-> -ne).

Попробуйте онлайн!

Это полная программа, которая принимает входные данные в формате канонического массива Ruby на STDIN и выводит trueили falseна 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

23-байтовая версия функции:

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

Это процесс, который принимает один аргумент, массив для тестирования.

Спасибо Мартину Эндеру за байт и Вентеро за два байта!

Желе , 4 байта

FẠ_Ṇ

Попробуйте онлайн!

Ȧвозвращает, 0если вход пуст или содержит 0, в противном случае это 1.

FẠВозвращает, 0если сглаженный вход содержит a 0, оставляя только крайний случай пустого массива (поскольку вход гарантированно будет массивом).

Ṇэто не векторизованная логическая не монада, и, следовательно, возвращает 0для любого непустого списка и 1для пустого списка. Таким образом, это может быть просто вычтено из результата FẠиспользования _.

05AB1E , 9 8 байт

-1 байт благодаря Emigna

)Q¹˜0å~_

Объяснение:

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

Попробуйте онлайн!

Mathematica, 17 байт

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

FreeQвыполняет проверку 0для нас, но, конечно, он вернется Trueдля ввода {}, поэтому мы должны проверить этот случай отдельно.

APL (Dyalog), 21 12 7 байтов

Гольф 5 байтов благодаря Адаму с помощью вилок

⍬∘≡⍱0∊∊

Попробуйте онлайн!

Это моя первая попытка в Dyalog. Советы по гольфу приветствуются!

объяснение

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

Язык сценариев работы Flashpoint , 199 188 байт

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

Звоните с:

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

или с:

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

Объяснение:

На языке сценариев игры может быть вызвана любая строка, содержащая код. Фигурные скобки {}обозначают начало и конец строки. (Кавычки работать тоже, но получает Messy , когда они вложены друг в друга.) Таким образом, A={...}присваивает строку переменной A, а переменная может быть названа как функция с: <argument> call A. По сути, любая строка может рассматриваться как блок кода.

Затем внутри «функции» Aмы определяем другую функцию f. privateобъявляет две переменные _iи _rлокальные для функции f. Имя локальной переменной должно начинаться с подчеркивания.

while {} do {}является циклом, где первая строка (обозначенная {}) содержит код для условия цикла, а вторая - для тела цикла.

_thisэто аргумент, который был передан с callфункцией. _thisможет быть любого типа, но здесь мы предполагаем, что это массив.

В цикле o=_this select _iполучает доступ к элементу _i: th массива и присваивает его переменной o. if (o in [o])хитрость, чтобы определить, oявляется ли другой массив или нет. Если oэто число (или что-либо, кроме массива), o in [o]будет вычислено как true, потому что inфункция находит значение, соответствующее oиз массива [o]. Если oэто массив, выражение дает false, потому что inотказывается сравнивать массивы.

Если oэто не массив, мы проверяем, равен ли он нулю, и если это так, мы устанавливаем переменную _r, которую мы будем использовать в качестве возвращаемого значения, равной нулю. В противном случае, если oэто массив, мы присваиваем _rвозвращаемое значение рекурсивного вызова fс новым массивом oв качестве аргумента.

После цикла, в конце функции f, мы оцениваем выражение _r, которое выдает значение _r, и, поскольку это последнее выражение для оценки, это то, что fвозвращает вызов функции .

Теперь, когда мы определили f( fне обязательно быть внутри A, но таким образом мы могли бы объявить его локальной переменной / функцией (на самом деле без разницы), Aесли бы мы не хотели сохранять несколько байтов), давайте вернемся A. if (count _this == 0)проверяет, является ли Aвходной массив пустым, и если он есть, Aвозвращает 0. В противном случае функция fвызывается и ее возвращаемое значение будет Aвозвращаемым значением.

Можно заметить, что кажется, что точка с запятой будет отсутствовать в нескольких местах, но это не так, потому что точка с запятой необходима только после оператора, если другой оператор следует за ним внутри того же блока кода (то есть строки).

Perl 5 , 15 байт

Сохранено 2 байта, используя ту же технику, что и в ответе Doorknob на Ruby .

14 байт кода + -pфлаг

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

Попробуйте онлайн!

/.../гарантирует, что массив не пустой (он будет совпадать с любым массивом, но [].
/\b0/будет совпадать, только если 0в массиве есть a ( \bгарантирует, что 0не является частью другого числа, а является целым числом).

Haskell , 48 байтов

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

Попробуйте онлайн!

Спасибо Линн за тестовые случаи и x<"[]"трюк.

Внешнее неравенство должно (x<"[]")быть Истинным (непустой список) и or[elem c"[,"|c:'0':_<-scanr(:)[]x]Ложным (без нулей).

Символы 0обнаруживаются как следующие за ,или [, в отличие от числа, подобного 20. Выражение scanr(:)[]xгенерирует все достаточно lи c:'0':_<-захватывает тех, чей второй символ '0'. Затем elem c"[,"проверяет, является ли первый символ ,или [.

Здесь я предполагаю, что списки в стиле Haskell не имеют пробелов, но в таком случае их ','можно просто заменить на ' '.

Вот более прямой 48-байтовый метод, хотя он производит 0's 1' и 's', которые не являются Истиной / Ложью в Хаскеле.

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

Желе , 4 байта

F;LẠ

Попробуйте онлайн!

Как это работает

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.

Обратите внимание, что атом Ạ ведет себя так же, как и Python, allи поэтому довольно сильно отличается от запрещенного Ȧ.

JavaScript (ES6), 34 байта

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

Контрольные примеры

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

Юлия, 45 байт

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

Это создает функцию, gкоторая указывает, будет ли Ȧ иметь значение 1 или 0, вызывая рекурсивную функцию a. Чтобы сделать подходящий a, мы используем несколько отправок:

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

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

Функция allпринимает аргумент функции, поэтому мы вызываем aкаждый элемент ввода. Затем мы просто определяем функцию для представления как

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

В основном нам просто нужно, aно с проверкой, чтобы правильно обрабатывать [].

Попробуйте онлайн!

Грязь , 16 14 11 байт

Спасибо Zgarb за сохранение 5 байтов.

e`s\0v#|!..

Попробуйте онлайн!

eГоворит копоти , чтобы попытаться соответствовать весь ввод и печать 0или в 1зависимости от того , что это возможно.

|!Фактически является «ни» оператор, потому что x|!yэто сокращение (x|y)!. Таким образом, мы проверяем, что входные данные не содержат ноль, которому предшествует символ, и не являются строкой только из двух символов ( []).

Примечание о второй половине: P#соответствует прямоугольнику, который содержит хотя бы одно совпадение P. Тем не менее, в нашем случае Pсостоит из обоих sи \0так, что обычно требует скобок: (s\0)#(потому что приоритет #слишком высок). Но у Grime есть действительно удобная функция, в которой вы можете изменить приоритет операторов с помощью ^и v. Таким образом, v#мы используем более низкий #приоритет, чтобы он был ниже, чем у любого другого оператора (включая конкатенацию), что позволяет нам сохранять байт в скобках.

Пип , 12 байт

#Va&`\b0`NIa

Принимает массив в качестве аргумента командной строки в форме repr Pip, например [1;[2;3]]. Возвращается 1за правду, 0за фалси. Попробуйте онлайн или проверьте все контрольные примеры .

объяснение

              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

Бонусный ответ, 12 байт

Вот функция, которая принимает список вместо:

#_>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 байта

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

Попробуйте онлайн!

fпринимает входные данные из своего потока в виде списка, который может содержать другие списки и целые числа. Возвращает, 1если aправдива и ничего иного. Вспомогательная функция gпроверяет, aсодержит ли нули.

Объяснение:

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

Решение, использующее регулярные выражения, может быть короче.

Этот ответ мог бы быть короче, если бы ему было разрешено возвращать несколько значений. Это обсуждалось в одном из моих ответов ранее, и был сделан вывод, что в правилах по умолчанию разрешено возвращать разные значения «истина» и «ложь» для разных входных данных, но по какой-то причине OP запрещает это здесь и там. :(

Чудо , 15 байт

@&#0! iO0flat#0

Использование:

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

Сгладить ввод, получить все вхождения 0, логическое НЕ, логическое И с вводом.

Haskell , 62 байта

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

Попробуйте онлайн!

Это функция String -> Bool. Списки на Haskell разнородны, поэтому нет встроенного способа представления таких списков, как [0, [0]].

Python 2 , 45 39 38 байт

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

Попробуйте онлайн!

-6 благодаря @BenFrankel

предыдущая версия, без преобразования списка в строку repr, 68 байт:

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

MATLAB, 49 байтов

Так как MATLAB (как и Octave) не допускает такого рода вложенных массивов, мы интерпретируем его как строку.

Сначала мы заменяем все нецифровые символы пробелом. Затем мы используем его str2numдля преобразования в (1D) массив, к которому мы можем применить all(что разрешено, так как это не полностью решает эту задачу самостоятельно).

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

egrep, 7 + 3 = 10 байт

\<0|^.]

+3 байта для требуемого -vфлага, чтобы инвертировать результат.

Grep не имеет никакого представления о массивах, поэтому здесь используется строковое представление, приведенное в вопросе. Принимает ввод в одну строку из stdin, возвращает через код выхода (игнорировать stdout).

(Теперь использую версию, которая не учитывает 01и похожую, так как, по словам Бога, все в порядке)

Оригинальная запись bash / grep:

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

Находит 0s в любом месте (используя проверку границ слова \<и \>для исключения таких вещей, как 10или a1), или сопоставление всей строки [], затем инвертирует совпадение.

Сломать:

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 символа

Работает с массивом, возвращает 1или 0:

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

Тест:

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 байта

i0Bu

объяснение

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 

Если результат нужно вывести ...

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

Предыдущее решение

Я написал это до того, как понял, что основанные на стеке языки могут оставить значение в стеке как форму вывода

i0B¿0oP?!¿o?

объяснение

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

Хаскелл, 45

Как отмечали Линн и xnor , Haskell не имеет гетерогенно-вложенного типа списка. Но это легко добавить их в качестве типа пользовательских данных и функция работать на этом типе, и это гораздо preferrable к работе на (Urgh!) Строк .

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

Чтобы действительно иметь возможность выписывать такие списки как литералы с [1, [2]]синтаксисом, вам также нужен некоторый класс типов fu. Полный тестовый пример:

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

Попробуйте онлайн!

Vim, 23 байта

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

Попробуйте онлайн!

Выводит пустую строку для false или 1для true. Это может быть короче, если я могу вывести пустую строку или [] для false (оба из которых являются ложными значениями в vim).

С накоплением , 20 байтов

:size\flat,0 eq none

Попробуйте онлайн!

В качестве альтернативы, используя строку:

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

Попробуйте онлайн!

Lithp , 74 байта

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

Попробуйте онлайн!

Ну, это оказалось дольше, чем я надеялся. []Дело споткнулся меня и добавил несколько байт. Он просто выравнивает список и делает сгиб слева над ним, и если он находит 0, он устанавливает аккумулятор в 0.

Рубин , 24 22 байта

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

Попробуйте онлайн!

Да, я знаю, что в Ruby есть лучшее решение, но я хотел найти такое, которое будет использовать массив вместо ввода.

тинилисп , 70 64 байта

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

Последняя строка - это неназванная лямбда-функция, которая принимает список и возвращает 1«правду-под-Ȧ» и « 0ложь». Попробуйте онлайн!

Ungolfed

(load library)

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

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

Рекурсивная вспомогательная функция _Ȧвыполняет большую часть работы. Если его аргумент является списком, мы обращаемся map _Ȧк его элементам и возвращаемся, 1если они allправдивы, 0если они ложные. (Удобно, когда allвозвращается 1пустой список.) В противном случае аргумент должен быть целым числом; мы возвращаем его как есть ( 0это ложь, а все другие целые числа истинны в tinylisp).

Основная функция Ȧпроверяет, является ли список непустым. Если это так, он звонит _Ȧ; если нет, то возвращается 0.

Гольф-версия использует некоторое неопределенное поведение: вместо (e(type X)List)проверки Xиспользуется целое число или список (c()X), в котором делается попытка cons(предварять) пустой список X. Если Xэто список, это приводит к непустому списку, который является правдивым. Если Xэто целое число, tinylisp выводит сообщение об ошибке и возвращает пустой список, который является ложным. Поскольку stderr игнорируется, этот подход является действительным.

PHP, 63 54 байта

9 байтов сохранено @ user63956

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

принимает массив в качестве входных данных; возвращает trueили false: Если $aне пусто,
проверьте, print_rсодержит ли выход 0значение.

матричное решение, 83 байта

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

рекурсивная функция возвращает 1или 0.

сломать

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
}