Panjang String Menggunakan Set Theory

20

Dari Wikipedia Set-teoritik definisi bilangan asli

Himpunan N dari bilangan alami didefinisikan sebagai himpunan terkecil yang berisi 0 dan ditutup di bawah fungsi penerus S yang didefinisikan oleh S (n) = n ∪ {n}.

Beberapa angka pertama yang didefinisikan dengan cara ini adalah 0 = {}, 1 = {0} = {{}}, 2 = {0,1} = {{}, {{}}}, 3 = {0,1,2 } = {{}, {{}}, {{}, {{}}}}.

Dengan menggunakan definisi bilangan alami ini, hitung panjang string.

Masukkan serangkaian karakter dari a-zA-Z dengan panjang berapa pun

Keluarkan panjang string dalam notasi yang disetel tanpa pemisah

Contohnya

Masukkan string kosong

Keluaran {}

Masukan a

Keluaran {{}}

Masukan aaaa

Keluaran {{} {{}} {{} {{}}} {{} {{}} {{}} {{}}}}}

Untuk keluaran keterbacaan untuk 'aaaa' dengan pemisah adalah

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

Kondisi

  1. Tidak ada angka 0 hingga 9 yang muncul dalam kode;
  2. Tidak ada penggunaan konversi kode karakter untuk menghasilkan angka;
  3. Tidak menggunakan + - * / untuk perhitungan aritmatika termasuk kenaikan dan penurunan;
  4. Tidak ada operasi matematika selain Boolean Logic;
  5. String input tidak dihitung dalam menentukan panjang byte;

Pemenang Panjang kode terpendek dalam byte.

Karena ini adalah pertanyaan pertama saya, saya harap saya telah membuatnya cukup jelas dan keras. Saran ramah diterima.

code-golf  math  restricted-source  arithmetic  set-theory 
— jing3142
sumber
Hm, bisakah Anda menerapkan definisi rekursif tanpa menelepon f(n-1)?
— Martin Ender
1
Saya punya solusi (tidak optimal dalam hal panjang byte) yang tidak menggunakan rekursi. Jika A adalah array maka A.pop (); f (A) bersifat rekursif.
— jing3142
Itu poin yang bagus.
— Martin Ender
1
@ jing3142 Kudos untuk menerapkan solusi sendiri untuk memastikan itu mungkin. +1 untuk pertanyaan hebat.
— Kyle Strand
Apa arti dari pembatasan terhadap a-zA-Z? Haruskah kita mendeteksi spasi putih / rubi? atau haruskah kita mengharapkan ini dan melaporkan panjangnya, memperhatikan konten?
— VX

Jawaban:

7

GolfScript ( 18 17 byte)

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

Mengambil input pada stack (jadi jika dijalankan sebagai program, via stdin). Meninggalkan output sebagai dua string pada stack (jadi jika dijalankan sebagai program, output yang benar dikirim ke stdout).

Untuk meninggalkan satu string pada stack, tambahkan +ke concat, atau gunakan alternatif

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

Pembedahan

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

Alternatif:

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

Dampak pembatasan

Jika pengurangan diizinkan, itu akan memungkinkan solusi 15-byte

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

Fungsi Haskell, 35 34 karakter

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

Program Haskell dengan input hardcoded, 48 atau 49 47 atau 48 karakter

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

(47 karakter jika Anda tidak keberatan dengan kutipan tambahan di sekitar output; jika Anda melakukannya, gunakan putStrsebagai ganti printtotal 48 karakter)

Program Haskell, 51 50 karakter

f[]="{}";f(_:x)='{':f x++tail(f x);main=interact f
— John Dvorak
sumber
Jika Anda baik-baik saja dengan membalik urutan, karena ini adalah set, Anda dapat menggunakan: f [] = "{}"; f (_: x) = '{': f x ++ (tail.f) x untuk menyimpan karakter.
— isaacg
@isaacg Bagus. OP harus memberi tahu kami jika dia keberatan.
— John Dvorak
Karena urutannya tidak masalah maka saran
— @isaacg
5

Python 3 - 64

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

Jika memasukkan input diperbolehkan:

Python 2 - 54

o=['{}']
for a in'whatever':o+=['{'+''.join(o)+'}']
print o.pop()
— isaacg
sumber
Bukan input mentah () metode input bukan string input itu sendiri. Tidak terbiasa dengan berbagai bahasa yang mungkin saya tidak mengizinkan panjang string jika sesuatu seperti w = 'aaaaaaaaaaaa' diperlukan dalam kode. Maaf jika tidak jelas. Setiap bantuan dalam pertanyaan kata-kata diterima.
— jing3142
Saya melihat. Saya akan menulis ulang kode saya sesuai. Secara umum, bagaimanapun, saya pikir Anda harus meninggalkan garis itu. Pada dasarnya setiap bahasa memiliki sistem I / O.
— isaacg
Anda dapat menyimpan simbol dengan menggunakan o[-1]bukano.pop()
— aland
1
"Tidak ada angka 0 hingga 9 untuk muncul dalam kode;"
— isaacg
1
Karakter-save aneh untuk yang pertama: Inisialisasi o=[], yang menjadi o=['{}']setelah satu langkah, dan memperpanjang input dengan satu dengan menggantinya dengan '_'+input(), memotong spasi setelah in.
— xnor
3

Javascript 70 (karakter)

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

Ini adalah usaha saya sebelum mengajukan pertanyaan. Saya akan berasumsi seseorang dengan pengetahuan Javascript lebih dari saya mungkin bisa mengalahkannya.

Terima kasih Jan Dvorak dan Peter Taylor untuk pengurangan lebih lanjut

sekarang 62

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

dan sekarang 61

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

Penjelasan Kode Asli

set s menjadi kosong

masukkan string ke c dan pisahkan menjadi array

sementara dimungkinkan untuk memunculkan () karakter dari c melakukannya dan mengatur ulang s = s {s} sebagai penerus

arus keluaran tetapi perlu dikelilingi dengan tanda kurung.

— jing3142
sumber
Anda tidak perlu kawat gigi setelah while(menyimpan satu karakter).
— John Dvorak
1
Ada penghematan 7-char tanpa memerlukan pengetahuan JS: inisialisasi s='{'dan parit keduanya '{'+. (Ini kemudian berperilaku seperti solusi GS saya). Ada penghematan 1-ar lebih lanjut dengan menggunakan foralih-alih whiledan menarik salah satu dari dua inisialisasi ke inisialisasi loop.
— Peter Taylor
@ peter-taylor tidak yakin bagaimana maksud Anda untuk melamar. Saya hanya pernah menggunakannya untuk menghitung.
— jing3142
3
for(a;b;c){d}secara langsung setara dengan a;while(b){d;c}di sebagian besar bahasa yang memiliki keduanya. Jadi sementara for(;b;)identik dengan while(b)efek dan jumlah karakter, for(a;b;)simpan satu karakter a;while(b)dan efeknya identik.
— Peter Taylor
@ peter-taylor +1 untuk penjelasan yang sangat jelas dan ringkas dalam komentar
— jing3142
3

J - 22 20 char

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

Bagaimana ini diturunkan:

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

Atau, ini bisa ditulis '{','{'&(,,~)&'}'@#, artinya hal yang sama.

Pemakaian:

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

Haskell - 35 karakter

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

Solusi dipengaruhi oleh Jan Dvorak, tetapi tanpa membalik urutan.

— pengguna102417
sumber
2

Scala, 64 karakter

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

Perhatikan peran ganda yang menahan dan sbermain dalam kode ini.

EDIT: menghapus satu digit

— Karol S
sumber
Ada angka dalam kode
— jing3142
@ jing3142 Ups. Tidak lagi.
— Karol S
2

Python 3 (44)

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

Pada setiap langkah, sadalah string yang mewakili set dengan final }dihilangkan. Kami membuat himpunan yang mewakili n+1dari himpunan yang mewakili nmelalui hubungan f (n + 1) = f (n) ∪ {f (n)}. Untuk mengimplementasikan penyatuan dengan string, kami menambahkan string untuk {f (n)}, yang persis stetapi dengan yang }dikembalikan, dan lalai untuk memasukkan yang terakhir }dalam hasil. Akhirnya, kami menambahkan kembali final '}'sebelum dicetak.

Jika saya dapat membuat hardcode string, jumlah karakter berkurang hingga 35 karakter, beralih ke Python 2 untuk menyimpan paranthes di print.

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

Mungkin ada cara untuk menghemat ruang setelahnya printdengan melakukan sesuatu seperti print'{'+sdengan terbalik s, tetapi ini mengacaukan dengan +=menambahkan di sebelah kanan.

— Tidak
sumber
2

gs2, 12 byte

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

ilmu tentang cara menghafal:

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

Mathematica, 115 karakter

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

Kode lengkap seperti yang ditunjukkan memiliki 121 karakter, tetapi 6 di antaranya digunakan untuk string input ( "test") yang, menurut aturan, tidak masuk hitungan.

Tanpa persyaratan bahwa tidak ada pembatas, panjang kode dapat dikurangi lebih jauh dengan 24 karakter; tanpa konversi eksplisit ke string maka 9 karakter lain dapat dihapus.

— celtschk
sumber
1
Saya berpikir bahwa menghilangkan kebutuhan untuk pembatas, yang biasanya diperlukan dalam notasi yang ditetapkan, saya membantu mengurangi ukuran kode. Jadi, jika menggunakannya mengurangi ukuran kode Anda, gunakan dan gunakan.
— jing3142
1

Ruby, 27, agak curang

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

Hal yang dipertanyakan:

  1. Outputnya seperti [[], [[]], [[], [[]]], [[], [[]], [[], [[]]]]]
  2. Sebagian besar metode input ke ruby ​​akan menyertakan baris baru, yang mengembang jumlah dengan 1.
— histokrat
sumber
1
Itu harus benar-benar sah jika Anda inspectarray secara manual dan trhasilnya.
— John Dvorak
1

Pure Bash, 54

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

Keluaran:

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

Julia 43

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

Konstruk {z ...} memperluas string z ke dalam array. Lipat loop atas semua elemen array yang mengabaikan konten dan bukannya membangun dari string kosong. Folder fungsi tersedia dalam Julia 0.30.

Output Sampel

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

Mathematica, 45 57 48 byte

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

Solusi 36 byte:

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

Namun, ia menggunakan beberapa perhitungan aritmatika.

— alephalpha
sumber
0

Delphi XE3 (264)

Ok saya bahkan tidak mendekati yang lain tapi itu menyenangkan untuk dilakukan :)
Mungkin terlalu banyak berpikir. Akan melihat apakah ada cara yang lebih baik untuk melakukan ini.

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.

Tidak disatukan

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.

Hasil pengujian

String yang diuji dengan panjang 0..10

{}
{{} }
{{} {{}} }
{{} {{}} {{}{{}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}}} }
{{} {{}} {{}{{}}} {{}{{}}{{}{{}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}}} {{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}{{}{{}}{{}{{}}}{{}{{}}{{}{{}}}}}}}}}} }
— Teun Pronk
sumber
Terima kasih telah mencoba. Dalam pikiran saya, saya mempertimbangkan panjang sebagai operasi matematika karena mengembalikan angka dan seperti penggunaan loop 'untuk' yang melibatkan penghitungan.
— jing3142
0

Perl 5: 33 karakter

Tidak jelas karakter mana yang harus saya hitung sebagai bagian dari solusi. Mungkin bukan echo ... |bagian karena itu hanya digunakan untuk memberi makan garis ke stdin. Mungkin bukan nama biner perl, karena Anda dapat mengubah nama itu menjadi apa pun yang Anda inginkan.

Jadi saya sudah menghitung switch baris perintah yang dilewatkan ke perl, tanda kutip melilit kode Perl, dan kode Perl itu sendiri.

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

Juga terkait .

— tobyink
sumber
1
Anda harus menghitung plsebagai standar, tetapi Anda mendapatkan -edan tanda kutip di sekitar kode secara gratis. Ref
— Peter Taylor
0

Perl 6: 37 karakter

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

atau dari STDIN:

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

{"\{@_.join()\}"}...*membuat daftar malas dari himpunan bentuk bilangan asli, dan kita hanya mengambil yang kita butuhkan get.chars.

Daftar malas mungkin lebih mudah ditulis:

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

Yang berbunyi sangat mirip dengan definisi.

— Mouq
sumber
0

Dart: 85 karakter

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

(dengan tambahan baris baru untuk keterbacaan).

Persyaratan untuk tidak menggunakan "0" benar-benar gigitan, jika .firsttidak akan [0]dan (..).isNegativeakan ..<0.

— Tuan
sumber
0

Pyth, 13 byte

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

Ini adalah Pyth yang setara golf dari jawaban Python @ xnor. Perhatikan bahwa Pyth lebih baru dari pertanyaan ini, jadi jawaban ini tidak memenuhi syarat untuk memenangkan tantangan ini.

Demonstrasi.

— isaacg
sumber
— Leaky Nun
0

Javascript, 171 149 147 142 byte

(Kemungkinan akan golf lebih lanjut nanti)

n = prompt (). split (""); for (a = []; n.pop ();) a.push (a.slice ()); lansiran (JSON.stringify ({a: a}) [ R = "ganti"] (/ [^ \ [\]] / g, "") [R] (/ \ [/ g, "{") [R] (/ \] / g, "}")) ;
— SuperJedi224
sumber
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.