20

Da Wikipedia Definizione set-teorica dei numeri naturali

L'insieme N di numeri naturali è definito come l'insieme più piccolo contenente 0 e chiuso sotto la funzione successiva S definita da S (n) = n ∪ {n}.

I primi pochi numeri definiti in questo modo sono 0 = {}, 1 = {0} = {{}}, 2 = {0,1} = {{}, {{}}}, 3 = {0,1,2 } = {{}, {{}}, {{}, {{}}}}.

Usando questa definizione di numeri naturali conta la lunghezza di una stringa.

Inserisci una stringa di caratteri da a-zA-Z di qualsiasi lunghezza

Emette la lunghezza della stringa in notazione set senza separatori

Esempi

Inserisci stringa vuota

Output {}

Inserire a

Output {{}}

Inserisci aaaa

Output {{} {{}} {{} {{}}} {{} {{}} {{} {{}}}}}

Per l'output di leggibilità per "aaaa" con separatori è

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

condizioni

Nessuna cifra da 0 a 9 appare nel codice;
Nessun uso della conversione del codice carattere per generare numeri;
Nessun uso di + - * / per calcoli aritmetici inclusi incremento e decremento;
Nessuna operazione matematica diversa dalla logica booleana;
La stringa di input non conta per determinare la lunghezza del byte;

Vincitore Lunghezza del codice più breve in byte.

Dato che questa è la mia prima domanda, spero di averlo reso abbastanza chiaro e rigoroso. Consiglio amichevole accettato.

— jing3142
fonte

Hm, puoi implementare una definizione ricorsiva senza chiamare f(n-1)?

— Martin Ender,

1

Ho una soluzione (non ottimale in termini di lunghezza dei byte) che non utilizza la ricorsione. Se A è un array, allora A.pop (); f (A) è ricorsivo.

— jing3142,

È un buon punto.

— Martin Ender,

1

@ jing3142 Complimenti per aver implementato una soluzione tu stesso per assicurarti che sia possibile. +1 per una grande domanda.

— Kyle Strand,

Che cosa significa la restrizione ad a-zA-Z? Dovremmo rilevare spazi bianchi / rubish? o dovremmo semplicemente aspettarci questo e riportare la lunghezza della stringa, i saluti sul contenuto?

— VX,

7

GolfScript ( 18 17 byte)

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

Accetta input nello stack (quindi, se eseguito come programma, tramite stdin). Lascia l'output come due stringhe nello stack (quindi, se eseguito come programma, l'output corretto viene inviato a stdout).

Per lasciare una singola stringa nello stack, aggiungi +a concat o usa l'alternativa

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

Dissezione

# 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>
    ++
}/

Impatto delle restrizioni

Se il decremento fosse consentito, consentirebbe la soluzione a 15 byte

'{}'\{;..,(/*}/

— Peter Taylor
fonte

12

Funzione Haskell, 35 34 caratteri

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

Programma Haskell con input hardcoded, 48 o 49 47 o 48 caratteri

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

(47 caratteri se non ti dispiace le virgolette aggiuntive attorno all'output; in tal caso, utilizza putStrinvece di printper un totale di 48 caratteri)

Programma Haskell, 51 50 caratteri

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

— John Dvorak
fonte

Se stai bene invertendo l'ordine, dato che è un set, puoi usare: f [] = "{}"; f (_: x) = '{': f x ++ (tail.f) x per salvare un personaggio.

— isaacg,

@isaacg Nice one. OP dovrebbe dirci se gli dispiace, però.

— John Dvorak,

Dato che si tratta di un ordine prestabilito, non importa, quindi il suggerimento di

— @isaacg

5

Python 3 - 64

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

Se è consentito inserire l'input:

Python 2 - 54

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

— isaacg
fonte

Raw-input () non è il metodo di input non la stringa di input stessa. Non avendo familiarità con la gamma di lingue possibili, stavo impedendo la lunghezza della stringa se nel codice era necessario qualcosa come w = 'aaaaaaaaaaaa'. Scusa se non chiaro. È stato accettato qualsiasi aiuto nella domanda di riformulazione.

— jing3142,

Vedo. Riscriverò il mio codice di conseguenza. In generale, tuttavia, penso che dovresti semplicemente lasciare quella linea. In sostanza ogni lingua ha un sistema I / O.

— isaacg

È possibile salvare un simbolo utilizzando o[-1]invece dio.pop()

— aland l'

1

"Nessuna cifra da 0 a 9 per apparire nel codice;"

— isaacg,

1

Uno strano salvataggio del personaggio per il primo: Inizializza o=[], che diventa o=['{}']dopo un passo, e allunga l'input di uno sostituendolo con '_'+input(), tagliando lo spazio dopo in.

— xnor

3

Javascript 70 (caratteri)

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

Questo è stato il mio sforzo prima di porre la domanda. Suppongo che qualcuno con più conoscenza di Javascript di me probabilmente possa batterlo.

Grazie Jan Dvorak e Peter Taylor per ulteriori riduzioni

ora 62

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

e ora 61

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

Spiegazione del codice originale

impostare s come vuoto

stringa di input in ce divisa in un array

mentre è possibile far apparire () un carattere da c farlo e resettare s = s {s} come successore

corrente di uscita s ma è necessario circondare con parentesi quadre impostate.

— jing3142
fonte

Non hai bisogno di parentesi graffe dopo while(salva un personaggio).

— John Dvorak,

1

C'è un risparmio di 7 caratteri senza ulteriori conoscenze di JS richieste: inizializzare s='{'e abbandonare i due '{'+. (Questo si comporta quindi come la mia soluzione GS). C'è un ulteriore risparmio di 1 carattere usando forinvece di whilee tirando in una delle due inizializzazioni all'inizializzazione for-loop.

— Peter Taylor,

@ peter-taylor non sono sicuro di come intendi applicare for-loop. L'ho usato solo per contare.

— jing3142

3

for(a;b;c){d}è direttamente equivalente a a;while(b){d;c}nella maggior parte delle lingue che hanno entrambe. Quindi, mentre for(;b;)è identico while(b)all'effetto e al conteggio dei personaggi, for(a;b;)salva un carattere a;while(b)ed è identico nell'effetto.

— Peter Taylor,

@ peter-taylor +1 per una spiegazione molto chiara e concisa in un commento

— jing3142

3

J - 22 20 caratteri

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

Come questo può essere derivato:

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

In alternativa, questo può essere scritto '{','{'&(,,~)&'}'@#, intendendo la stessa cosa.

Uso:

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

— algorithmshark
fonte

2

Haskell - 35 caratteri

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

La soluzione è influenzata da quella di Jan Dvorak, ma senza invertire l'ordine.

— user102417
fonte

2

Scala, 64 caratteri

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

Nota i doppi ruoli che entrambe le parentesi graffe e ssvolgono in questo codice.

EDIT: rimosso una cifra

— Karol S
fonte

C'è una cifra nel codice

— jing3142

@ jing3142 Oops. Non più.

— Karol S

2

Python 3 (44)

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

Ad ogni passaggio, sè la stringa che rappresenta il set con il finale }rimosso. Creiamo l'insieme che rappresenta n+1dall'insieme che rappresenta ntramite la relazione f (n + 1) = f (n) ∪ {f (n)}. Per implementare l'unione con le stringhe, aggiungiamo la stringa per {f (n)}, che è esattamente sma con il finale }restituito, e trascuriamo di includere il finale }nel risultato. Infine, aggiungiamo nuovamente un finale '}'prima di stampare.

Se posso codificare la stringa, il conteggio dei caratteri si riduce a 35 caratteri, passando a Python 2 per salvare le parentesi sul file print.

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

Potrebbe esserci un modo per salvare lo spazio dopo il printfacendo qualcosa di simile print'{'+scon un invertito s, ma questo si confonde con l' +=aggiunta a destra.

— XNOR
fonte

2

gs2, 12 byte

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

mnemonica:

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

— Lynn
fonte

1

Mathematica, 115 caratteri

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

Il codice completo come mostrato ha 121 caratteri, ma 6 di questi sono usati per la stringa di input ( "test") che, secondo le regole, non conta.

Senza il requisito che non vi siano delimitatori, la lunghezza del codice potrebbe essere ulteriormente ridotta di 24 caratteri; senza conversione esplicita in stringa, è possibile rimuovere altri 9 caratteri.

— celtschk
fonte

1

Ho pensato che eliminando la necessità di delimitatori, che di solito sono richiesti nella notazione set, stavo aiutando a ridurre la dimensione del codice. Quindi, se li usi riduce le dimensioni del tuo codice, vai avanti e usali.

— jing3142,

1

Ruby, 27 anni, una specie di imbroglione

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

Cose discutibili:

L'output è simile [[], [[]], [[], [[]]], [[], [[]], [[], [[]]]]]
La maggior parte dei metodi di input per ruby includerà una nuova riga finale, che gonfia il conteggio di 1.

— histocrat
fonte

1

Dovrebbe essere perfettamente legittimo se inspectl'array è manualmente e tril risultato.

— John Dvorak,

1

Pure Bash, 54

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

Produzione:

$ ./strlenset.sh
{}
$ ./strlenset.sh a
{{}}
$ ./strlenset.sh aa
{{} {{}}}
$ ./strlenset.sh aaa
{{} {{}} {{} {{}}}}
$ ./strlenset.sh aaaa
{{} {{}} {{} {{}}} {{} {{}} {{} {{}}}}}
$

— Trauma digitale
fonte

1

Julia 43

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

Il costrutto {z ...} espande la stringa z in un array. Piega i cicli su tutti gli elementi dell'array ignorando il contenuto e invece costruendo dalla stringa vuota. La funzione foldl è disponibile in Julia 0.30.

Uscita campione

julia> f("")
"{}"
julia> f("aa")
"{{}{{}}}"
julia> f("aaaa")
"{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}"
julia> f("aaaaaa")
"{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}"

— waTeim
fonte

1

Haskell, 31 byte

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

— alephalpha
fonte

1

Mathematica, 45 57 48 byte

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

Una soluzione di 36 byte:

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

Tuttavia, utilizza alcuni calcoli aritmetici.

— alephalpha
fonte

0

Delphi XE3 (264)

Ok, non mi avvicino nemmeno all'altro, ma è stato divertente da fare :)
Probabilmente ci penso troppo. Andando a vedere se c'è un modo migliore per farlo.

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.

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.

Risultati dei test

Stringhe testate con lunghezza 0..10

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

— Teun Pronk
fonte

Grazie per averci provato. Nella mia mente stavo considerando la lunghezza come un'operazione matematica in quanto restituisce un numero e come è l'uso di un ciclo "for" che comporta il conteggio.

— jing3142,

0

Perl 5: 33 caratteri

Non è del tutto chiaro quali personaggi dovrei contare come parte della soluzione. Probabilmente non è la echo ... |parte perché è stata appena utilizzata per alimentare una linea in stdin. Probabilmente non il nome del binario perl, perché potresti rinominarlo come preferisci.

~~Quindi ho contato le opzioni della riga di comando passate a perl, le virgolette racchiuse intorno al codice Perl e al codice Perl stesso.~~

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

Inoltre, correlati .

— tobyink
fonte

1

Dovresti contare plcome standard, ma ottieni -ee le virgolette attorno al codice sono gratuite. Rif

— Peter Taylor,

0

Perl 6: 37 caratteri

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

o da STDIN:

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

{"\{@_.join()\}"}...*crea un elenco pigro delle forme stabilite dei numeri naturali e prendiamo semplicemente quello di cui abbiamo bisogno get.chars.

L'elenco pigro potrebbe essere scritto più facilmente:

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

Che si legge in modo abbastanza simile alla definizione.

— Mouq
fonte

0

Dardo: 85 caratteri

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

(con newline extra per la leggibilità).

Il requisito di non usare "0" morde davvero, altrimenti .firstsarebbe [0]e (..).isNegativesarebbe ..<0.

— LRN
fonte

0

Pyth, 13 byte

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

Questo è l'equivalente Pyth golfato della risposta Python di @ xnor. Nota che Pyth è più recente di questa domanda, quindi questa risposta non è idonea a vincere questa sfida.

Dimostrazione.

— isaacg
fonte

u+G]GlQY

— Leaky Nun,

0

Javascript, 171 149 147 142 byte

(Probabilmente verrà golfato più avanti)

. N = prompt () Split ( ""); for (a = []; n.pop ();) a.push (a.slice ()); alert (JSON.stringify ({a: a}) [ R = "sostituire"] (/ [^ \ [\]] / g, "") [R] (/ \ [/ g, "{") [R] (/ \] / g, "}")) ;

— SuperJedi224
fonte

Lunghezza della stringa usando Set Theory

GolfScript ( 18 17 byte)

Dissezione

Impatto delle restrizioni

Funzione Haskell, 35 34 caratteri

Programma Haskell con input hardcoded, 48 o 49 47 o 48 caratteri

Programma Haskell, 51 50 caratteri

Python 3 - 64

Python 2 - 54

Javascript 70 (caratteri)

ora 62

e ora 61

J - 22 20 caratteri

Scala, 64 caratteri

Python 3 (44)

gs2, 12 byte

Mathematica, 115 caratteri

Ruby, 27 anni, una specie di imbroglione

Pure Bash, 54

Julia 43

Haskell, 31 byte

Mathematica, 45 57 48 byte

Delphi XE3 (264)

golfed

Ungolfed

Risultati dei test

Perl 6: 37 caratteri

Dardo: 85 caratteri

Pyth, 13 byte

Javascript, 171 149 147 142 byte