Analisar uma lista de listas em uma Sad-List

12

Nesse desafio, você deve analisar uma lista de listas em um formato de lista mais simples.

Esse desafio é baseado no meu analisador sadflak. No meu analisador sadflak, todos os () foram removidos, substituídos pela soma dos () s no início da lista, para acelerar a execução do programa.

Para analisar uma Sad-List, você precisa fazer isso (coisa de implementação em python, usa uma tupla de tuplas):

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

Esta é uma função recursiva. Para uma lista, inicie uma nova lista, começando com o número de () da entrada da lista e, em seguida, o restante desta lista são versões da lista triste de todas as listas que não eram () da entrada da lista, em ordem. retorne a lista.

Entrada:

você pode receber entradas em alguns formatos diferentes:

  • você pode tomá-lo como uma lista
  • você pode tomá-lo como uma tupla
  • você pode tomá-lo como uma corda

se você a usar como uma corda, use algum conjunto de colchetes, como aparece no cérebro. você não pode usar os caracteres 1 e 2

apenas seja razoável

A entrada sempre estará dentro de uma lista, mas seu programa pode assumir uma camada de lista implícita fora da entrada, ou seja, () () () = (() () ())) ou pode optar por não. Exemplos serão com lista externa explícita

resultado:

pode ser lista ou tupla ou string, ou qualquer outra coisa. você pode usar qualquer formato de saída razoável, como é o meta consenso.

Exemplo:

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

note que a entrada não é estrita. essas entradas podem ser:

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

ou algum outro formato razoável

caso de teste explicado:

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

para "entristecer" isso, primeiro contamos o número de ()

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

3. depois removemos e adicionamos um 3 no início

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

existe uma lista nesta lista. nós entristecemos isso

((())())

quantos ()?

     ()
((())  )

1. removemos e adicionamos um 1 no início

(1,(()))

isso tem uma lista nele

(())

contagem

 ()
(  )

remover e adicionar contagem

(1)

então colocamos isso de volta em sua lista

(1,(1))

então colocamos isso de volta em sua lista

(3,(1,(1)))

feito

Isso é , então quanto menor, melhor

Limão destrutível
fonte
Note-se que no analisador sad-Flak real, o número de () é na verdade o segundo item da lista, eo primeiro item é o índice do comando
Destrutível Lemon
Bom e velho JavaScript for... in, me fazendo lembrar por que você nunca o usa: Fiddle
Stephen
Suponho que ((((())())())(())()) = [1, [1, [1, [1]], [1]]deveria ser ((((())())())(())()) = [1, [1, [1, [1]]], [1]].
Renzo:

Respostas:

4

Pitão , 13 bytes

L+]/bYyM-b]Yy

Conjunto de teste .

Como funciona

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
Freira Furada
fonte
Você pode remover primeiro ].
Erik the Outgolfer
3

CommonLisp, 49 bytes

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

tome entrada como lista de listas.

Experimente online!

Renzo
fonte
2

Braquilog , 21 bytes

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

Experimente online!

Freira Furada
fonte
Bytes e caracteres não são equivalentes. Usando UTF-8, isso ocuparia 33 bytes, apesar de ter apenas 21 caracteres.
Samadi
1
O @Samadi Brachylog usa sua própria página de códigos , que é permitida por esta meta resposta .
Freira vazada
Ah entendo. Eu estava um pouco confuso. Obrigado por esclarecer!
precisa
@Samadi Não há problema, esta pergunta é feita o tempo todo.
Leaky Nun
2

Mathematica, 42 bytes

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

Evita recursão explícita usando //@( MapAll) que mapeia uma função sobre cada nó em uma árvore. Isso também significa que as funções são executadas das folhas para cima. No entanto, ele também será aplicado ao {}qual será transformado {0}no processo. É por isso que contamos e remover {0}vez {}.

Martin Ender
fonte
2

Clojure, 59 bytes

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

Não é muito diferente da resposta do CommonLisp . É counte removeparece aceitar uma construção um pouco melhor, aqui eu tive que usar conjuntos.

NikoNyrh
fonte
2

Na verdade , 12 bytes

;[]@c@;░Q£Mo

Experimente online!

Recebe entrada como uma lista de colchetes separados por vírgula com colchetes externos explícitos.

Explicação:

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

Python 2 , 69 46 45 bytes

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

Experimente online!

ovs
fonte
Eu acho que você precisa adicionar f=ao seu bytecount, já que você está usando a função f, e nomeá-lo de outra forma prejudicaria a sua solução #
217
@ Leo Você está certo.
ovs 27/06
1

Gelatina , 10 bytes

Tị߀;@ċ“”$

Experimente online!

Recebe entrada como lista de listas de listas ...

Obviamente, ele usa o algoritmo usado pelas outras respostas. ;)

Erik, o Outgolfer
fonte
Isso não é 10 bytes. São 10 caracteres . O número de bytes dependerá da codificação usada.
Samadi
2
@Samadi Não, o Jelly possui um conjunto de caracteres dedicado, que é o padrão, e pode representar esses caracteres como um byte cada. Veja aqui .
Adám 26/06
Entendo. Obrigado pelo esclarecimento!
precisa
1

Haskell , 102 bytes

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

Experimente online!

Como Haskell é estritamente digitado, não há listas aninhadas arbitrariamente. Como remédio, data L=I Int|T[L]deriving Showdeclara listas aninhadas em forma de árvore com Ints ou listas vazias como folhas.

Entrada é como no segundo exemplo formato, com um construtor adicional Tantes de cada chave de abertura: T[T[T[]],T[],T[T[]]]. O mesmo vale para a saída, com cada número sendo precedido por um construtor I. Função fexecuta o entristecimento .

Saídas para os casos de teste:

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]
Laikoni
fonte
1

Javascript (ES6), 77 bytes

Golfe:

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

Ungolfed:

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

Demo

HonoredMule
fonte