Trong ngôn ngữ lập trình bí truyền xoăn, các chương trình chỉ bao gồm các dấu ngoặc nhọn {}và dấu chấm phẩy ;. Mặc dù bộ công cụ khiêm tốn này, xoăn có nghĩa đen có thể đại diện cho bất kỳ số nguyên không âm nào. Tuy nhiên, định dạng hơi khó đọc đối với người không quen biết, vì vậy hãy viết một số mã để thực hiện chuyển đổi cho chúng tôi.

Định dạng số

Số xoăn được cấu trúc theo các quy tắc sau:

1. Thêm một dấu chấm phẩy thêm một vào số.
2. Một số được bao quanh trong dấu ngoặc nhọn được nhân với bốn.
3. Các nhóm giằng xoăn có thể được lồng nhưng không được nối. Niềng răng phải phù hợp.
4. Dấu chấm phẩy bên ngoài một bộ dấu ngoặc nhọn phải đến sau chứ không phải trước đó.
5. Để tránh sự mơ hồ trong phân tích cú pháp, một số phải luôn bắt đầu bằng dấu ngoặc nhọn.

Vài ví dụ:

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

(Lưu ý rằng quy tắc 5 có nghĩa là các số từ 0 đến 3 phải bắt đầu bằng một cặp dấu ngoặc nhọn trống.)

Và một số ví dụ không hợp lệ:

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

Đây là một ngữ pháp BNF cho các số xoăn:

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

Các số như {;;;;}(hơn 3 dấu chấm phẩy liên tiếp) hoặc {{};}(các nhóm nẹp trống không cần thiết) được gọi là các số xoăn không đúng . Chúng tuân theo ngữ pháp trên và có thể được đánh giá theo cách thông thường, nhưng chúng cũng có khả năng biểu diễn ngắn hơn (đối với các ví dụ trên {{;}}và {;}tương ứng).

Các thách thức

Viết chương trình hoặc hàm nhập / nhận chuỗi. Nếu chuỗi là một số thập phân số nguyên dương, sản lượng / trả lại đúng (tức là ngắn nhất có thể) đại diện cho Quăn số nguyên đó. Nếu chuỗi là một số xoăn, xuất / trả về biểu diễn thập phân của nó.

Đầu vào có thể được nhận thông qua STDIN, đối số dòng lệnh hoặc tham số hàm. Nó phải là một chuỗi; nghĩa là, bạn không được viết hàm chấp nhận chuỗi cho số Quăn mà là số nguyên cho số thập phân.

Đầu ra có thể được in ra STDOUT hoặc trả về từ hàm. Một hàm có thể trả về một số nguyên khi thích hợp hoặc nó có thể trả về các chuỗi trong mọi tình huống.

Chương trình của bạn không phải xử lý đầu vào xấu (Số xoăn phá vỡ quy tắc định dạng, số dấu phẩy động, số nguyên âm, văn bản ngẫu nhiên) và không bắt buộc phải xử lý số Quăn không đúng (nhưng xem bên dưới). Đầu vào sẽ chỉ bao gồm các ký tự ASCII có thể in được.

Chấm điểm

Mã ngắn nhất tính bằng byte thắng. Nếu chương trình của bạn có thể làm cả hai điều sau đây:

1. xử lý chính xác các số xoăn không chính xác và
2. khi được cung cấp số xoăn, bỏ qua bất kỳ ký tự phụ nào không {};

sau đó trừ 10% từ điểm số của bạn. (Đầu vào số nguyên sẽ không bao giờ có các ký tự không liên quan, ngay cả đối với phần thưởng.)

Các trường hợp thử nghiệm

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

Đối với phần thưởng:

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

_{Lưu ý: Quăn chưa được thực hiện. Nhưng nếu câu hỏi này làm tốt, tôi có thể phát triển nó hơn nữa.}

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

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

Dùng thử trực tuyến: Trình diễn hoặc Test Suite

chỉnh sửa: Hóa ra, tôi vô tình cũng có thể xử lý Số xoăn không đúng. Không có kế hoạch gì cả. ;-)

Giải trình:

Có hai biểu thức trong mã. Số thứ nhất chuyển đổi một số thành Số xoăn và số thứ hai chuyển đổi Số xoăn thành số thông thường. .xxử lý, biểu thức được in. Nó sẽ cố gắng in biểu thức đầu tiên. Nếu có bất kỳ chữ số nào trong đầu vào, biểu thức đầu tiên sẽ thất bại (thông qua Ngoại lệ). .xbắt ngoại lệ và in cái thứ hai

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

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

Dùng thử trực tuyến: chạy mẫu | bộ kiểm tra

Làm thế nào nó hoạt động

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

Trong thực hiện này, clà chức năng đáp ứng các yêu cầu. Nó trả về một chuỗi nếu được cung cấp một số nguyên không âm làm đầu vào hoặc một số nguyên nếu được cung cấp một số xoăn làm đầu vào.

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

Boy là tôi không một mã golfer chưa = /, nhưng đó 10% đã giúp tôi ra rất nhiều khi điểm số của tôi vẫn còn hơn 1000!

Tôi có một phiên bản đầy đủ (và dài dòng) của mã này ở đây. Nó sẽ nhận ra tính hợp lệ của các số xoăn và cung cấp giao diện được lặp để nhập số để kiểm tra.

(Nhận xét chỉ để làm rõ)

Xem mã này trong hành động

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

Cảm ơn Erik Konstantopoulos vì đã giảm byte lớn! Bạn có thể nói ... anh ấy thực sự đã lấy ... byte ... ra khỏi mã của tôi ... * tự năm *

CJam, 87 byte 80.1 điểm (89 byte - 10% tiền thưởng)

Phiên bản cập nhật đủ điều kiện nhận thưởng trong khi tăng thêm 2 byte:

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

Dùng thử trực tuyến

Lần đầu tiên tôi sử dụng đệ quy trong CJam! Toàn bộ mọi thứ có thể trông dài dòng, nhưng hai chuyển đổi hoàn toàn riêng biệt cộng lại.

Tôi đã sử dụng một trường hợp hoàn toàn riêng biệt để chuyển đổi các số nhỏ hơn 4 thành Quăn. Có lẽ có thể tránh điều đó, nhưng việc xử lý trường hợp đặc biệt thành hàm đệ quy sẽ không hoàn toàn tầm thường. Và việc thêm phần bổ sung {}như một bước xử lý hậu kỳ thực sự không tốt hơn chút nào, mặc dù tôi nên thử lại nếu nó có thể ngắn hơn một chút.

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

Điều này không xác nhận và chỉ tìm kiếm ;và các }ký tự. Nó giả định tất cả các {nhân vật đến trước bất kỳ ;nhân vật. Điều khó nhất tôi tìm thấy là không chèn một chữ số {}vào giữa số Quăn.

Ngắt dòng và thụt lề cho rõ ràng:

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

Đây là chương trình hoàn chỉnh được viết bằng 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));}}}

Tôi chắc rằng nó có thể ngắn hơn nhiều nhưng tôi không thể có nhiều thời gian để tối ưu hóa nó

GNU sed, 330 326 - 10% = 293.4

(Tôi đã thêm một lần cho việc sử dụng -rtrước khi nhận 10% tiền thưởng; tôi hy vọng điều đó đúng)

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

Phiên bản đầy đủ cho thấy hầu hết các phần trên là chuyển đổi giữa thập phân và đơn nguyên:

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

Đây có thể không phải là câu trả lời ngắn nhất của Perl, nhưng tôi nghĩ nó đủ thú vị để đăng (đầu vào $_, đầu ra là giá trị trả về):

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

Chúng tôi quan sát rằng xoăn chỉ đơn giản là ký hiệu bậc bốn (cơ sở-4). Chúng tôi hơi bị cản trở bởi sự thiếu hỗ trợ bản địa của Perl cho bộ tứ, nhưng may mắn thay, mỗi bộ tứ là hai bit trong nhị phân, và chúng tôi có thể đọc và viết nhị phân. Vì vậy, chúng tôi có những điều sau đây:

1. Quăn thành thập phân: chuyển đổi mỗi chữ số Quăn thành 2 chữ số nhị phân, nối và chuyển đổi thành số thập phân
2. Số thập phân thành xoăn: in số ở dạng nhị phân (buộc một số chữ số chẵn), sau đó chuyển đổi từng cặp bit thành xoăn.

Phiên bản mở rộng

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

Kiểm tra chạy đoạn mã dưới đây

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>

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

Sử dụng đệ quy để chuyển đổi thập phân thành dạng xoăn. Loại bỏ kiểm tra để bỏ qua các ký tự bên ngoài /[;{}]/làm tăng điểm số 0.4tại thời điểm này.

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 byte - 10% + 1 tiền phạt)

$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 giải quyết các curlies.
Việc tạo ra các curlies được thực hiện khác nhau.

Kiểm tra

Tệp kiểm tra cũng chứa các trường hợp tiền thưởng

$ 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

Võng mạc , 69 64 byte

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

Dùng thử Test Suite

Giải trình

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

Phân hủy các niềng răng trong cùng để chỉ ;s. Vòng lặp cho đến khi không còn niềng răng.

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

Chuyển đổi giữa thập phân và đơn nguyên ;

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

Tìm lần chạy dài nhất trong số ;đó là bội số của 4 và lồng vào các dấu ngoặc, lặp cho đến khi không còn tồn tại 4+ nữa.

^;|^$
{}$&

Nếu số xoăn kết quả bắt đầu bằng ;hoặc là chuỗi rỗng, hãy thêm {}vào phía trước.

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

Hãy thử trực tuyến!

Một câu trả lời Python 2 được đánh gôn nhiều hơn để xử lý các trường hợp tiền thưởng. Không muốn đăng bài viết chết với nhận xét này, vì vậy đây là.

Nó hoạt động từ bên trong trong các số xoăn, thêm 4 ^ (số dấu ngoặc nhọn kết thúc còn lại trong chuỗi) vào tổng cho mỗi dấu chấm phẩy được tìm thấy. Nếu chuỗi là một số, thì nó đệ quy tạo ra số xoăn theo cách tương tự như ngữ pháp được cung cấp.