W ezoterycznym języku programowania Curly programy składają się wyłącznie z nawiasów klamrowych {}i średników ;. Pomimo tego skromnego zestawu narzędzi, Curly ma literały, które mogą reprezentować dowolną nieujemną liczbę całkowitą. Format jest jednak nieco trudny do odczytania przez niewtajemniczonych, więc napiszmy kod, który przeprowadzi dla nas konwersję.

Format liczb

Liczby kręcone są uporządkowane zgodnie z następującymi zasadami:

1. Dodanie średnika dodaje jeden do liczby.
2. Liczba zamknięta w nawiasy klamrowe jest mnożona przez cztery.
3. Grupy nawiasów klamrowych mogą być zagnieżdżone, ale nie łączone. Nawiasy klamrowe muszą być odpowiednio dopasowane.
4. Średniki poza zestawem nawiasów klamrowych muszą pojawić się później, a nie wcześniej.
5. Aby uniknąć dwuznaczności podczas analizowania, liczba musi zawsze zaczynać się od nawiasów klamrowych.

Kilka przykładów:

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

(Uwaga: reguła 5 oznacza, że ​​liczby od 0 do 3 muszą zaczynać się od pustej pary nawiasów klamrowych).

I niektóre nieprawidłowe przykłady:

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

Oto gramatyka BNF dla liczb kręconych:

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

Liczby takie jak {;;;;}(więcej niż 3 średniki z rzędu) lub {{};}(niepotrzebne puste grupy nawiasów klamrowych) są nazywane nieprawidłowymi liczbami kręconymi. Przestrzegać ich wyżej gramatyki i może być rozpatrywane w zwykły sposób, ale są również zdolne do krótszych przedstawień (w powyższych przykładach, {{;}}a {;}odpowiednio).

Wyzwanie

Napisz program lub funkcję, która wprowadza / odbiera ciąg znaków. Jeśli ciąg jest nieujemną liczbą całkowitą dziesiętną, wyślij / zwróć odpowiednią (tj. Najkrótszą możliwą) reprezentację Curly dla tej liczby całkowitej. Jeśli ciąg jest liczbą Curly, wyślij / zwróć jego reprezentację dziesiętną.

Dane wejściowe można odbierać za pomocą STDIN, argumentu wiersza poleceń lub parametru funkcji. To musi być sznurek; to znaczy, nie możesz napisać funkcji, która akceptuje łańcuchy dla liczb Curly, ale liczby całkowite dla liczb dziesiętnych.

Wyjście można wydrukować do STDOUT lub zwrócić z funkcji. Funkcja może zwracać liczbę całkowitą, gdy jest to właściwe, lub może zwracać ciągi we wszystkich sytuacjach.

Twój program nie musi obsługiwać złe wejście (liczby Curly, które łamią zasady formatowanie liczb zmiennoprzecinkowych, ujemnych liczb całkowitych, tekst losowe), a to jest nie muszą obsługiwać niewłaściwych numerów Curly (ale patrz niżej). Dane wejściowe będą składały się wyłącznie z drukowalnych znaków ASCII.

Punktacja

Najkrótszy kod w bajtach wygrywa. Jeśli Twój program może wykonać obie następujące czynności:

1. poprawnie obsługiwać niewłaściwe liczby kręcone, oraz
2. po otrzymaniu liczby Curly zignoruj ​​dodatkowe znaki, które nie są {};

następnie odejmij 10% od swojego wyniku. (Dane liczbowe całkowite nigdy nie będą miały obcych znaków, nawet dla bonusu).

Przypadki testowe

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

Aby otrzymać bonus:

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

_{Uwaga: Curly nie jest jeszcze zaimplementowany. Ale jeśli to pytanie się powiedzie, mogę je rozwinąć.}

Pyth, 35 32 bajtów - 10% = 28,8

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

Wypróbuj online: pakiet demonstracyjny lub testowy

edytuj: Jak się okazało, przez przypadek mogę również obsługiwać niewłaściwe numery kręcone. W ogóle nie był planowany. ;-)

Wyjaśnienie:

Kod zawiera dwa wyrażenia. Pierwszy przekształca liczbę w Liczbę kręconą, a drugi przekształca Liczbę kręconą w liczbę zwykłą. .xuchwyty, których wyrażenie zostanie wydrukowane. Spróbuje wydrukować pierwsze wyrażenie. Jeśli na wejściu są jakieś cyfry, pierwsze wyrażenie nie powiedzie się (przez wyjątek). .xwyłapuje wyjątek i drukuje drugi.

.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 bajtów

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

Wypróbuj online: uruchomienie próbne | pakiet testowy

Jak to działa

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 bajtów - 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("}")])

W tej implementacji cjest funkcja, która spełnia wymagania. Zwraca ciąg, jeśli podano nieujemną liczbę całkowitą jako dane wejściowe lub liczbę całkowitą, jeśli podano liczbę kręconą jako dane wejściowe.

Python 266 bajtów - 10% = 1268,1 326,7 239,4 bajtów

Chłopiec nie jestem golfistą jeszcze kodu = /, ale 10% pomógł mi się na wiele , kiedy mój wynik był nadal ponad 1000!

Mam tutaj w pełni rozwiniętą (i pełną) wersję tego kodu . Będzie rozpoznawał ważność liczb kręconych i zapewni zapętlony interfejs do wprowadzania liczb do testowania.

(Komentarze tylko w celu wyjaśnienia)

Zobacz ten kod w akcji

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

Podziękowania dla Erika Konstantopoulosa za znaczną redukcję bajtów! Można powiedzieć, że ... naprawdę wyjął ... bajt ... z mojego kodu ... * siebie pięć *

CJam, 87 bajtów wynik 80,1 (89 bajtów - 10% bonusu)

Zaktualizuj wersję, która kwalifikuje się do premii, powiększając się o 2 bajty:

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

Wypróbuj online

Pierwszy raz użyłem rekurencji w CJam! Całość może wydawać się długa, ale suma dwóch całkowicie osobnych konwersji.

Użyłem zupełnie osobnego przypadku do konwersji liczb mniejszych niż 4 na Curly. Prawdopodobnie można tego uniknąć, ale złożenie obsługi specjalnych przypadków do funkcji rekurencyjnej nie byłoby całkowicie trywialne. Dodanie tego dodatku {}jako etapu przetwarzania końcowego nie wyglądało wcale lepiej, chociaż powinienem spróbować ponownie, jeśli może być nieco krótszy.

C #, 173 - 10% = 155,7 171,0, 177,3

To nie robi walidacji i tylko wygląda na ;i }znaków. Zakłada, że ​​wszystkie {postacie występują przed dowolnymi ;postaciami. Najtrudniejszą rzeczą, jaką znalazłem, było nie wstawianie znaku {}pośrodku liczby Curly.

Podziały linii i wcięcia dla przejrzystości:

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 bajtów - 10% = 294 bajtów

Jest to kompletny program napisany w Javie,

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

Jestem pewien, że może być znacznie krótszy, ale nie mam teraz dużo czasu na jego optymalizację

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

(Dodałem jeden do wykorzystania -rprzed zażądaniem premii 10%; mam nadzieję, że to prawda)

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

Pełna wersja pokazuje, że większość z powyższych to konwersja między dziesiętną a jednostkową:

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

To może nie być najkrótsza odpowiedź Perla, ale myślę, że jest wystarczająco interesująca, aby opublikować (wejście $_, wyjście jako wartość zwracana):

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

Zauważamy, że Curly to po prostu notacja czwartorzędowa (podstawa-4). Trochę przeszkadza nam brak natywnego wsparcia dla czwartego kwartału przez Perla, ale na szczęście każdy z czwartorzędowych bitów ma dwa bity, i możemy czytać i pisać w formacie binarnym. Mamy więc następujące:

1. Curly na decimal: zamień każdą cyfrę Curly na 2 cyfry binarne, połącz i zamień na dziesiętne
2. Dziesiętna na nawias: wydrukuj liczbę w systemie binarnym (wymuszając parzystą liczbę cyfr), a następnie przekonwertuj każdą parę bitów na nawias.

Wersja rozszerzona

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

Przetestuj poniższy fragment kodu

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>

Rubin, 126,9 129,6 (144-10%)

Używa rekurencji do konwersji dziesiętnej na formę nawiasową. Usunięcie zaznaczenia ignorowania postaci poza wartością /[;{}]/zwiększa wynik 0.4w tej chwili.

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 bajtów - 10% + 1 kara)

$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 i eval rozwiązują curlies.
Generowanie loków odbywa się inaczej.

Test

Plik testowy zawiera również przypadki bonusowe

$ 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 bajtów

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

Wypróbuj pakiet testowy

Wyjaśnienie

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

Rozkład wewnętrzne klamry na tylko ;s. Pętla, aż nie będzie więcej nawiasów klamrowych.

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

Konwertuj między dziesiętną a jednostkową ;

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

Znajdź najdłuższy z nich ;to wielokrotność 4 i zagnieźdź w nawiasy klamrowe, zapętlaj, aż nie będzie już więcej serii 4+.

^;|^$
{}$&

Jeśli wynikowa liczba kręcona zaczyna się od ;lub jest pustym ciągiem, dodaj {}z przodu.

Python 2 , 157 bajtów -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

Wypróbuj online!

Bardziej golfowa odpowiedź na Python 2, która obsługuje przypadki bonusowe. Nie chciałem nekrologować martwych postów z tym komentarzem, więc oto jest.

Działa od wewnątrz na liczbach kręconych, dodając 4 ^ (liczbę końcowych nawiasów klamrowych pozostałych w ciągu) do sumy dla każdego znalezionego średnika. Jeśli ciąg jest liczbą, rekurencyjnie tworzy liczbę kręconą w taki sam sposób, jak podaną gramatykę.