Vamos definir a função "tamanho não empacotado" u
de uma lista aninhada l
(contendo apenas listas) pelas seguintes regras:
- Se
l
estiver vazio, entãou(l)
é 1. - Se
l
não estiver vazio,u(l)
é igual à soma dos tamanhos desembrulhados de cada elementol
, mais um.
Sua tarefa é escrever um programa (ou função) que recebe uma lista como entrada e gera (ou retorna) o tamanho desembrulhado da lista.
Casos de teste:
[] -> 1
[[[]],[]] -> 4
[[[]],[[[[]],[]]],[[[]],[[[[]],[[],[[]]]]]]] -> 19
[[[[]]]] -> 4
Isso é código-golfe , então o programa mais curto (em bytes) vence.
code-golf
string
array-manipulation
counting
Esolanging Fruit
fonte
fonte
()
vez de[]
?[[[]][]]
não[[[]],[]]
no seu segundo exemplo?["This is some text [with square brackets in] ...[& maybe more than one pair]"]
?]
pareça ser a solução mais curta em muitos idiomas, também existem muitas respostas que realmente resolvem esse desafio por meio da manipulação de listas e, pelo menos em esolangs, contar as ocorrências de um caractere fixo também é bem diferente de contar as ocorrências de um caractere de entrada.Respostas:
Retina , 1 byte
Experimente online! (A primeira linha ativa um conjunto de testes separado por avanço de linha.)
Por padrão, a Retina conta o número de correspondências do regex especificado na entrada. O tamanho desembrulhado é simplesmente igual ao número de
[]
pares na entrada e, portanto, ao número de]
.fonte
Mathematica, 9 bytes
Acontece que há um built-in para isso ...
Observe que isso não funcionaria se as listas realmente contivessem elementos que não são da lista. O que
LeafCount
realmente faz é contar o número de subexpressões atômicas. Para entrada{{}, {{}}}
, a expressão realmente lê:Aqui as subexpressões atômicas são na verdade as cabeças
List
.fonte
Brainfuck,
716159 bytesPega a entrada de STDIN no formato fornecido na pergunta e gera o caractere cujo código ASCII é o "tamanho desembrulhado da lista".
Eu ainda sou um amador completo em Brainfuck, então provavelmente existem muitas otimizações que ainda podem ser feitas.
Experimente online!
Ungolfed:
fonte
JavaScript (ES6),
2927 bytesEu adoro quando uma recursão acaba bem. Essa é basicamente uma pesquisa aprofundada da entrada, adicionando 1 sempre que o final de uma matriz for atingido.
Se uma matriz vazia for falsificada em JS, isso pode ser de 24 bytes:
Mas, infelizmente, não é. Outras tentativas:
fonte
f=a=>a[0]?f(a.pop())+f(a):1
? (Embora mesmo contagem de bytes.)f=a=>a.reduce((n,a)=>n+f(a),1)
Agora,.f=(n,a)=>n+a.reduce(f,1)
É de apenas 24 bytes, mas infelizmente os parâmetros estão na ordem errada.)f=a=>a.map(a=>n+=f(a),n=1)&&n
Perl,
987 + 1 = 8 bytesRequer a
-p
bandeiraGraças a @Dada por dois bytes salvos (eu estou adorando este ponto-e-vírgula explorar btw)
fonte
-p
para salvar 1 byte;)y;[;
para salvar mais um byteCJam ,
75 bytesObrigado a Peter Taylor por remover 2 bytes! (em
e=
vez def=:+
)Experimente online!
fonte
05AB1E , 4 bytes
Experimente online!
Eu acho que pode ser jogado mais, mas que 'I' é obrigatório, caso contrário, a entrada é considerada uma matriz real em vez de uma string
fonte
"[[[]],[[[[]],[]]],[[[]],[[[[]],[[],[[]]]]]]]"
na entrada remove esseI
requisito, embora eu não saiba se isso é permitido.Labirinto , 8 bytes
Experimente online!
Explicação
Isso conta os colchetes de abertura através de um pouco de mágica bit a bit. Se considerarmos os resultados dos códigos de caracteres do bit a bit E de
[
,,
e]
com2
, temos:Portanto, se apenas resumirmos o resultado dessa operação para cada caractere, obteremos o dobro do valor que queremos.
Quanto ao código em si, o bloco 2x2 no início é um pequeno loop. Na primeira iteração
&-
, não faça nada, exceto que eles colocam um zero explícito no topo dos implícitos na parte inferior da pilha. Este será o total em execução (e será realmente negativo salvar um byte mais tarde). Em seguida, o loop é o seguinte:Uma vez que deixamos o loop, o seguinte bit linear é executado:
O IP então atinge um morto e se vira. Quando tenta executar
/
novamente, o programa termina devido à tentativa de divisão por zero.fonte
Python
32,3623 bytesNotei que
u(l)
é igual ao número de[
na representação de string del
, portanto, este programa tenta fazer isso. Provavelmente, ele poderia ser jogado mais longe, encontrando outra maneira de fazer isso, embora ...fonte
lambda x:`x`.count("[")
Python, 26 bytes
Fórmula recursiva simples.
fonte
C #,
4641 bytesl é a string da lista aninhada. Teste aqui .
fonte
return
usar uma função de expressão corporal. Tambémchar
lança implicitamenteint
assim que você pode usar91
em vez de'['
:int u(string l)=>l.Count(c=>c==91);
Além disso, você pode soltar a assinatura da função e usar um método lambda:l=>l.Count(c=>c==91);
.Gelatina , 4 bytes
Não usa manipulação de string. Experimente online! ou verifique todos os casos de teste .
Como funciona
fonte
Ruby, 13 (+1) bytes
Chamado com
-n
argumento:EDIT: Alterado para realmente imprimir a resposta
fonte
->s{s.count ?[}
seria um envio válido.Regex, 1 byte
Experimente online!
fonte
Flacidez Cerebral ,
63, 61 bytesExperimente online! 58 bytes de código e +3 para o
-a
sinalizador que ativa a entrada ASCII.Versão / explicação legível:
fonte
Befunge ,
221816 bytesTryItOnline!
Edit: Obrigado a Martin Ender por cortar 4 bytes!
Edit2: Crédito para David Holderness por otimizar mais dois
fonte
///, 13 bytes
Saída em unário.
Experimente online!
Explicação:
fonte
///
?PHP, 35 bytes
preg_match_all
localiza todas as instâncias correspondentes da expressão regular e retorna um número, e é por isso que as tags de eco curto são necessárias.Como a maioria das respostas, conta o número de
[
na entrada e gera esse númerofonte
]
vez de[
, não precisará escapar dela.count_chars()[91];
faz praticamente a mesma coisa, mas é mais curto.Raquete 82 bytes
Ungolfed:
Teste:
Resultado:
fonte
V , 10 bytes
Experimente online!
Isso contém alguns caracteres não imprimíveis, aqui está a versão legível:
<C-a>
representa "ctrl-a" (ASCII0x01
) e<esc>
representa a chave de escape (ASCII0x1b
).Versão mais divertida e menos divertida:
Experimente online!
fonte
Scala, 15 bytes
Ungolfed:
count
conta quantos elementos atendem a um predicado, nesse caso92<
, qual é o método<
de92
.fonte
O , 15 bytes
Experimente aqui!
Na entrada, qualquer vírgula deve ser removida ou substituída por espaços.
Explicação
Se pudermos trabalhar em uma sequência: 10 bytes
fonte
> <> ,
212018 bytesEdit: score 1 for goto declarações!
Edit 2: Aparentemente> <> difere do Befunge, pois permite deslocamento de IP diferente de zero após o empacotamento (em outras palavras, usando uma instrução de trampolim, eu posso empacotar para (1, 0) em vez de (0, 0)). Interessante.
TryItOnline!
fonte
Brainfuck, 28 bytes
Experimente online.
Isso conta o número de caracteres de entrada divisíveis por 3, ou seja, o número de
]
caracteres.Solução alternativa de 34 bytes, contando
[
caracteres diretamente e confiando nas células de 8 bits:fonte
C,
4846 bytesGuardado dois bytes graças a kirbyfan64sos
Código de teste
Casos de teste
fonte
*v++^91?0:i++
parai+=*v==91
para salvar 3 bytes.i+=*v++==91
para salvar dois bytes.repl do tinylisp , 39 bytes
Define uma função
u
que pode ser chamada como(u (q ((())()) ))
(para o segundo caso de teste). Fazê-lo na repl salva 4 bytes devido a parênteses fechados automaticamente.Explicação
A
x-(0-y)
construção é necessária porque tinylisp não possui uma função de adição interna, apenas subtração.fonte
Befunge-98 ,
1211109 bytesTryItOnline!
Edit: Obrigado a Martin Ender por raspar um byte
fonte
Haskell,
20 1917 bytesExperimente online!
Pega a lista como string e coloca uma
1
em uma lista para cada uma]
, depois resume todas as1
s.Versão sem ponto: (19 bytes)
Assume que
, [ ]
são os únicos caracteres na string. Filtra a lista para obter todos os caracteres maiores que[
, que são todos]
e retorna o comprimento.Uso:
fonte
Bash + coreutils, 29 bytes
fonte
tr -d -c [|wc -c
, que por padrão lerá a lista da entrada padrão.DASH , 14 bytes
Simplesmente conta
]
. Uso:Solução de bônus, 15 bytes
Este conta recursivamente a partir de uma lista real. Uso:
fonte