Diamo una funzione che accetta una stringa e rimuove tutte le coppie di caratteri identici adiacenti. Per esempio$f$

$f(a\color{red}{bb}ba\color{red}{cc}) = aba$

Nota che quando due coppie si sovrappongono ne rimuoviamo solo una.

Chiameremo una stringa perfettamente accoppiata se un'applicazione ripetuta alla fine produce la stringa vuota. Ad esempio la stringa sopra $abbbacc$ non è perfettamente accoppiata perché se applichiamo di nuovo $f$ otteniamo ancora $aba$ . Tuttavia una stringa come $eabbccadde$ è perfettamente accoppiata perché se applichiamo $f$ tre volte otteniamo la stringa vuota

$f(ea\color{red}{bbcc}a\color{red}{dd}e) = eaae$

$f(e\color{red}{aa}e) = ee$

$f(\color{red}{ee}) =$

Il tuo compito è quello di scrivere un codice per computer perfettamente accoppiato che accetta una stringa (di ASCII stampabile) e decide se è perfettamente accoppiato. Il bytestring del tuo sorgente deve essere esso stesso una stringa perfettamente accoppiata , sebbene il tuo codice non debba necessariamente essere limitato all'ASCII stampabile.

È possibile generare due valori distinti: uno per il caso in cui l'input è perfettamente accoppiato e un altro per i casi in cui non lo è.

Questa è una domanda di code-golf, quindi le risposte verranno assegnate in base alla dimensione in byte della loro sorgente con un numero inferiore di byte migliori.

Casi test

$abbbacc \rightarrow \mathrm{False}\\ abcba \rightarrow \mathrm{False}\\ abab \rightarrow \mathrm{False}\\ abbbaabacc \rightarrow \mathrm{True}\\ eabbccadde \rightarrow \mathrm{True}\\ bbbb \rightarrow \mathrm{True}$

Haskell, 146 124 byte

((""##))
a===bb=bb==a
((aa:bb))##((cc:dd))|aa===cc=bb##dd|1==1=((cc:aa:bb))##dd
a##""=""===a
""##cc=((cc!!00:cc!!00:""))##cc

Non ci sono commenti. Restituisce Trueo False.

Provalo online!

Modifica: -22 byte grazie alla procedura guidata @Cat

Python 2 , 94 byte

ss=''

for cc in input():ss=[cc+ss,ss[1:]][cc==ss[:1]]

print''==ss##tnirp[,+[=:)(tupni nirof=

Provalo online!

L'intero passaggio di aggiornamento viene ss=[cc+ss,ss[1:]][cc==ss[:1]]annullato solo =[+,[.

05AB1E , 26 24 22 20 18 byte

-2 byte grazie agli ovs . Emette 0 se la stringa è perfettamente accoppiata, 1 altrimenti.

ΔγʒgÉ}JJ}ĀqqĀÉgʒγΔ

Provalo online!

ΔγʒgÉ} JJ} ĀqqĀÉgʒγΔ - Programma completo.
Δ} - Fino a quando il risultato non cambia più:
 γʒ} - Dividi la stringa in blocchi di caratteri uguali e filtra per:
   gÉ - La lunghezza è strana?
      JJ - E dopo aver filtrato, unisci nuovamente le parti, ma fallo
                     due volte per salvare 2 byte, come nelle versioni precedenti.
         Â - Controlla se il risultato è vuoto
          q - Termina (esci) esecuzione. Il resto del codice viene ignorato.
           qĀÉgʒγΔ - Riflette la parte non abbinata per aiutare con il layout di origine.

Versione precedente

Questo si basa esclusivamente su un comportamento indefinito (quindi non esiste un "codice morto") e genera [['0']] per stringhe perfettamente accoppiate e [['1']] per stringhe non perfettamente abbinate:

ΔγεDgÉ£}JJ}ĀĀ£ÉgDεγΔ 

E la versione a 22 byte, spiegata, che è solo il precedente ma non abusa di UB e produce valori sani .

ΔγεDgÉ£}JJ}ĀqqĀ£ÉgDεγΔ – Full program.
Δ         }            – Until fixed point is reached (starting from the input value):
 γε    }                 – Group equal adjacent values, and for each chunk,
   DgÉ                     – Duplicate, get its length mod by 2.
      £                    – And get the first ^ characters of it. This yields the
                             first char of the chunk or "" respectively for odd-length
                             and even-length chunks respectively.
         JJ                – Join the result to a string, but do this twice to help
                             us with the source layout, saving 2 bytes.
            Ā           – Check if the result is an empty string.
             q          – Terminate the execution. Any other commands are ignored.
              qĀ£ÉgDεγΔ – Mirror the part of the program that isn't otherwise removed
                          anyways. This part forgoes }JJ} because that substring will
                          always be trimmed by the algorithm anyway.

Cubix , 54 byte

U#;!u1@.Oi>??>i..??O.@1^^...u--u.u!ww;..#..U..;..;!^^!

Non emette nulla se la stringa è perfettamente accoppiata e 1altrimenti.
Provalo qui

Cubified

      U # ;
      ! u 1
      @ . O
i > ? ? > i . . ? ? O .
@ 1 ^ ^ . . . u - - u .
u ! w w ; . . # . . U .
      . ; .
      . ; !
      ^ ^ !

Spiegazione

La maggior parte dei caratteri sono riempitivi necessari per abbinare perfettamente il codice. Sostituendo quelli con .(no-op), otteniamo

      U # ;
      ! u 1
      @ . O
i . ? . > i . . ? . . .
. . ^ . . . . u - . . .
. . . w ; . . . . . . .
      . ; .
      . ; !
      ^ ^ !

Questo può essere suddiviso in tre passaggi:

• Controlla contro la stringa vuota (sinistra ie ?).
• Ripeti, lancia i personaggi in pila e lancia i duplicati (tutto in basso a destra).
• Controlla se la pila è vuota (la roba in alto).

V , 20 , 18 byte

òóˆ±òø‚

::‚øò±ˆóò

Provalo online!

hexdump:

00000000: f2f3 88b1 f2f8 820a 0a3a 3a82 f8f2 b188  .........::.....
00000010: f3f2                                     ..                   ....

Emette 0 per verità, 1 per falsa. Grazie a nmjcman101 per il risparmio indiretto di 2 byte.

ò        ò        " Recursively...
 ó                "   Remove...
  <0x88>          "     Any printable ASCII character
        ±         "     Followed by itself
          ø       " Count...
           <0x82> "   The number of non-empty strings

::<0x82>øò±<0x88>óò      " NOP to ensure that the code is paired

R , 142 126 byte

Logica più stretta e alcuni byte di commento giocati da @Giuseppe

f=function(x,p="(.)\\1")"if"(grepl(p,x),f(sub(p,"",x)),!nchar(x))##x(rahcn!,x,,p(bus(f,)x,p(lperg("fi")"1\\).("=p,x(noitcnuf=f

Provalo online!

f=function(x,p="(.)\\1")"if"(nchar(x),"if"(grepl(p,x),f(sub(p,"",x)),0),1)##)1,)0,xp(bus(f,)x,p(lperg("fi",)x(rahcn("fi")"1).("=p,x(noitcnuf=f

Originale:

Provalo online!

Funzione rilevatore ricorsivo seguita da commento con tutti i caratteri nella funzione in ordine inverso.

APL (Dyalog) , 38 byte

''≡{'(.)\1'⎕R''⊢⍵}⍣≡⍝⍝≡⍣}⍵⊢R⎕'1\).('{≡

Provalo online!

Retina , 28 26 byte

+`(.)\1

C`^$

$^`C1\).(`+

Provalo online!

Output `C1\).(`+0`C1\).(`+per falsità e `C1\).(`+1`C1\).(`+casi veritieri.

Brain-Flak , 228 200 byte

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

Provalo online!

Questa è una prova del concetto. Probabilmente potrebbe essere più breve. Tuttavia non utilizza alcun commento.

Emette 0,0se l'ingresso è perfettamente accoppiato e 0,1se non lo è.

sed 4.2.2 , 34 byte

:;:t;ss((..??\??))\1ss1;t;/..??/cc

Provalo online!

Le stringhe accoppiate danno un output vuoto, quelle non accoppiate danno ct:

La banale versione palindromica è a 32 :;ss(.)\1ss;t;/./cc/./;t;1\).(;:. La vecchia soluzione era :;ss((..??\??))\1ss1;t;;/./cc/./t:(cambiata perché quella attuale ha abusato di cmeno, modifica: yay ora c'è solo 1 carattere dopo c: D)

(nota che ;è il separatore di istruzioni)

: dichiara un'etichetta vuota

:t dichiara l'etichetta t

ss((..??\??))\1ss1è una sostituzione, in sed puoi cambiare il delimitatore in una sostituzione, e questo è quello che ho fatto cambiandolo in s, quindi quello che fa è sostituire il primo (come indicato dalla 1fine)

• partita di ((..??\??))\1

  • . qualsiasi personaggio
  • .?? seguito da un carattere opzionale facoltativo
  • \?? e un facoltativo ?
  • seguito dalla stessa cosa accanto

• con niente

Ora questa sostituzione è accoppiata con se stessa, quindi anche le ;s prima e dopo vengono cancellate

t e tornare all'etichetta fino a quando non ci sono più sostituzioni riuscite

/..?/se .(carattere jolly) seguito da .?un carattere opzionale corrisponde

• cc cambia il buffer in c

Brain-Flak , 112 110 108 byte

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

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

Provalo online!

Questo si basa sulla mia risposta da Le parentesi sono abbinate? .

Ho provato a non usare i commenti, ma si è bloccato cercando di accoppiare i pop nilads ( {}). Il problema sta nel modo più semplice per accoppiare una coppia di parentesi è circondarlo in un'altra coppia dello stesso tipo. Mentre questo è facile per altri nilad, la {...}monade crea anelli. Per uscire dal ciclo devi premere uno 0, ma una volta uscito dal ciclo, devi far apparire lo 0, il che aggrava il problema.

La soluzione pre-accoppiata a 66 byte è:

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

Provalo online!

Uscite 1o 1,0se l'ingresso è un accoppiamento perfetto, in 0,0caso contrario.

Versione senza commenti, 156 byte

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

Provalo online!

Come ha sottolineato Cat Wizard, la prima risposta non funziona per tutti gli interpreti, poiché non tutti gestiscono i #commenti. Questa versione non contiene commenti.

Japt, 24 22 byte

Output falseper verità e truefalsità.

&&!!e"(.)%1"PP"1%).("e

Provalo

Brain-Flak , 96 byte

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

Provalo online!

Non emette nulla se l'ingresso è perfettamente accoppiato, e 0altrimenti.

Versione (originale) non perfettamente abbinata:

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

Provalo online!

Haskell , 66 byte

null.foldr((%))"";;cc%((r:t))|cc==r=t;;t%s=t:s--s:t=s%=r|t:dlof.un

Provalo online!

Cat Wizard ha salvato 6 byte.

Aggiungi ++ , 146 byte

D,g,@~~,L2_|*;;*|_2L,@,g,D
D,ff,@^^,BG€gBF;;FBg€GB,@D1:?:

xx:?

aa:1
`bb
Bxx;;B
Waa*bb,`yy,$ff>xx,`aa,xx|yy,`bb,Byy,xx:yy

O;;O:,B,`,|,`,>$,`,*W`

Provalo online!

Curiosità: erano 272 byte molto prima dell'inizio della spiegazione, ora batte Java.

Uscite Trueper stringhe perfettamente bilanciate e Falsealtro

Con mia grande soddisfazione, questo batte la noiosa versione palindromica di 2 byte, per evitare che il risultato venga stampato due volte. Ho anche mirato ad avere il minor numero di dead code possibile, tuttavia ci sono ancora alcune sezioni commentate e il codice esce con un codice di errore 1 , dopo aver stampato il valore corretto.

NB : è BFstato corretto un bug con i comandi mentre questa risposta era in fase di sviluppo.

Come funziona

$\mathit{ff}$$g$$\mathit{ff}$$\mathit{ff}$$g$$S$$\mathit{ff}(S)$$S$

$S$$abbbaabacc$$[[a], [bbb], [aa], [b], [a], [cc]]$$g$e sostituire gli elenchi secondari con il risultato della funzione.

$g$$2$$x$$[a]$$[bb]$$[ccc]$

$x$$x > 2$$x - 2$$x$*

$g(s)$$s$BF^D,ff,@^^,$g$$r$$r$;;

$\mathit{ff}$$g$$\mathit{ff}$

• $\mathit{xx}$$\mathit{ff}$
• $\mathit{yy}$$\mathit{ff}$
• $\mathit{aa}$
• $\mathit{bb}$$\mathit{yy}$

$g$$\mathit{xyab}$$g$

€$\mathit{abc}${...}$g${...}$\mathit{gg}$$\mathit{ff}$$g$

D,gg,@~~,L2_|*;;*|_2L,@D             (NB: -2 bytes)
D,ff,@^^,BG€{gg}BF;;FB}gg{€GB,@D?:   (NB: +6 bytes)

che è di 4 byte in più.

$x = 5$$x = 15$

x+10 ; Explicit argument
+10  ; Implicit argument, as x is active

$x$`

$\mathit{ff}$$g$$\mathit{xx}$xx:?$\mathit{xx}$$\mathit{aa}$aa:1$1$$\mathit{xx}$$\mathit{bb}$

`bb
Bxx

$\mathit{bb}$$\mathit{xx}$$\mathit{aa} := 1$$\mathit{bb} := \neg \neg \mathit{xx}$

Quindi entriamo nel nostro ciclo while:

Waa*bb,`yy,$ff>xx,`aa,xx|yy,`bb,Byy,xx:yy

Un ciclo while è un costrutto in Add ++: opera direttamente sul codice, piuttosto che sulle variabili. I costrutti prendono una serie di istruzioni di codice, separate con le ,quali operano. Le istruzioni while e if prendono anche una condizione direttamente prima della prima ,che consistono in una singola istruzione valida, come un comando infix con variabili. Una cosa da notare: la variabile attiva non può essere omessa dalla condizione.

aa*bb$\mathit{aa}$$\mathit{bb}$$\mathit{yy}$$\mathit{ff}(x)$

`yy,$ff>xx

$\mathit{aa}$

• 1) Il nuovo valore non equivale al vecchio valore (loop mentre univoco)
• 2) Il nuovo valore non è la stringa vuota

Uno dei maggiori svantaggi di Add ++ è la mancanza di istruzioni composte, che richiede una seconda variabile di ciclo. Assegniamo le nostre due variabili:

Con il codice

`aa,xx|yy,`bb,Byy

|B $\mathit{xx}$$\mathit{yy}$xx:yy

$\mathit{ff}$$\mathit{aa}$$\mathit{bb}$

$\mathit{aa}$$\mathit{x} = \mathit{y}$$\mathit{aa}$$\mathit{yy}$$\mathit{bb}$$\mathit{aa}$

Raggiungiamo quindi la nostra dichiarazione finale:

O

$\mathit{bb}$

• $\mathit{aa} = 1$$\mathit{bb} = \mathrm{False}$$\mathrm{False}$
• $\mathit{aa} = \mathrm{True}$$\mathit{bb} = \mathrm{False}$$\mathrm{False}$
• $\mathit{aa} = \mathrm{False}$$\mathit{bb} = \mathrm{True}$$\mathrm{True}$

$\mathit{bb}$$\mathit{bb}$$\mathrm{True}$$\mathrm{False}$

JavaScript (ES6), 76 byte

Restituisce un valore booleano.

ff=ss=>ss==(ss=ss.replace(/(.)\1/,''))?!ss:ff(ss)//)(:!?,/1\).(/(ecalper.=(>

Provalo online!

Suggerito da @Shaggy: 58 byte restituendo una stringa vuota per l' abbinamento perfetto o lanciando un errore in caso contrario.

Wolfram Language (Mathematica) , 70 64 byte

{#//.{aa___,bb__,bb_,cc___}:>{aa,cc}}=={{}}(**(,{>:}_,{.#{&)**)&

Provalo online!

Senza commenti, 92 byte

((#//.bb_:>StringReplace[00[ecalpeRgnirtS>aa__:_.#&];bb,{{,}};00>00;00;aa:_~~aa_:>""]))==""&

Provalo online!

Lua , 178 byte

p=...S={}for a in p:gmatch"."do E=S[#S]~=a;S[E and#S+1 or#S]=E and a or X end;print(#S==0)--)0S#(tnirp;dne X ro a dna E=]S#ro 1+S#dna E[S;a=~]S#[S=E od"."hctamg:p ni a rof}{=S.=p

Provalo online!

Sebbene sia una soluzione terribilmente lunga, questo fa un po 'uso delle stranezze specifiche di Lua. Questo è in realtà un algoritmo di stack di forza bruta minimizzato. Il programma è complicato dal fatto che i modelli di Lua non consentono la sostituzione di coppie e che regex non è integrato.

Spiegazione:

p=... -- command-line argument
S={} -- the stack
for c in p:gmatch"." do -- shorter than "for i=1,#p do ..."
    E=S[#S]~=c -- check whether we have the right letter on top of stack
    -- could've saved some bytes by doing == instead of ~=
    -- but the double negation is necessary for ternary operator
    -- to work with nil values
    S[E and #S+1 or #S]=E and c or X -- Lua's awesome "ternary operator"
end
-- i'm sure there is a better way to output this (table indexing?)
print(#S==0)

Gol> <> , 30 byte

1ll1**F:}}:{=Q{~~||lzBBzl{Q={F

Provalo online!

Tutto dopo il primo Bè un codice in eccesso e non viene eseguito. Una funzione che restituisce la parte superiore dello stack come 1se l'input sia un accoppiamento perfetto,0 altrimenti.

Spiegazione:

1       Push 1 as the end string marker
 ll1**  Push n, where n (len+1)*(len+2), 
        This is larger than the amount of steps needed to determine pairing
      F           |  Repeat that many times
       :}}:{=        Compare the first two characters of the string
             Q   |   If they are equal
              {~~    Pop both of them
        String is also rotated by 1
        If the string becomes empty, the 1 is compared to itself and removed.
                   lzB   Return whether the length of the stack is 0
                      Bzl{Q={F  Excess code to match unpaired symbols

Cubix , 30 byte

1O@;??;@ii??O;>>;;;..1Wcc1??1W

Provalo online!

Emette 1se la stringa è perfettamente accoppiata e nient'altro.

Cubified

      1 O @
      ; ? ?
      ; @ i
i ? ? O ; > > ; ; ; . .
1 W c c 1 ? ? 1 W . . .
. . . . . . . . . . . .
      . . .
      . . .
      . . .

semplificata

      1 O @
      ; ? .
      . @ .
i ? . . . . > ; ; ; . .
. W c . . . ? 1 W . . .
. . . . . . . . . . . .
      . . .
      . . .
      . . .

La logica e la struttura generale sono le stesse della risposta di Mnemonic, ma senza un controllo esplicito per la stringa vuota.

Haskell , 92 byte

gg""

gg((aa:cc:bb))dd|aa==cc=gg bb dd

gg  aa""=""==aa

gg  aa((bb:c))=gg((bb:aa))c--c:=c:|

Provalo online!

La risposta di @ nimi è piuttosto interessante, non usa alcun commento. Questo è più corto ma usa un commento.

La risposta di @ xnor è anche piuttosto interessante, usa i commenti ed è più breve di questa.

Python 2 , 114 byte

import re

e=lambda i,nn=1:e(*re.subn('(.)\\1','',i))if nn else''==i##ieslef'1).('(nbus.er*(e:1=,i adbmal=r tropmi

Provalo online!

Restituisce Truestringhe perfettamente accoppiate, Falsealtrimenti.

(In realtà non riesce a verificare se stesso, perché (.)non corrisponde alle nuove righe nel codice! Ma la procedura guidata @Cat ha detto che va bene, perché le nuove righe non sono caratteri ASCII stampabili, quindi il mio programma non deve gestirle.)

Questa è una versione perfettamente abbinata di:

import re;p=lambda s,n=1:p(*re.subn('(.)\\1','',s))if n else''==i

per cui una perfezionamento "più pigro" di code + '##' + f(code[::-1])darebbe 120 byte. (Cioè, rinominando le variabili ecc. Per introdurre più coppie compresse all'interno del commento la metà del codice ha salvato 6 byte.)

re.subnè una variante poco nota re.subche restituisce una tupla (new_string, number_of_substitutions_made). È abbastanza buono per trovare punti fissi di sostituzione regex!

Gelatina , 26 24 22 byte

ẠƬµF€ḂLḣgŒŒgḣLḂ$$€FµƬẠ

Provalo online!

Stranamente sembra funzionare senza spostare il codice all'indietro su un collegamento non utilizzato.

Restituisce 0 se l'ingresso è perfettamente accoppiato, 1 altrimenti.

Codice attivo:

ŒgḣLḂ$$€FµƬẠ
Œg            Group runs 'abbbcc'->['a','bbb','cc']
       €      For each of these strings:
      $       Monad{
     $            Monad{
   L                  Find the length...
    Ḃ                 ...mod 2. 
                      } -> [1, 1, 0] in this example.
  ḣ               Take this many characters from the string.
                  } -> [['a'], ['b'], []]
        F     Flatten -> ['a', 'b']
          Ƭ   Repeat...
         µ    The last monadic chain until a fixed point is reached.
           Ạ  All. If it is not a perfectly paired string, all elements in the 
              result of Ƭ will be nonempty and 1 is returned.
              If it is perfectly paired, the last element is [] which is falsy
              and 0 is returned.

Attache , 82 byte

{0=#Fixpoint[{Replace[_,/"(.)\\1",""]},_]}??}]_,}],"1).("/,_[ecalpeR{[tniopxiF#=0{

Provalo online!

Niente di incredibile qui. Fixpointuna funzione che rimuove le coppie consecutive.

Java 8, 158 156 154 byte

n->{for(;n.matches(".*(.)\\1.*");n=n.replaceAll("(.)\\1",""));return  n.isEmpty();}//};)(ytpmEsi.ruter;,"1).("(Aecalper.n=n;)"*.1).(*."(sehctam.n;(rof{>-n

Restituisce un valore booleano ( true/ false).

-2 byte grazie a @raznagul .

Provalo online.

Spiegazione:

n->{                              // Method with String parameter and boolean return-type
  for(;n.matches(".*(.)\\1.*");   //  Loop as long as the String still contains pairs
    n=n.replaceAll("(.)\\1","")); //   Remove all pairs
  return  n.isEmpty();}           //  Return whether the String is empty now
//};)(ytpmEsi.ruter;,"1).("(Aecalper.n=n;)"*.1).(*."(sehctam.n;(rof{>-n
                                  // Comment reversed of the source code,
                                  // minus the pairs: '\\';'ll';'\\';'""))';'n  n';'//'