একটি বেসিক পাইথ-এর মতো সিনট্যাক্স পরীক্ষক

Question

Pyth একটি golfing পাইথন উপর ভিত্তি করে ভাষা। এটি প্রতিটি কমান্ডের একটি পৃথক আরটি রয়েছে (এটি স্বীকার করে নেয় এমন আর্গুমেন্টের সংখ্যা) সহ উপসর্গ স্বরলিপি ব্যবহার করে।

আপনার কাজটি হ'ল (অস্তিত্বহীন) পাইথ-জাতীয় ভাষা, পিথের জন্য সিন্ট্যাক্স পরীক্ষক লিখুন।

পিথের সিনট্যাক্স

পিঠে 8 টি সিঙ্গেল-চার আদেশ রয়েছে:

01234()"

01234প্রত্যেকের সংশ্লিষ্ট সংখ্যার আধ্যাত্মিকতা রয়েছে এবং তাই এর পরে এটির অনেক যুক্তি প্রত্যাশা করে। উদাহরণ স্বরূপ,

400010

একটি সঠিক পিথ প্রোগ্রাম কারণ 4চারটি আর্গুমেন্ট অনুসরণ করা হয় 0 0 0এবং এর 10মধ্যে সর্বশেষটি 1একক যুক্তি অনুসরণ করে 0। এটি কল্পনা করতে, আমরা নীচের গাছটি দেখতে পারি:

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

Rমূল নোড যেখানে এটি সম্পর্কে ভাবার বিকল্প উপায় হ'ল প্রতিটি সংখ্যা উপরের গাছে সংশ্লিষ্ট নোডের শিশুদের সংখ্যা বোঝায়।

একাধিক বেস কমান্ড সহ এখানে আরও একটি বৈধ পিথ প্রোগ্রাম রয়েছে:

210010

সংশ্লিষ্ট

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

অন্য দিকে,

3120102100

হয় না একটি সঠিক pith প্রোগ্রাম কারণ প্রাথমিক 3মাত্র দুটি আর্গুমেন্ট, যা আমরা নিচের গাছ দিকে তাকিয়ে দেখতে পারেন আছে:

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

এরপরে (একটি আনবাউন্ড করা শুরু হয় এবং আনবাউন্ড করা )শেষ হয়। আনবাউন্ডেড যে কোনও সংখ্যক আর্গুমেন্ট (লোভের সাথে) নেয় এবং যে কোনও প্যারেন্ট কমান্ডের একক যুক্তি হিসাবে গণ্য হয়। প্রোগ্রামের শেষে এখনও যে আনবাউন্ডেডগুলি খোলা আছে তা স্বয়ংক্রিয়ভাবে বন্ধ হয়ে যায়। একটি )কমান্ড একটি ত্রুটি না থাকলে কোনো unboundeds খোলা থাকে - এটা শুধু কিছুই না *।

উদাহরণস্বরূপ, পিথ প্রোগ্রাম

)31(0)0(201000100

গাছের সাথে মিলে যায়

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

খালি আনবাউন্ডেজ ঠিক আছে, তাই ()একটি বৈধ পিথ প্রোগ্রাম।

আনবাউন্ডেড সহ একটি অবৈধ পিথ প্রোগ্রাম

12(010

যেহেতু 2একমাত্র একটি যুক্তি (আনবাউন্ডেড) পায়।

অবশেষে, "একটি স্ট্রিং শুরু হয় এবং শেষ হয় যা সর্বদা 0 arity এবং একক যুক্তি হিসাবে গণনা করা হয়, যেমন

2"010""44)()4"

যা কেবল একটি 2দুটি স্ট্রিং আর্গুমেন্ট "010"এবং পাস করা হচ্ছে "44)()4"। আনবাউন্ডজেডগুলির মতো, স্ট্রিংগুলিও খালি থাকতে পারে এবং প্রোগ্রামের শেষে কোনও অনাবৃত স্ট্রিং স্বয়ংক্রিয়ভাবে বন্ধ হয়ে যায়।

^{* এই অংশটি মূল পাইথের থেকে পৃথক, যা আসলে ক্ষেত্রে কিছু করে যেমন 1)1-আরটিটি শেষ করে ত্রুটি উত্থাপন করে।}

ইনপুট আউটপুট

ইনপুটটি কেবলমাত্র অক্ষর সমন্বিত একক অ-খালি স্ট্রিং হবে 01234()"। আপনি বিকল্পভাবে ধরে নিতে পারেন যে অতিরিক্ত ট্রেলিং করা নতুন লাইনটি সর্বদা উপস্থিত থাকে। আপনি এই চ্যালেঞ্জের জন্য একটি ফাংশন বা একটি সম্পূর্ণ প্রোগ্রাম লিখতে পারেন।

যদি ইনপুটটি সিনট্যাকটিকভাবে বৈধ পিথ হয়, বা অন্যথায় মিথ্যা মান থাকে তবে আপনার সত্যের মান আউটপুট করা উচিত। সত্যবাদী এবং মিথ্যা মানগুলি অবশ্যই ঠিক করতে হবে, সুতরাং আপনি 1একটি বৈধ প্রোগ্রাম এবং 2অন্যটির জন্য আউটপুট নিতে পারবেন না ।

স্কোরিং

এটি কোড-গল্ফ, সুতরাং কয়েকটি বাইটের কোডটি জয়ী।

পরীক্ষার মামলা

Truthy:

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(""))

Comments

20100100 (প্রথম সীমাহীন উদাহরণে) গাছটি হওয়া উচিত নয় [( [2 [0] [1 [0] ] ] [0] [1 [0]] [0] ]? আপনার যার শাখা রয়েছে 2, 0, 0, 1 এবং 0 - দ্বিতীয়টি সেখানে থাকা উচিত নয়।

— বিসিএসবি 1001

@ বিসিএসবি 1001 ধন্যবাদ এবং সংশোধন করা হয়েছে। আমি দেখানোর জন্য unboundeds উপরে 4. যেতে পারেন যে চেয়েছিলেন

— Sp3000

@Ypnypn এ পরীক্ষার কেস রয়েছে যা বলছে যে এর একাধিক শিকড় থাকতে বৈধ

— অপটিমাইজার

আপনি কি দয়া করে পরীক্ষার কেস যুক্ত করবেন ())2)1))0"3())"))(যা সত্য হওয়া উচিত, আমি মনে করি)।

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

@ n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ যোগ করেছেন - এটি সত্যই সত্য (যেহেতু এটি মূলত ()210""প্রচুর পরিমাণে অপস নেই)

— Sp3000

Answer 1

সিজেম, 65 বাইট

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

হ্যাঁ, আমি চাই সিজেমের রেজেক্স থাকত, এটি তখন 50 বাইটেরও কম সময়ে সম্পন্ন করা যেত

মূল ধারণা থেকে কাপড় হ্রাস রাখা 0অর্থাত 10করতে 0, 200করতে 0ইত্যাদি। একবার যে কাজ, তখন আমরা সব মিলেছে বন্ধনী কমাতে 0, অর্থাত্ ()করার 0, (0)করতে 0, (00)করতে 0ইত্যাদি। আমরা চক্র বারগুলি পুনরাবৃত্তি করি Lযেখানে Lইনপুট দৈর্ঘ্য।

ইনপুট স্ট্রিংটি প্রাথমিকভাবে অতিরিক্ত প্রসেসিংয়ের মধ্য দিয়ে যায় যেখানে আমরা তুলনামূলকভাবে সামঞ্জস্য করি এবং তুলনাহীনতার জন্য ক্ষতিপূরণ দেওয়ার জন্য "প্রচুর পরিমাণে যুক্ত করি)(

এটি নিশ্চিত করে যে সমস্ত পুনরাবৃত্তির পরে, আমাদের কাছে স্ট্রিংয়ের মধ্যে কেবল 0(এবং কোনও বিকল্প নেই )) থাকা উচিত ।

আপডেট - একটি বাগ ঠিক করা যেখানে শীর্ষ স্তরের )নো-অপশনকে ক্ষতিকারক হিসাবে বিবেচনা করা হয়

কোড সম্প্রসারণ

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

এটি এখানে অনলাইনে চেষ্টা করুন বা পুরো স্যুটটি চালান

Answer 2

রেজেক্স, পিসিআরই স্বাদ, 83 বাইট

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

এখানে চেষ্টা করুন।

রেজেক্স, পিসিআরই স্বাদ, 85 বাইট

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

এখানে চেষ্টা করুন।

এই ড্যান 1111 এর উত্তরে কিছু ধারণা ব্যবহার করা হয়েছে ।

সম্পর্কে কিছু ব্যাখ্যা(?2)*(()(?1))? ।

Comments

(?2)*(()(?1))?আমি খুঁজছিলাম চূড়ান্ত ধাঁধা টুকরা হয়। ভাল লাগছে! ;)

— মার্টিন ইন্ডার

আমি যদি (?2)*(()(?1))?অংশটি সঠিকভাবে বুঝতে পারি তবে (()(?1))?অংশটি কখনই কোনও কিছুর সাথে মেলে না, যেহেতু (?2)*ইতিমধ্যে ম্যাচের মতো সমস্ত কিছু খায় (()(?1))?এবং এই কনস্ট্রাক্টটি ক্যাপচারিং গ্রুপ 3 সেট করার জন্য ব্যবহৃত হয় যখন আমরা প্রবেশের (বাইরে গ্রুপ 3 প্রবেশ করি এবং আনসেট সেট করি না ()(মিলার জন্য অনুমতি দেওয়ার জন্য) আনকিয়ারড ))।

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

Answer 3

লেক্স, 182 বাইট (157 ডাব্লু / নির্দিষ্ট আকারের স্ট্যাক)

এই প্রোগ্রামগুলির জন্য বৈধ অক্ষরের একক নতুন লাইন টার্মিনেটেড স্ট্রিং হওয়া ইনপুটটির প্রয়োজন।

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

Comments

আমার ধারণা আমি কিছুটা পরিষ্কার হওয়া উচিত ছিল - আপনি ধরে নিতে পারেন যে নিউলাইনটি কখনও হয় না, বা সর্বদা থাকে। এটা কি সাহায্য করে?

— Sp3000

স্থির আকারের স্ট্যাক প্রোগ্রামটি ব্যবহার করা সম্ভব হবে, তবে স্ট্যাকটির আকারটি ইনপুটটির দৈর্ঘ্যে সেট করতে?

— isaacg

@ আইসাকগ যেহেতু ইনপুটটি স্টিডিন তাই এটি না পড়া পর্যন্ত আমাদের কোনও ধারণা নেই। আমি সহজেই এমন কোনও ড্রাইভার লিখতে পারি যা কমান্ড লাইন আরগ বা স্ট্রিং ব্যবহার করে তবে গল্ফের অন্যান্য অগ্রাধিকার থাকে। 25 টি অক্ষরে গতিশীল স্ট্যাক সি মানদণ্ডে খারাপ নয়, তবে আমি নিশ্চিত এটি এখনও গল্ফ করা যেতে পারে।

— ধনী

Answer 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 হিসাবে প্রক্রিয়া করা হয়।

ফাংশন প্রোটোটাইপ (সি তে) (ফাংশনটি অবৈধ হলে 0 এবং বৈধ হলে 1 প্রদান করে):

int __cdecl test(char *in);

সমতুল্য সমাবেশ (এনএএসএম):

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

সিতে নিম্নলিখিত কোডটি জিসিসির সাথে একটি পসিক্স সিস্টেমে পরীক্ষার জন্য ব্যবহার করা যেতে পারে:

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

Answer 5

পাইথন 2, 353 বাইট

পার্স ফাংশনটি একবারে টোকেনগুলির মধ্য দিয়ে যায় এবং প্রোগ্রাম কাঠামোর একটি গাছ তৈরি করে। অবৈধ প্রোগ্রামগুলি একটি ব্যতিক্রম ট্রিগার করে যার ফলে শূন্য (মিথ্যা) মুদ্রণ করা হয়, অন্যথায় সফল পার্সিংয়ের ফলাফল একটি।

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

Comments

ব্যতিক্রম চমৎকার (আব) ব্যবহার! ==পরীক্ষাগুলিতে অপারেটরদের ক্রমটি অদলবদল করে আপনি কয়েকটি স্পেস সংরক্ষণ করতে পারেন - স্ট্রিংগুলি প্রথমে রাখার অর্থ আপনি করতে পারেন if')'==q। আমি বিশ্বাস করি যে breakবিবৃতিগুলির একটির সাথে এটি প্রতিস্থাপন করা যেতে পারে f=0, যেহেতু এটি আপনাকে while fঠিক লুপ থেকেও সরিয়ে ফেলবে । অবশেষে, পরিবর্তে assert x==yআপনি 1/(x==y)একটি ব্যবহার করতে পারেন ZeroDivisionError। ;)

— ডিএলকস

@ ডিএলকস, কিছু কার্যকর গল্ফিং টিপসের জন্য ধন্যবাদ। আমি যদি গল্ফিং প্রতিযোগিতার নেতাদের মধ্যে থাকি তবে আমি আপনার ধারণাগুলি প্রতিযোগিতায় ব্যবহার করব। যেহেতু আমার এন্ট্রিটি প্রতিযোগিতামূলক (গল্ফ-ওয়াইজ) থেকে অনেক দূরে, আমি বরং এটি বেশিরভাগ পাঠযোগ্য উদাহরণ হিসাবে ছেড়ে দেব। ভবিষ্যতের ব্যবহারের জন্য আমি আপনার চালাক কৌশলগুলি লক্ষ্য করেছি ;-)

— লজিক নাইট

Answer 6

পিপ , 88 72 বাইট

অপ্টিমাইজারের সিজেএম থেকে নেওয়া আইডিয়া । পুনরাবৃত্ত বংশদ্ভুত পার্সারের সমস্যাটিতে আমার আসল ছুরিকাটি ছিল ... বরং আরও দীর্ঘ longer

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

আকর্ষণীয় কৌশল:

• অনেক অপারেটর তালিকা এবং ব্যাপ্তিতে আইটেম-ভিত্তিক কাজ করে wise সুতরাং 0X,5, উদাহরণস্বরূপ, হয় 0 X [0 1 2 3 4] == ["" "0" "00" "000" "0000"]।
• কিছু দিন আগে হিসাবে, Rটেরিনারি এপ্লেস অপারেটর এর যে কোনও যুক্তির জন্য একটি তালিকা নিতে পারে: উদাহরণস্বরূপ, "abracadabra" R ["br" "ca"] 'bদেয় ababdaba। আমি zএখানে এই বৈশিষ্ট্যটির ভাল ব্যবহার করি ।
• পিপের মিথ্যা মানগুলির মধ্যে শূন্য স্ট্রিং "", খালি তালিকা []এবং যে কোনও স্কেলারের শূন্য রয়েছে। সুতরাং, 0মিথ্যা, কিন্তু 0.0এবং "0000000"। এই বৈশিষ্ট্যটি কখনও কখনও অসুবিধে হয় (কোনও স্ট্রিং ফাঁকা রয়েছে কিনা তা পরীক্ষা করার জন্য, অবশ্যই এর দৈর্ঘ্য পরীক্ষা করতে হবে কারণ "0"এটিও মিথ্যা), তবে এই সমস্যার জন্য এটি নিখুঁত।

Answer 7

জাভাস্ক্রিপ্ট (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,""))