{কোঁকড়া সংখ্যা};


33

মূল প্রোগ্রামিং ল্যাঙ্গুয়েজ কোঁকড়াতে, প্রোগ্রামগুলি সম্পূর্ণরূপে কোঁকড়া ধনুর্বন্ধনী {}এবং সেমিকোলন নিয়ে গঠিত ;। এই নম্র টুলসেট সত্ত্বেও, কোঁকড়ির কাছে আক্ষরিকাগুলি রয়েছে যা কোনও অবৈধ পূর্ণসংখ্যাকে উপস্থাপন করতে পারে। বিনীত অবিচ্ছিন্নভাবে পড়ার জন্য ফর্ম্যাটটি কিছুটা শক্ত, তবে আমাদের জন্য রূপান্তর করতে কিছু কোড লিখি।

সংখ্যার ফর্ম্যাট

কোঁকড়া সংখ্যা নিম্নলিখিত নিয়ম অনুযায়ী কাঠামোগত হয়:

  1. একটি সেমিকোলন যুক্ত করা সংখ্যায় একটি যোগ করে।
  2. কোঁকড়া ধনুর্বন্ধনী মধ্যে সংযুক্ত একটি সংখ্যা চার দ্বারা গুণিত হয়।
  3. কোঁকড়া-ব্রেস গ্রুপগুলি নেস্টেড হতে পারে তবে কনটেনটেটেড নয়। ধনুর্বন্ধনী অবশ্যই সঠিকভাবে মেলে।
  4. কোঁকড়া ধনুর্বন্ধনী সংকলনের একটি সেটের বাইরে সেমিকোলনগুলি পরে আসতে হবে, এর আগে নয়।
  5. বিশ্লেষণে অস্পষ্টতা এড়াতে, একটি সংখ্যা সর্বদা একটি কোঁকড়া ধনুর্বন্ধনী সঙ্গে শুরু করা উচিত।

কিছু উদাহরণ:

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

(নোট করুন যে নিয়ম 5 এর অর্থ 0 থেকে 3 নম্বরগুলি অবশ্যই একটি খালি জোড়া কোঁকড়ানো ধনুর্বন্ধনী দিয়ে শুরু করা উচিত))

এবং কিছু অবৈধ উদাহরণ:

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

কোঁকড়া সংখ্যার জন্য এখানে একটি বিএনএফ ব্যাকরণ রয়েছে:

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

মত নাম্বার {;;;;}(ক সারিতে অধিক 3 সেমিকোলন) অথবা {{};}(অপ্রয়োজনীয় খালি বক্রবন্ধনী গোষ্ঠী) বলা হয় অপ্রকৃত কোঁকড়া নম্বর। তারা উপরের ব্যাকরণকে মান্য করে এবং সাধারণ উপায়ে মূল্যায়ন করা যায় তবে তারা সংক্ষিপ্ত উপস্থাপনেও সক্ষম (উপরের উদাহরণগুলির জন্য, {{;}}এবং{;} যথাক্রমে)।

চ্যালেঞ্জ

এমন একটি প্রোগ্রাম বা ফাংশন লিখুন যা স্ট্রিংকে ইনপুট করে / গ্রহণ করে। যদি স্ট্রিংটি দশমিক দশমিক পূর্ণসংখ্যার হয় তবে সেই পূর্ণসংখ্যার জন্য আউটপুট / যথাযথ (অর্থাত্ সংক্ষিপ্ততম সম্ভব) কোঁকড়া প্রতিনিধিত্ব করুন। যদি স্ট্রিংটি একটি কোঁকড়ানো নম্বর হয় তবে আউটপুট / তার দশমিক উপস্থাপনা ফেরত দেয়।

এসটিডিআইএন, কমান্ড-লাইন আর্গুমেন্ট বা ফাংশন প্যারামিটারের মাধ্যমে ইনপুট পাওয়া যায়। এটা অবশ্যই একটি স্ট্রিং হতে ; এটি হল, আপনি কোনও ফাংশন লিখতে পারবেন না যা কুঁকড়ানো সংখ্যার জন্য স্ট্রিং গ্রহণ করে তবে দশমিক সংখ্যার জন্য পূর্ণসংখ্যার জন্য।

আউটপুট STDOUT এ মুদ্রিত বা ফাংশন থেকে ফিরে আসতে পারে। একটি ফাংশন হতে পারে যখন পূর্ণসংখ্যার ফিরে আসতে , বা এটি সব পরিস্থিতিতে স্ট্রিং ফিরে আসতে পারে।

আপনার প্রোগ্রামকে খারাপ ইনপুট (ফর্ম্যাটিং নিয়ম, ভাসমান পয়েন্ট সংখ্যা, নেতিবাচক পূর্ণসংখ্যার, এলোমেলো পাঠ্যগুলি ভেঙে এমন কোঁকড়া সংখ্যা) পরিচালনা করতে হবে না এবং এটি হয় না হ্যান্ডেল হবে অনুচিত কোঁকড়া সংখ্যাগুলি হ্যান্ডেল করার প্রয়োজন নেই (তবে নীচে দেখুন)। ইনপুটটিতে কেবল মুদ্রণযোগ্য এএসসিআইআই অক্ষর থাকবে।

স্কোরিং

বাইটের মধ্যে সংক্ষিপ্ততম কোডটি জয়ী। যদি আপনার প্রোগ্রামটি নিম্নলিখিত দুটি করতে পারে :

  1. সঠিকভাবে অনুচিত কোঁকড়া সংখ্যা হ্যান্ডেল করুন এবং
  2. যখন একটি কোঁকড়ানো নম্বর দেওয়া হয়, কোনও অতিরিক্ত অক্ষর নেই যা উপেক্ষা করুন {};

তারপরে আপনার স্কোর থেকে 10% বিয়োগ করুন। (পূর্ণসংখ্যার ইনপুটটিতে কখনই বহিরাগত অক্ষর থাকবে না, এমনকি বোনাসের জন্যও))

পরীক্ষার মামলা

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

বোনাসের জন্য:

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

দ্রষ্টব্য: কোঁকড়া এখনও প্রয়োগ করা হয়নি। তবে এই প্রশ্নটি যদি ভাল করে তবে আমি এটি আরও বিকাশ করতে পারি।


আপনার যদি প্যারেনেসিসের সংখ্যার মিল না থাকে তবে কীভাবে এটি কেস করবেন? নাকি আমি ধরে নেব যে এটি কখনও ঘটবে না?
ব্যবহারকারী 902383

@ user902383 আপনি ধরে নিতে পারেন যে অ-ম্যাচিং কোঁকড়ানো ধনুর্বন্ধনী কখনও ঘটবে না।
ডিএলস্ক

2
আমি একটি রেটিনা সমাধান তৈরি করতে যাচ্ছিলাম, তবে এটি একটি কোঁকড়ানো স্ট্রিং (মাত্র 20 বাইট) হ্যান্ডেল করার পরে, আমি বুঝতে পেরেছিলাম এটির ইতিবাচক পূর্ণসংখ্যা -> কোঁকড়ানোও হ্যান্ডেল করা দরকার, তাই আমি হাল ছেড়ে দিলাম।
mbomb007

@ডলকস হ্যাঁ, এটি জিততে পারে না, তাই আমি সময় ব্যয় করব না।
mbomb007

@ mbomb007 আমি এই প্রশ্নটি বিশেষভাবে বোঝাতে চেয়েছি, যেখানে পাইথ সলিউশনটি ইতিমধ্যে সংক্ষিপ্ত সিজেএম সমাধানের চেয়ে 22% কম এবং বোনাসের জন্য যোগ্যতা অর্জন করেছে। যাইহোক, এটি বলার চেষ্টা করা একটি অলৌকিক প্রশ্ন ছিল, "না, তবে এটি মজাদার হতে পারে এবং কিছু উত্স অর্জন করতে পারে।" যদিও আপনি "মজাদার" অংশের সাথে একমত নন, যদিও তা ঠিক আছে।
ডিএলসক

উত্তর:


15

পাইথ, 35 32 বাইট - 10% = 28.8

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

এটি অনলাইনে ব্যবহার করে দেখুন: বিক্ষোভ বা পরীক্ষার স্যুট

সম্পাদনা: দেখা যাচ্ছে যে, আমি দুর্ঘটনাক্রমেও অনুচিত কোঁকড়ানো নম্বরগুলি পরিচালনা করতে পারি। মোটেই পরিকল্পনা করা হয়নি। ;-)

ব্যাখ্যা:

কোডটিতে দুটি এক্সপ্রেশন রয়েছে। প্রথমটি কোনও সংখ্যাকে একটি কোঁকড়া সংখ্যায় রূপান্তর করে এবং দ্বিতীয়টি একটি কোঁকড়া সংখ্যাটিকে নিয়মিত সংখ্যায় রূপান্তর করে। .xহ্যান্ডলগুলি, যা প্রকাশিত হয় মুদ্রিত। এটি প্রথম প্রকাশটি মুদ্রণের চেষ্টা করবে। যদি ইনপুটটিতে কোনও অ-অঙ্ক থাকে তবে প্রথম অভিব্যক্তি ব্যর্থ হয় (ব্যতিক্রমের মাধ্যমে)। .xব্যতিক্রম ধরা পড়ে এবং দ্বিতীয়টি মুদ্রণ করে।

.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

2
পশ্চিমে দ্রুততম বন্দুক :( আমি ভুলে গিয়েছিলাম যে এটি .[Z2প্রয়োজনীয় ছিল তা বাদ দিয়ে আমার এই সঠিক সমাধানটি ছিল
orp

12

সিজেম, 51 47 44 41 বাইট

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

অনলাইনে এটি ব্যবহার করে দেখুন: নমুনা রান | পরীক্ষা স্যুট

কিভাবে এটা কাজ করে

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#

7

পাইথন 2, 167 বাইট - 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("}")])

এই বাস্তবায়নে, cপ্রয়োজনীয়তা পূরণ করে এমন ফাংশনটি হয়। ইনপুট হিসাবে একটি nonnegative পূর্ণসংখ্যা দেওয়া হয় অথবা ইনপুট হিসাবে একটি কোঁকড়া সংখ্যা দেওয়া হয় একটি পূর্ণসংখ্যা যদি এটি একটি স্ট্রিং প্রদান করে।


6

পাইথন 266 বাইট - 10% = 1268.1 326.7 239.4 বাইট

ছেলে আমি একটি কোড গল্ফ খেলোয়াড় এখনো = /, কিন্তু যে 10% সাহায্য করেছে আমাকে আউট অনেক যখন আমার স্কোর এখনও 1000 ছিল!

আমার এখানে এই কোডটির একটি সম্পূর্ণরূপে সংস্কৃত (এবং ভার্বোস) সংস্করণ রয়েছে এটি কোঁকড়া সংখ্যার বৈধতা স্বীকৃতি দেবে এবং পরীক্ষার জন্য নম্বরগুলি প্রবেশের জন্য একটি লুপযুক্ত ইন্টারফেস সরবরাহ করবে।

(কেবলমাত্র স্পষ্টকরণের জন্য মন্তব্যগুলি)

ক্রিয়াকলাপে এই কোডটি দেখুন

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

বড় বাইট হ্রাসের জন্য এরিক কনস্ট্যান্টপৌলসকে ধন্যবাদ! আপনি বলতে পারেন ... তিনি আমার কোডের বাইরে ... বেল্ট ... সত্যিই নিয়েছেন ... * সেলফ ফাইভ *


4
Welcome to PPCG! Your code contains a lot of unrequired print statements and a comment, your variable names are too long and some whitespace can be eliminated. I also recommend reading Tips for golfing in Pyrhon.
Dennis

Great resource, thanks! I'll make the appropriate changes to this code and see how far it gets me. Looks like if I want to be anybody on this site, I either need to learn CJam or Pyth, or write my own language lol.
Taylor Lopez

3
@iAmMortos Not necessarily. Do if you find it enjoyable, or stick with Python if not. :)
DLosc

2
Usually, golfing is done in three steps: 1) make your program like you would do normally, as minimal as possible (i.e., no debug statements, no need to handle invalid input, minimal output) 2) remove as much as possible: whitespace, rename variables (value to v etc), 3) do clever golfing stuff: this is the point where you need to look at Dennis' link. I'm curious to see how much you can cut this down!
Sanchises

1
Never have I received such a warm welcome on a community. lol, I think I like it here.
Taylor Lopez

4

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

Update version that qualifies for the bonus while growing by 2 bytes:

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

Try it online

First time I used recursion in CJam! The whole thing may look kind of lengthy, but the two completely separate conversions add up.

I used a completely separate case for converting numbers smaller than 4 to Curly. It's probably possible to avoid that, but folding the special case handling into the recursive function wouldn't be entirely trivial. And adding the extra {} as a post-processing step didn't really look any better, even though I should try again if it might be slightly shorter.


Wouldn't your score be 80.1?
PurkkaKoodari

4
@Pietu1998 Thanks. Not only are my solutions too long, apparently I also fail at basic arithmetic...
Reto Koradi

3

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

This does no validation and only looks for ; and } characters. It assumes all { characters come before any ; characters. The hardest thing I found was to not insert a {} in the middle of a Curly number.

Line breaks and indents for clarity:

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

You can save one Byte by using var instead of char in the foreach loops.
raznagul

@DLosc, sorry, I was confused by bonus #1. I though that applied to output rather than input.
Hand-E-Food

2

Java 326 bytes - 10% = 294 bytes

It is complete program written in 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));}}}

I'm sure it can be much shorter but i cant have much time now to optimize it


@DLosc damn, right, and thought i can have a nice result with java:(
user902383

also: common optimisation on java is to avoid the public before class
masterX244

replace the public static void main(String[]c){ with static{
das_j

2

GNU sed, 330 326 - 10% = 293.4

(I added one for the use of -r before claiming the bonus 10%; I hope that's correct)

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

The full version shows that most of the above is conversion between decimal and 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

Unfortunately, this question explicitly says decimal is required, which is why I bothered converting.
Toby Speight

You're right, which is a bit astonishing to me since excluding unary wasn't my intention. Oh well, guess it's too late to change the question now. I reaffirm my +1, sir.
DLosc

2

Perl, 183 177

This might not be the shortest Perl answer, but I think it's interesting enough to post (input in $_, output as return value):

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

We observe that Curly is simply quaternary (base-4) notation. We're slightly hampered by Perl's lack of native support for quaternary, but luckily, each quaternit is two bits in binary, and we can read and write binary. So we have the following:

  1. Curly to decimal: convert each Curly digit to 2 binary digits, concatenate and convert to decimal
  2. Decimal to Curly: print the number in binary (forcing an even number of digits), then convert each bit-pair to Curly.

Expanded 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 $_ <= {};;;
    }
}

1

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

Test running the snippet below

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>


Could you please post your actual code? Also, your score is 94.5.
Erik the Outgolfer

@ErikKonstantopoulos my actual code was posted at top of the test snippet. Now it is at top of the answer too. About the score (that should be in bytes), I always feel funny measuring half (or less) byte and prefer rouniding up
edc65

edc65: Yeah, but rounding up is bad for you! 94.5<95 thus smaller score, which means that it probably beats more submissions. Also, the "top of the snippet" is not the place to show your code.
Erik the Outgolfer

1

Ruby, 126.9 129.6 (144 - 10%)

Uses recursion to convert decimal into curly form. Removing the check for ignoring characters outside of /[;{}]/ increases the score by 0.4 at the moment.

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

It's fixed now. Thanks for reporting the bug; score has been updated.
Value Ink

1

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

$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 resolve the curlies.
The generation of the curlies is done differently.

Test

Test file contains also the bonus cases

$ 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

Added the -1 penalty for -p. The $b=$r<2?"{}":""; was added for the exception of 0 & 1. {};;; is the input in the test.
LukStorms

Needed some time to test it. It's fixed now. :)
LukStorms

I think the +1 penalty comes after -10% bonus.
Erik the Outgolfer

Interesting observation. Not sure if that's now it should be, but it makes sense so I changed it anyway. Not that it changes the end score.
LukStorms

1

Retina, 69 64 bytes

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

Try Test Suite


Explanation

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

Decompose the innermost braces to just ;s. Loop until no more braces.

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

Convert between decimal and unary ;

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

Find the longest run of ; that is a multiple of 4 and nest into braces, loop until no more runs of 4+ exist.

^;|^$
{}$&

If the resulting curly number begins with ; or is empty string, add {} in front.


1

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

Try it online!

A more golfed Python 2 answer that handles the bonus cases. Didn't want to necro dead posts with this as a comment, so here it is.

It works from the inside in on curly numbers, adding 4^(the number of end curly brackets left in the string) to the sum for each semicolon found. If the string is a number, then it recursively creates the curly number in the same way as the grammar provided.


That's awkward. I even had test cases in there for numbers less than 2. Fixed for +5 bytes total.
Arnold Palmer

@DLosc I swear I'm normally not this bad. Fixed, and golfed a bit to make it a bit more competitive.
Arnold Palmer
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.