Pemeriksa Sintaks Dasar Pyth-like

25

Pyth adalah bahasa golf yang didasarkan pada Python. Ini menggunakan notasi awalan, dengan setiap perintah memiliki arity yang berbeda (jumlah argumen yang diterimanya).

Tugas Anda adalah menulis pemeriksa sintaksis untuk bahasa yang mirip Pyth (tidak ada), Pith.

Sintaksis empulur

Empulur hanya memiliki 8 perintah char tunggal:

01234()"

01234masing-masing memiliki arity dari angka yang sesuai, dan karenanya mengharapkan banyak argumen setelahnya. Sebagai contoh,

400010

adalah program empulur yang benar karena 4diikuti oleh empat argumen 0 0 0dan 10, yang terakhir 1diikuti oleh argumen tunggal 0. Untuk memvisualisasikan ini, kita dapat melihat pohon berikut:

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

di mana Rsimpul root. Cara alternatif untuk memikirkan hal ini adalah bahwa setiap angka mengacu pada jumlah anak yang dimiliki simpul yang sesuai pada pohon di atas.

Berikut ini adalah program empulur lain yang valid, dengan lebih dari satu perintah dasar:

210010

sesuai dengan

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

Di samping itu,

3120102100

adalah tidak program empulur yang benar karena awal 3hanya memiliki dua argumen, yang dapat kita lihat dengan melihat pohon di bawah ini:

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

Selanjutnya (dimulai tanpa batas, dan )berakhir tanpa batas. Yang tidak terikat mengambil sejumlah argumen (dengan rakus), dan dianggap sebagai argumen tunggal untuk perintah induk mana pun. Setiap batasan yang masih terbuka pada akhir program akan ditutup secara otomatis. Sebuah )perintah bukanlah kesalahan jika tidak ada unboundeds terbuka - itu hanya tidak apa-apa *.

Misalnya, program Empulur

)31(0)0(201000100

sesuai dengan pohon

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

Kosong tanpa ()batas tidak apa-apa, begitu juga program empulur yang valid.

Program empulur yang tidak valid dengan tidak terikat adalah

12(010

karena 2hanya menerima satu argumen (yang tidak terikat).

Akhirnya, "dimulai dan diakhiri string, yang selalu 0 arity dan dihitung sebagai argumen tunggal, misalnya

2"010""44)()4"

yang hanya 2sedang melewati dua argumen string "010"dan "44)()4". Seperti tidak terikat, string juga dapat kosong, dan string yang tidak tertutup pada akhir program secara otomatis ditutup.

* Bagian ini berbeda dengan Pyth asli yang sebenarnya tidak melakukan sesuatu dalam kasus seperti 1), mengakhiri 1-arity dan meningkatkan kesalahan.

Input output

Input akan berupa string tunggal yang tidak kosong yang hanya terdiri dari karakter 01234()". Anda dapat mengasumsikan bahwa tambahan baris baru tambahan selalu ada. Anda dapat menulis fungsi atau program lengkap untuk tantangan ini.

Anda harus menampilkan nilai kebenaran jika inputnya empati valid secara sintaksis, atau nilai palsu sebaliknya. Nilai kebenaran dan kepalsuan harus diperbaiki, sehingga Anda tidak dapat menampilkan 1untuk satu program yang valid dan yang 2lain.

Mencetak gol

Ini adalah kode-golf, jadi kode dalam byte paling sedikit menang.

Uji kasus

Benar:

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

Falsy:

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
sumber
Bukankah seharusnya pohon untuk 20100100 (dalam contoh tidak terikat pertama) [( [2 [0] [1 [0] ] ] [0] [1 [0]] [0] ]? Yang Anda miliki memiliki cabang 2, 0, 0, 1 dan 0 - yang kedua tidak boleh ada.
bcsb1001
@ bcsb1001 Terima kasih dan diperbaiki. Saya ingin menunjukkan bahwa tanpa
batas
@Ypnypn ada kasus uji yang mengatakan bahwa valid untuk memiliki beberapa akar
Pengoptimal
Tolong tambahkan test case untuk ())2)1))0"3())"))(yang seharusnya benar, saya pikir).
n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳
@ n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ Ditambahkan - memang benar (karena pada dasarnya ()210""dengan banyak no-ops)
Sp3000

Jawaban:

12

CJam, 65 byte

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

Astaga, saya berharap CJam memiliki Regex, ini bisa diselesaikan dalam waktu kurang dari 50 byte

Ide utama adalah untuk menjaga mengurangi hal untuk 0yaitu 10untuk 0, 200untuk 0dan sebagainya. Setelah itu selesai, kami mengurangi semua tanda kurung yang cocok ke 0, yaitu ()ke 0, (0)ke 0, (00)ke 0dan seterusnya. Kami mengulangi waktu siklus L, di mana Lpanjang input.

String input awalnya melewati pemrosesan ekstra di mana kami menyesuaikan untuk yang tak tertandingi "dan menambahkan banyak )untuk mengimbangi yang tidak cocok(

Ini memastikan bahwa setelah semua iterasi, kita seharusnya hanya 0(dan tanpa op )) yang tersisa dalam string.

Perbarui - memperbaiki bug di mana )no-op tingkat atas dianggap berbahaya

Perluasan kode

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";

Cobalah online di sini atau jalankan seluruh rangkaian

Pengoptimal
sumber
11

Regex, rasa PCRE, 83 byte

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

Coba di sini.

Regex, rasa PCRE, 85 byte

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

Coba di sini.

Menggunakan beberapa ide dalam jawaban dan1111 ini .

Beberapa penjelasan tentang(?2)*(()(?1))? .

jimmy23013
sumber
(?2)*(()(?1))?adalah potongan puzzle terakhir yang saya cari. Temuan yang bagus! ;)
Martin Ender
Jika saya memahami (?2)*(()(?1))?bagian dengan benar, (()(?1))?bagian itu tidak pernah cocok dengan apa pun, karena (?2)*sudah memakan semua yang (()(?1))?bisa cocok, dan konstruk ini digunakan untuk mengatur grup menangkap 3 ketika kita masuk (dan tidak mengatur grup menangkap 3 ketika kita berada di luar ()konstruksi (untuk memungkinkan pencocokan tidak berpasangan )).
n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳
4

lex, 182 byte (157 w / tumpukan ukuran tetap)

Program-program ini membutuhkan input untuk menjadi string karakter baru yang diakhiri baris baru.

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

Program di atas akan segfault jika kehabisan memori, yang secara teoritis bisa terjadi jika Anda memberikannya cukup (. Tetapi karena segfault dianggap sebagai kegagalan, saya menganggapnya sebagai "falsey", meskipun deskripsi masalah tidak mengatakan apa yang harus dilakukan jika sumber daya tidak mencukupi.

Saya memotong 157 byte dengan hanya menggunakan tumpukan ukuran tetap, tapi itu tampak seperti curang.

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

Untuk mengkompilasi:

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

Uji:

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

Output tes:

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
rici
sumber
Saya kira saya seharusnya sedikit lebih jelas - Anda dapat mengasumsikan bahwa baris baru tidak pernah ada, atau selalu ada di sana. Apakah itu membantu?
Sp3000
Apakah mungkin untuk menggunakan program tumpukan ukuran tetap, tetapi untuk mengatur ukuran tumpukan dengan panjang input?
isaacg
@isaacg Karena inputnya stdin, kami tidak tahu sampai dibaca. Saya bisa dengan mudah menulis driver yang menggunakan baris perintah arg atau string tetapi golf memiliki prioritas lain. Stack dinamis dalam 25 karakter tidak buruk menurut standar c, tapi saya yakin itu masih bisa di-golf.
rici
4

80386 Assembler, 97 byte

Hex dump:

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                                       .

Ini dijalankan melalui input sekali, mendorong angka lebih besar dari nol ke tumpukan dan menurunkannya ketika nol diproses. Tanpa batas diproses sebagai -1.

Prototipe fungsi (dalam C) (fungsi mengembalikan 0 jika tidak valid dan 1 jika valid):

int __cdecl test(char *in);

Majelis Setara (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

Kode berikut dalam C dapat digunakan dengan GCC pada sistem POSIX untuk menguji:

#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
sumber
3

Python 2, 353 byte

Fungsi parse melangkah melalui token satu per satu dan membangun pohon struktur program. Program yang tidak valid memicu pengecualian yang menyebabkan angka nol (Falsy) dicetak, jika tidak hasil parsing akan berhasil.

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

Output dari tes menunjukkan output parser:

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

Kode sebelum minifier:

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
Ksatria Logika
sumber
Nice (ab) penggunaan pengecualian! Anda dapat menghemat beberapa ruang dengan menukar urutan operan ke ==dalam tes - menempatkan string terlebih dahulu berarti Anda bisa melakukannya if')'==q. Saya percaya salah satu breakpernyataan bisa diganti f=0, karena itu akan membuat Anda keluar dari while flingkaran juga. Akhirnya, alih-alih assert x==yAnda dapat menggunakan 1/(x==y)untuk ZeroDivisionError. ;)
DLosc
@Dosc, terima kasih untuk beberapa tips golf yang sangat berguna. Jika saya berada di antara para pemimpin dalam kompetisi golf, saya akan menggunakan ide-ide Anda untuk bersaing. Karena entri saya jauh dari kompetitif (golf-bijaksana), saya lebih suka meninggalkannya sebagai contoh yang paling mudah dibaca. Saya telah mencatat teknik cerdik Anda meskipun untuk penggunaan di masa depan ;-)
Logic Knight
1

Pip , 88 72 byte

Ide diambil dari CJam Pengoptimal . Penusukan orisinal saya pada masalah dengan parser keturunan rekursif adalah ... agak lebih lama.

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

Diformat, dengan penjelasan:

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

Trik menarik:

  • Banyak operator menggunakan item pada daftar dan rentang. Jadi 0X,5, misalnya, adalah 0 X [0 1 2 3 4] == ["" "0" "00" "000" "0000"].
  • Pada beberapa hari yang lalu, Roperator ternary eplace dapat mengambil daftar untuk setiap argumennya: "abracadabra" R ["br" "ca"] 'bmemberi ababdaba, misalnya. Saya memanfaatkan fitur ini dengan baik di zsini.
  • Nilai-nilai palsu di Pip termasuk string ""kosong [], daftar kosong , dan skalar apa pun yang nol. Jadi, 0itu salah, tetapi juga 0.0dan "0000000". Fitur ini kadang-kadang tidak nyaman (untuk menguji apakah string kosong, seseorang harus menguji panjangnya karena "0"salah juga), tetapi untuk masalah ini sempurna.
DLosc
sumber
1

Javascript (ES6), 289 288 285 282 278 244 241 230 byte

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
sumber