Un controllo sintassi di base simile a Pyth


25

Pyth è un linguaggio da golf basato su Python. Usa la notazione con prefisso, con ogni comando con un'arità diversa (numero di argomenti che accetta).

Il tuo compito è scrivere un correttore di sintassi per un linguaggio (inesistente) simile a Pyth, Pith.

Sintassi di Pith

Pith ha solo 8 comandi a carattere singolo:

01234()"

01234ognuno ha arità del numero corrispondente e quindi si aspetta che molti argomenti dopo di esso. Per esempio,

400010

è un programma Pith corretto perché 4è seguito da quattro argomenti 0 0 0e 10, l'ultimo dei quali è 1seguito dal singolo argomento 0. Per visualizzare questo, possiamo guardare il seguente albero:

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

dov'è Ril nodo principale. Un modo alternativo di pensare a questo è che ogni numero si riferisce al numero di figli che il nodo corrispondente ha nella struttura in alto.

Ecco un altro programma Pith valido, con più di un comando di base:

210010

corrisponde a

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

D'altro canto,

3120102100

non è un programma Pith corretto perché l'iniziale 3ha solo due argomenti, che possiamo vedere guardando l'albero sotto:

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

Successivamente (inizia un illimitato e )termina un illimitato. Un illimitato accetta qualsiasi numero di argomenti (avidamente) e conta come singolo argomento per qualsiasi comando genitore. Eventuali limiti non ancora aperti entro la fine del programma vengono automaticamente chiusi. Un )comando non è un errore se non sono aperti limiti illimitati, ma non fa nulla. *

Ad esempio, il programma Pith

)31(0)0(201000100

corrisponde all'albero

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

I vuoti illimitati vanno bene, quindi ()è un programma Pith valido.

Un programma Pith non valido con un illimitato è

12(010

poiché l' 2unico riceve un argomento (il illimitato).

Infine, "inizia e termina una stringa, che è sempre 0 arity e conta come un singolo argomento, ad es

2"010""44)()4"

che è solo un 2essere passato due argomenti stringa "010"e "44)()4". Analogamente a quanto non limitato, anche le stringhe possono essere vuote e tutte le stringhe non chiuse entro la fine del programma vengono automaticamente chiuse.

* Questa parte è diversa dal Pyth originale che in realtà fa qualcosa in un caso come 1), terminando l'1-arity e generando un errore.

Input Output

L'input sarà una singola stringa non vuota composta solo da caratteri 01234()". È possibile presumere facoltativamente che sia sempre presente una nuova riga finale aggiuntiva. È possibile scrivere una funzione o un programma completo per questa sfida.

Dovresti generare un valore di verità se l'input è Pith sintatticamente valido, o altrimenti un valore di falsa. I valori di verità e falsità devono essere fissi, quindi non è possibile eseguire l'output 1per un programma valido e 2per un altro.

punteggio

Questo è code-golf, quindi vince il codice nel minor numero di byte.

Casi test

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

L'albero per 20100100 (nel primo esempio illimitato) non dovrebbe essere [( [2 [0] [1 [0] ] ] [0] [1 [0]] [0] ]? Quello che hai ha rami di 2, 0, 0, 1 e 0 - il secondo non dovrebbe essere lì.
bcsb1001,

@ bcsb1001 Grazie e corretto. Volevo dimostrare che i limiti illimitati possono andare oltre 4.
Sp3000,

@Ypnypn ci sono casi di test che affermano che è valido avere radici multiple
Optimizer

Vorresti per favore aggiungere il test case ())2)1))0"3())"))(che dovrebbe essere vero, penso).
n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

@ n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ Aggiunto - è davvero vero (dal momento che è fondamentalmente ()210""con un sacco di no-ops)
Sp3000

Risposte:


12

CJam, 65 byte

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

Accidenti, vorrei che CJam avesse Regex, questo avrebbe potuto essere completato in meno di 50 byte allora

L'idea principale è quella di continuare a ridurre le cose ad 0esempio 10a 0, 200a 0e così via. Una volta fatto ciò, riduciamo tutte le parentesi corrispondenti a 0, ovvero ()a 0, (0)a 0, (00)a 0e così via. Ripetiamo i Ltempi di ciclo , dove Lè la lunghezza di input.

La stringa di input inizialmente passa attraverso un'elaborazione aggiuntiva in cui ci adeguiamo per ineguagliati "e ne aggiungiamo molti )per compensare ineguagliati(

Questo assicura che dopo tutte le iterazioni dovremmo avere solo 0(e no-op )) nella stringa.

Aggiornamento: risolto un bug in cui il )no-op di livello superiore veniva considerato dannoso

Espansione del codice

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

Provalo online qui o esegui l'intera suite


11

Regex, sapore PCRE, 83 byte

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

Provalo qui.

Regex, sapore PCRE, 85 byte

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

Provalo qui.

Ho usato alcune idee nella risposta di questo dan1111 .

Alcune spiegazioni in merito(?2)*(()(?1))? .


(?2)*(()(?1))?è l'ultimo pezzo del puzzle che stavo cercando. Bella scoperta! ;)
Martin Ender il

Se capisco (?2)*(()(?1))?correttamente la parte, la (()(?1))?parte non corrisponde mai a nulla, poiché (?2)*già consuma tutto ciò che (()(?1))?può corrispondere, e questo costrutto viene utilizzato per impostare il gruppo di acquisizione 3 quando entriamo (e disinseriamo il gruppo di acquisizione 3 quando siamo fuori dal ()costrutto (per consentire la corrispondenza spaiato )).
n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

4

lex, 182 byte (157 con stack di dimensioni fisse)

Questi programmi richiedono che l'input sia una stringa terminata a nuova riga di caratteri validi.

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

Il programma di cui sopra segfault se esaurisce la memoria, il che potrebbe teoricamente accadere se lo dai abbastanza ( . Ma dato che un segfault è considerato un fallimento, lo prendo come "falso", sebbene la descrizione del problema non dica cosa fare se le risorse non bastano.

L'ho ridotto di 157 byte usando solo uno stack di dimensioni fisse, ma mi è sembrato un imbroglio.

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

Compilare:

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

Test:

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

Uscita di prova:

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

Immagino che avrei dovuto essere un po 'più chiaro - puoi presumere che la newline non sia mai lì, o sia sempre lì. Questo aiuta?
Sp3000,

Sarebbe possibile utilizzare il programma di stack a dimensione fissa, ma impostare la dimensione dello stack sulla lunghezza dell'input?
isaacg,

@isaacg Poiché l'input è stdin, non abbiamo idea fino a quando non viene letto. Avrei potuto facilmente scrivere un driver che utilizza una riga di comando arg o stringa ma il golf ha altre priorità. Lo stack dinamico in 25 caratteri non è male per gli standard c, ma sono sicuro che può ancora essere giocato a golf.
rici,

4

80386 Assemblatore, 97 byte

Discarica esadecimale:

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                                       .

Questo passa attraverso l'input una volta, spingendo i numeri maggiori di zero nello stack e diminuendoli quando viene elaborato uno zero. I illimitati vengono elaborati come -1.

Prototipo di funzione (in C) (la funzione restituisce 0 se non valido e 1 se valido):

int __cdecl test(char *in);

Assemblaggio equivalente (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

Il seguente codice in C può essere utilizzato con GCC su un sistema POSIX per testare:

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

La funzione di analisi passa attraverso i token uno alla volta e crea un albero della struttura del programma. Programmi non validi attivano un'eccezione che causa la stampa di uno zero (Falsy), altrimenti l'analisi ha esito positivo in uno.

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

L'output dei test che mostra l'output del 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

Il codice prima del minificatore:

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

Nice (ab) uso delle eccezioni! Puoi salvare alcuni spazi sostituendo l'ordine degli operandi ==nei test: mettere le stringhe al primo posto significa che puoi farlo if')'==q. Credo che una delle breakaffermazioni potrebbe essere sostituita f=0, dal momento che anche questo ti farà uscire dal while fgiro. Infine, invece di assert x==yte puoi usare 1/(x==y)per a ZeroDivisionError. ;)
DLosc,

@DLosc, grazie per alcuni consigli sul golf molto utili. Se fossi tra i leader nella competizione del golf, userei le tue idee per competere. Dato che il mio ingresso è tutt'altro che competitivo (per quanto riguarda il golf), preferirei lasciarlo come esempio per lo più leggibile. Ho notato le tue tecniche intelligenti per un uso futuro ;-)
Logic Knight,

1

Pip , 88 72 byte

Idea presa da CJam di Optimizer . La mia pugnalata originale al problema con un parser di discesa ricorsiva era ... piuttosto lunga.

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

Formattato, con spiegazione:

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

Trucchi interessanti:

  • Molti operatori lavorano su elementi e liste. Quindi 0X,5, per esempio, lo è 0 X [0 1 2 3 4] == ["" "0" "00" "000" "0000"].
  • A partire da un paio di giorni fa, il ternario Roperatore eplace può prendere una lista per uno dei suoi argomenti: "abracadabra" R ["br" "ca"] 'bababdaba, per esempio. Faccio buon uso di questa funzione con zqui.
  • I valori falsi in Pip includono la stringa ""vuota [], l' elenco vuoto e qualsiasi scalare che è zero. Pertanto, 0è falso, ma anche 0.0e "0000000". Questa funzionalità è scomoda a volte (per verificare se una stringa è vuota, è necessario verificarne la lunghezza perché "0"è troppo falsa), ma per questo problema è perfetta.

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,""))
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.