12

У цьому виклику ви повинні розібрати список списків у більш простий формат списку.

Цей виклик грунтується на моєму аналізаторі sadflak. У моєму аналізаторі sadflak він видалив (() замінено сумою () s на початку списку), щоб програма запустила швидше.

Щоб розібратися в Sad-List, ви повинні зробити це (річ реалізації python, використовує набір кортежів):

def sadlistfunc(list):
    new-sadlist = [0]
    for i in list:
        if i == ():
            new-sadlist[0]+=1
        else:
            new-sadlist.append(sadlistfunc(i))

Це рекурсивна функція. Для списку почніть новий список, починаючи з числа () на вході списку, потім решта цього списку - це версії сумного списку кожного списку, який не був () зі списку, в порядку. повернути список.

Вхід:

Ви можете скористатися інформацією в декількох різних форматах:

ви можете взяти це як список
ви можете прийняти це як кортеж
ви можете прийняти це як рядок

якщо ви сприймаєте це як рядок, вам слід скористатися деяким набором дужок, як це відображається в мозку. ви не можете використовувати символи 1 і 2

просто бути розумним

Введення завжди буде всередині одного списку, але ваша програма може припускати неявний список списку поза вхідним джерелом, тобто () () () = (() () ()), або він може вирішити не робити. Приклади будуть із явним зовнішнім списком

вихід:

може бути список, кортеж або рядок, або будь-що інше. Ви можете використовувати будь-який розумний вихідний формат, як це мета-консенсус.

Приклад:

(()()()) = [3]
(((()))) = [0,[0,[1]]]
((())()(())) = [1, [1], [1]]
() = invalid input, if the outside bracket is explicit.
((((())())())(())()) = [1, [1, [1, [1]]], [1]]

зауважте, що введення не є суворим. ці входи можуть бути:

[[],[],[]]
[[[[]]]]
[[[]],[],[[]]]
[]
[[[[[]],[]],[]],[[]],[]]

або якийсь інший розумний формат

пояснено тестовий випадок:

(()()((())())())

щоб "зафіксувати" це, спочатку підрахуємо кількість ()

 ()()        ()
(    ((())())  )

3. потім видаляємо ці і додаємо 3 на початку

(3,((())()))

в цьому списку є один список. ми це сумніваємо

((())())

як багато ()?

     ()
((())  )

1. видаляємо і додаємо 1 на початку

(1,(()))

у цьому є один список

(())

рахувати

 ()
(  )

видалити та додати кількість

(1)

то ми повертаємо це назад у його список

(1,(1))

то ми повертаємо це назад у його список

(3,(1,(1)))

зроблено

Це код-гольф , тому коротше - краще

code-golf array-manipulation brain-flak

— Руйнуючий лимон
джерело

Зауважте, що у фактичному аналізаторі сумного спалаху кількість () насправді є другим елементом списку, а перший пункт - індекс команди

— Руйнуючий лимон

Добре, JavaScript for... in, що змушує мене згадати, чому ти ніколи його не використовуєш: Fiddle

— Стівен

Я гадаю, ((((())())())(())()) = [1, [1, [1, [1]], [1]]має бути ((((())())())(())()) = [1, [1, [1, [1]]], [1]].

— Ренцо

4

Pyth , 13 байт

L+]/bYyM-b]Yy

Тестовий набір .

Як це працює

L+]/bYyM-b]Yy
L               define a function y with argument b:
   /bY              list 1: count how many [] can be found in b
  ]                         wrap into singleton
        -b]Y        list 2: filter out [] from b
      yM                    apply y (this function) to each
 +                  concatenate the two lists above
            y   apply y to the input

— Лина монахиня
джерело

Ви можете видалити спочатку ].

— Ерік Аутгольфер

3

CommonLisp, 49 байт

(defun s(l)(cons(count()l)(mapcar's(remove()l))))

приймати введення як список списків.

Спробуйте в Інтернеті!

— Ренцо
джерело

2

Брахілог , 21 байт

;[[]]x{↰₀}ᵐA&{∋∅}ᶜg,A

Спробуйте в Інтернеті!

— Лина монахиня
джерело

Байти та символи не рівноцінні. Використовуючи UTF-8, це займе 33 байти, незважаючи на те, що це лише 21 символ.

— Самаді

1

@Samadi Brachylog використовує власну кодову сторінку , дозволену відповідно до цього метавідповіді .

— Лина монашка

А, бачу. Я був трохи збентежений. Дякуємо за уточнення!

— Самаді

@Samadi Немає проблем, це питання постійно задають.

— Лина монашка

2

Математика, 42 байти

{#~Count~{0},##&@@#~DeleteCases~{0}}&//@#&

Уникає явної рекурсії за допомогою //@( MapAll), який відображає функцію над кожним вузлом дерева. Це також означає, що функції виконуються від листя вгору. Однак він також буде застосований до того, до {}чого перетворюються {0}. Тому {0}замість цього ми рахуємо та видаляємо {}.

— Мартін Ендер
джерело

2

Сітківка , 42 байти

+`(({()|}(?<-3>))*)(?!\3){}
1$1
{(1*)
{$.1

Спробуйте в Інтернеті!

— Мартін Ендер
джерело

2

Clojure, 59 байт

(fn f[i](conj(map f(remove #{[]}i))(count(filter #{[]}i))))

Не сильно відрізняється від відповіді CommonLisp . Його countі, removeздається, прийняти трохи приємнішу конструкцію, тут мені довелося використовувати набори.

— NikoNyrh
джерело

2

Власне , 12 байт

;[]@c@;░Q£Mo

Спробуйте в Інтернеті!

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

Пояснення:

;[]@c@;░Q£Mo
;[]@c         count the number of empty lists
     @;░      filter out empty lists
        Q£Mo  recurse with filtered list and append result

— Мего
джерело

2

Python 2 , 69 46 45 байт

f=lambda l:[l.count([])]+map(f,filter(len,l))

Спробуйте в Інтернеті!

— овс
джерело

Я думаю, що вам потрібно додати f=свій рахунок, оскільки ви використовуєте функцію f, а іменування її в іншому випадку порушить ваше рішення

— Лев,

@Leo Ви маєте рацію.

— ов

1

Желе , 10 байт

Tịß€;@ċ“”$

Спробуйте в Інтернеті!

Вводиться як список списків списків ...

Звичайно, він використовує алгоритм, який використовують інші відповіді. ;)

— Ерік Аутгольфер
джерело

Це не 10 байт. Це 10 символів . Кількість байтів буде залежати від того, яке кодування ви використовуєте.

— Самаді

2

@Samadi Ні, у Jelly є виділений набір символів, який є його за замовчуванням, і він може представляти ці символи як один байт кожен. Дивіться тут .

— Адам

Я бачу. Дякуємо за роз’яснення!

— Самаді

1

Haskell , 102 байти

data L=I Int|T[L]deriving Show
(I n:r)#m=r#(n+m)
(x:r)#m=x:r#m
_#m=[I m]
f(T[])=I 1
f(T t)=T$map f t#0

Спробуйте в Інтернеті!

Оскільки Haskell строго набраний, немає довільно вкладених списків. Як засібdata L=I Int|T[L]deriving Show оголошує деревоподібні вкладені списки з Ints або порожніми списками як листя.

Вхідні дані , як у другому прикладі форматі, з додатковим конструктором Tперед кожною відкриває дужкою: T[T[T[]],T[],T[T[]]]. Те саме стосується виводу, кожному номеру передує конструктор I. Функцію fвиконує засмучення .

Виходи для тестових випадків:

T [I 3]
T [T [T [I 1],I 0],I 0]
T [T [I 1],T [I 1],I 1]
T [T [T [T [I 1],I 1],I 1],T [I 1],I 1]

— Лайконі
джерело

1

Javascript (ES6), 77 байт

Гольф:

let m=a=>!a.length||a.map(m).reduce((b,c)=>(c.length?b.push(c):b[0]++,b),[0])

Безголівки:

const traverse = arr => !arr.length || arr
    .map(traverse)
    .reduce(
        (accum, val) => (val.length ? accum.push(val) : accum[0]++, accum),
        [0]
    );

Демо

Показати фрагмент коду

let m=a=>!a.length||a.map(m).reduce((b,c)=>(c.length?b.push(c):b[0]++,b),[0])

o.innerHTML = [
    JSON.stringify(m([[],[],[]])),
    JSON.stringify(m([[[[]]]])),
    JSON.stringify(m([[[]],[],[[]]])),
    JSON.stringify(m([])),
    JSON.stringify(m([[[[[]],[]],[]],[[]],[]]))
].join('\n')

<pre id=o></pre>

Розгорніть фрагмент

— ЗаслуженийМуль
джерело

Розбирайте список списків на список сум

Вхід:

вихід:

Приклад:

пояснено тестовий випадок:

Pyth , 13 байт

Як це працює

CommonLisp, 49 байт

Брахілог , 21 байт

Математика, 42 байти

Сітківка , 42 байти

Clojure, 59 байт

Власне , 12 байт

Python 2 , 69 46 45 байт

Желе , 10 байт

Haskell , 102 байти

Javascript (ES6), 77 байт

Демо