Länge der Zeichenkette unter Verwendung der Mengenlehre

20

Aus Wikipedia Satztheoretische Definition natürlicher Zahlen

Die Menge N natürlicher Zahlen ist als die kleinste Menge definiert, die 0 enthält und unter der Nachfolgerfunktion S abgeschlossen ist, die durch S (n) = n ∪ {n} definiert ist.

Die ersten so definierten Zahlen sind 0 = {}, 1 = {0} = {{}}, 2 = {0,1} = {{}, {{}}, 3 = {0,1,2 } = {{}, {{}}, {{}, {{}}}.

Mit dieser Definition von natürlichen Zahlen wird die Länge einer Zeichenfolge gezählt.

Geben Sie eine Zeichenfolge von a-zA-Z beliebiger Länge ein

Ausgabe der Länge der Zeichenfolge in Mengen - Notation ohne Trenn

Beispiele

Eingabe Leere Zeichenfolge

Ausgabe {}

Eingabe a

Ausgabe {{}}

Eingabe aaaa

Ausgabe {{} {{}} {{} {{}} {{} {{}} {{} {{}}}}

Für die Lesbarkeit ist die Ausgabe für 'aaaa' mit Trennzeichen

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

Bedingungen

  1. Der Code enthält keine Ziffern von 0 bis 9.
  2. Keine Verwendung der Zeichencode-Konvertierung zum Generieren von Zahlen;
  3. Keine Verwendung von + - * / für arithmetische Berechnungen einschließlich Inkrementieren und Dekrementieren;
  4. Keine anderen mathematischen Operationen als die Boolesche Logik;
  5. Die Eingabezeichenfolge wird bei der Bestimmung der Bytelänge nicht berücksichtigt.

Gewinner Kürzeste Codelänge in Bytes.

Da dies meine erste Frage ist, hoffe ich, dass ich sie klar und deutlich genug formuliert habe. Freundliche Beratung akzeptiert.

code-golf  math  restricted-source  arithmetic  set-theory 
— jing3142
quelle
Hm, können Sie eine rekursive Definition implementieren, ohne aufzurufen f(n-1)?
— Martin Ender
1
Ich habe eine Lösung (nicht optimal in Bezug auf die Bytelänge), die keine Rekursion verwendet. Wenn A ein Array ist, ist A.pop (); f (A) rekursiv.
— Jing3142
Das ist ein guter Punkt.
— Martin Ender
1
@ jing3142 Ein großes Lob für die Implementierung einer Lösung, um sicherzustellen, dass dies möglich ist. +1 für eine gute Frage.
— Kyle Strand
Was bedeutet die Beschränkung auf a-zA-Z? Sollten wir Whitespace / Rubish erkennen? oder sollen wir das einfach erwarten und die länge des strings angeben, egal was der inhalt betrifft?
— VX

Antworten:

7

GolfScript ( 18 17 Bytes)

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

Übernimmt die Eingabe auf dem Stapel (wenn also als Programm ausgeführt, über stdin). Lässt die Ausgabe als zwei Zeichenfolgen auf dem Stapel (wenn Sie also als Programm ausgeführt werden, wird die richtige Ausgabe an stdout gesendet).

Um eine einzelne Zeichenfolge im Stapel +zu belassen, fügen Sie sie entweder an concat an oder verwenden Sie die Alternative

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

Präparation

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

Alternative:

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

Auswirkungen der Beschränkungen

Wenn eine Dekrementierung zulässig wäre, würde dies die 15-Byte-Lösung ermöglichen

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

Haskell-Funktion, 35 34 Zeichen

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

Haskell-Programm mit fest codierter Eingabe, 48 oder 49 47 oder 48 Zeichen

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

(47 Zeichen, wenn Sie keine zusätzlichen Anführungszeichen für die Ausgabe benötigen; verwenden Sie in diesem Fall putStranstelle von printinsgesamt 48 Zeichen)

Haskell-Programm, 51 50 Zeichen

f[]="{}";f(_:x)='{':f x++tail(f x);main=interact f
— John Dvorak
quelle
Wenn Sie mit dem Umkehren der Reihenfolge einverstanden sind, können Sie Folgendes verwenden: f [] = "{}"; f (_: x) = '{': f x ++ (tail.f) x, um a zu speichern Charakter.
— Isaacg
@isaacg Schöne. OP sollte uns jedoch mitteilen, ob es ihm etwas ausmacht.
— John Dvorak
Da eine feste Reihenfolge keine Rolle spielt, ist @isaacgs Vorschlag gut
— jing3142 10.04.14
5

Python 3 - 64

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

Wenn Inlining erlaubt ist:

Python 2 - 54

o=['{}']
for a in'whatever':o+=['{'+''.join(o)+'}']
print o.pop()
— isaacg
quelle
Ist nicht raw-input () die Methode zur Eingabe, nicht die Eingabezeichenfolge selbst. Da ich nicht mit den möglichen Sprachen vertraut war, habe ich die Länge der Zeichenfolge nicht zugelassen, wenn im Code etwas wie w = 'aaaaaaaaaa' erforderlich war. Entschuldigung, wenn nicht klar. Jede Hilfe bei der Umformulierung Frage akzeptiert.
— Jing3142
Aha. Ich werde meinen Code entsprechend umschreiben. Generell denke ich jedoch, dass Sie diese Zeile einfach weglassen sollten. Grundsätzlich hat jede Sprache ein I / O-System.
— Isaacg
Sie können mit einem Symbol speichern o[-1]statto.pop()
— Aland
1
Msgstr "Keine Ziffern 0 bis 9 im Code erscheinen;"
— Isaacg
1
Ein seltsames Speichern von Zeichen für das erste: Initialisieren Sie o=[], was o=['{}']nach einem Schritt erfolgt, und verlängern Sie die Eingabe um eins, indem Sie sie durch ersetzen '_'+input()und den Raum danach verkürzen in.
— xnor
3

Javascript 70 (Zeichen)

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

Dies war meine Anstrengung, bevor ich die Frage stellte. Ich würde davon ausgehen, dass jemand mit mehr Javascript-Kenntnissen als ich es wahrscheinlich schlagen kann.

Vielen Dank an Jan Dvorak und Peter Taylor für weitere Ermäßigungen

jetzt 62

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

und jetzt 61

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

Erklärung des Originalcodes

setze s auf leer

String in c eingeben und in ein Array aufteilen

während es möglich ist, ein Zeichen aus c zu pop () und s = s {s} als Nachfolger zurückzusetzen

Ausgangsstrom s, müssen jedoch mit gesetzten Klammern umgeben sein.

— jing3142
quelle
Sie brauchen keine geschweiften Klammern nach while(speichert ein Zeichen).
— John Dvorak
1
Es gibt eine 7-Zeichen-Speicherung, ohne dass weitere Kenntnisse über JS erforderlich sind: Initialisieren Sie s='{'die beiden und lassen Sie sie los '{'+. (Das verhält sich dann wie meine GS-Lösung). Es gibt eine weitere Einsparung von 1 Zeichen, indem forstatt whileeiner der beiden Initialisierungen die for-Loop-Initialisierung verwendet und aufgerufen wird.
— Peter Taylor
@ Peter-Taylor nicht sicher, wie Sie for-Schleife anwenden möchten. Ich habe es immer nur zum Zählen benutzt.
— jing3142
3
for(a;b;c){d}ist a;while(b){d;c}in den meisten Sprachen, die beides haben, direkt äquivalent . Solange for(;b;)also identisch mit der while(b)Anzahl der Effekte und Charaktere ist, wird for(a;b;)ein Zeichen gespeichert a;while(b)und die Wirkung ist identisch.
— Peter Taylor
@ Peter-Taylor +1 für sehr klare und
— präzise
3

J - 22 20 char

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

Wie kann das abgeleitet werden:

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

Alternativ kann dies geschrieben werden '{','{'&(,,~)&'}'@#, was dasselbe bedeutet.

Verwendung:

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

Haskell - 35 Charaktere

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

Die Lösung wird von Jan Dvoraks beeinflusst, ohne jedoch die Reihenfolge umzukehren.

— user102417
quelle
2

Scala, 64 Zeichen

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

Beachten Sie die doppelten Rollen, die sowohl die Klammern als sauch in diesem Code spielen.

BEARBEITEN: eine Ziffer entfernt

— Karol S
quelle
Es gibt eine Ziffer im Code
— jing3142
@ jing3142 Ups. Nicht mehr.
— Karol S
2

Python 3 (44)

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

Bei jedem Schritt swird die Zeichenfolge angezeigt, die den Satz darstellt, bei dem das Finale }entfernt wurde. Wir erzeugen die Mengenrepräsentation n+1aus der Mengenrepräsentation nüber die Beziehung f (n + 1) = f (n) ∪ {f (n)}. Um die Vereinigung mit Zeichenfolgen zu implementieren, hängen wir die Zeichenfolge für {f (n)} an, die genau smit dem zurückgegebenen Finale }übereinstimmt, und vernachlässigen, das Finale }in das Ergebnis aufzunehmen. Zum Schluss fügen wir '}'vor dem Drucken noch ein Finale hinzu .

Wenn ich die Zeichenfolge fest codieren darf, wird die Zeichenanzahl auf 35 Zeichen reduziert, und es wird zu Python 2 gewechselt, um Klammern auf der zu speichern print.

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

Es könnte eine Möglichkeit geben, den Platz nach dem zu sparen, printindem Sie so etwas wie print'{'+seinen umgekehrten sVorgang ausführen. Dies führt jedoch zu Problemen mit +=dem rechts angehängten Text.

— xnor
quelle
2

gs2, 12 bytes

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

Mnemonik:

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

Mathematica, 115 Zeichen

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

Der vollständige Code, wie gezeigt, hat 121 Zeichen, aber 6 davon werden für die Eingabezeichenfolge ( "test") verwendet, die gemäß den Regeln nicht zählt.

Ohne das Erfordernis, dass es keine Begrenzer gibt, könnte die Codelänge weiter um 24 Zeichen verringert werden. ohne explizite Umwandlung in einen String könnten dann weitere 9 Zeichen entfernt werden.

— Celtschk
quelle
1
Ich dachte, dass ich die Notwendigkeit von Trennzeichen, die normalerweise in der Set-Notation erforderlich sind, beseitigt habe, um die Codegröße zu reduzieren. Wenn Sie sie also verwenden, verringern Sie Ihre Codegröße, und verwenden Sie sie.
— Jing3142
1

Ruby, 27, betrügt mich irgendwie

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

Fragwürdige Dinge:

  1. Die Ausgabe sieht aus wie [[], [[]], [[], [[]]], [[], [[]], [[], [[]]]]]
  2. Die meisten Eingabemethoden für Ruby enthalten eine nachgestellte Newline, die die Zählung um 1 erhöht.
— Histokrat
quelle
1
Es sollte völlig legitim sein, wenn Sie inspectdas Array manuell und trdas Ergebnis.
— John Dvorak
1

Pure Bash, 54

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

Ausgabe:

$ ./strlenset.sh
{}
$ ./strlenset.sh a
{{}}
$ ./strlenset.sh aa
{{} {{}}}
$ ./strlenset.sh aaa
{{} {{}} {{} {{}}}
$ ./strlenset.sh aaaa
{{} {{}} {{} {{}} {{} {{}} {{} {{}}}}
$
— Digitales Trauma
quelle
1

Julia 43

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

Das Konstrukt {z ...} erweitert den String z zu einem Array. Falte Schleifen über alle Elemente des Arrays, ignoriere den Inhalt und baue stattdessen aus der leeren Zeichenkette auf. Die Funktion foldl ist in Julia 0.30 verfügbar.

Beispielausgabe

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

Mathematica, 45 57 48 Bytes

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

Eine 36-Byte-Lösung:

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

Es werden jedoch einige arithmetische Berechnungen verwendet.

— Alephalpha
quelle
0

Delphi XE3 (264)

Ok, ich komme nicht mal in die Nähe des anderen, aber es hat Spaß gemacht :)
Wahrscheinlich habe ich darüber nachgedacht. Gehen Sie zu sehen, ob es einen besseren Weg gibt, dies zu tun.

Golf gespielt

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.

Testergebnisse

Getestete Saiten mit Länge 0..10

{}
{{} }
{{} {{}} }
{{} {{}} {{}{{}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}}}} }
— Teun Pronk
quelle
Danke für den Versuch. In meinen Gedanken betrachtete ich die Länge als eine mathematische Operation, da sie eine Zahl zurückgibt und die Verwendung einer For-Schleife, bei der gezählt wird.
— Jing3142
0

Perl 5: 33 Zeichen

Es ist nicht ganz klar, welche Zeichen ich als Teil der Lösung zählen soll. Wahrscheinlich nicht das echo ... |Teil, weil es nur verwendet wird, um eine Zeile in stdin einzugeben. Wahrscheinlich nicht der Name der Perl-Binärdatei, da Sie diese beliebig umbenennen können.

Also habe ich die an Perl übergebenen Befehlszeilenoptionen, die um den Perl-Code geschriebenen Anführungszeichen und den Perl-Code selbst gezählt.

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

Auch verwandt .

— tobyink
quelle
1
Sie sollten plals Standard zählen, aber Sie erhalten -eund die Anführungszeichen um den Code kostenlos. Ref
— Peter Taylor
0

Perl 6: 37 Zeichen

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

oder von STDIN:

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

{"\{@_.join()\}"}...*erstellt eine faule Liste der Mengenformen der natürlichen Zahlen, und wir greifen einfach zu der, die wir brauchen get.chars.

Die faule Liste könnte leserlicher geschrieben sein:

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

Welches liest sich ziemlich ähnlich wie die Definition.

— Mouq
quelle
0

Dart: 85 Zeichen

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

(mit zusätzlichen Zeilenumbrüchen zur besseren Lesbarkeit).

Die Forderung, nicht "0" zu verwenden, beißt wirklich, sonst .firstwäre [0]und (..).isNegativewäre ..<0.

— lrn
quelle
0

Pyth, 13 Bytes

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

Dies ist das Golf-Pyth-Äquivalent zu @ xnors Python-Antwort. Beachten Sie, dass Pyth neuer als diese Frage ist, sodass diese Antwort nicht berechtigt ist, diese Herausforderung zu gewinnen.

Demonstration.

— isaacg
quelle
— Undichte Nonne
0

Javascript, 171 149 147 142 Bytes

(Wird wahrscheinlich später weiter golfen)

n = prompt (). split (""); for (a = []; n.pop ();) a.push (a.slice ()); alert (JSON.stringify ({a: a}) [ R = "Ersetzen"] (/ [^ \ [\]] / g, "") [R] (/ \ [/ g, "{") [R] (/ \] / g, "}") ;
— SuperJedi224
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.