Longitud de la cadena usando la teoría de conjuntos

20

De Wikipedia Definición teórica de conjuntos de números naturales

El conjunto N de números naturales se define como el conjunto más pequeño que contiene 0 y se cierra bajo la función sucesora S definida por S (n) = n ∪ {n}.

Los primeros números definidos de esta manera son 0 = {}, 1 = {0} = {{}}, 2 = {0,1} = {{}, {{}}}, 3 = {0,1,2 } = {{}, {{}}, {{}, {{}}}}.

Usando esta definición de números naturales se cuenta la longitud de una cadena.

Ingrese una cadena de caracteres de a-zA-Z de cualquier longitud

Salida de la longitud de la cadena en notación establecida sin separadores

Ejemplos

Introducir cadena vacía

Salida {}

Ingrese un

Salida {{}}

Entrada aaaa

Salida {{} {{}} {{} {{}}} {{} {{}} {{} {{}}}}}

Para la legibilidad, la salida para 'aaaa' con separadores es

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

Condiciones

  1. No aparecen dígitos del 0 al 9 en el código;
  2. No se utiliza la conversión del código de caracteres para generar números;
  3. Sin uso de + - * / para cálculos aritméticos, incluidos incrementos y decrementos;
  4. No hay operaciones matemáticas que no sean lógica booleana;
  5. La cadena de entrada no cuenta para determinar la longitud del byte;

Ganador La longitud de código más corta en bytes.

Como esta es mi primera pregunta, espero haberlo dejado lo suficientemente claro y riguroso. Consejo amistoso aceptado.

code-golf  math  restricted-source  arithmetic  set-theory 
— jing3142
fuente
Hm, ¿puedes implementar una definición recursiva sin llamar f(n-1)?
— Martin Ender
1
Tengo una solución (no óptima en términos de longitud de bytes) que no utiliza la recursividad. Si A es una matriz, entonces A.pop (); f (A) es recursivo.
— jing3142
Ese es un buen punto.
— Martin Ender
1
@ jing3142 Felicitaciones por implementar una solución usted mismo para asegurarse de que sea posible. +1 por buena pregunta.
— Kyle Strand
¿Qué significa la restricción a a-zA-Z? ¿Deberíamos detectar espacios en blanco / rubish? ¿O deberíamos esperar esto e informar la longitud de la cadena, independientemente del contenido?
— VX

Respuestas:

7

GolfScript ( 18 17 bytes)

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

Toma entrada en la pila (por lo tanto, si se ejecuta como un programa, a través de stdin). Deja la salida como dos cadenas en la pila (por lo tanto, si se ejecuta como un programa, la salida correcta se envía a stdout).

Para dejar una sola cadena en la pila, agregue +a concat o use la alternativa

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

Disección

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

Alternativa:

# 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 de las restricciones

Si se permitiera la disminución, permitiría la solución de 15 bytes

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

Función de Haskell, 35 34 caracteres

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

Programa Haskell con entrada codificada, 48 o 49 47 o 48 caracteres

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

(47 caracteres si no le importan las comillas adicionales alrededor de la salida; si lo hace, use en putStrlugar de printun total de 48 caracteres)

Programa Haskell, 51 50 caracteres

f[]="{}";f(_:x)='{':f x++tail(f x);main=interact f
— John Dvorak
fuente
Si está de acuerdo con invertir el orden, ya que es un conjunto, puede usar: f [] = "{}"; f (_: x) = '{': f x ++ (tail.f) x para guardar un personaje.
— isaacg
@isaacg Una buena. Sin embargo, OP debería decirnos si le importa.
— John Dvorak
Como es un orden establecido, no importa, así que la sugerencia de
— @isaacg
5

Python 3 - 64

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

Si se permite la entrada en línea:

Python 2 - 54

o=['{}']
for a in'whatever':o+=['{'+''.join(o)+'}']
print o.pop()
— isaacg
fuente
No es raw-input () el método de entrada, no la cadena de entrada en sí. Al no estar familiarizado con la gama de idiomas posibles, estaba rechazando la longitud de la cadena si era necesario algo como w = 'aaaaaaaaaaaa' dentro del código. Lo siento si no está claro. Cualquier ayuda en la redacción de la pregunta aceptada.
— jing3142
Veo. Reescribiré mi código en consecuencia. En general, sin embargo, creo que deberías dejar esa línea. Esencialmente, cada idioma tiene un sistema de E / S.
— isaacg
Puede guardar un símbolo utilizando en o[-1]lugar deo.pop()
— aland
1
"No aparecen dígitos del 0 al 9 en el código;"
— isaacg
1
Un extraño guardado de caracteres para el primero: Inicializar o=[], que se convierte o=['{}']después de un paso, y alargar la entrada por uno reemplazándolo por '_'+input(), cortando el espacio después in.
— xnor
3

Javascript 70 (caracteres)

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

Este fue mi esfuerzo antes de formular la pregunta. Supongo que alguien con más conocimiento de Javascript que yo probablemente pueda vencerlo.

Gracias Jan Dvorak y Peter Taylor por nuevas reducciones

ahora 62

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

y ahora 61

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

Explicación del código original

establecer s para estar vacío

cadena de entrada en c y dividida en una matriz

Si bien es posible hacer pop () un carácter de c, hacerlo y restablecer s = s {s} como sucesor

Corriente de salida s pero necesita rodear con paréntesis establecidos.

— jing3142
fuente
No necesitas llaves después while(guarda un personaje).
— John Dvorak
1
Hay un ahorro de 7 caracteres sin más conocimiento de JS requerido: inicializar s='{'y deshacerse de los dos '{'+. (Esto se comporta como mi solución GS). Hay un ahorro adicional de 1 carácter al usar en forlugar de whileuna de las dos inicializaciones en la inicialización de bucle.
— Peter Taylor
@Peter-taylor no está seguro de cómo quiere aplicar para el bucle. Solo lo he usado para contar.
— jing3142
3
for(a;b;c){d}es directamente equivalente a a;while(b){d;c}en la mayoría de los idiomas que tienen ambos. Entonces, si bien for(;b;)es idéntico al while(b)efecto y al recuento de caracteres, for(a;b;)guarda un carácter a;while(b)y tiene un efecto idéntico.
— Peter Taylor
@ peter-taylor +1 para una explicación muy clara y concisa dentro de un comentario
— jing3142
3

J - 22 20 char

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

Cómo se puede derivar esto:

   #'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, esto se puede escribir '{','{'&(,,~)&'}'@#, lo que significa lo mismo.

Uso:

   '{','}' '{'&(,,~)~# 'aaaa'
{{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}
   f =: '{','}' '{'&(,,~)~#  NB. can be assigned to a function
   f 'VeryBig'
{{{{{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}{{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}{{{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}{{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}{{{{}}{}}{{}}{}}{{{}}{}}{{}}{}}
— Algoritmo de tiburón
fuente
2

Haskell - 35 caracteres

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

La solución está influenciada por la de Jan Dvorak, pero sin invertir el orden.

— usuario102417
fuente
2

Scala, 64 caracteres

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

Tenga en cuenta los roles duales que desempeñan las llaves y el sjuego en este código.

EDITAR: eliminó un dígito

— Karol S
fuente
Hay un dígito en el código
— jing3142
@ jing3142 ¡Vaya! Ya no.
— Karol S
2

Pitón 3 (44)

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

En cada paso, ses la cadena que representa el conjunto con el final }eliminado. Creamos el conjunto que representa a n+1partir del conjunto que representa a ntravés de la relación f (n + 1) = f (n) ∪ {f (n)}. Para implementar la unión con cadenas, agregamos la cadena para {f (n)}, que es exactamente spero con la final }devuelta, y no incluimos la final }en el resultado. Finalmente, agregamos una final '}'antes de imprimir.

Si puedo codificar la cadena, el recuento de caracteres se reduce a 35 caracteres, cambiando a Python 2 para guardar las paréntesis en el print.

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

Puede haber una manera de ahorrar espacio después printde hacer algo como print'{'+scon un reverso s, pero esto se equivoca con los +=anexos a la derecha.

— xnor
fuente
2

gs2, 12 bytes

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

mnemotécnica:

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

Mathematica, 115 caracteres

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

El código completo como se muestra tiene 121 caracteres, pero 6 de ellos se usan para la cadena de entrada ( "test") que, según las reglas, no cuenta.

Sin el requisito de que no haya delimitadores, la longitud del código podría reducirse aún más en 24 caracteres; sin una conversión explícita a cadena, se podrían eliminar otros 9 caracteres

— celtschk
fuente
1
Pensé que eliminando la necesidad de delimitadores, que generalmente se requieren en la notación de conjunto, estaba ayudando a reducir el tamaño del código. Entonces, si usarlos reduce el tamaño de su código, continúe y úselos.
— jing3142
1

Ruby, 27, una especie de trampa

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

Cosas cuestionables

  1. La salida se ve como [[], [[]], [[], [[]]], [[], [[]], [[], [[]]]]]
  2. La mayoría de los métodos de entrada a ruby ​​incluirán una nueva línea final, que infla el recuento en 1.
— histocrat
fuente
1
Debería ser perfectamente legítimo si inspectla matriz se realiza manualmente y trel resultado.
— John Dvorak
1

Pure Bash, 54

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

Salida:

$ ./strlenset.sh
{}
$ ./strlenset.sh a
{{}}
$ ./strlenset.sh aa
{{} {{}}}
$ ./strlenset.sh aaa
{{} {{}} {{} {{}}}}
$ ./strlenset.sh aaaa
{{} {{}} {{} {{}}} {{} {{}} {{} {{}}}}}
PS
— Trauma digital
fuente
1

Julia 43

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

La construcción {z ...} expande la cadena z en una matriz. Dobla los bucles sobre todos los elementos de la matriz ignorando el contenido y, en su lugar, construyéndolo desde la cadena vacía. La función foldl está disponible en Julia 0.30.

Salida de muestra

julia> f("")
"{}"
julia> f("aa")
"{{}{{}}}"
julia> f("aaaa")
"{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}"
julia> f("aaaaaa")
"{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}"
— WaTeim
fuente
1

Mathematica, 45 57 48 bytes

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

Una solución de 36 bytes:

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

Sin embargo, utiliza algunos cálculos aritméticos.

— alephalpha
fuente
0

Delphi XE3 (264)

Ok, ni siquiera me acerco al otro, pero fue divertido hacerlo :)
Probablemente pensándolo demasiado. A ver si hay una mejor manera de hacer esto.

Golfed

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.

Sin golf

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 de las pruebas

Cuerdas probadas con longitud 0..10

{}
{{} }
{{} {{}} }
{{} {{}} {{}{{}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}}}} }
— Teun Pronk
fuente
Gracias por intentarlo. En mi opinión, estaba considerando la longitud como una operación matemática, ya que devuelve un número y el uso de un bucle 'for' que implica contar.
— jing3142
0

Perl 5: 33 caracteres

No está del todo claro qué caracteres debería contar como parte de la solución. Probablemente no sea la echo ... |parte porque solo se usa para alimentar una línea en stdin. Probablemente no sea el nombre del binario perl, porque podrías cambiarle el nombre a lo que quieras.

Así que he contado los cambios de línea de comando pasados ​​a perl, las comillas envueltas alrededor del código Perl y el código Perl en sí.

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

Además, relacionado .

— tobyink
fuente
1
Debes contar plcomo estándar, pero obtienes -elas cotizaciones del código de forma gratuita. Ref.
— Peter Taylor
0

Perl 6: 37 caracteres

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

o de STDIN:

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

{"\{@_.join()\}"}...*hace una lista perezosa de las formas establecidas de los números naturales, y simplemente tomamos la que necesitamos get.chars.

La lista perezosa podría escribirse de manera más legible:

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

Que se lee bastante similar a la definición.

— Mouq
fuente
0

Dart: 85 caracteres

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

(con nueva línea adicional para facilitar la lectura).

El requisito de no usar "0" realmente muerde, de lo contrario .firstsería [0]y (..).isNegativesería ..<0.

— lrn
fuente
0

Pyth, 13 bytes

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

Este es el equivalente Pyth golfizado de la respuesta Python de @ xnor. Tenga en cuenta que Pyth es más nuevo que esta pregunta, por lo que esta respuesta no es elegible para ganar este desafío.

Demostración.

— isaacg
fuente
— Leaky Nun
0

Javascript, 171 149 147 142 bytes

(Probablemente se jugará golf más tarde)

n = prompt (). split (""); for (a = []; n.pop ();) a.push (a.slice ()); alert (JSON.stringify ({a: a}) [ R = "reemplazar"] (/ [^ \ [\]] / g, "") [R] (/ \ [/ g, "{") [R] (/ \] / g, "}")) ;
— SuperJedi224
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.