Comprimento da corda usando a teoria dos conjuntos

20

Wikipedia: Definição teórica dos números naturais

O conjunto N de números naturais é definido como o menor conjunto contendo 0 e fechado sob a função sucessora S definida por S (n) = n ∪ {n}.

Os primeiros números definidos dessa maneira são 0 = {}, 1 = {0} = {{}}, 2 = {0,1} = {{}, {{}}}, 3 = {0,1,2 } = {{}, {{}}, {{}, {{}}}}.

O uso dessa definição de números naturais conta o comprimento de uma string.

Insira uma sequência de caracteres de a-zA-Z de qualquer tamanho

Saída do comprimento da string na notação definida sem separadores

Exemplos

String vazia de entrada

Saída {}

Introduza um

Saída {{}}

Entrada aaaa

Saída {{} {{}} {{} {{}}} {{} {{}} {{} {{}}}}}

Para legibilidade, a saída para 'aaaa' com separadores é

{ 
    {} 
    {{}} 
    {{} {{}} } 
    {{}   {{}}   {{} {{} } }   }
}

Condições

  1. Não há dígitos de 0 a 9 para aparecer no código;
  2. Não há uso de conversão de código de caracteres para gerar números;
  3. Nenhum uso de + - * / para cálculos aritméticos, incluindo incremento e decremento;
  4. Nenhuma operação matemática além da lógica booleana;
  5. A sequência de entrada não conta na determinação do comprimento dos bytes;

Vencedor Menor comprimento do código em bytes.

Como esta é minha primeira pergunta, espero ter esclarecido e rigorosamente o suficiente. Aceitamos conselhos amigáveis.

code-golf math restricted-source arithmetic set-theory jing3142
fonte
Hum, você pode implementar uma definição recursiva sem chamar f(n-1)?
Martin Ender
1
Eu tenho uma solução (não ideal em termos de comprimento de bytes) que não usa recursão. Se A é uma matriz, então A.pop (); f (A) é recursivo.
precisa saber é o seguinte
Este é um bom ponto.
Martin Ender
1
@ jing3142 Parabéns por implementar você mesmo uma solução para garantir que seja possível. +1 para uma ótima pergunta.
Kyle Strand
O que significa a restrição para a-zA-Z? Devemos detectar espaço em branco / rubish? ou devemos apenas esperar isso e informar o comprimento da string, em relação ao conteúdo?
VX

Respostas:

7

GolfScript ( 18 17 bytes)

'{'\{;.'}'++}/'}'

Recebe entrada na pilha (portanto, se for executado como um programa, via stdin). Deixa a saída como duas strings na pilha (portanto, se executada como um programa, a saída correta é enviada para stdout).

Para deixar uma única string na pilha, acrescente +a concat ou use a alternativa

'{}'\{;.);\'}'++}/

Dissecação

# Stack: input-str
'{'\
# Stack: <0< input-str  where <0< means the string representing 0 without its final }
# Loop over each character of the input string
{
    # Stack: <n< char
    # Discard the input character
    ;
    # Concatenate two copies of <n< and a }
    .'}'++
}/
# Push the final } to the stack
'}'

Alternativo:

# Stack: input-str
'{}'\
# Stack: <0> input-str  (where <0> means the string representing 0)
# Loop over each character of the input string
{
    # Stack: <n> char
    # Discard the input character
    ;
    # Duplicate <n> and remove the final '}'
    .);
    # Stack manipulations
    \'}'
    # Stack: <n>-less-final-'}' <n> '}'
    # Concatenate the three strings to get <n+1>
    ++
}/

Impacto das restrições

Se o decréscimo fosse permitido, permitiria a solução de 15 bytes

'{}'\{;..,(/*}/
Peter Taylor
fonte
12

Função Haskell, 35 34 caracteres

f[]="{}";f(_:x)='{':f x++tail(f x)

Programa Haskell com entrada codificada, 48 ou 49 47 ou 48 caracteres

 f[]="{}";f(_:x)='{':f x++tail(f x);main=print$f"aaaa"

(47 caracteres, se você não se importa com aspas extras na saída; se o fizer, use em putStrvez de, printno total, 48 caracteres)

Programa Haskell, 51 50 caracteres

f[]="{}";f(_:x)='{':f x++tail(f x);main=interact f
John Dvorak
fonte
Se você estiver invertendo a ordem, já que é um conjunto, você pode usar: f [] = "{}"; f (_: x) = '{': f x ++ (tail.f) x para salvar um personagem.
Isaacg
@isaacg Nice one. OP deve nos dizer se ele se importa, no entanto.
John Dvorak
Como o próprio uma ordem estabelecida não importa tanto @isaacg 's sugestão é boa
jing3142
5

Python 3-64

o=['{}']
for a in input():o+=['{'+''.join(o)+'}']
print(o.pop())

Se a entrada embutida for permitida:

Python 2-54

o=['{}']
for a in'whatever':o+=['{'+''.join(o)+'}']
print o.pop()
isaacg
fonte
Não é raw-input () o método de entrada, não a própria string de entrada. Não estando familiarizado com o intervalo de idiomas possível, eu estava desaprovando o comprimento da string se algo como w = 'aaaaaaaaaaaa' fosse necessário no código. Desculpe se não estiver claro. Qualquer ajuda na redação da pergunta é aceita.
precisa saber é o seguinte
Entendo. Vou reescrever meu código de acordo. Em geral, porém, acho que você deveria deixar essa linha de fora. Essencialmente, todos os idiomas possuem um sistema de E / S.
Isaacg
Você pode salvar um símbolo usando o[-1]em vez deo.pop()
Aland
1
"Nenhum dígito de 0 a 9 para aparecer no código;"
Isaacg
1
Um caractere estranho para o primeiro: inicialize o=[], que se torna o=['{}']após uma etapa, e amplie a entrada por uma, substituindo-a por '_'+input(), cortando o espaço depois in.
Xnor
3

Javascript 70 (caracteres)

s='';c=prompt().split('');while(c.pop()){s+='{'+s+'}'}alert('{'+s+'}')

Este foi o meu esforço antes de definir a pergunta. Eu diria que alguém com mais conhecimento de Javascript do que eu provavelmente pode vencê-lo.

Obrigado Jan Dvorak e Peter Taylor por mais reduções

agora 62

s='{';c=prompt().split('');while(c.pop())s+=s+'}';alert(s+'}')

e agora 61

s='{';for(c=prompt().split('');c.pop();)s+=s+'}';alert(s+'}')

Explicação do código original

definir s para estar vazio

string de entrada em ce dividido em uma matriz

enquanto é possível pop () um caractere de c fazê-lo e redefinir s = s {s} como sucessor

corrente de saída s, mas precisa cercar com colchetes.

jing3142
fonte
Você não precisa de chaves depois while(salva um caractere).
John Dvorak
1
Há uma economia de 7 caracteres sem o conhecimento de JS necessário: inicialize s='{'e abandone os dois '{'+. (Isso se comporta como minha solução GS). Há uma economia adicional de 1 caractere, usando em forvez de whilee puxando uma das duas inicializações para a inicialização do loop for.
Peter Taylor
@ peter-taylor não sabe ao certo como pretende aplicar o loop for. Eu só o usei para contar.
precisa saber é o seguinte
3
for(a;b;c){d}é diretamente equivalente a;while(b){d;c}na maioria dos idiomas que possuem os dois. Portanto, embora for(;b;)seja idêntico ao while(b)efeito e à contagem de caracteres, for(a;b;)economiza um caractere a;while(b)e é idêntico no efeito.
Peter Taylor
@ peter-taylor +1 para explicação muito clara e concisa dentro de um comentário
jing3142
3

J - 22 20 car

'{','}' '{'&(,,~)~#

Como isso pode ser derivado:

   #'123'                      NB. string length
3
   'Left' (,,~) 'Right'        NB. dyad to concat L,R,R
LeftRightRight
   '{' (,,~) '}'               NB. using braces
{}}
   '{'&(,,~) '}'               NB. bind left argument, now it's a monad
{}}
   '{'&(,,~) '{'&(,,~) '}'     NB. twice
{{}}{}}
   '{'&(,,~)^:2 '}'            NB. ^: is monad functional power
{{}}{}}
   '{'&(,,~)^:3 '}'            NB. any integer
{{{}}{}}{{}}{}}
   3 '{'&(,,~) '}'             NB. convenient feature of dyadic &
{{{}}{}}{{}}{}}
   '}' '{'&(,,~)~ 3            NB. swap argument order
{{{}}{}}{{}}{}}
   '}' '{'&(,,~)~ #'123'       NB. using string length
{{{}}{}}{{}}{}}
   '{', '}' '{'&(,,~)~ #'123'  NB. add final brace
{{{{}}{}}{{}}{}}
   ('{','}' '{'&(,,~)~#) '123' NB. works as a verb
{{{{}}{}}{{}}{}}

Alternativamente, isso pode ser escrito '{','{'&(,,~)&'}'@#, significando a mesma coisa.

Uso:

   '{','}' '{'&(,,~)~# 'aaaa'
{{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}
   f =: '{','}' '{'&(,,~)~#  NB. can be assigned to a function
   f 'VeryBig'
{{{{{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}{{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}{{{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}{{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}
algoritmshark
fonte
2

Haskell - 35 caracteres

g[]="{}";g(_:x)=(init.g)x++g x++"}"

A solução é influenciada pela de Jan Dvorak, mas sem reverter a ordem.

user102417
fonte
2

Scala, 64 caracteres

def f(s:String):String=s"{${s.tails.toSeq.tail.map(f)mkString}}"

Observe os papéis duplos que os aparelhos e sdesempenham neste código.

EDIT: removido um dígito

Karol S
fonte
Há um dígito no código
jing3142 10/04
@ jing3142 Opa. Não mais.
Karol S
2

Python 3 (44)

s='{'
for _ in input():s+=s+'}'
print(s+'}')

Em cada etapa, sé a sequência que representa o conjunto com a final }removida. Criamos o conjunto que representa a n+1partir do conjunto que representa natravés do relacionamento f (n + 1) = f (n) ∪ {f (n)}. Para implementar a união com strings, anexamos a string para {f (n)}, que é exatamente smas com o final }retornado, e deixamos de incluir o final} no resultado. Finalmente, adicionamos uma final '}'antes de imprimir.

Se eu puder codificar a string, a contagem de caracteres diminui para 35, alternando para Python 2 para salvar parênteses no print.

s='{'
for _ in'string':s+=s+'}'
print s+'}'

Pode haver uma maneira de economizar espaço após o printprocedimento, fazendo algo parecido print'{'+scom o invertido s, mas isso atrapalha o +=anexo à direita.

xnor
fonte
2

gs2, 12 bytes

7b 7d 05 27 a0 42 30 30 e4 43 2e 32

mnemônicos:

"{}"
right-uncons @0 swap + + b5
rot length times
Lynn
fonte
1

Mathematica, 115 caracteres

StringReplace[ToString@Function[s,NestWhile[#~Append~#&,{},(s~Read~Character//StringQ)&]]@StringToStream@"test",", "->""]

O código completo, como mostrado, possui 121 caracteres, mas 6 deles são usados ​​para a sequência de entrada ("test" ) que, de acordo com as regras, não conta.

Sem a exigência de que não haja delimitadores, o tamanho do código pode ser reduzido ainda mais em 24 caracteres; sem conversão explícita em string, outros 9 caracteres podem ser removidos.

celtschk
fonte
1
Eu pensei que, removendo a necessidade de deliminadores, que geralmente são necessários na notação de conjunto, eu estava ajudando a reduzir o tamanho do código. Portanto, se usá-los reduz o tamanho do seu código, vá em frente e use-os.
jing3142
1

Ruby, 27 anos, meio que trapaceando

a=*a
gets.chars{a=*a,a}
p a

Coisas questionáveis:

  1. Saída parece [[], [[]], [[], [[]]], [[], [[]], [[], [[]]]]]
  2. A maioria dos métodos de entrada no ruby ​​inclui uma nova linha à direita, que aumenta a contagem em 1.
histocrata
fonte
1
Deve ser perfeitamente legítimo se você fizer inspecta matriz manualmente e tro resultado.
John Dvorak
1

Pure Bash, 54

f()([ $@ ]&&(a=`f ${@%?}`
echo $a{$a}))
echo {`f $@`}

Saída:

$ ./strlenset.sh
{}
$ ./strlenset.sh a
{{}}
$ ./strlenset.sh aa
{{} {{}}}
$ ./strlenset.sh aaa
{{} {{}} {{} {{}}}}
$ ./strlenset.sh aaaa
{{} {{}} {{} {{}}} {{} {{}} {{} {{}}}}}}}
$
Trauma Digital
fonte
1

Julia 43

f(z)="{"foldl((x,y)->"$x{$x}","",{z...})"}"

A construção {z ...} expande a cadeia z em uma matriz. Dobre loops sobre todos os elementos da matriz, ignorando o conteúdo e construindo a partir da sequência vazia. A função foldl está disponível em Julia 0.30.

Saída de amostra

julia> f("")
"{}"
julia> f("aa")
"{{}{{}}}"
julia> f("aaaa")
"{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}"
julia> f("aaaaaa")
"{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}"
waTeim
fonte
1

Haskell, 31 bytes

foldl(\s _->init s++s++"}")"{}"
alefalpha
fonte
1

Mathematica, 45 57 48 bytes

"{"~~Fold[#~~"{"~~#~~"}"&,"",Characters@#]~~"}"&

Uma solução de 36 bytes:

Fold[{##{##}}&@@#&,{},Characters@#]&

No entanto, ele usa alguns cálculos aritméticos.

alefalpha
fonte
0

Delphi XE3 (264)

Ok, eu nem chego perto do outro, mas foi divertido fazer :)
Provavelmente, pensando demais. Indo para ver se há uma maneira melhor de fazer isso.

Golfe

uses System.SysUtils;var s,f:string;a:TArray<char>;b:TArray<string>;i,x:integer;begin readln(s);a:=s.ToCharArray;f:='{';setlength(b,Length(a));for I:=Low(a)to High(a) do begin s:='{';for x:=Low(b)to High(b)do s:=s+b[x];b[i]:=s+'}';f:=f+b[i];end;writeln(f+'}');end.

Ungolfed

uses
  System.SysUtils;
var
  s,f:string;
  a:TArray<char>;
  b:TArray<string>;
  i,x:integer;
begin
    readln(s);
    a:=s.ToCharArray;
    f:='{';
    setlength(b,Length(a));
    for I:=Low(a)to High(a) do
    begin
      s:='{';
      for x:=Low(b)to High(b)do
        s:=s+b[x];
      b[i]:=s+'}';
      f:=f+b[i];
    end;
    writeln(f+'}');
end.

Resultados dos testes

Cordas testadas com comprimento 0..10

{}
{{} }
{{} {{}} }
{{} {{}} {{}{{}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}}}} }
Teun Pronk
fonte
Obrigado por tentar. Em minha mente, eu estava considerando o comprimento como uma operação matemática, pois retorna um número e, assim como o uso de um loop 'for', que envolve a contagem.
precisa saber é o seguinte
0

Perl 5: 33 caracteres

Não está claro quais caracteres devo contar como parte da solução. Provavelmente não é a echo ... |parte porque é usada apenas para alimentar uma linha no stdin. Provavelmente não é o nome do binário perl, porque você pode renomeá-lo para o que quiser.

Portanto, contei as opções da linha de comando passadas para o perl, as aspas contidas no código Perl e o próprio código Perl.

#                                1         2         3
#                     12  3456789012345678901234567890123
$ echo "aaaa" | perl -ple'$s.="{$s}"while s/.//;$_="{$s}"'

Além disso, relacionado .

tobyink
fonte
1
Você deve contar plcomo padrão, mas obtém -ee as aspas ao redor do código gratuitamente. Ref
Peter Taylor
0

Perl 6: 37 caracteres

say ({"\{@_.join()\}"}...*)["(input string)".chars]

ou de STDIN:

say ({"\{@_.join()\}"}...*)[get.chars]

{"\{@_.join()\}"}...*faz uma lista preguiçosa das formas definidas dos números naturais, e simplesmente pegamos a que precisamos get.chars.

A lista lenta pode ser escrita com mais facilidade:

-> *@prev { '{'~ @prev.join ~'}' } ... *

Que lê de forma muito semelhante à definição.

Mouq
fonte
0

Dardo: 85 caracteres

a(p,i)=>(--i).isNegative?p:a("$p{$p}",i);
main(s){print("{${a("",s.first.length)}}");}

(com nova linha extra para facilitar a leitura).

O requisito de não usar "0" realmente morde, caso contrário .firstseria [0]e (..).isNegativeseria ..<0.

lrn
fonte
0

Pitão, 13 bytes

+u++GG\}z\{\}

Este é o equivalente Pyth em golfe da resposta Python do @ xnor. Observe que Pyth é mais recente que esta pergunta, portanto, esta resposta não é elegível para vencer esse desafio.

Demonstração.

isaacg
fonte
u+G]GlQY
Leaky Nun
0

Javascript, 171 149 147 142 142 bytes

(Provavelmente será jogado mais tarde)

n = prompt (). split (""); para (a = []; n.pop ();) a.push (a.slice ()); alert (JSON.stringify ({a: a}) [ R = "substituir"] (/ [^ \ [\]] / g, "") [R] (/ \ [/ g, "{") [R] (/ \] / g, "}")) ;
SuperJedi224
fonte