Ezoterik programlama dilinde Kıvırcık, programlar yalnızca kaşlı ayraçlar {}ve noktalı virgüllerden oluşur ;. Bu mütevazi araç setine rağmen, Curly'nin herhangi bir olumsuz olmayan tamsayıyı temsil edebilecek gerçekleri vardır. Biçimde henüz kimsenin okumaması biraz zor, bu yüzden bize dönüşüm için bazı kodlar yazalım.

Sayıların formatı

Kıvırcık sayılar aşağıdaki kurallara göre yapılandırılmıştır:

1. Noktalı virgül eklemek, numaraya bir tane ekler.
2. Kıvrımlı parantez içine alınmış bir sayı dört ile çarpılır.
3. Kıvrımlı ayraç grupları iç içe olabilir, ancak birleştirilemez. Diş telleri uygun şekilde eşleşmelidir.
4. Bir küme parantezi kümesinin dışındaki noktalı virgüller daha önce değil, sonra gelmelidir.
5. Ayrıştırmadaki belirsizliği önlemek için, bir sayı daima bir küme ayracı ile başlamalıdır.

Bazı örnekler:

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

(Kural 5'in 0'dan 3'e kadar olan sayıların boş bir küme paranteziyle başlaması gerektiği anlamına geldiğini unutmayın.)

Ve bazı geçersiz örnekler:

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

Kıvırcık sayılar için bir BNF dilbilgisi:

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

Gibi Numaralar {;;;;}(üst üste en fazla 3 noktalı virgül) ya da {{};}(gereksiz boş ayracı gruplar) olarak adlandırılır uygunsuz Kıvırcık numaralar. Yukarıdaki gramerlere uyarlar ve her zamanki gibi değerlendirilebilirler, ancak aynı zamanda daha kısa temsiller de yapabilirler (yukarıdaki örnekler için {{;}}ve {;}sırasıyla).

Meydan okuma

Bir dize giren / alan bir program veya işlev yazın. Dize negatif olmayan bir ondalık tamsayıysa, uygun tamsayı için uygun (yani mümkün olan en kısa) Kıvırcık gösterimi verir / verir. Dize bir Kıvırcık sayı ise, ondalık gösterimini verir / verir.

Giriş , STDIN, komut satırı argümanı veya function parametresi ile alınabilir. Bu gerekir bir dize; başka bir deyişle, Kıvırcık sayılar için dizeleri kabul eden bir fonksiyon yazamazsınız, ondalık sayılar için tamsayılar yazabilirsiniz.

Çıktı STDOUT'a yazdırılabilir veya işlevden geri döndürülebilir. Bir fonksiyon olabilir , uygun bir tamsayı dönmek, ya da her durumda dizeleri döndürebilir.

Programınızın hatalı giriş yapması gerekmez (biçimlendirme kurallarını kıran kıvrımlı sayılar, kayan nokta sayıları, negatif tam sayılar, rastgele metinler) ve uygun olmayan kıvrımlı sayıları işlemek için gerekli değildir (aşağıya bakınız). Giriş yalnızca yazdırılabilir ASCII karakterlerinden oluşacaktır.

puanlama

Bayt cinsinden en kısa kod kazanır. Programınız aşağıdakilerden her ikisini de yapabiliyorsa :

1. Doğru olmayan Kıvırcık sayıları doğru şekilde
2. Kıvırcık bir sayı verildiğinde, gösterilmeyen fazladan karakterleri yoksay {};

daha sonra puanınızdan% 10 çıkarın. (Tam sayı girişi, bonus için bile hiçbir zaman yabancı karakterlere sahip olmaz.)

Test durumları

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

Bonus için:

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

_{Not: Kıvırcık henüz uygulanmadı. Fakat bu soru iyi giderse, daha da geliştirebilirim.}

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

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

Çevrimiçi deneyin: Gösteri veya Test Paketi

düzenleme: O çıktı, ben yanlışlıkla yanlış Kıvırcık Numaraları da işleyebilir. Hiç planlanmadı. ;-)

Açıklama:

Kodda iki ifade var. Birincisi bir sayıyı Kıvırcık Sayıya, ikincisi bir Kıvırcık Sayıyı normal sayıya dönüştürür. .xhangi ifadenin basılacağına bakar. İlk ifadeyi basmaya çalışacaktır. Girişte herhangi bir rakam bulunmuyorsa, ilk ifade başarısız olur (İstisna ile). .xÖzel Durum'u yakalar ve ikincisini yazdırır.

.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 bayt

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

Çevrimiçi deneyin: örnek çalışma | test odası

Nasıl çalışır

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 bayt -% 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("}")])

Bu uygulamada cgereklilikleri yerine getiren fonksiyondur. Girdi olarak negatif olmayan bir tamsayı verilirse bir dize veya girdi olarak kıvırcık bir sayı verilirse bir tamsayı döndürür.

Python 266 byte -% 10 = 1268,1 326,7 239,4 bayt

Çocuğum henüz bir kod golfçü değilim = /, ancak puanım hala 1000'in üzerindeyken % 10'u bana çok yardımcı oldu !

Burada bu kodun tamamen parçalanmış (ve ayrıntılı) bir sürümüne sahibim . Kıvırcık sayıların geçerliliğini tanıyacak ve test için sayı girmek için döngüsel bir arabirim sağlayacaktır.

(Sadece açıklama için yorumlar)

Bu kodu çalışırken görün

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)                         # 

Büyük bir bayt azaltması için Erik Konstantopoulos'a teşekkürler! Söyleyebilirsiniz ... gerçekten bir ... bayt ... kodumun dışına aldı ... * beşlik *

CJam, 87 bayt 80,1 puan (89 bayt -% 10 bonus)

2 bayt büyürken bonusa hak kazandıran sürümü güncelle:

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

Çevrimiçi deneyin

İlk defa CJam'da özyinelemeyi kullandım! Her şey biraz uzun görünebilir, ancak iki tamamen ayrı dönüşümler toplanır.

4'ten küçük sayıları Curly'ye dönüştürmek için tamamen ayrı bir kasa kullandım. Bundan kaçınmak muhtemelen mümkündür, ancak özel durum işlemenin özyinelemeli işleve katlanması tamamen önemsiz olmaz. Ve ekstra {}işlem sonrası adım olarak eklemek, biraz daha kısa olsa bile, tekrar denememe rağmen, daha iyi görünmüyordu.

C #, 173 -% 10 = 155.7 171.0, 177.3

Bu hiçbir onaylama yapmaz ve sadece ;ve }karakterleri arar . Tüm {karakterlerin herhangi bir ;karakterden önce geldiğini varsayar . Bulduğum en zor şey {}bir Kıvırcık sayısının ortasına bir sokmamaktı.

Satır sonları ve netlik için girintiler:

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 bayt - 10% = 294 bayt

Java ile yazılmış komple bir programdır.

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));}}}

Çok daha kısa olacağına eminim ama şimdi optimize etmek için çok zamanım yok

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

( -rBonusu% 10 talep etmeden önce bir tane kullandım ; umarım doğrudur)

/;/{
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

Tam sürüm, yukarıdakilerin çoğunun ondalık ve unary arasındaki dönüşüm olduğunu gösterir:

#!/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

Bu en kısa Perl cevabı olmayabilir, ancak göndermenin yeterince ilginç olduğunu düşünüyorum (giriş $_, dönüş değeri olarak çıkış):

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

Curly'nin sadece kuaterner (4 no'lu temel) gösterimi olduğunu gözlemliyoruz. Perl’in dördüncül için yerel destek eksikliği yüzünden birazcık engelleniyoruz, ama neyse ki, her dördüncül ikili olarak iki bit ve ikili okuyabilir ve yazabiliriz. Yani aşağıdakilere sahibiz:

1. Ondalık kıvrılarak: her bir Kıvrımlı haneyi 2 ikili basamağa dönüştür, birleştir ve ondalık basamağa dönüştür
2. Kıvırcık için Ondalık: sayıyı ikili olarak yazdırır (çift basamakta zorlayarak), sonra her bir bit çiftini Kıvırcık'a dönüştürün.

Genişletilmiş sürüm

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

Aşağıdaki pasajı çalıştıran testi

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>

Yakut, 126.9 129.6 (% 144 - 10)

Ondalık kıvrık forma dönüştürmek için özyineleme kullanır. Karakterleri göz ardı etme kontrolünün kaldırılması, /[;{}]/puanları 0.4şu anda artırır .

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 Bayt -% 10 + 1 Ceza)

$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 ve eval eğrileri çözer.
Kıvırcıkların oluşumu farklı şekilde yapılır.

Ölçek

Test dosyası ayrıca bonus durumlarda

$ 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 bayt

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

Test Suite'i deneyin

açıklama

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

En içteki parantezleri sadece ;s'ye ayırın . Artık teli kalmayıncaya kadar döngüleyin.

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

Ondalık ve tekli arasında dönüştürme ;

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

Bunun en uzun akışını ;4'ün katları olarak bulun ve 4 + daha fazla koşulana kadar döngü içine alın.

^;|^$
{}$&

Elde edilen kıvırcık sayısı ile başlarsa ; boş dize veya boşsa, {}önüne ekleyin .

Python 2 , 157 bayt -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

Çevrimiçi deneyin!

Bonus durumlarını ele alan daha Golfed Python 2 cevabı. Ölü mesajları nekro olarak yorum yapmak istemiyordu, işte burada.

İçinde kıvırcık sayılarla çalışır, bulunan her noktalı virgül için toplamı 4 ^ (dizgede kalan uç küme parantezi sayısı) ekler. Dize bir sayı ise, yinelenen bir şekilde kıvırcık sayıyı sağlanan gramerle aynı şekilde oluşturur.