In der esoterischen Programmiersprache Curly bestehen Programme ausschließlich aus geschweiften Klammern {}und Semikolons ;. Trotz dieses bescheidenen Toolsets verfügt Curly über Literale, die eine beliebige nichtnegative Ganzzahl darstellen können. Das Format ist jedoch für die Uneingeweihten etwas schwierig zu lesen. Schreiben wir also Code, um die Konvertierung für uns durchzuführen.

Format der Zahlen

Geschweifte Zahlen sind nach folgenden Regeln aufgebaut:

1. Durch Hinzufügen eines Semikolons wird die Zahl um eins erhöht.
2. Eine Zahl in geschweiften Klammern wird mit vier multipliziert.
3. Geschweifte Klammergruppen können verschachtelt, aber nicht verkettet sein. Hosenträger müssen richtig passen.
4. Semikolons außerhalb einer Reihe von geschweiften Klammern müssen nachher kommen, nicht vorher.
5. Um Mehrdeutigkeiten beim Parsen zu vermeiden, muss eine Zahl immer mit einer geschweiften Klammer beginnen.

Einige Beispiele:

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

(Beachten Sie, dass Regel 5 bedeutet, dass die Zahlen 0 bis 3 mit einem leeren Paar geschweifter Klammern beginnen müssen.)

Und einige ungültige Beispiele:

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

Hier ist eine BNF-Grammatik für Curly-Zahlen:

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

Zahlen wie {;;;;}(mehr als 3 Semikolons in einer Reihe) oder {{};}(unnötige leere Klammergruppen) werden als falsche geschweifte Zahlen bezeichnet. Sie gehorchen die obige Grammatik und können in der üblichen Weise ausgewertet werden, aber sie sind auch in der Lage kürzerer Darstellungen (für die obigen Beispiele {{;}}und {;}respectively).

Die Herausforderung

Schreiben Sie ein Programm oder eine Funktion, die eine Zeichenfolge eingibt / empfängt. Wenn die Zeichenfolge eine nichtnegative Dezimalzahl ist, geben Sie die richtige (dh kürzestmögliche) Curly-Darstellung für diese Ganzzahl aus bzw. geben Sie sie zurück. Wenn es sich bei der Zeichenfolge um eine geschweifte Zahl handelt, geben Sie die Dezimaldarstellung aus bzw. geben Sie sie zurück.

Eingaben können über STDIN, Befehlszeilenargument oder Funktionsparameter empfangen werden. Es muss eine Zeichenfolge sein; Das heißt, Sie dürfen keine Funktion schreiben, die Zeichenfolgen für geschweifte Zahlen akzeptiert, sondern ganze Zahlen für Dezimalzahlen.

Die Ausgabe kann auf STDOUT gedruckt oder von der Funktion zurückgegeben werden. Eine Funktion kann gegebenenfalls eine Ganzzahl oder in allen Situationen Zeichenfolgen zurückgeben.

Ihr Programm muss keine falschen Eingaben verarbeiten (geschweifte Zahlen, die gegen die Formatierungsregeln verstoßen, Gleitkommazahlen, negative Ganzzahlen, zufälliger Text), und es muss keine falschen geschweiften Zahlen verarbeiten (siehe unten). Die Eingabe besteht nur aus druckbaren ASCII-Zeichen.

Wertung

Der kürzeste Code in Bytes gewinnt. Wenn Ihr Programm beide der folgenden Funktionen ausführen kann :

1. richtig mit unsachgemäßen geschweiften Zahlen umgehen, und
2. Wenn Sie eine geschweifte Zahl haben, ignorieren Sie alle zusätzlichen Zeichen, die nicht vorhanden sind {};

Dann ziehen Sie 10% von Ihrer Punktzahl ab. (Die Ganzzahleingabe wird auch für den Bonus niemals überflüssige Zeichen enthalten.)

Testfälle

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

Für den Bonus:

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

_{Hinweis: Curly ist noch nicht implementiert. Aber wenn diese Frage gut ist, kann ich sie weiterentwickeln.}

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

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

Probieren Sie es online aus: Demo oder Test Suite

edit: Wie sich herausstellte, kann ich auch versehentlich mit falschen Curly Numbers umgehen. War überhaupt nicht geplant. ;-)

Erläuterung:

Der Code enthält zwei Ausdrücke. Der erste wandelt eine Zahl in eine geschweifte Zahl um, und der zweite wandelt eine geschweifte Zahl in eine reguläre Zahl um. .xbehandelt, welcher Ausdruck gedruckt wird. Es wird versucht, den ersten Ausdruck zu drucken. Wenn die Eingabe keine Ziffern enthält, schlägt der erste Ausdruck fehl (über Exception). .xfängt die Ausnahme ab und druckt die zweite.

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

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

Probieren Sie es online aus: Probelauf | Testsuite

Wie es funktioniert

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

In dieser Implementierung cist die Funktion, die die Anforderungen erfüllt. Es gibt eine Zeichenfolge zurück, wenn eine nicht negative Ganzzahl als Eingabe angegeben wird, oder eine Ganzzahl, wenn eine geschweifte Zahl als Eingabe angegeben wird.

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

Junge, ich bin noch kein Code-Golfer = /, aber diese 10% haben mir sehr geholfen , als meine Punktzahl noch über 1000 lag!

Ich habe hier eine vollständig ausgearbeitete (und ausführliche) Version dieses Codes . Es erkennt die Gültigkeit von geschweiften Zahlen und bietet eine Schleifenschnittstelle zur Eingabe von Zahlen zum Testen.

(Kommentare nur zur Verdeutlichung)

Sehen Sie diesen Code in Aktion

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

Vielen Dank an Erik Konstantopoulos für die große Reduzierung der Bytes! Man könnte sagen ... er hat wirklich ein ... Byte ... aus meinem Code genommen ... * self five *

CJam, 87 bytes 80.1 score (89 bytes - 10% bonus)

Update-Version, die sich für den Bonus qualifiziert und gleichzeitig um 2 Byte wächst:

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

Probieren Sie es online aus

Zum ersten Mal habe ich die Rekursion in CJam! Das Ganze mag etwas langweilig aussehen, aber die beiden völlig getrennten Konvertierungen summieren sich.

Ich habe einen völlig separaten Fall für die Konvertierung von Zahlen kleiner als 4 in Curly verwendet. Es ist wahrscheinlich möglich, dies zu vermeiden, aber das Falten der Sonderfallbehandlung in die rekursive Funktion wäre nicht ganz trivial. Und das Hinzufügen des Extra {}als Nachbearbeitungsschritt sah nicht wirklich besser aus, obwohl ich es noch einmal versuchen sollte, wenn es etwas kürzer sein könnte.

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

Dies führt keine Validierung durch und sucht nur nach ;und }Zeichen. Es wird davon ausgegangen, dass alle {Zeichen vor den ;Zeichen stehen. Das Schwierigste, was ich gefunden habe, war, keine {}in die Mitte einer Curly-Zahl einzufügen .

Zeilenumbrüche und Einrückungen zur Verdeutlichung:

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

Es ist ein vollständiges Programm, das in Java geschrieben wurde.

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

Ich bin sicher, dass es viel kürzer sein kann, aber ich kann jetzt nicht viel Zeit haben, um es zu optimieren

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

(Ich habe eine für die Verwendung von hinzugefügt, -rbevor ich den Bonus 10% beanspruchte. Ich hoffe, das ist richtig.)

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

Die Vollversion zeigt, dass der größte Teil der obigen Konvertierung zwischen Dezimal und Unär ist:

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

Dies ist möglicherweise nicht die kürzeste Perl-Antwort, aber ich denke, es ist interessant genug, sie zu posten (Eingabe in $_, Ausgabe als Rückgabewert):

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

Wir beobachten, dass Curly einfach eine quaternäre Notation (Basis 4) ist. Wir sind ein wenig behindert von Perls mangelnder nativer Unterstützung für Quaternary, aber zum Glück besteht jede Quaternit aus zwei binären Bits und wir können Binärdateien lesen und schreiben. Wir haben also folgendes:

1. Curly to decimal: Konvertiert jede Curly-Ziffer in 2 Binärziffern, verkettet sie und konvertiert sie in eine Dezimalzahl
2. Dezimal in Curly: Gibt die Zahl in Binärform aus (erzwingt eine gerade Anzahl von Ziffern) und konvertiert dann jedes Bitpaar in Curly.

Erweiterte Version

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

Testen Sie das folgende Snippet

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

Verwendet die Rekursion, um Dezimalzahlen in geschweifte Form umzuwandeln. Das Deaktivieren des Kontrollkästchens zum Ignorieren von Zeichen außerhalb von /[;{}]/erhöht die Punktzahl 0.4im Moment um.

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

$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 lösen die Locken auf.
Die Erzeugung der Locken erfolgt unterschiedlich.

Prüfung

Die Testdatei enthält auch die Bonusfälle

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

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

Testen Sie die Test Suite

Erläuterung

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

Zerlegen Sie die innersten Klammern in ;s. Schleife, bis keine Klammern mehr vorhanden sind.

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

Zwischen Dezimalzahl und Unärzahl konvertieren ;

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

Suchen Sie den längsten Lauf mit ;einem Vielfachen von 4 und schachteln Sie in geschweiften Klammern. Führen Sie eine Schleife aus, bis keine Läufe mit 4+ mehr vorhanden sind.

^;|^$
{}$&

Wenn die resultierende geschweifte Zahl mit einer ;leeren Zeichenfolge beginnt oder leer ist, fügen Sie diese {}voran.

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

Probieren Sie es online!

Eine eher golfene Antwort auf Python 2, die die Bonusfälle behandelt. Wollte keine toten Beiträge mit diesem als Kommentar necro, also hier ist es.

Es funktioniert von innen nach innen mit geschweiften Zahlen und addiert 4 ^ (die Anzahl der in der Zeichenfolge verbleibenden geschweiften Klammern) zur Summe für jedes gefundene Semikolon. Wenn es sich bei der Zeichenfolge um eine Zahl handelt, wird die geschweifte Zahl auf die gleiche Weise wie in der angegebenen Grammatik rekursiv erstellt.