Aggiunge o Prepends? Dipende


23

Domani, un anno fa il cervello ! In onore del suo compleanno, stiamo organizzando una festa di compleanno in stile PPCG, in cui diversi utenti pubblicano domande correlate al cervello! Aiutaci a festeggiare! :)


Brain-flak è un linguaggio esoterico che ho scritto in cui tutti i comandi sono parentesi e tutte le parentesi devono essere completamente abbinate. Per prendere in prestito la mia definizione :

  • Ai fini di questa sfida, una "staffa" è uno di questi personaggi: ()[]{}<>.

  • Una coppia di parentesi è considerata "abbinata" se le parentesi aperta e chiusa sono nell'ordine giusto e non hanno caratteri al loro interno, come

    ()
    []{}
    

    O se anche ogni sottoelemento al suo interno è abbinato.

    [()()()()]
    {<[]>}
    (()())
    

    I sottoelementi possono anche essere nidificati a più livelli di profondità.

    [(){<><>[()]}<>()]
    <[{((()))}]>
    
  • Una stringa è considerata "Completamente abbinata" se e solo se:

    1. Ogni singolo personaggio è una parentesi,

    2. Ogni coppia di staffe ha la staffa di apertura e chiusura corretta e nel giusto ordine

Per celebrare il primo compleanno di brain-flak, la sfida di oggi consiste nel prendere un set squilibrato di parentesi e determinare quali tipi di operazioni sono necessarie per renderlo valido-brain-flak.

  • Ad esempio, ((non è un codice valido per scartare il cervello, ma se lo accodiamo ))diventa (()), che è completamente bilanciato, e quindi valido per scartare il cervello. Ciò rende questo input appendibile .

  • Allo stesso modo, >}non è valido, ma possiamo anteporre {<a esso per fare {<>}, che è valido. Ciò rende questo input prependibile .

  • Alcuni input sono leggermente più complicati. Ad esempio, )][({non può essere reso valido esclusivamente aggiungendo o anteponendo. Ma può essere reso valido anteponendo [(e aggiungendo })]. Pertanto, questo input è sia prependibile che appendibile .

  • Infine, alcuni input non possono mai essere resi validi come codice del cervello-flak da qualsiasi combinazione di aggiunta o aggiunta. Ad esempio, (>non può mai essere reso valido. (Anteponendo <crea <(>e l'accodamento )crea (>), nessuno dei quali sono valide) Pertanto, questo ingresso è né appendable o prependable.

Per la sfida di oggi, è necessario scrivere un programma o una funzione che accetta una stringa di parentesi e determina se la stringa è

appendable
prependable
both
neither

Puoi scegliere quali valori utilizzare per rappresentare per ciascun caso. Ad esempio, l'output 1, 2, 3, 4, o 'a', 'p', 'b', 'n', o 1, 'foo', 3.1415, -17, o qualunque cosa vada bene. Finché ogni output è distinto e coerente , va bene. Tuttavia, è necessario specificare chiaramente quale output corrisponde a quale caso.

È possibile restituire questo valore in qualsiasi formato sia più comodo (ad esempio, tornare da una funzione, stampare su STDOUT, modificare argomenti, scrivere su un file, ecc.).

Si può presumere che l'input non sarà mai valido in modo errato o vuoto.

Esempi

I seguenti input sono tutti prependibili :

))
(((()()())))}
)>}]
()[]{}<>)

Questi sono tutti appendibili :

(({}{})
((((
([]()())(
{<<{

Questi sono tutti e due :

))((
>()[(()){
>{

E questi non sono tutti né due :

)(}
{(((()()()))>
[}
((((((((((>
((((((((((<>()]

Come al solito, si tratta di , quindi si applicano scappatoie standard e vince la risposta più breve in byte!


Questa sfida è particolarmente difficile con il cervello-flak, quindi il massimo brownie indica qualsiasi risposta scritta nel cervello-flak. :)


1
maximum brownie pointsPenso che offrire il massimo dei punti brownie e dei cookie incoraggerebbe invece Brain-Flaking a questa sfida più dei semplici punti brownie, dal momento che non credo affatto banale in nessuna lingua, figuriamoci Brain-Flak. : P
Erik the Outgolfer,

Cordiali saluti: Tutti e due i test terminano con parentesi aperte, tutti e nessuno dei test termina con parentesi chiuse.
Jonathan Allan,

2
Direi che "entrambi" è il termine sbagliato. Una stringa come non][ è appendibile, poiché nulla che puoi aggiungere può renderla valida. Allo stesso modo, non è prepagabile. È ... "inseribile"! Puoi inserirlo in una stringa per rendere l'intero Brainflak valido.
orlp

Le stringhe già bilanciate sono entrambe o nessuna delle due?
Wheat Wizard

@wheatwizard Le stringhe bilanciate non verranno fornite come input. You can assume that the input will never be valid brain-flak or empty.
DJMcMayhem

Risposte:


6

Gelatina , 33 32 37 35 34 byte

bug trovato, correzione orribile +5 byte, correzione migliore - 2 byte, usando un trucco di Adnan che ho visto qui per -1 in più.

“({[<“)}]>”Z;@WœṣF¥/µÐLO‘&2µIṀ>0ȯQ

Valori di ritorno:

prepends [2]
 appends [0]
    both [2,0]
 neither 1

(L'input non valido restituisce risultati spuri, sebbene ritorni del cervello validi, ritorni [].)

Provalo online! - una suite di test (stampa rappresentazioni confuse, quindi20per[2,0]e ignora le righe che contengono-).


5

Retina , 41 40 41 byte

1 byte salvato grazie a @MartinEnder

+`\(\)|\[]|{}|<>

[]})>]+
1
\W+
0
...+
01

Provalo online!

  • Prependibile è 1
  • Appendable is 0
  • Entrambi lo sono 10
  • Nessuno lo è 01

Le modifiche

  • Ha ottenuto 1 byte per correggere il bug notato da @Neil

[]})>]salva un byte.
Martin Ender,

@MartinEnder Ah, è perché i set di caratteri non possono essere vuoti, grazie!
Kritixi Lithos,

Questo non funziona per tutti gli input non appendibili, ad esempio (][). Penso che possa essere risolto al costo di un byte cambiando 101in ...+.
Neil,

@Neil Grazie per notare il bug, mi chiedo se ci sono casi del genere con Bothcosì
Kritixi Lithos

No, penso 10sia l'unica combinazione valida per Both.
Neil,

3

Lotto, 337 byte

@echo off
set/ps=
:g
set "t=%s:<>=%
set "t=%t:()=%
set "t=%t:[]=%
set "t=%t:{}=%
if not "%t%"=="%s%" set "s=%t%"&goto g
set "s=%s:<=[%
set s=%s:>=]%
set s=%s:(=[%
set s=%s:)=]%
set s=%s:{=[%
set s=%s:}=]%
:l
if %s:~,2%==]] set s=%s:~1%&goto l
:r
if %s:~-2%==[[ set s=%s:~,-1%&goto l
if not _%s:~2%==_ set s=[]
echo %s%

Output ]per prepend, [per append, ][per entrambi, []per nessuno dei due.


3

Haskell , 115 108 byte

MODIFICARE:

  • -7 byte: usa più protezioni.
(""#)
s#""=[s>"",1>0]
s#(c:d)|Just a<-lookup c$zip"([{<"")]}>"=(a:s)#d|(a:b)<-s=[1|a==c]>>b#d|0<1=take 1$s#d

Provalo online!

Usa come (""#) "))". I risultati sono dati come:

[False,True]: needs nothing
[False]: prependable
[True,True]: appendable
[True]: both
[]: neither

Come funziona

  • La codifica di output viene scelta in modo tale che una necessità di anteporre venga segnalata rilasciando il secondo elemento del risultato per il resto, se presente, mentre viene segnalata una mancata corrispondenza completa eliminandoli tutti.
  • s#danalizza una stringa rimanente d, data una stringa / pila sdi parentesi quadre previste.
    • La s#""riga controlla se sono state trovate tutte le parentesi quadre alla fine della stringa, altrimenti è necessario aggiungere.
    • Il primo ramo s#(c:d)verifica se il carattere successivo cè una parentesi aperta e, in tal caso, lascia la corrispondente parentesi di chiusura in pila per la ricorsione.
    • Altrimenti, se la pila contiene parentesi di chiusura, il secondo ramo controlla se quello in cima corrisponde al carattere successivo e, in caso contrario, restituisce un elenco vuoto invece di ricorrere.
    • Infine, nell'ultimo ramo lo stack è vuoto e abbiamo una parentesi di chiusura senza pari che può essere riparata anteponendo, prima di ricorrere.

2

Japt , 44 byte

=Ue"%(%)|%[]|\{}|<>" ®c -1&2|1})f31 |UfD |Ug

Output 1per prependable, 3per appendable, 13per entrambi e 31per nessuno dei due.

Provalo online! oppure Verifica tutti i casi di test contemporaneamente.

Come funziona

 =Ue"%(%)|%[]|\{}|<>" ®   c -1&2|1})f31 |UfD |Ug
U=Ue"%(%)|%[]|\{}|<>" mZ{Zc -1&2|1})f31 |UfD |Ug

                    // "(((()()())))}"  "([({}{})"    ">()[(()){"  "((((<>()]"
Ue"%(%)|%[]|\{}|<>" // Recursively remove all instances of "()", "[]", "{}", and "<>" from U.
                    // "}"              "(["          ">[{"        "((((]"
mZ{Zc -1&2|1}       // Replace each char Z with (Z.charCodeAt() - 1) & 2 | 1.
                    // "1"              "33"          "133"        "33331"
U=                  // Save the result in U.
f31 |UfD |Ug        // Match all instances of "31" and "13" (D = 13) and bitwise-OR the results with the first char.
                    // null|null|1      null|null|3   null|13|1    31|null|3
                    // 1                3             13           31
                    // Implicit: output result of last expression

2

PHP, 137 byte

for($c=1;$c;)$a=preg_replace("#<>|\(\)|\[\]|\{\}#","",$a=&$argn,-1,$c);echo($a=preg_replace(["#[]})>]+#","#[[{(<]+#"],[1,2],$a))<13?$a:0;

1 => appendibile,

2 => prependibile,

12 => entrambi,

0 => nessuno dei due

Casi test


"Finché ogni output è distinto e coerente, va bene". Questo non sembra avere un valore coerente per nessuno dei due.
Cyoce,

@Cyoce Ora è stato risolto
Jörg Hülsermann il
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.