ในการเขียนโปรแกรมภาษาลึกลับหยิกโปรแกรม แต่เพียงการประกอบวงเล็บปีกกาและอัฒภาค{} ;แม้ชุดเครื่องมือต่ำต้อยนี้ลอนมีตัวอักษรที่สามารถแสดงจำนวนเต็มที่ไม่ใช่ค่าลบใด ๆ รูปแบบนั้นค่อนข้างยากสำหรับผู้ที่ไม่ได้ฝึกอ่านดังนั้นให้เขียนโค้ดเพื่อทำการแปลงให้เรา

รูปแบบของตัวเลข

ตัวเลขลอนมีโครงสร้างตามกฎต่อไปนี้:

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

นี่คือไวยากรณ์ BNF สำหรับหมายเลขลอน:

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

ตัวเลขเช่น{;;;;}(มากกว่า 3 อัฒภาคในแถว) หรือ{{};}(กลุ่มวงเล็บปีกกาว่างเปล่าที่ไม่จำเป็น) เรียกว่าหมายเลขลอนที่ไม่เหมาะสม พวกเขาเชื่อฟังไวยากรณ์ข้างต้นและสามารถประเมินได้ในวิธีปกติ แต่พวกเขาก็ยังสามารถเป็นตัวแทนที่สั้นกว่า (สำหรับตัวอย่างข้างต้น{{;}}และ{;}ตามลำดับ)

ความท้าทาย

เขียนโปรแกรมหรือฟังก์ชั่นที่อินพุต / รับสตริง หากสตริงเป็นจำนวนเต็มฐานสิบที่ไม่ใช่ค่าลบเอาต์พุต / ส่งกลับค่าที่เหมาะสม (นั่นคือสั้นที่สุด) การเป็นตัวแทนลอนสำหรับจำนวนเต็มนั้น ถ้าสตริงเป็นจำนวนลอนผลลัพธ์ / ส่งกลับแทนทศนิยม

สามารถรับอินพุตได้ผ่าน STDIN อาร์กิวเมนต์บรรทัดคำสั่งหรือพารามิเตอร์ฟังก์ชัน มันต้องเป็นสตริง นั่นคือคุณไม่สามารถเขียนฟังก์ชั่นที่ยอมรับสตริงสำหรับตัวเลขหยิก แต่จำนวนเต็มสำหรับตัวเลขทศนิยม

สามารถพิมพ์เอาต์พุตไปที่ STDOUT หรือส่งคืนจากฟังก์ชัน ฟังก์ชั่นอาจคืนค่าจำนวนเต็มเมื่อเหมาะสมหรืออาจส่งคืนสตริงในทุกสถานการณ์

โปรแกรมของคุณไม่จำเป็นต้องจัดการอินพุตที่ไม่ถูกต้อง (ตัวเลขหยิกที่ละเมิดกฎการจัดรูปแบบหมายเลขทศนิยมจำนวนเต็มลบข้อความสุ่ม) และไม่จำเป็นต้องจัดการกับตัวเลขหยิกที่ไม่เหมาะสม (แต่ดูด้านล่าง) ข้อมูลที่ป้อนจะประกอบด้วยอักขระ ASCII ที่พิมพ์ได้เท่านั้น

เกณฑ์การให้คะแนน

รหัสที่สั้นที่สุดในหน่วยไบต์ชนะ หากโปรแกรมของคุณสามารถทำทั้งสองอย่างต่อไปนี้:

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

_{หมายเหตุ: ลอนยังไม่ได้ใช้งาน แต่ถ้าคำถามนี้ทำได้ดีฉันอาจจะพัฒนาต่อไป}

Pyth, 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

CJam, 51 47 44 41 bytes

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#

Python 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เป็นฟังก์ชั่นที่ตรงตามข้อกำหนด มันจะส่งกลับสตริงหากได้รับจำนวนเต็มไม่ใช่ค่าลบเป็นอินพุตหรือจำนวนเต็มถ้ากำหนดตัวเลขเป็นหยิก

Python 266 ไบต์ - 10% = 1268.1 326.7 239.4 ไบต์

บอยผมไม่ได้เป็นนักกอล์ฟรหัสเลย = / แต่ที่ 10% ช่วยฉันออกมากเมื่อคะแนนของฉันก็ยังคงมากกว่า 1000!

ฉันมีรหัสนี้ (และ verbose) เนื้ออย่างเต็มที่ที่นี่ มันจะรับรู้ถึงความถูกต้องของตัวเลขหยิกและให้อินเตอร์เฟซแบบวนลูปเพื่อป้อนหมายเลขสำหรับการทดสอบ

(ความเห็นเพียงเพื่อชี้แจง)

ดูการทำงานของรหัสนี้

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

ขอบคุณ Erik Konstantopoulos สำหรับการลดจำนวนไบต์ที่สำคัญ! คุณสามารถพูดได้ว่า ... เขาเอา ... byte ... ออกจากรหัสของฉัน ... * self five *

CJam, 87 bytes 80.1 คะแนน (89 bytes - โบนัส 10%)

อัปเดตเวอร์ชันที่มีคุณสมบัติรับโบนัสขณะที่เพิ่มขึ้น 2 ไบต์:

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

ลองออนไลน์

ครั้งแรกที่ฉันใช้การเรียกซ้ำใน CJam! สิ่งทั้งหมดอาจดูยาวไปหน่อย แต่การแปลงทั้งสองแยกกันก็เพิ่มขึ้น

ฉันใช้ตัวพิมพ์เล็กมากสำหรับการแปลงตัวเลขที่มีขนาดเล็กกว่า 4 ถึงหยิก อาจเป็นไปได้ที่จะหลีกเลี่ยงปัญหานั้น แต่การพับเคสพิเศษเข้าไปในฟังก์ชั่นวนซ้ำนั้นอาจไม่สำคัญเลย และการเพิ่มส่วนเสริม{}เป็นขั้นตอนหลังการประมวลผลไม่ได้ดูดีกว่านี้จริงๆถึงแม้ว่าฉันควรลองอีกครั้งหากอาจสั้นกว่านี้เล็กน้อย

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

นี่ไม่ใช่การตรวจสอบความถูกต้องและจะค้นหา;และ}อักขระเท่านั้น มันถือว่า{ตัวละครทุกตัวมาก่อน;ตัวละครใด ๆ สิ่งที่ยากที่สุดที่ฉันพบคือการไม่ใส่ a {}ตรงกลางของจำนวนลอน

การขึ้นบรรทัดใหม่และการเยื้องเพื่อความชัดเจน:

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 ไบต์ - 10% = 294 ไบต์

มันเป็นโปรแกรมที่สมบูรณ์เขียนด้วยภาษาจาวา

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

ฉันแน่ใจว่ามันจะสั้นกว่านี้ แต่ฉันไม่สามารถมีเวลามากพอที่จะปรับให้เหมาะสม

รุ่น GNU, 330 326 - 10% = 293.4

(ฉันเพิ่มอีกหนึ่งสำหรับการใช้งาน-rก่อนที่จะรับโบนัส 10% ฉันหวังว่ามันจะถูกต้อง)

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

เวอร์ชันเต็มแสดงให้เห็นว่าส่วนใหญ่ข้างต้นเป็นการแปลงระหว่างทศนิยมและไม่เป็นเอกภาพ:

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

นี่อาจไม่ใช่คำตอบ Perl ที่สั้นที่สุด แต่ฉันคิดว่ามันน่าสนใจพอที่จะโพสต์ (อินพุต$_, เอาต์พุตเป็นค่าส่งคืน):

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

เราสังเกตว่าลอนเป็นสัญกรณ์ quaternary (ฐาน 4) อย่างง่าย เราได้รับผลกระทบเล็กน้อยจากการที่ Perl ไม่ได้รับการสนับสนุนจาก quaternary แต่โชคดีที่ quaternit แต่ละตัวมีสองบิตในไบนารีและเราสามารถอ่านและเขียนไบนารีได้ ดังนั้นเราจึงมีดังต่อไปนี้:

1. หยิกเป็นทศนิยม: แปลงแต่ละหลักหยิกเป็น 2 หลัก, เรียงต่อกันและแปลงเป็นทศนิยม
2. Decimal to Curly: พิมพ์ตัวเลขเป็นเลขฐานสอง (บังคับให้มีจำนวนหลักเท่ากับ) จากนั้นแปลงแต่ละบิตคู่เป็นหยิก

รุ่นขยาย

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

ทดสอบการเรียกใช้ตัวอย่างข้อมูลด้านล่าง

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>

ทับทิม, 126.9 129.6 (144 - 10%)

ใช้การเรียกซ้ำเพื่อแปลงทศนิยมให้อยู่ในรูปแบบลอน การลบการตรวจสอบสำหรับการละเว้นอักขระนอกการ/[;{}]/เพิ่มคะแนนโดย0.4ในขณะนี้

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 การลงโทษ)

$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 แก้ไข curlies
รุ่นของ curlies จะทำแตกต่างกัน

ทดสอบ

ไฟล์ทดสอบมีกรณีโบนัสด้วย

$ 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

เรติน่า , 69 64 ไบต์

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

ลองชุดทดสอบ

คำอธิบาย

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

สลายวงเล็บปีกกาในสุดให้เหลือเพียง;s วนซ้ำจนกว่าจะไม่มีวงเล็บปีกกามากขึ้น

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

แปลงระหว่างทศนิยมและ unary ;

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

ค้นหาการวิ่งที่ยาวที่สุด;ซึ่งเป็นผลคูณของ 4 และซ้อนในวงเล็บปีกกาวนรอบจนกว่าจะไม่มีการวิ่งมากกว่า 4+ อีกต่อไป

^;|^$
{}$&

หากจำนวนหยิกที่เกิดขึ้นเริ่มต้นด้วย;หรือเป็นสตริงว่างเพิ่ม{}ในด้านหน้า

Python 2 , 157 ไบต์ -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

ลองออนไลน์!

คำตอบของ Python 2 ที่ตีกอล์ฟที่จัดการกรณีโบนัส ไม่ต้องการ necro โพสต์ที่ตายแล้วด้วยสิ่งนี้เป็นความคิดเห็นดังนั้นนี่คือ

มันทำงานได้จากด้านในด้วยตัวเลขหยิกเพิ่ม 4 ^ (จำนวนวงเล็บปีกกาสิ้นสุดที่เหลืออยู่ในสตริง) ไปยังผลรวมสำหรับแต่ละอัฒภาคที่พบ หากสตริงเป็นตัวเลขมันจะสร้างตัวเลขหยิกซ้ำในลักษณะเดียวกับไวยากรณ์ที่ให้ไว้