Pyth 는 Python 기반의 골프 언어입니다. 접두사 표기법을 사용하며 각 명령에는 다른 arity (수용 가능한 인수 수)가 있습니다.

당신의 임무는 존재하지 않는 Pyth와 같은 언어 Pith에 대한 구문 검사기를 작성하는 것입니다.

피스의 문법

Pith에는 8 개의 단일 문자 명령 만 있습니다.

01234()"

01234각각은 해당 숫자의 arity를 ​​가지므로 많은 인수가 필요합니다. 예를 들어

400010

4뒤에는 네 개의 인수가 0 0 0있고 10마지막 1인수는 단일 인수 가 있기 때문에 올바른 Pith 프로그램 0입니다. 이를 시각화하기 위해 다음 트리를 볼 수 있습니다.

      R
      |
      4
      |
-------------
|   |   |   |
0   0   0   1
            |
            0

R루트 노드는 어디에 있습니까 ? 이것을 생각하는 다른 방법은 각 숫자는 해당 노드가 위의 트리에있는 자식의 수를 나타냅니다.

하나 이상의 기본 명령을 가진 또 다른 유효한 Pith 프로그램이 있습니다.

210010

에 해당하는

           R
           |
     -------------
     |           |
     2           1
     |           |
 ---------       0
 |       |
 1       0
 |
 0

반면에

3120102100

초기 에는 두 개의 인수 만 있기 때문에 올바른 Pith 프로그램 이 아닙니다 . 3아래 트리를 보면 알 수 있습니다.

                R
                |
                3
                |
     ------------------------ ??
     |          |
     1          2
     |          |
     2        ------
     |        |    |
   ------     1    0
   |    |     |
   0    1     0
        |
        0

다음 (은 무제한을 시작하고 무제한을 )종료합니다. 무제한은 많은 수의 인수를 취하고 (부정적으로) 모든 상위 명령에 대한 단일 인수로 계산됩니다. 프로그램이 끝날 때까지 열려있는 모든 제한은 자동으로 닫힙니다. )더 unboundeds가 열려없는 경우 명령이 오류가 아닙니다 - 그냥 아무것도하지 않는다 *.

예를 들어, Pith 프로그램

)31(0)0(201000100

나무에 해당

            R
            |
            3
            |
    ------------------------------
    |       |                    |
    1       0                    (
    |                            |
    (              -----------------------------
    |              |      |      |      |      |
    0              2      0      0      1      0
                   |                    |
                -------                 0
                |     |
                0     1
                      |
                      0

빈 무제한은 괜찮습니다 (). 유효한 Pith 프로그램도 마찬가지 입니다.

제한이없는 잘못된 Pith 프로그램은

12(010

2하나만 인수를받지 않기 때문에 (무한한).

마지막으로 "문자열을 시작하고 종료합니다. 문자열은 항상 0 개이며 단일 인수로 계산됩니다. 예 :

2"010""44)()4"

이는 단지입니다 2두 개의 문자열 인수를 전달되는 "010"과 "44)()4". 언 바운드와 마찬가지로 문자열도 비어있을 수 있으며 프로그램 끝의 닫히지 않은 문자열은 자동으로 닫힙니다.

^{*이 부분은 실제로 원래 Pyth 다른 수행 과 같은 경우에 무언가를 1)1-인수에 대응을 종료하고 오류를 제기.}

입출력

입력은 문자만으로 구성된 비어 있지 않은 단일 문자열 01234()"입니다. 선택적으로 추가 후행 줄 바꿈이 항상 있다고 가정 할 수 있습니다. 이 도전에 대한 기능이나 전체 프로그램을 작성할 수 있습니다.

입력이 구문 상 유효한 Pith이면 참 값을, 그렇지 않으면 거짓 값을 출력해야합니다. 진실과 허위 값은 고정되어야하므로 1하나의 유효한 프로그램과 2다른 프로그램에 대해 출력 할 수 없습니다 .

채점

이것은 코드 골프이므로 가장 적은 바이트의 코드가 이깁니다.

테스트 사례

진실한 :

0
)
(
"
()
""
10
400010
210010
("")00
3"""""
(0)))0)1)0
2(2(2(0)0)0)0
2"010""44)()4"
)31(0)0(201000100
())2)1))0"3())"))
3("4321("301(0)21100"4")"123"00)40"121"31000""01010

거짓 :

1
1(310
(1)0)
12(010
4"00010"
3120102100
20(2((0)(0)))
2(2(2(0)0)0)01)
4(0102)00)00000
2"00"("00"2(""))

CJam, 65 바이트

q'"/La+2%{0s*}:Z~_,:L')*+{L{4{)_Z+s/Z}/L{'(\Z')++/Z}/}*')-}2*0s-!

이봐, CJam에 정규식이 있었으면 좋겠다.

주요 아이디어에 물건을 줄여 유지하는 것입니다 0즉, 10에 0, 200에 0등등. 이 작업이 완료되면, 우리는 모든 일치하는 괄호 감소 0, 즉, ()에 0, (0)에 0, (00)에 0등을. 입력 L시간 은 사이클 시간 을 반복합니다 L.

입력 문자열은 처음에 추가 처리를 수행하여 일치하지 않는 것을 조정하고 일치하지 않는 것을 보완하기 위해 "많은 것을 추가 )합니다.(

이렇게하면 모든 반복 후에 문자열에 0(및 no-op )) 만 남아 있어야합니다.

업데이트-최상위 )no-op가 유해한 것으로 간주 되는 버그가 수정되었습니다.

코드 확장

q'"/La+2%{0s*}:Z~_,:L')*      "Part 1 - Preprocessing";
q'"/                          "Read the input and split it on quote";
    La+                       "Add an extra empty array to the split array to compensate";
                              "for unmatched ending quote";
        2%                    "Take every other splitted part, ignoring the contents";
                              "of the strings in the code";
          {0s*}:Z~            "Join the parts by string 0. Also create a function Z";
                              "that does that for future use. We are now done with";
                              "reducing "XYZ" to 0 ";
                  _,:L        "Store the length of the remaining code in L";
                      ')*     "Append L ) to the string to compensate for unmatched (";

{L{4{)_Z+s/Z}/L{'(\Z')++/Z}/}*')-}2*   "Part 2 - the reducing loop";
 L{                         }*         "Run the reduction logic L times";
   4{)_Z+s/Z}/                         "Part 2a - reducing arities";
   4{       }/                         "Run the iteration for 0, 1, 2 and 3";
     )_                                "Increment the iteration number and make a copy";
       Z+s                             "Get that many 0 and append it to the number";
          /Z                           "Split the code onto this number and convert it";
                                       "to 0. This successfully reduces 10, 200, ";
                                       "3000 and 4000 to 0";
              L{'(\Z')++/Z}/           "Part 2b - reducing groups";
              L{          }/           "Run the iteration for 0 through L - 1";
                '(\Z')++               "Get the string '(<iteration number of 0>)'";
                        /Z             "split on it and join by 0. This successfully";
                                       "reduces (), (0), (00) and so on .. to 0";
                              ')-      "After running the part 2 loop L times, all";
                                       "reducible arities and brackets should be reduced";
                                       "except for cases like '30)00' where the no-op )";
                                       "breaks the flow. So we remove ) from the code";
                                       "and run Part 2 L times again";

0s-!                          "Now, if the code was valid, we should only have 0 in the";
                              "remaining code. If not, the code was invalid";

여기에서 온라인으로 시도 하거나 전체 제품군을 실행하십시오.

정규식, PCRE 플레이버, 83 바이트

^(?3)*\)*$(()((?(2)|\)*)(\((?1)*(\)|$)|0|"[^"]*.?|(1|(2|(3|4(?3))(?3))(?3))(?3))))?

여기에서 시도하십시오.

정규식, PCRE 플레이버, 85 바이트

^((?(3)|\)*)(?>\((?2)*(()(?1))?(\)|$)|0|"[^"]*.?|(1|(2|(3|4(?1))(?1))(?1))(?1)))*\)*$

여기에서 시도하십시오.

이 dan1111의 답변 에서 몇 가지 아이디어를 사용했습니다 .

에 대한 설명이(?2)*(()(?1))? 있습니다.

lex, 182 바이트 (157w 고정 크기 스택)

이러한 프로그램은 입력이 단일 개행으로 끝나는 유효한 문자 스트링이어야합니다.

%%
 int n=0,s=0,*t=0;
[0-4] n+=*yytext-48-!!n;
\( (t=realloc(t,(s+1)*sizeof n))[s++]=n-!!n;n=0;
\) if(s&&n)exit(1);s&&(n=t[--s]);
\"[^"]*.? n-=!!n;
\n while(s)t[--s]&&n++;exit(!!n);

위의 프로그램은 메모리가 부족할 경우 segfault가 될 것 (입니다. 이론적으로 충분히 주면 발생할 수 있습니다 . 그러나 segfault는 실패로 간주되므로 문제 설명에서 리소스가 충분하지 않으면 어떻게해야하는지 말하지는 않지만이를 "거짓"으로 간주합니다.

고정 크기 스택을 사용하여 157 바이트를 줄 였지만 부정 행위처럼 보였습니다.

%%
 int n=0,s=0,t[9999];
[0-4] n+=*yytext-48-!!n;
\( t[s++]=n-!!n;n=0;
\) if(s&&n)exit(1);s&&(n=t[--s]);
\"[^"]*.? n-=!!n;
\n while(s)t[--s]&&n++;exit(!!n);

컴파일하기:

flex -o pith.c pith.l    # pith.l is the above file
c99 -o pith pith.c -lfl

테스트:

while IFS= read -r test; do
  printf %-78s "$test"
  if ./pith <<<"$test"; then echo "OK"; else echo "NO"; fi
done <<EOT
0
)
(
"
()
""
10
400010
210010
("")00
3"""""
2(2(2(0)0)0)0
2"010""44)()4"
)31(0)0(201000100
3("4321("301(0)21100"4")"123"00)40"121"31000""01010
1
1(310
12(010
4"00010"
3120102100
20(2((0)(0)))
2(2(2(0)0)0)01)
4(0102)00)00000
2"00"("00"2(""))
EOT

테스트 출력 :

0                                                                             OK
)                                                                             OK
(                                                                             OK
"                                                                             OK
()                                                                            OK
""                                                                            OK
10                                                                            OK
400010                                                                        OK
210010                                                                        OK
("")00                                                                        OK
3"""""                                                                        OK
2(2(2(0)0)0)0                                                                 OK
2"010""44)()4"                                                                OK
)31(0)0(201000100                                                             OK
3("4321("301(0)21100"4")"123"00)40"121"31000""01010                           OK
1                                                                             NO
1(310                                                                         NO
12(010                                                                        NO
4"00010"                                                                      NO
3120102100                                                                    NO
20(2((0)(0)))                                                                 NO
2(2(2(0)0)0)01)                                                               NO
4(0102)00)00000                                                               NO
2"00"("00"2(""))                                                              NO

80386 어셈블러, 97 바이트

육각 덤프 :

0000000: 8b54 2404 5589 e531 c96a ff8a 022c 303c  .T$.U..1.j...,0<
0000010: f275 04f6 d530 c084 ed75 263c f875 0141  .u...0...u&<.u.A
0000020: 3cf9 750f 84c9 7419 4958 3c00 7c03 50eb  <.u...t.IX<.|.P.
0000030: 2430 c084 c075 0958 483c ff7f 0140 ebf3  $0...u.XH<...@..
0000040: 5042 8a02 84c0 75c5 4a84 edb0 2275 be84  PB....u.J..."u..
0000050: c9b0 2975 b85a 31c0 39e5 7501 4089 ec5d  ..)u.Z1.9.u.@..]
0000060: c3                                       .

이것은 입력을 한 번 실행하여 0보다 큰 숫자를 스택으로 푸시하고 0이 처리되면 감소합니다. 무제한은 -1로 처리됩니다.

함수 프로토 타입 (C) (유효하지 않은 경우 함수는 0을, 유효하면 1을 리턴합니다) :

int __cdecl test(char *in);

동등한 어셈블리 (NASM) :

bits 32
; get input pointer into edx
mov edx, [esp+4]                ; 8B 54 24 04

; save ebp; set ebp = esp
push ebp                        ; 55
mov ebp, esp                    ; 89 E5

; clear ecx
xor ecx, ecx                    ; 31 C9

; push base -1
push byte(-1)                   ; 6A FF

; get top char
mov al, [edx]                   ; 8A 02

    sub al, 0x30                ; 2C 30

    ; if al == quote
    cmp al, 0xF2                ; 3C F2
    jne $+6                     ; 75 04
        ; set ch (in quote?) to opposite
        not ch                  ; F6 D5
        ; set value to 0
        xor al, al              ; 30 C0

    ; if in quote, continue
    test ch, ch                 ; 84 ED
    jnz $+40                    ; 75 26

    cmp al, 0xF8                ; 3C F8
    jne $+3                     ; 75 01
        ; increment cl=depth
        inc ecx                 ; 41

    cmp al, 0xF9                ; 3C F9
    jne $+17                    ; 75 0F
        ; check depth = 0
        test cl, cl             ; 84 C9
        jz $+27                 ; 74 19
        ; decrement cl=depth
        dec ecx                 ; 49
        ; pop and check -1
        pop eax                 ; 58
        cmp al, 0               ; 3C 00
        jl $+5                  ; 7C 03
            push eax            ; 50
            jmp $+38            ; EB 24
        xor al, al              ; 30 C0

    test al, al                 ; 84 C0
    jnz $+11                    ; 75 09
        pop eax                 ; 58
        dec eax                 ; 48
        cmp al, -1              ; 3C FF
        jg $+3                  ; 7F 01
            inc eax             ; 40
        jmp $-11                ; EB F3
    push eax                    ; 50

    inc edx                     ; 42
    mov al, [edx]               ; 8A 02
    test al, al                 ; 84 C0
    jnz $-57                    ; 75 C5

    dec edx                     ; 4A

    ; in quote?
    test ch, ch                 ; 84 ED
    mov al, 0x22                ; B0 22
    jnz $-64                    ; 75 BE

    ; depth not zero?
    test cl, cl                 ; 84 C9
    mov al, 0x29                ; B0 29
    jnz $-70                    ; 75 B8

; pop base -1
pop edx                         ; 5A

; set return value based on ebp/esp comparison
xor eax, eax                    ; 31 C0
cmp ebp, esp                    ; 39 E5
jne $+3                         ; 75 01
inc eax                         ; 40
; restore esp
mov esp, ebp                    ; 89 EC
; restore ebp
pop ebp                         ; 5D
; return
ret                             ; C3

POSIX 시스템에서 GCC와 함께 C의 다음 코드를 사용하여 테스트 할 수 있습니다.

#include <sys/mman.h>
#include <stdio.h>
#include <string.h>

int main(){
    char code[] = {
        0x8b, 0x54, 0x24, 0x04, 0x55, 0x89, 0xe5, 0x31, 0xc9, 0x6a, 0xff,
        0x8a, 0x02, 0x2c, 0x30, 0x3c, 0xf2, 0x75, 0x04, 0xf6, 0xd5, 0x30, 
        0xc0, 0x84, 0xed, 0x75, 0x26, 0x3c, 0xf8, 0x75, 0x01, 0x41, 0x3c, 
        0xf9, 0x75, 0x0f, 0x84, 0xc9, 0x74, 0x19, 0x49, 0x58, 0x3c, 0x00, 
        0x7c, 0x03, 0x50, 0xeb, 0x24, 0x30, 0xc0, 0x84, 0xc0, 0x75, 0x09, 
        0x58, 0x48, 0x3c, 0xff, 0x7f, 0x01, 0x40, 0xeb, 0xf3, 0x50, 0x42, 
        0x8a, 0x02, 0x84, 0xc0, 0x75, 0xc5, 0x4a, 0x84, 0xed, 0xb0, 0x22, 
        0x75, 0xbe, 0x84, 0xc9, 0xb0, 0x29, 0x75, 0xb8, 0x5a, 0x31, 0xc0, 
        0x39, 0xe5, 0x75, 0x01, 0x40, 0x89, 0xec, 0x5d, 0xc3,
    };
    void *mem = mmap(0, sizeof(code), PROT_WRITE|PROT_EXEC, MAP_ANON|MAP_PRIVATE, -1, 0);
    memcpy(mem, code, sizeof(code));
    int __cdecl (*test)(char *) = (int __cdecl (*)(char *)) mem;

    #define TRY(s) printf(s ": %d\n", test(s))

    printf("Truthy tests:\n");
    TRY("0");
    TRY(")");
    TRY("(");
    TRY("\"");
    TRY("()");
    TRY("\"\"");
    TRY("10");
    TRY("400010");
    TRY("210010");
    TRY("(\"\")00");
    TRY("3\"\"\"\"\"");
    TRY("(0)))0)1)0");
    TRY("2(2(2(0)0)0)0");
    TRY("2\"010\"\"44)()4\"");
    TRY(")31(0)0(201000100");
    TRY("())2)1))0\"3())\"))");
    TRY("3(\"4321(\"301(0)21100\"4\")\"123\"00)40\"121\"31000\"\"01010");

    printf("\nFalsy tests:\n");
    TRY("1");
    TRY("1(310");
    TRY("(1)0)");
    TRY("12(010");
    TRY("4\"00010\"");
    TRY("3120102100");
    TRY("20(2((0)(0)))");
    TRY("2(2(2(0)0)0)01)");
    TRY("4(0102)00)00000");
    TRY("2\"00\"(\"00\"2(\"\"))");

    munmap(mem, sizeof(code));
    return 0;
}

파이썬 2, 353 바이트

구문 분석 기능은 한 번에 하나씩 토큰을 단계별로 실행하고 프로그램 구조의 트리를 작성합니다. 유효하지 않은 프로그램은 예외를 트리거하여 0 (거짓)을 인쇄합니다. 그렇지 않으면 구문 분석에 성공하면 1이됩니다.

def h(f,k=0):
 b=[]
 if k:
  while f:b+=[h(f)]
  return b
 q=f.pop(0)
 if q==')':return[]
 elif q=='"':
  while f:
   q+=f.pop(0)
   if q[-1]=='"':break
 elif q=='(':
  while f:
   if f and f[0]==')':f.pop(0);break
   b+=h(f)
 else:
  for i in range(int(q)):b+=h(f)
  assert len(b)==int(q)
 return[[q,b]]
try:h(list(raw_input()));r=1
except:r=0
print r

파서 출력을 보여주는 테스트 출력 :

------------------------------------------------------------
True: 0
    0

------------------------------------------------------------
True: )

------------------------------------------------------------
True: (
    (

------------------------------------------------------------
True: "
    "

------------------------------------------------------------
True: ()
    (

------------------------------------------------------------
True: ""
    ""

------------------------------------------------------------
True: 10
    1
        0

------------------------------------------------------------
True: 400010
    4
        0
        0
        0
        1
            0

------------------------------------------------------------
True: 210010
    2
        1
            0
        0
    1
        0

------------------------------------------------------------
True: ("")00
    (
        ""
    0
    0

------------------------------------------------------------
True: 3"""""
    3
        ""
        ""
        "

------------------------------------------------------------
True: 2(2(2(0)0)0)0
    2
        (
            2
                (
                    2
                        (
                            0
                        0
                0
        0

------------------------------------------------------------
True: 2"010""44)()4"
    2
        "010"
        "44)()4"

------------------------------------------------------------
True: )31(0)0(201000100
    3
        1
            (
                0
        0
        (
            2
                0
                1
                    0
            0
            0
            1
                0
            0

------------------------------------------------------------
True: 3("4321("301(0)21100"4")"123"00)40"121"31000""01010
    3
        (
            "4321("
            3
                0
                1
                    (
                        0
                2
                    1
                        1
                            0
                    0
            "4"
        "123"
        0
    0
    4
        0
        "121"
        3
            1
                0
            0
            0
        ""
    0
    1
        0
    1
        0

------------------------------------------------------------
False: 1
0
------------------------------------------------------------
False: 1(310
0
------------------------------------------------------------
False: 12(010
0
------------------------------------------------------------
False: 4"00010"
0
------------------------------------------------------------
False: 3120102100
0
------------------------------------------------------------
False: 20(2((0)(0)))
0
------------------------------------------------------------
False: 2(2(2(0)0)0)01)
0
------------------------------------------------------------
False: 4(0102)00)00000
0
------------------------------------------------------------
False: 2"00"("00"2(""))
0

축소 기 앞의 코드 :

def parse(tokens, first=False):
    toklist = []
    if first:
        while tokens :
            toklist += [parse(tokens)]
        return toklist
    tok = tokens.pop(0)
    if tok == ')' :
        return []
    elif tok == '"':
        while tokens:
            tok += tokens.pop(0)
            if tok[-1] == '"' :
                break
    elif tok == '(':
        while tokens:
            if tokens and tokens[0] == ')' :
                tokens.pop(0);
                break
            toklist += parse(tokens)
    else:
        for i in range(int(tok)) :
            toklist += parse(tokens)
        assert len(toklist) == int(tok)
    return [[tok, toklist]]

try :
    parse(list(raw_input()));
    r = 1
except :
    r = 0
print r

핍 , 88 72 바이트

Optimizer의 CJam 에서 가져온 아이디어 . 재귀 강하 파서와 관련된 문제에 대한 나의 원래의 찌르기는 다소 길었습니다.

Qpz:,5.iX,5AL'(.0X,#p.')p^:'"Fj,#pIj%2p@j:0p:Jpp.:')X#pL#ppR:z0!pRM')Rz0

설명과 함께 형식화 :

Qp                Query user for p
z:                Store the following list in z:
  ,5 . 0X,5         For x in range(5), concatenate x zeros to it
  AL                (append list)
  '(. 0X,#p .')     For x in range(len(p)), concatenate x zeros inside parens
p^: '"            Split p on " and assign result back to p
Fi,#p             Loop over the indices of the resulting list:
 Ii%2               If index is odd:
  p@i:0               Replace that item with 0
p: Jp             Concatenate the results and assign back to p
p.: ')X#p         Append len(p) closing parens to p
L#p               Loop len(p) times:
 pR:z0              Replace every occurrence in p of items of z with 0
! pRM')Rz0        Remove ) from result and replace z with 0 one more time; then
                  take logical negation, which will be true iff string is empty OR
                  consists only of zeros

흥미로운 속임수 :

• 많은 연산자가 목록 및 범위에서 항목별로 작업합니다. 따라서 0X,5, 예를 들어,이다 0 X [0 1 2 3 4] == ["" "0" "00" "000" "0000"].
• 며칠 전, 삼항 Replace 연산자는 예를 들어 "abracadabra" R ["br" "ca"] 'bgives ababdaba등 의 인수에 대한 목록을 가져올 수 있습니다 . z여기 에서이 기능을 잘 활용 합니다.
• Pip의 잘못된 값에는 빈 문자열 "", 빈 목록 []및 스칼라가 0입니다. 따라서, 0뿐만 아니라, 거짓 0.0과 "0000000". 이 기능은 때때로 불편합니다 (문자열이 비어 있는지 테스트하기 위해, "0"거짓으로 인해 길이를 테스트해야합니다 ).이 문제의 경우에는 완벽합니다.

자바 (ES6) 289 288 285 282 278 244 241 230 바이트

c=prompt(k="0"),j=c[l="length"];if((c.match(/"/g)||[])[l]%2)c+='"';c=c[R="replace"](/".*?"/g,k);c+=")".repeat(j);while(j--)c=c[R](/\(0*\)/,k)[R](/10/g,k)[R](/200/g,k)[R](/3000/g,k)[R](/40000/g,k);alert(!c[R](/0/g,"")[R](/\)/g,""))