Basit bir Pyth benzeri Sözdizimi Denetleyicisi


25

Pyth , Python'u temel alan bir golf dilidir. Her komutun farklı bir özelliği (kabul ettiği argüman sayısı) olduğunda önek notasyonu kullanır.

Görevin bir (olmayan) Pyth benzeri dil, Pith için bir sözdizimi denetleyicisi yazmaktır.

Pith'in sözdizimi

Pith sadece 8 tane tek char komutuna sahiptir:

01234()"

01234her biri karşılık gelen sayının açıklığına sahiptir ve bu nedenle ondan sonra birçok argümanın olmasını bekler. Örneğin,

400010

çünkü doğru bir Mantar programı 4, dört bağımsız değişken tarafından takip edilir 0 0 0ve 10A, bunlardan sonuncusu, 1tek değişken, ardından 0. Bunu görselleştirmek için aşağıdaki ağaca bakabiliriz:

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

Rkök düğüm nerede . Bunu düşünmenin alternatif bir yolu, her sayının ilgili düğümün yukarıdaki ağaçtaki çocuk sayısını ifade etmesidir.

İşte birden fazla temel komut ile başka bir geçerli Pith programı:

210010

karşılık gelen

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

Diğer yandan,

3120102100

olduğu değil başlangıç çünkü doğru Mantar programı 3sadece biz ağacın altında bakarak görebilirsiniz iki argüman vardır:

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

Sonra (bir sınırsız başlar ve sınırlanmamış )bir biter. Sınırlandırılmamış herhangi bir sayıda argüman alır (iştahla) ve herhangi bir üst komut için tek bir argüman olarak sayılır. Programın sonunda hala açık olan sınırsızlar otomatik olarak kapatılır. Bir )hayır unboundeds açık olduğunda komut bir hata değildir - bu sadece bir şey yapmaz *.

Örneğin, Pith programı

)31(0)0(201000100

ağaca karşılık gelir

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

Boş sınırsızlar tamam, ()geçerli bir Pith programı.

Sınırlandırılmamış geçersiz bir Pith programı

12(010

çünkü 2tek bir bağımsız değişken (sınırsız) alır.

Son olarak, "her zaman 0 arite olan ve tek bir argüman olarak sayılan bir dize başlar ve biter;

2"010""44)()4"

Bu sadece bir 2dize iki dize argüman geçirilen "010"ve "44)()4". Sınırsız olanlar gibi, dizeler de boş olabilir ve programın sonundaki kapatılmamış dizeler otomatik olarak kapatılır.

* Bu kısım aslında orijinal Pyth farklıdır yapar böyle bir durumda bir şeyler 1)1-Arity biten ve bir hata yükselterek.

Giriş çıkış

Giriş, yalnızca karakterlerden oluşan boş olmayan tek bir dize olacaktır 01234()". İsteğe bağlı olarak, her zaman ek bir son satırın olduğunu varsayabilirsin. Bu görev için bir işlev veya tam bir program yazabilirsiniz.

Girdi sözdizimsel olarak geçerliyse, aksi takdirde sahte bir değerse, bir gerçek değeri vermelisiniz. Hakikat ve sahte değerler sabit olmalıdır, bu nedenle 1geçerli bir program ve diğeri için çıktı alamazsınız 2.

puanlama

Bu kod golf, yani en az bayttaki kod kazanıyor.

Test durumları

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

20100100 ağacı (ilk sınırsız örnekte) olmamalı [( [2 [0] [1 [0] ] ] [0] [1 [0]] [0] ]mı? Sahip olduğunuzun dalları 2, 0, 0, 1 ve 0'dır - ikincisi orada olmamalıdır.
bcsb1001

@ bcsb1001 Teşekkürler ve düzeltildi. Sınırsızların 4'ün üstüne çıkabileceğini göstermek istedim.
Sp3000

Onun geçerli çoklu kökleri için diyerek testi durumlar vardır @Ypnypn
Doktoru

Lütfen test senaryosunu ekler misiniz ())2)1))0"3())"))(ki bence doğru olmalı).
n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

@ n̴̖̋h̷͉a̷̭̿h̸̡̅ẗ̵̨d̷̰ĥ̷̳ Eklendi - (temelde beri gerçekten doğrudur ()210""no-op bir sürü)
SP3000

Yanıtlar:


12

CJam, 65 bayt

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

Tanrım, CJam’ın Regex’e sahip olmasını diliyorum, bu 50 bayttan daha kısa sürede tamamlanmış olabilir.

Ana fikrin şeyler azaltarak devam etmektir 0ie 10için 0, 200için 0vb. Bu işlem tamamlandıktan sonra, biz için Tüm eşleşen parantez azaltmak 0, yani ()etmek 0, (0)için 0, (00)için 0vb. Döngü Lzamanlarını tekrarlıyoruz L, giriş uzunluğu nerede .

Giriş dizesi başlangıçta, eşleşmeyen için ayar yaptığımız ekstra işlemden geçer "ve )eşleşmeyenleri telafi edecek pek çok şey ekler.(

Bu, tüm yinelemelerden sonra , dizgede yalnızca 0(ve hayır-op )) kalan kalmamızı sağlar .

Güncelleme - üst düzey )no-op’un zararlı sayıldığı bir hata düzeltildi

Kod genişletme

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

Burada çevrimiçi deneyin veya tüm süiti çalıştırın


11

Regex, PCRE lezzet, 83 bayt

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

Burada dene.

Regex, PCRE lezzet, 85 bayt

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

Burada dene.

Bu dan1111'in cevabında bazı fikirler kullandım .

Hakkında bazı açıklamalar(?2)*(()(?1))? .


(?2)*(()(?1))?aradığım son bulmaca parçası. Güzel bul! ;)
Martin Ender

Ben anlamak (?2)*(()(?1))?doğru parçası, (()(?1))?çünkü parçası her şeyle eşleşir asla (?2)*zaten herşeyi yiyor (()(?1))?eşleşebilir ve bu yapı grubunun 3 biz girmek yakalama seti için kullanılır (dışarıda olduğunda ve unset yakalama grubunu 3 ()yapı (eşleştirme için izin vermek eşleştirilmemiş )).
n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

4

lex, 182 bayt (157 w / sabit boyutlu yığın)

Bu programlar, girişin tek bir yeni satır sonlandırılmış geçerli karakter dizisi olmasını gerektirir.

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

Yukarıdaki program, hafızasının tükenmesi durumunda arızalanacaktır, eğer yeteri kadar verirseniz teorik olarak gerçekleşebilir (. Ancak, bir segfault başarısızlık olarak kabul edildiğinden, kaynakların yetmemesi durumunda ne yapılacağını söylemese de, bunu “falsey” olarak kabul ediyorum.

Sadece sabit boyutlu bir yığın kullanarak 157 byte indirdim, ancak hile gibi görünüyordu.

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

Derlemek için:

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

Ölçek:

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

Test çıkışı:

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

Sanırım biraz daha net olmalıydım - ya yeni hattın asla orada olmadığını ya da her zaman orada olduğunu varsayabilirsin. Bu yardımcı olur mu?
Sp3000,

Sabit boyutlu yığın programını kullanmak mümkün olabilir, ancak yığının boyutunu girdi uzunluğuna ayarlamak mümkün müdür?
isaacg

@isaacg Girdi stdin olduğu için okunana kadar hiçbir fikrimiz yok. Kolayca komut satırı arg veya string kullanan bir sürücü yazabilirdim ama golfün başka öncelikleri var. 25 karakterdeki dinamik yığın c standartlarına göre fena değil, ama hala golf oynayabileceğinden eminim.
rici

4

80386 Birleştirici, 97 bayt

Hex dökümü:

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                                       .

Bu, girdi üzerinden bir kez geçerek sıfırdan büyük sayıları yığına iter ve bir sıfır işlendiğinde bunları azaltır. Sınırlandırılmamışlar -1 olarak işlenir.

İşlev prototipi (C cinsinden) (işlev geçersizse 0, geçerliyse 1 döndürür):

int __cdecl test(char *in);

Eşdeğer montaj (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'deki aşağıdaki kod, test etmek için bir POSIX sistemindeki GCC ile birlikte kullanılabilir:

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

3

Python 2,353 bayt

Ayrıştırma işlevi, belirteçler boyunca birer birer ilerler ve program yapısının bir ağacını oluşturur. Geçersiz programlar, sıfırın (Falsy) yazdırılmasına neden olan bir istisnayı tetikler, aksi halde başarılı ayrıştırma bir birinde sonuçlanır.

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

Ayrıştırıcı çıktısını gösteren testlerin çıktısı:

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

Minifier'den önceki kod:

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

İstisnaların (ab) güzel kullanımı! İşlenenlerin sırasını ==testlerde değiştirerek bazı alanlarda tasarruf sağlayabilirsiniz - dizeleri ilk önce yapabileceğiniz anlamına gelir if')'==q. breakİfadelerden birinin değiştirilebileceğine inanıyorum f=0, çünkü bu sizi de while fdöngüden çıkaracak . Son olarak, yerine assert x==ysize kullanabilirsiniz 1/(x==y)bir için ZeroDivisionError. ;)
DLosc

@DLosc, bazı çok yararlı golf ipuçları için teşekkürler. Golf yarışmasında liderler arasında olsaydım, fikirlerinizi rekabet etmek için kullanırdım. Girişim rekabetçi olmaktan uzak (golf bilge) olduğundan, çoğunlukla okunaklı bir örnek olarak bırakmayı tercih ederim. Gelecekte kullanım için olsa bile zeki tekniklerine dikkat çektim ;-)
Logic Knight

1

Pip , 88 72 bayt

Optimizer’ın CJam’ından alınan fikir . Özyinelemeli bir iniş çözümleyici ile ilgili sorunumdaki asıl bıçağım daha uzun sürdü.

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

Açıklama ile biçimlendirilmiş:

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

İlginç püf noktaları:

  • Birçok operatör listelerde ve aralıklarda öğe bazında çalışır. Yani 0X,5, mesela 0 X [0 1 2 3 4] == ["" "0" "00" "000" "0000"].
  • Birkaç gün önce itibariyle üçlü Replace operatörü bağımsız değişkenlerinin herhangi biri için bir liste alabilir: "abracadabra" R ["br" "ca"] 'bverir ababdabaörneğin,. zBurada bu özelliği iyi kullanıyorum .
  • Pip'deki sahte değerler boş dizgiyi "", boş listeyi []ve sıfır olan herhangi bir skalayı içerir . Böylece, 0yanlıştır, ama aynı zamanda 0.0ve "0000000". Bu özellik bazen sakıncalıdır (bir dizgenin boş olup olmadığını test etmek için, birinin uzunluğu "0"yanlış olduğundan da test edilmesi gerekir ), ancak bu sorun için mükemmel.

1

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

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,""))
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.