Pythは、Pythonに基づいたゴルフ言語です。プレフィックス表記を使用し、各コマンドは異なるアリティ（受け入れる引数の数）を持ちます。

あなたの仕事は、（存在しない）Pythライクな言語Pithの構文チェッカーを書くことです。

髄の構文

Pithには8つの単一文字コマンドしかありません。

01234()"

01234それぞれが対応する数のアリティを持っているため、その後に多くの引数が必要です。例えば、

正しい髄プログラムがあるためである4四つの引数が続いている0 0 0と10されたのは、最後の1単一の引数が続きます0。これを視覚化するために、次のツリーを見ることができます。

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

どこRがルートノードです。これについて考える別の方法は、各数値が、対応するノードが上のツリーに持つ子の数を指すということです。

次に、複数のベースコマンドを使用した別の有効なPithプログラムを示します。

対応する

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

一方、

3120102100

イニシャルには2つの引数しかないため、正しい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は1つの引数（無制限）のみを受け取るためです。

最後に、"文字列を開始および終了します。これは常に0アリティであり、単一の引数としてカウントされます。たとえば、

2"010""44)()4"

これは、22つの文字列引数が渡されるだけです"010"と"44)()4"です。無制限のように、文字列も空である可能性があり、プログラムの終了までに閉じられていない文字列は自動的に閉じられます。

^{*この部分は実際には、元のPyth異なるないような場合には何かを1) 1-アリティを終了し、エラーを発生させます。}

入出力

入力は、文字のみで構成される単一の空でない文字列になります 01234()"。オプションで、追加の末尾の改行が常に存在すると想定できます。このチャレンジのために関数または完全なプログラムを書くことができます。

入力が構文的に有効なPithである場合は真偽値を出力し、そうでない場合は偽の値を出力する必要があります。真実と偽の値は修正する必要がある1ため、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(""))

— Sp3000
ソース

20100100のツリーは（最初の無制限の例では）あり[( [2 [0] [1 [0] ] ] [0] [1 [0]] [0] ]ませんか？あなたが持っているものには、2、0、0、1、および0のブランチがあります-2番目のブランチはそこにあるべきではありません。

— bcsb1001

@ bcsb1001ありがとう、訂正。無制限は4を超えることができることを示したかったです。

— Sp300015年

@Ypnypn複数のルートを持つことが有効であると言うテストケースがあります

— オプティマイザー

テストケースを追加してください())2)1))0"3())"))（これは正しいと思います）。

— -n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

@ n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳が追加されました-それは確かに本当です（基本的()210""に多くのノーオペレーションがあるため）

— -Sp3000

12

CJam、65バイト

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

まあ、私はCJamに正規表現があればいいのですが、これは50バイト未満で完了できたはずです

主なアイデアは、0つまり、10to 0、200to 0などへと物を減らし続けることです。それが完了したら、一致したすべての括弧を0、つまり()to 0、(0)to 0、(00)to 0などに減らします。サイクルL時間を繰り返しLます。ここで、は入力長です。

入力文字列は最初に追加の処理を経て、不一致を調整し、不一致を補うために"多くを追加します)(

これにより、すべての反復の後、文字列にのみ0（および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";

こちらからオンラインで試すか、スイート全体を実行してください

— オプティマイザ
ソース

11

正規表現、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))?。

— ジミー23013
ソース

(?2)*(()(?1))?私が探していた最後のパズルのピースです。素敵な発見！;）

— マーティン・エンダー

私が理解していれば(?2)*(()(?1))?、正しく一部を、(()(?1))?部分があるため、何も一致したことがない(?2)*すべてのものまで、すでに食べる(()(?1))?一致させることができ、そしてこの構造は、我々が入力したときに、グループ3のキャプチャ設定するために使用され(、我々は外にいるときと解除キャプチャグループ3 ()構造のマッチングを可能にするために（ペアリングされていない)）。

— n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

4

lex、182バイト（157 w固定サイズスタック）

これらのプログラムでは、入力が有効な文字の単一の改行で終わる文字列である必要があります。

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

上記のプログラムは、メモリが不足するとセグメンテーション違反になります。 (。しかし、セグメンテーション違反は失敗としてカウントされるので、問題の説明ではリソースが十分でない場合の対処方法を説明していませんが、それを「偽」と見なしています。

固定サイズのスタックを使用して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

— リチ
ソース

私はもう少し明確にすべきだったと思います-改行は決して存在しないか、常に存在すると仮定できます。それは役立ちますか？

— Sp3000

固定サイズのスタックプログラムを使用できますが、スタックのサイズを入力の長さに設定できますか？

— isaacg

@isaacg入力は標準入力なので、読み取られるまでわかりません。コマンドライン引数または文字列を使用するドライバーを簡単に作成できましたが、ゴルフには他の優先事項があります。25文字のダイナミックスタックは、Cの標準では悪くありませんが、それでもゴルフができると確信しています。

— リチ

4

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                                       .

これは、入力を1回実行し、ゼロより大きい数をスタックにプッシュし、ゼロが処理されるとそれらをデクリメントします。無制限は-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

Cの次のコードをPOSIXシステムのGCCで使用してテストできます。

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

— es1024
ソース

3

Python 2、353バイト

解析関数は、トークンを1つずつステップ実行し、プログラム構造のツリーを構築します。無効なプログラムは例外をトリガーし、ゼロ（偽）が出力されます。そうでない場合、解析が成功すると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

— ロジックナイト
ソース

例外の素晴らしい（ab）使用！==テストでオペランドの順序を入れ替えることで、いくつかのスペースを節約できますif')'==q。最初に文字列を入力すると、実行できます。breakステートメントの1つをに置き換えることができると信じています。これf=0により、while fループから抜け出すことができます。最後に、代わりにassert x==yあなたが使用することができる1/(x==y)ためZeroDivisionError。;）

— DLosc

@DLosc、非常に役立つゴルフのヒントをありがとう。もし私がゴルフ大会のリーダーであったなら、あなたのアイデアを使って競争するでしょう。私のエントリは競争力のある（ゴルフに関して）にはほど遠いので、私はそれをほとんど読みやすい例として残したいです。将来の使用のためにあなたの巧妙なテクニックに注意しました;-)

— ロジックナイト

1

ピップ、88 72バイト

オプティマイザーの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"] 'b提供しますababdaba例えば、。zここでこの機能をうまく利用しています。
Pipの偽の値に空の文字列が含まれています ""、空のリスト[]、ゼロのスカラーが含まれます。したがって、0はfalseですが、0.0and も"0000000"です。この機能は不便な場合があります（文字列が空かどうかをテストするに"0"は、falseであるためその長さをテストする必要があります）が、この問題に対しては完璧です。

— DLosc
ソース

1

Javascriptを（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,""))

— SuperJedi224
ソース

基本的なPythのような構文チェッカー