sfondo

Stack Cats è un linguaggio esoterico reversibile creato da Martin Ender. Ogni comando in Stack Cats è l'inverso di se stesso (rappresentato come un carattere simmetrico, come -_:T|), o ha il suo comando inverso (rappresentato come l'immagine speculare, come () {} [] <>). Stack Cats ha un forte requisito sintattico che l'intero programma dovrebbe essere l'immagine speculare di se stesso. Si noti che ciò significa che qualsiasi programma Stack Cats valido è un ambigramma di immagine speculare naturale .

Ecco l'intero set di comandi di Stack Cats:

• Self-simmetrica: !*+-:=ITX^_|
• Coppie simmetriche: () {} [] <> \/

Qualsiasi altro personaggio non è valido; qualsiasi input che abbia un carattere non nel set di caratteri sopra dovrebbe produrre false.

La lingua ha ulteriori vincoli che ()e{} coppie devono essere sempre bilanciate, ma per semplicità, non è necessario verificare questa condizione.

Di seguito sono riportati alcuni esempi di un programma Stack Cats valido (di nuovo, si noti che non si controlla la presenza di parentesi bilanciate):

{[+]==[+]}
[)>^<(]
({T)}|{(T})
<(*]{[:!-_:>}<[<)*(>]>{<:_-!:]}[*)>

Questi non sono:

b<+>d
())(
({[<++<]})

Sfida

Scrivi un programma o una funzione che determina se la stringa specificata è un programma Stack Cats valido. Il tuo codice dovrebbe anche essere un ambigramma di immagine speculare naturale , il che significa:

• Il tuo codice dovrebbe essere un'immagine speculare di se stesso.
  • Il tuo codice può avere una o più nuove righe, purché l'intero codice, visualizzato in modo naturale, sia un'immagine speculare di se stesso.
  • È possibile omettere o aggiungere spazi bianchi finali su ciascuna riga, poiché non cambia la visualizzazione.
  • I caratteri di tabulazione non sono consentiti poiché presentano alcune ambiguità in mostra.

Nota: il codice non deve essere un programma Stack Cats valido; può contenere alcuni caratteri extra che non sono ammessi in Stack Cats. (Vedi sotto per l'elenco completo.)

Ad esempio, i seguenti due programmi sono simmetrici (e quindi una presentazione valida ), mentre il terzo no:

({bTd})
[<q|p>]

({bTd})
  IXI

({bTd})
IXI

• Per quanto riguarda la "simmetria speculare", viene presa in considerazione solo la simmetria in stile Stack Cats (ad es ({IH}) non è un contributo valido, anche se ha una simmetria speculare).
• Il tuo codice può contenere solo questi set di caratteri, oltre a newline:
  • Auto-simmetrico: spazio (0x20 ) +!"'*+-.8:=AHIMOTUVWXY^_ovwx|
  • Coppie simmetriche: () /\ <> [] bd pq {}

Il set di caratteri viene scelto come strettamente simmetrico o auto-simmetrico quando viene visualizzato come codice su SE.

Ingresso e uscita

L'intervallo di input è qualsiasi stringa di una riga di caratteri ASCII stampabili .

Puoi scegliere di prendere l'input come una stringa, un elenco di caratteri o un elenco di valori ASCII.

Puoi scegliere di produrre:

• Qualsiasi valore di verità / falsità definito dalla lingua di tua scelta
  • I valori dei risultati effettivi possono differire tra gli ingressi (ad es. Uscita 1 per un ingresso sincero e 2 per un altro sincero).
  • Lo scambio di valori di verità e falsità non è consentito.
• Qualsiasi due valori costanti rispettivamente per true / false
  • In questo caso, i valori del risultato dovrebbero essere esattamente uno dei due valori costanti.

È necessario specificare il metodo di input e i valori di output nell'invio.

Condizioni vincenti

Questo è code-golf , quindi vince il byte più basso in ogni lingua.

Appunti

• Le scappatoie standard sono vietate come al solito.
• Ovviamente puoi risolverlo in Stack Cats, ma la possibilità è che non puoi usare un flag che ti consenta di ridurre della metà la dimensione del tuo codice. Ed è un linguaggio davvero difficile da imparare: P

JavaScript (ES6), 487 467 378 298 292 280 266 264 byte

Salvato 14 byte grazie a @Bubbler

I=>(V=v=>!I[v]||((T=o=>[[]][+!!A[o]]||[(I[v]!=A[o]||A)[o^o<88/8]]+T(++o))(8-8)==I.pop())*V(++v))(V|(A='(){}[]<>\\/ !*+-:=ITX^_|'))//\\(('|_^XTI=:-+*! \//<>[]{}()'=A)|V)((v++)V*(()qoq.I==(8-8)((o++)T+[[8\88>o^o](A||[o]A=![v]I)]||[[o]A!!+][[]]<=o=T))||[v]I!<=v=V)<=I

Definisce una funzione anonima che accetta una matrice di caratteri e restituisce l'output desiderato. L'output è verità / falsa; di solito 1/ 0, ma la stringa vuota dà true.

Come?

Il trucco più ovvio è usare //\\come punto centrale per commentare la versione speculare del codice. Successivamente, diventa un gioco per capire il modo più breve per risolvere il problema usando solo il set di caratteri fornito.

Il primo problema che incontriamo è la mancanza di parole chiave e incorporati. Abbiamo miracolosamente ancora fatto .pop(), ma tutto il resto dovrà essere fatto tramite gli operatori consentiti (che include a[b]e f(c)), con la ricorsione per emulare i loop.

Il secondo problema è la mancanza di operatori logici. Nessuno dei due &e ?sono ammessi, il che significa che l' unico operatore decisionale che possiamo utilizzare è ||. Pertanto, dobbiamo strutturare attentamente la nostra logica per tenere conto di ciò.

La prima cosa che ho fatto è stata definire una funzione Tche rispecchi un singolo personaggio. L'idea di base è quella di passare in rassegna ogni personaggio in una serie di caratteri speculari, verificandone l'uguaglianza con il carattere dato. Se è uguale, restituiamo il suo specchio: il carattere index^1per (){}[]<>\/o il carattere stesso per il resto.

Il primo problema che ho riscontrato qui è stato ottenere il carattere speculare o un valore errato su ogni iterazione. La soluzione che alla fine mi è venuta in mente è stata (x!=A[o]||A)[o^o<88/8], dove si xtrova il carattere di input, Aè l'alfabeto di mirroring ed oè l'indice corrente. Se xnon è lo stesso di A[o], questo dà truee l'espressione dell'indice valuta undefined; in caso contrario, ||Aviene attivato e alla fine otteniamo A[o^(o<11)].

Il secondo problema è come terminare la ricorsione. Ho scoperto che il modo migliore per farlo è semplicemente concatenare i risultati di ogni iterazione, restituendo la stringa vuota quando Aviene raggiunta la fine di . Questo ci presenta altri due problemi: convertire la undefineds in stringhe vuote e restituire ||qualcosa alla stringa vuota . Questi possono essere risolti con un abuso di array: [a]+""fornisce la rappresentazione della stringa ao la stringa vuota se anon definita. Come bonus, []è veritiero ma si stringe alla stringa vuota, quindi possiamo usarlo comodamente come una "stringa vuota veritiera".

Ora possiamo usare la Tfunzione per rispecchiare qualsiasi singolo carattere. Lo facciamo in modo ricorsivo, confrontando il mirroring di fino I[v++]a I.pop()quando non viene raggiunta la fine dell'array di caratteri. Non possiamo usare &&o &verificare se tutti i confronti sono veritieri, ma usa *invece. Moltiplicando tutti questi risultati insieme si ottiene 1se ogni personaggio è lo specchio di quello opposto o 0se un confronto fallisce.

Ed è sostanzialmente così che funziona questa risposta. Probabilmente non l'ho spiegato molto chiaramente, quindi per favore fai tutte le domande che potresti avere e sottolinea gli errori che ho fatto.

Stax , 76 70 byte

:Wx^^MH_=_"{([</!*+-:=ITX^_|":W-!*pq*!-W:"|_^XTI=:-+*!\>])}"_=_HM^^xW:

Esegui ed esegui il debug

Stax è amico di Stack Cats e ha degli interni per generare la metà successiva di un programma Stack Cats a partire dalla prima metà. Se non ci interessa la restrizione sull'origine e non è necessario controllare il set di caratteri, ecco una soluzione a 4 byte:

4 byte

:R_=

Esegui ed esegui il debug

Spiegazione

:Wx^^MH_=_"{([</!*+-:=ITX^_|":W-!*pq...
:W                                         "Mirror" the string
                                           Equivalent to appending the reverse of the string to itself
                                           And map `{([</\>])}` to its mirror in the appended string
  x^^                                      2, but we can't just use `2` here ...
     MH                                    Partition the "mirror"ed string to two parts, take the later part.
       _=                                  The string is the same as the original one (*)
                                           `:Wx^^MH_=` is just `:R_=`, but we can't use `R` here ...
         _                                 Input string
          "{([</!*+-:=ITX^_|":W-           Remove valid characters from input
                                !          The final string is empty (**)
                                 *         (*) and (**)
                                  p        Pop and print result
                                   q       Peek stack and print
                                           Since the stack is now empty, this causes the program to terminate
                                    ...    Not executed