Dalam bahasa pemrograman esoterik Curly, program hanya terdiri dari kurung kurawal {}dan titik koma ;. Meskipun toolset sederhana ini, Curly memiliki literal yang dapat mewakili bilangan bulat negatif. Formatnya agak sulit bagi yang belum tahu untuk membaca, jadi mari kita menulis beberapa kode untuk melakukan konversi untuk kita.

Format angka

Angka keriting disusun berdasarkan aturan berikut:

1. Menambahkan titik koma menambahkan satu ke nomor tersebut.
2. Angka yang disertakan dalam kurung kurawal dikalikan empat.
3. Kelompok kurung kurawal mungkin bersarang tetapi tidak disatukan. Kawat gigi harus cocok dengan benar.
4. Titik koma di luar satu set kawat gigi keriting harus datang sesudahnya, bukan sebelumnya.
5. Untuk menghindari ambiguitas dalam penguraian, angka harus selalu dimulai dengan kurung kurawal.

Beberapa contoh:

{;;}     2*4 = 8
{{;};};  (1*4+1)*4+1 = 21
{};;;    0*4+3 = 3

(Perhatikan bahwa aturan 5 berarti angka 0 hingga 3 harus dimulai dengan sepasang kurung kurawal yang kosong.)

Dan beberapa contoh tidak valid:

{{;}{;;}}  Curly brace groups side-by-side, not nested
{;}}       Unmatched brace
{;{;}}     Semicolon before curly-brace group
;;;        Number does not start with curly brace

Berikut ini adalah tata bahasa BNF untuk angka Curly:

<number> ::= "{" <inner> "}" <semis>
<inner>  ::= <semis>
           | <number>
<semis>  ::= ";" <semis>
           | ""

Angka seperti {;;;;}(lebih dari 3 titik koma berturut-turut) atau {{};}(kelompok kurung kosong yang tidak perlu) disebut angka Keriting yang tidak tepat . Mereka mematuhi tata bahasa di atas dan dapat dievaluasi dengan cara biasa, tetapi mereka juga mampu representasi yang lebih pendek (untuk contoh di atas, {{;}}dan {;}masing - masing).

Tantangan

Tulis program atau fungsi yang menginput / menerima string. Jika string adalah bilangan bulat desimal negatif, output / kembalikan representasi Keriting yang tepat (sesingkat mungkin) untuk bilangan bulat itu. Jika string adalah angka Keriting, output / kembalikan representasi desimalnya.

Input dapat diterima melalui STDIN, argumen baris perintah, atau parameter fungsi. Itu harus berupa string; artinya, Anda tidak boleh menulis fungsi yang menerima string untuk angka Keriting tetapi bilangan bulat untuk angka desimal.

Output dapat dicetak ke STDOUT atau dikembalikan dari fungsi. Suatu fungsi dapat mengembalikan bilangan bulat jika perlu, atau dapat mengembalikan string dalam semua situasi.

Program Anda tidak harus menangani input yang buruk (Angka keriting yang melanggar aturan pemformatan, angka titik mengambang, bilangan bulat negatif, teks acak), dan tidak perlu menangani angka Keriting yang tidak benar (tetapi lihat di bawah). Input hanya akan terdiri dari karakter ASCII yang dapat dicetak.

Mencetak gol

Kode terpendek dalam byte menang. Jika program Anda dapat melakukan kedua hal berikut:

1. menangani nomor Keriting yang tidak benar, dan
2. ketika diberi nomor Keriting, abaikan karakter tambahan yang tidak {};

lalu kurangi 10% dari skor Anda. (Input integer tidak akan pernah memiliki karakter asing, bahkan untuk bonus.)

Uji kasus

Input       Output
{;;}        8
{{;};};     21
{};;;       3
{{{{;}}};}  260
{}          0
4           {;}
17          {{;}};
1           {};
0           {}
96          {{{;};;}}

Untuk bonus:

{};;;;;     5
{{;;;;};;}  72
c{u;r;l}y;! 9
42{;} ;;;;  8

_{Catatan: Curly belum diimplementasikan. Tetapi jika pertanyaan ini berhasil, saya dapat mengembangkannya lebih lanjut.}

Pyth, 35 32 byte - 10% = 28,8

.x.U+jb`HZ*R\;.[Z2jsz4i/R\;cz\}4

Cobalah online: Demonstrasi atau Test Suite

sunting: Ternyata, saya tidak sengaja juga dapat menangani Angka Keriting yang tidak tepat. Tidak direncanakan sama sekali. ;-)

Penjelasan:

Ada dua ekspresi dalam kode. Yang pertama mengubah angka menjadi Nomor Keriting, dan yang kedua mengubah Nomor Keriting menjadi angka biasa. .xmenangani, ekspresi mana yang akan dicetak. Ini akan mencoba untuk mencetak ekspresi pertama. Jika ada non-digit dalam input, ekspresi pertama gagal (melalui Pengecualian). .xmenangkap Pengecualian dan mencetak yang kedua.

.U+jb`HZ*R\;.[Z2jsz4   # number to Curly Number
                 sz    read the input and converts it to an int
                j  4   convert to base 4
            .[Z2       pad zeros on the left, until length is >= 2
        *R\;           convert each digit to ";"s
                       lets call this list of ";"s Y
.U                     reduce this list, start with b=Y[0], 
                       Z iterates over Y[1], Y[2], ..., 
                       update b in each step with:
   jb`H                   put b into curly brackets
  +    Z                  and append Z

i/R\;cz\}4             # Curly Number to regular number
     cz\}              split the input by "}"
 /R\;                  count the ";"s in each string
i        4             convert this list from base 4 to base 10

CJam, 51 47 44 41 byte

r_'{-_@={i4bYUe[';f*{{}s@*\+}*}{'}/:,4b}?

Cobalah online: contoh jalankan | test suite

Bagaimana itu bekerja

r        e# Read a token from STDIN.
_'{-     e# Remove all left curly brackets from a copy of the token.
_@       e# Copy the modified token and rotate the original on top of it.
=        e# Check for equality.
{        e# If the strings were equal:
  i4b    e#   Convert to integer, then to base 4.
  YUe[   e#   Left-pad the resulting array with zeroes to a length of 2.
  ';f*   e#   Replace each digit with that many semicolons.
  {      e#   For each string of semicolons but the first:
    {}s  e#     Push the string "{}".
    @    e#     Rotate the first string or the result of the previous 
         e#     iteration on top of the stack.
    *    e#     Join, i.e., surround the string with curly brackets.
    \+   e#     Append the current string of semicolons to the result.
  }*     e#
}{       e# Else:
  '}/    e#   Split the modified input at right curly brackets.
  :,     e#   Replace each run of 0 to 3 semicolons by its length.
  4b     e#   Convert from base 4 to integer.
}?       e#

Python 2, 167 byte - 10% = 150,3

d=lambda x:("{"+d(x//4)+"}"if x>3 else"")+";"*(x%4)
c=lambda n:"{}"*(int(n)<4)+d(int(n))if n.isdigit()else reduce(lambda x,y:x*4+y,[x.count(";")for x in n.split("}")])

Dalam implementasi ini, cadalah fungsi yang memenuhi persyaratan. Ini mengembalikan string jika diberi bilangan bulat negatif sebagai input, atau bilangan bulat jika diberi angka keriting sebagai input.

Python 266 byte - 10% = 1268.1 326.7 239,4 byte

Anak saya tidak pegolf kode belum = /, tapi itu 10% membantu saya keluar banyak ketika skor saya masih lebih dari 1000!

Saya memiliki versi yang lengkap (dan verbose) dari kode ini di sini. Ini akan mengenali validitas angka keriting, dan menyediakan antarmuka melingkar untuk memasukkan angka untuk pengujian.

(Komentar hanya untuk klarifikasi)

Lihat kode ini dalam aksi

def c(t):                           # curly to int function
 v=0                                #  int value of input
 for a in t:                        #  for each character of input
  if a==';':v+=1                    #   if you find a ';', add one to total
  if a=='}':v*=4                    #   if you find a '}', multiply total by 4
 print v                            #  print value
def i(t):                           # int to curly function
 v=int(t);f,b="{}"if v<4 else"",""  #  get integer value. initialize front (f) and back (b) strings
 while 1:                           #  loop until stopped
  r,v=v%4,int(v/4)                  #   get remainder of v/4 and int value of v/4
  if r>0:b=';'*r+b                  #   if remainder exists, prepend that many ';' to back string
  if v>0:f=f+'{';b='}'+b            #   if remaining value > 4, append '{' to front and prepend '}' to back
  if v<4:b=';'*v+b;break            #   if remaining value < 4, prepend that many ';' to back string and break
 print f+b                          #  print result
t=raw_input()                       # get raw input
try:int(t);i(t)                     # use try block to determine which function to call
except:c(t)                         # 

Terima kasih kepada Erik Konstantopoulos untuk pengurangan byte utama! Bisa dibilang ... dia benar-benar mengambil ... byte ... dari kode saya ... * self five *

Skor CJam, 87 byte 80,1 (89 byte - 10% bonus)

Perbarui versi yang memenuhi syarat untuk bonus sambil bertambah 2 byte:

l_'{#){VX@{";{}"#)" _@+\ 4* 4/"S/=~}/;}{i_4<{"{}"\';*}{{4md\_{F'{\+'}+}{;L}?\';*+}:F~}?}?

Cobalah online

Pertama kali saya menggunakan rekursi di CJam! Semuanya mungkin terlihat agak panjang, tetapi dua konversi yang sepenuhnya terpisah bertambah.

Saya menggunakan kasing yang sepenuhnya terpisah untuk mengonversi angka yang lebih kecil dari 4 ke Curly. Mungkin mungkin untuk menghindari itu, tetapi melipat penanganan kasus khusus ke dalam fungsi rekursif tidak akan sepenuhnya sepele. Dan menambahkan ekstra {}sebagai langkah pasca-pemrosesan tidak benar-benar terlihat lebih baik, meskipun saya harus mencoba lagi jika mungkin sedikit lebih pendek.

C #, 173 - 10% = 155,7 171.0, 177.3

Ini tidak valid dan hanya mencari ;dan }karakter. Ini mengasumsikan semua {karakter datang sebelum ;karakter apa pun . Hal tersulit yang saya temukan adalah untuk tidak memasukkan{} di tengah angka keriting.

Jeda baris dan indentasi untuk kejelasan:

string C(string a,int b=0){
    int n;
    if(int.TryParse(a,out n))
        a=(n>=b?"{"+C(""+n/4,4)+"}":"")+";;;".Remove(n%4);
    else
        foreach(int c in a)
            a=""+(c==59?++n:c==125?n*=4:n);
    return a;
}

Java 326 byte - 10% = 294 byte

Ini adalah program lengkap yang ditulis dalam java,

public class a{static String c(long a,int v){if(a==0)return v==0?"{}":"";String x="";for(int i=0;i<a%4;i++)x+=";";return "{"+c(a/4,v+1)+"}"+x;}public static void main(String[]c){try{System.out.println(c(Long.parseLong(c[0]),0));}catch(Exception e){System.out.println(c[0].chars().reduce(0,(a,b)->b==';'?a+1:b=='}'?a*4:a));}}}

Saya yakin ini bisa jauh lebih pendek tetapi saya tidak punya banyak waktu sekarang untuk mengoptimalkannya

GNU sed, 330 326 - 10% = 293,4

(Saya menambahkan satu untuk penggunaan -rsebelum mengklaim bonus 10%; Saya harap itu benar)

/;/{
s/[^};]//g
:c
s/(;*)\}/\1\1\1\1/
tc
:d
/;/{
s/;;;;;/v/g
s/vv/x/g
/[;v]/!s/\b/0/2
s/;;/b/g
s/bb/4/
s/b;/3/
s/v;/6/
s/vb/7/
s/v3/8/
s/v4/9/
y/;bvx/125;/
td
}
n
}
:u
s/\b9/;8/
s/\b8/;7/
s/\b7/;6/
s/\b6/;5/
s/\b5/;4/
s/\b4/;3/
s/\b3/;2/
s/\b2/;1/
s/\b1/;0/
s/\b0//
/[^;]/s/;/&&&&&&&&&&/g
tu
:v
s/;;;;/v/g
s/v+/{&}/
y/v/;/
tv

Versi lengkap menunjukkan bahwa sebagian besar di atas adalah konversi antara desimal dan unary:

#!/bin/sed -rf

/;/{

# Delete non-Curly characters
s/[^};]//g

# Curly to unary
:c
s/(;*)\}/\1\1\1\1/
tc

# unary to decimal
:d
/;/{
s/;;;;;/v/g
s/vv/x/g
/[;v]/!s/\b/0/2
s/;;/b/g
s/bb/4/
s/b;/3/
s/v;/6/
s/vb/7/
s/v3/8/
s/v4/9/
y/;bvx/125;/
td
}

# done
n

}


# Decimal to unary
:u
s/\b9/;8/
s/\b8/;7/
s/\b7/;6/
s/\b6/;5/
s/\b5/;4/
s/\b4/;3/
s/\b3/;2/
s/\b2/;1/
s/\b1/;0/
s/\b0//
/[^;]/s/;/&&&&&&&&&&/g
tu

# Unary to Curly
:v
s/;;;;/v/g
s/v+/{&}/
y/v/;/
tv

Perl, 183 177

Ini mungkin bukan jawaban Perl terpendek, tapi saya pikir itu cukup menarik untuk dikirim (input $_, output sebagai nilai balik):

sub f{if(/}/){s/[{}]/00/g;oct'0b'.s/00(;+)/sprintf'%02b',length$1/ger}else{$_=sprintf'%064b',$_;s/../oct"0b$&"/ge;s/^0+(?!$)//;$_='{'x length.$_;s/\d/'}'.';'x$&/ge;s/\Q{{}/{/r}}

Kami mengamati bahwa Curly hanyalah notasi kuartener (basis-4). Kami sedikit terhambat oleh kurangnya dukungan asli untuk kuernener, tetapi untungnya, setiap quaternit adalah dua bit dalam biner, dan kita dapat membaca dan menulis biner. Jadi kami memiliki yang berikut:

1. Curly ke desimal: konversi setiap Curly digit ke 2 digit biner, gabungkan dan konversi ke desimal
2. Desimal ke Curly: cetak angka dalam biner (memaksa angka genap), lalu konversikan setiap bit-pair ke Curly.

Versi yang diperluas

sub f
{
    if (/}/) {
        s/[{}]/00/g;     # digits are now 00 00; 00;; 00;;;
                         # and opening braces become harmless leading zeros
        s/00(;+)/sprintf'%02b',length $1/ge;
                         # convert semicolons to binary, leaving zeros alone
        oct "0b$_"       # now to decimal
    } else {
        $_=sprintf'%064b',$_;   # decimal to binary
        s/../oct"0b$&"/ge;      # bit-pair to quaternit
        s/^0+(?!$)//;           #/remove leading zeros
        $_='{'x length.$_;      # prefix enough opening braces
        s/\d/'}'.';'x$&/ge;     #/digit to semicolons
        s/{{}/{/r               # first empty brace, unless $_ <= {};;;
    }
}

JavaScript (ES6), 95 (105-10%)

f=(n,r='{}')=>-1-n?(n>3?'{'+f(n>>2,'')+'}':r)+';'.repeat(n&3):n.replace(/[;}]/g,c=>c>';'?n*=4:++n,n=0)&&n

Tes menjalankan cuplikan di bawah ini

f=(n,r='{}')=>-1-n?(n>3?'{'+f(n>>2,'')+'}':r)+';'.repeat(n&3)
:n.replace(/[;}]/g,c=>c>';'?n*=4:++n,n=0)&&n

// Test
function out(x) { O.innerHTML=x+'\n'+O.innerHTML; }

function go() { out(I.value + ' --> ' + f(I.value)) }

;[ 
  ['{;;}', 8]
, ['{{;};};', 21 ]
, ['{};;;', 3 ]
, ['{{{{;}}};}', 260 ]
, ['{}', 0 ]
, [ 4, '{;}' ]
, [ 17, '{{;}};' ]
, [ 1,'{};' ]
, [ 0, '{}' ]
, [ 96, '{{{;};;}}' ]
, ['{};;;;;', 5 ]
, ['{{;;;;};;}' , 72 ]
, ['c{u;r;l}y;!', 9 ]
, ['42{;} ;;;;', 8 ]
].forEach(t => {
  r=f(t[0])
  k=t[1]
  out('Test ' +(r==k?'OK':'Fail')+'\nInput:  '+t[0]+'\nResult: '+r+'\nCheck:  '+k+'\n')
})

Custom test <input id=I><button onclick='go()'>-></button>
<pre id=O></pre>

Ruby, 126.9 129.6 (144 - 10%)

Menggunakan rekursi untuk mengubah desimal menjadi bentuk keriting. Menghapus centang untuk mengabaikan karakter di luar /[;{}]/meningkatkan skor 0.4saat ini.

f=->s{s=~/^\d+$/?(n=s.to_i
"{#{n<1?'':f[(n/4).to_s].gsub('{}','')}}#{?;*(n%4)}"):eval(s.tr("^{;}","").gsub(/./){|c|c<?A?"+1":c>?|?")*4":"+(0"})}

Perl 5, 154 ( 185 170 Bytes - 10% + 1 Denda)

$e=$/;if($_=~/{/){s/[^{};]//g;s/;/+1/g;s/{/+4*(/g;s/}/+0)/g;$b=eval}else{$r=$_;$b=$r<4?"{}":"";while($r>0){if($r%4>0){$r--;$e=";$e"}else{$b.="{";$e="}$e";$r/=4}}}$_=$b.$e

Regex & eval menyelesaikan curlies.
Generasi ikal dilakukan secara berbeda.

Uji

File tes juga berisi kasus bonus

$ cat curlytestcases.txt
{}
{};
{};;
{};;;
{;;}
{{;};};
{{{{;}}};}
0
1
2
3
4
17
96
{};;;;;
42{;} ;;;;
c{u;r;l}y;!
{{;;;;};;}

$ cat curlytestcases.txt |perl -p curlies.pl
0
1
2
3
8
21
260
{}
{};
{};;
{};;;
{;}
{{;}};
{{{;};;}}
5
8
9
72

Retina , 69 64 byte

+`{(;*)}
$1$1$1$1
^\d+|^(;*)
$*;$.1
+`(;+)\1\1\1
{$1}
^;|^$
{}$&

Coba Test Suite

Penjelasan

+`{(;*)}
$1$1$1$1

Membusuk kawat gigi terdalam menjadi hanya ;s. Ulangi sampai tidak ada lagi kawat gigi.

^\d+|^(;*)
$*;$.1

Konversi antara desimal dan unary ;

+`(;+)\1\1\1
{$1}

Temukan jangka terpanjang dari ;itu adalah kelipatan dari 4 dan bersarang ke dalam kawat gigi, lingkaran sampai tidak ada lagi berjalan dari 4+.

^;|^$
{}$&

Jika nomor keriting yang dihasilkan dimulai dengan ;atau string kosong, tambahkan {}di depan.

Python 2 , 157 byte -10% = 141,3

lambda n:'{}'*(int(n)<4)+g(int(n))if n.isdigit()else sum((v==';')*4**n.count('}',i)for i,v in enumerate(n))
g=lambda n:'{%s}'%g(n/4)+';'*(n%4)if n>3else';'*n

Cobalah online!

Jawaban Python 2 yang lebih golf yang menangani kasus bonus. Tidak ingin menghapus posting yang mati dengan ini sebagai komentar, jadi ini dia.

Ini bekerja dari dalam ke dalam pada angka-angka keriting, menambahkan 4 ^ (jumlah kurung keriting ujung yang tersisa di string) ke jumlah untuk setiap titik koma yang ditemukan. Jika string adalah angka, maka secara rekursif menciptakan angka keriting dengan cara yang sama seperti tata bahasa yang disediakan.