난해한 프로그래밍 언어 Curly에서 프로그램은 중괄호 {}와 세미콜론 으로 만 구성됩니다 ;. 이 겸손한 툴셋에도 불구하고 Curly에는 음이 아닌 정수를 나타낼 수있는 리터럴이 있습니다. 그러나이 형식은 처음에는 읽기가 약간 어렵 기 때문에 변환을위한 코드를 작성해 보겠습니다.

숫자 형식

곱슬 번호는 다음 규칙에 따라 구성됩니다.

1. 세미콜론을 추가하면 숫자에 1이 추가됩니다.
2. 중괄호로 묶은 숫자에 4를 곱합니다.
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 개 이상 세미콜론) 또는 {{};}(불필요한 빈 괄호 그룹)이라고합니다 부적절한 곱슬 번호. 위의 문법을 따르고 일반적인 방식으로 평가할 수 있지만 더 짧은 표현도 가능합니다 (위의 예 {{;}}및 {;}각각).

도전

문자열을 입력 / 수신하는 프로그램 또는 함수를 작성하십시오. 문자열이 음이 아닌 10 진수 인 경우 해당 정수에 대한 적절한 (가장 짧은) 곱슬 표현을 출력 / 반환합니다 . 문자열이 곱슬 번호 인 경우 10 진수 표현을 출력 / 반환합니다.

STDIN, 명령 줄 인수 또는 함수 매개 변수를 통해 입력을 받을 수 있습니다. 그것은 해야한다 문자열이어야; 즉, Curly 숫자에는 문자열을 허용하고 10 진수에는 정수를 허용하는 함수를 작성할 수 없습니다.

출력 은 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

_{참고 : Curly는 아직 구현되지 않았습니다. 그러나이 질문이 잘되면 더 발전시킬 수 있습니다.}

Pyth, 35 32 바이트-10 % = 28.8

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

온라인으로 사용해보십시오 : 데모 또는 테스트 스위트

편집 : 밝혀 졌을 때 실수로 부적절한 곱슬 번호를 처리 할 수도 있습니다. 전혀 계획되지 않았습니다. ;-)

설명:

코드에는 두 가지 표현식이 있습니다. 첫 번째는 숫자를 Curly Number로 변환하고 두 번째는 Curly Number를 일반 숫자로 변환합니다. .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 바이트

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#

파이썬 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 때!

이 코드의 완전하고 자세한 버전이 있습니다. 곱슬 번호의 유효성을 인식하고 테스트를 위해 숫자를 입력 할 수있는 반복 인터페이스를 제공합니다.

(설명을 위해 코멘트)

이 코드를 실제로보십시오

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에게 감사드립니다! 당신은 말할 수 ... 그는 정말 ... 바이트 ... 내 코드에서 ... * 자기 다섯 *

CJam, 87 바이트 80.1 점 (89 바이트-10 % 보너스)

2 바이트 씩 증가하면서 보너스를받을 수있는 업데이트 버전 :

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

온라인으로 사용해보십시오

CJam에서 재귀를 처음 사용했습니다! 모든 것이 다소 길어 보일 수 있지만 완전히 별개의 전환 두 개가 더해집니다.

4보다 작은 숫자를 Curly로 변환하기 위해 완전히 별도의 대소 문자를 사용했습니다. 아마도 피할 수는 있지만 특수 사례 처리를 재귀 함수로 접는 것이 결코 쉬운 것은 아닙니다. 그리고 {}후 처리 단계로 추가를 추가하는 것은 조금 더 짧아도 다시 시도해야하지만 실제로 더 좋아 보이지는 않습니다.

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

이에 대한 유효성 검사 만 외모하지 않습니다 ;및 }문자. 모든 {문자가 모든 문자보다 먼저 나오는 것으로 가정합니다 ;. 내가 찾은 가장 어려운 것은 {}곱슬 번호의 중간에를 삽입하지 않는 것 입니다.

명확성을 위해 줄 바꿈 및 들여 쓰기 :

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

펄, 183 177

이것은 가장 짧은 펄 답변이 아닐 수도 있지만 게시하기에 충분히 흥미 롭습니다 (입력 $_, 반환 값으로 출력).

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

Curly는 단순히 4 차 (base-4) 표기법이라는 것을 알 수 있습니다. 우리는 Perl의 4 차 지원에 대한 기본 지원 부족으로 약간 방해를 받지만 운 좋게도 각 quaternit은 2 비트의 2 비트이며 바이너리를 읽고 쓸 수 있습니다. 그래서 우리는 다음을 가지고 있습니다 :

1. Curly to decimal : 각 곱슬 자리를 2 개의 이진수로 변환하고 연결하고 10 진수로 변환
2. 십진수를 꼬기 : 숫자를 이진수로 인쇄하고 (짝수 자릿수를 강제) 각 비트 쌍을 꼬부라기로 변환합니다.

확장 버전

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

자바 스크립트 (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 ( %)

재귀를 사용하여 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"})}

펄 5, 154 ( 185170 바이트-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

정규식 및 평가는 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

십진수와 단항 간 변환 ;

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

그 중 가장 긴 런 ;을 찾으면 4의 배수이며 중괄호에 중첩되어 더 이상 4 이상의 런이 없을 때까지 반복하십시오.

^;|^$
{}$&

결과 곱슬 번호가 시작 ;하거나 빈 문자열 인 경우 {}앞에 추가하십시오 .

파이썬 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 답변. 이것을 코멘트로 죽은 게시물을 괴롭 히고 싶지 않았으므로 여기에 있습니다.

내부에서 중괄호로 작동하며 발견 된 각 세미콜론의 합계에 4 ^ (문자열에 남은 중괄호 수)를 추가합니다. 문자열이 숫자 인 경우 제공된 문법과 같은 방식으로 중괄호를 재귀 적으로 만듭니다.