จากนิยามวิกิพีเดียตั้งทฤษฎีของจำนวนธรรมชาติ

ชุด N ของตัวเลขธรรมชาติถูกกำหนดเป็นชุดที่เล็กที่สุดที่มี 0 และปิดภายใต้ฟังก์ชันตัวตายตัวแทน S ที่กำหนดโดย S (n) = n ∪ {n}

ตัวเลขสองสามตัวแรกที่กำหนดด้วยวิธีนี้คือ 0 = {}, 1 = {0} = {{}}, 2 = {0,1} = {{}, {{}}}, 3 = {0,1,2 } = {{}, {{}}, {{}, {{}}}}

การใช้นิยามของตัวเลขธรรมชาตินี้จะนับความยาวของสตริง

ป้อน สตริงของอักขระจาก a-zA-Z ทุกความยาว

เอาต์พุตความยาวของสตริงในรูปแบบที่กำหนดโดยไม่มีตัวคั่น

ตัวอย่าง

ป้อน สตริงว่าง

เอาท์พุท {}

ป้อนข้อมูล

เอาท์พุท {{}}

ป้อน aaaa

ผลลัพธ์ {{} {{}} {{} {{}}} {{} {{}} {{} {{}}}}}}

สำหรับเอาต์พุตที่อ่านได้สำหรับ 'aaaa' พร้อมตัวคั่นคือ

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

เงื่อนไข

1. ไม่มีตัวเลข 0 ถึง 9 ที่จะปรากฏในรหัส
2. ไม่มีการใช้การแปลงรหัสอักขระเพื่อสร้างตัวเลข
3. ไม่มีการใช้ + - * / สำหรับการคำนวณทางคณิตศาสตร์รวมถึงการเพิ่มและลด
4. ไม่มีการดำเนินการทางคณิตศาสตร์ที่นอกเหนือจากบูลีนลอจิก;
5. สตริงอินพุตไม่นับในการกำหนดความยาวไบต์;

ผู้ชนะความยาวรหัสสั้นที่สุดในหน่วยไบต์

นี่เป็นคำถามแรกของฉันฉันหวังว่าฉันจะทำให้มันชัดเจนและเข้มงวดพอ คำแนะนำที่เป็นมิตรได้รับการยอมรับ

GolfScript ( 18 17 ไบต์)

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

รับอินพุตบนสแต็ก (ดังนั้นหากรันเป็นโปรแกรมผ่าน stdin) ปล่อยเอาต์พุตเป็นสองสตริงบนสแต็ก (ดังนั้นหากรันเป็นโปรแกรมเอาต์พุตที่ถูกต้องจะถูกส่งไปยัง stdout)

หากต้องการทิ้งสตริงเดี่ยวไว้บนสแต็กให้ผนวก+เข้าด้วยกันหรือใช้ทางเลือกอื่น

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

การผ่า

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

ทางเลือก:

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

ผลกระทบของข้อ จำกัด

หากอนุญาตให้มีการลดลงมันจะอนุญาตโซลูชัน 15- ไบต์

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

ฟังก์ชั่น Haskell 35 34 ตัวอักษร

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

โปรแกรม Haskell พร้อมอินพุตฮาร์ดโค้ด 48 หรือ 49 47 หรือ 48 ตัวอักษร

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

(47 ตัวอักษรหากคุณไม่คำนึงถึงเครื่องหมายคำพูดพิเศษรอบผลลัพธ์ถ้าคุณใช้ให้ใช้putStrแทนprintทั้งหมด 48 ตัวอักษร)

โปรแกรม Haskell 51 50 ตัวอักษร

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

Python 3 - 64

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

หากอนุญาตให้อินพุตอินไลน์:

Python 2 - 54

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

Javascript 70 (ตัวอักษร)

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

นี่คือความพยายามของฉันก่อนที่จะตั้งคำถาม ฉันจะสมมติคนที่มีความรู้เกี่ยวกับ Javascript มากกว่าที่ฉันจะเอาชนะได้

ขอบคุณ Jan Dvorak และ Peter Taylor สำหรับการลดราคาเพิ่มเติม

ตอนนี้ 62

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

และตอนนี้ 61

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

คำอธิบายของรหัสต้นฉบับ

ตั้งค่าให้ว่างเปล่า

สายป้อนเข้า c และแยกเป็นอาร์เรย์

ในขณะที่มันเป็นไปได้ที่จะป๊อป () ตัวละครจาก c ทำเช่นนั้นและรีเซ็ต s = s {s} เป็นตัวตายตัวแทน

เอาต์พุตปัจจุบัน แต่ต้องล้อมรอบด้วยชุดวงเล็บ

J - 22 20 ตัว

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

สามารถรับสิ่งนี้ได้อย่างไร:

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

อีกวิธีหนึ่งสามารถเขียนได้'{','{'&(,,~)&'}'@#ซึ่งหมายถึงสิ่งเดียวกัน

การใช้งาน:

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

Haskell - 35 ตัวอักษร

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

โซลูชันได้รับอิทธิพลจากหนึ่งใน Jan Dvorak แต่ไม่มีการย้อนกลับคำสั่ง

สกาลา, 64 ตัวอักษร

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

หมายเหตุบทบาทคู่ที่ทั้งเครื่องหมายวงเล็บและsเล่นในรหัสนี้

แก้ไข: ลบตัวเลขออก

Python 3 (44)

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

ในแต่ละขั้นตอนsเป็นสตริงที่แสดงถึงชุดที่มีการ}ลบครั้งสุดท้าย เราสร้างชุดที่เป็นตัวแทนn+1จากชุดที่เป็นตัวแทนnผ่านความสัมพันธ์ f (n + 1) = f (n) ∪ {f (n)} ในการใช้งานยูเนี่ยนกับสตริงเราผนวกสตริงสำหรับ {f (n)} ซึ่งเป็นสิ่งที่แน่นอนsแต่มีการ}ส่งคืนครั้งสุดท้ายและละเลยที่จะรวมสุดท้าย}ในผลลัพธ์ ในที่สุดเราเพิ่มกลับมาอีกครั้ง'}'ก่อนที่จะพิมพ์

ถ้าฉันอาจ hardcode สตริงตัดนับจำนวนตัวอักษรลงไป 35 ตัวอักษรสลับกับงูหลาม 2 printที่จะบันทึกในวงเล็บ

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

อาจมีวิธีการประหยัดพื้นที่หลังจากนั้นprintโดยทำสิ่งที่ชอบprint'{'+sด้วยการย้อนกลับsแต่สิ่งนี้ยุ่งกับการ+=ต่อท้ายทางด้านขวา

gs2, 12 ไบต์

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

จำ:

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

Mathematica 115 ตัวอักษร

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

รหัสที่สมบูรณ์ตามที่แสดงมี 121 ตัวอักษร แต่มี 6 ตัวที่ใช้สำหรับสตริงอินพุต ( "test") ซึ่งตามกฎจะไม่นับ

หากไม่มีข้อกำหนดว่าไม่มีตัวคั่นความยาวรหัสอาจลดลงได้อีก 24 อักขระ หากไม่มีการแปลงเป็นสตริงอย่างชัดเจนสามารถลบอักขระอื่นได้ 9 ตัว

Ruby, 27, ชนิดของการโกง

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

สิ่งที่น่าสงสัย:

1. ผลลัพธ์ดูเหมือนว่า [[], [[]], [[], [[]]], [[], [[]], [[], [[]]]]]
2. วิธีการป้อนข้อมูลส่วนใหญ่ไปยังทับทิมจะรวมถึงการขึ้นบรรทัดใหม่ซึ่งขยายจำนวน 1

Pure Bash, 54

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

เอาท์พุท:

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

Julia 43

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

โครงสร้าง{z ... }ขยายสตริง z ลงในอาร์เรย์ พับลูปไปที่องค์ประกอบทั้งหมดของอาร์เรย์โดยไม่สนใจเนื้อหาและแทนที่จะสร้างขึ้นจากสตริงว่าง ฟังก์ชันfoldlมีอยู่ใน Julia 0.30

ตัวอย่างผลลัพธ์

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

Haskell, 31 ไบต์

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

Mathematica, 45 57 48 ไบต์

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

โซลูชัน 36 ไบต์:

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

อย่างไรก็ตามมันใช้การคำนวณทางคณิตศาสตร์บางอย่าง

Delphi XE3 (264)

โอเคฉันไม่ได้เข้ามาใกล้กับคนอื่น ๆ แต่มันสนุกที่จะทำ :)
อาจจะคิดว่ามัน ไปดูว่ามีวิธีที่ดีกว่าในการทำเช่นนี้

แข็งแรงเล่นกอล์ฟ

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.

ผลการทดสอบ

สตริงที่ทดสอบแล้วที่มีความยาว 0..10

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

Perl 5: 33 ตัวอักษร

ยังไม่ชัดเจนว่าตัวละครตัวไหนที่ฉันควรนับเป็นส่วนหนึ่งของการแก้ปัญหา อาจไม่ใช่echo ... |ส่วนหนึ่งเพราะมันใช้เพื่อป้อนบรรทัดใน stdin อาจไม่ได้ชื่อของไบนารี Perl เพราะคุณสามารถเปลี่ยนชื่อสิ่งที่คุณต้องการ

ดังนั้นฉันจึงนับสวิตช์บรรทัดคำสั่งที่ส่งไปยัง Perl เครื่องหมายอัญประกาศล้อมรอบโค้ด Perl และโค้ด Perl เอง

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

นอกจากนี้ที่เกี่ยวข้อง

Perl 6: 37 ตัวอักษร

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

หรือจาก STDIN:

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

{"\{@_.join()\}"}...*get.charsทำให้รายการที่ขี้เกียจของชุดรูปแบบของหมายเลขธรรมชาติและเราก็คว้าหนึ่งที่เราต้องการด้วย

รายการสันหลังยาวอาจเขียนได้อ่านง่ายขึ้น:

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

ซึ่งอ่านได้ค่อนข้างคล้ายกับนิยาม

Dart: 85 ตัวอักษร

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

(พร้อมการขึ้นบรรทัดใหม่เพื่อความสะดวกในการอ่าน)

ความต้องการของไม่ได้ใช้ "0" จริงๆกัดมิฉะนั้น.firstจะเป็น[0]และจะเป็น(..).isNegative..<0

Pyth, 13 ไบต์

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

นี่คือ Pyth ของ golfed ที่เทียบเท่ากับคำตอบ Python ของ @ xnor โปรดทราบว่า Pyth นั้นใหม่กว่าคำถามนี้ดังนั้นคำตอบนี้จึงไม่มีสิทธิ์ชนะการท้าทายนี้

สาธิต.

Javascript, 171 149 147 142 ไบต์

(มีแนวโน้มว่าจะถูกเล่นกอล์ฟต่อไปในภายหลัง)

n. = พรอมต์ () แยก ( ""); สำหรับ (ก = []; n.pop ();) a.push (a.slice ()); alert (JSON.stringify ({A: a}) [ R = "แทนที่"] (/ [^ \ [\]] / g "") [R] (/ \ [/ g "{") [R] (/ \] / g "}")) ;