Detectar parejas perfectas

25

Tengamos una función que toma una cadena y elimina todos los pares de caracteres idénticos adyacentes. Por ejemploF

F(unasisisiunadodo)=unasiuna

Tenga en cuenta que cuando dos pares se superponen, solo eliminamos uno de ellos.

Llamaremos a una cadena perfectamente emparejada si la aplicación repetida finalmente produce la cadena vacía. Por ejemplo, la cadena de arriba de no está perfectamente emparejada porque si aplicamos nuevamente, todavía obtenemos . Sin embargo, una cadena como está perfectamente emparejada porque si aplicamos tres veces obtenemos la cadena vacíaunasisisiunadodoFunasiunamiunasisidodounareremiF

F(miunasisidodounareremi)=miunaunami

F(miunaunami)=mimi

F(mimi)=


Su tarea es escribir un código de computadora perfectamente emparejado que tome una cadena (de ASCII imprimible) y decida si está perfectamente emparejado. La cadena de bytes de su fuente debe ser una cadena perfectamente emparejada , aunque su código no necesariamente tiene que estar restringido a ASCII imprimible.

Puede generar dos valores distintos: uno para el caso en que la entrada está perfectamente emparejada y otro para los casos en que no lo está.

Esta es una pregunta de , por lo que las respuestas se puntuarán por el tamaño en bytes de su fuente con menos bytes mejor.


Casos de prueba

unasisisiunadodoFunalsmiunasidosiunaFunalsmiunasiunasiFunalsmiunasisisiunaunasiunadodoTrtumimiunasisidodounareremiTrtumisisisisiTrtumi

Asistente de trigo
fuente
1
Si bien puede ser demasiado tarde para cambiarlo ahora, siento que la parte "retorcida" del desafío se vuelve casi inútil si permite comentarios o un código similar "muerto".
Geobits
11
@Geobits no estoy de acuerdo. Por un lado, creo que rechazar el código muerto es solo un fango de definiciones vagas y, de todos modos, nunca resulta divertido. Para dos, creo que permitir comentarios reduce la barra de entrada. Para tres, creo que el código sin comentarios inevitablemente será una mejor puntuación que el código con comentarios completos. Tal vez el giro no sea divertido, pero definitivamente sería menos divertido si agregara restricciones irrefutables para que las respuestas lo hagan de una manera particular.
Wheat Wizard
44
A Unary le importa un comino su regla de restricción de fuente, mwahahahaha (es decir, siempre y cuando la respuesta tenga un número par de bytes).
Arnauld
2
@Geobits Una cosa que podría haber fomentado respuestas más creativas es factorizar el número de pasos para llegar a la cadena vacía en la puntuación. El uso de comentarios tiende a hacer que este número sea bastante alto porque los comentarios se anidan naturalmente donde una puntuación más baja requiere que entrelaces un poco los pares. Obviamente, es demasiado tarde para hacer ese cambio.
Wheat Wizard
1
@dylnan La cadena vacía puede ser, en bucle para siempre, sin embargo, no es una salida válida.
Wheat Wizard

Respuestas:

10

Haskell, 146124 bytes

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

Sin comentarios. Devuelve ya sea Trueo False.

Pruébalo en línea!

Editar: -22 bytes gracias a @Cat Wizard

nimi
fuente
2
Este es el haskell menos haskell que he visto en mi vida
Cubic
5

Python 2 , 94 bytes

ss=''

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

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

Pruébalo en línea!

Todo el paso de actualización se ss=[cc+ss,ss[1:]][cc==ss[:1]]cancela a solo =[+,[.

xnor
fuente
5

05AB1E , 26 24 22 20 18 bytes

-2 bytes gracias a los ovs . Emite 0 si la cadena está perfectamente emparejada, 1 de lo contrario.

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

Pruébalo en línea!

ΔγʒgÉ} JJ} ĀqqĀÉgʒγΔ - Programa completo.
Δ} - Hasta que el resultado ya no cambie:
 γʒ} - Divide la cadena en trozos de caracteres iguales y filtra por:
   gÉ - ¿Es la longitud impar?
      JJ - Y después de filtrar, une las partes nuevamente, pero haz esto
                     dos veces para guardar 2 bytes, como en las versiones anteriores.
         Ā - Comprueba si el resultado está vacío
          q - Terminar (salir) la ejecución. El resto del código se ignora.
           qĀÉgʒγΔ: refleja la parte no coincidente para ayudar con el diseño de origen.

Versión anterior

Éste se basa únicamente en un comportamiento indefinido (por lo que no hay un "código muerto"), y genera [['' 0 ']] para cadenas perfectamente emparejadas y [[' 1 ']] para cadenas no perfectamente combinadas:

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

Y la versión de 22 bytes, explicada, que es solo la anterior pero no abusa de UB, y arroja valores razonables .

Δγε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.
Sr. Xcoder
fuente
5

Cubix , 54 bytes

U#;[email protected]>??>i..??O.@1^^...u--u.u!ww;..#..U..;..;!^^!

No genera nada si la cadena está perfectamente emparejada y de lo 1contrario.
Pruébalo aquí

Cubified

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

Explicación

La mayoría de los caracteres son de relleno necesarios para emparejar perfectamente el código. Reemplazando aquellos con .(no-op), obtenemos

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

Esto se puede dividir en tres pasos:

  • Verifique con la cadena vacía (la izquierda iy la ?).
  • Bucle, arrojando personajes a la pila y haciendo estallar duplicados (todo en la parte inferior y derecha).
  • Compruebe si la pila está vacía (las cosas en la parte superior).

fuente
4

V , 20 , 18 bytes

òóˆ±òø‚

::‚øò±ˆóò

Pruébalo en línea!

Hexdump:

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

Salidas 0 para verdad, 1 para falsedad. Gracias a nmjcman101 por guardar indirectamente 2 bytes.

ò        ò        " 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
DJMcMayhem
fuente
Podrías reemplazar ^$con .y devolver 0 para verdad, ¿algo más para falsedad? Estoy un poco confuso sobre las reglas después de no hacer esto por un tiempo.
nmjcman101
Creo que funcionaría, excepto que las reglas decían que puede generar dos valores distintos , uno para el caso donde la entrada está perfectamente emparejada y otra para lo contrario. . Sin embargo, eso me da una idea ...
DJMcMayhem
3

R , 142126 bytes

Una lógica más estricta y algunos bytes de comentarios desarrollados por @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

Pruébalo en línea!

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

Original:

Pruébalo en línea!

Función de detector recursivo seguido de comentario con todos los caracteres de la función en orden inverso.

ngm
fuente
Su código actualmente arroja un error. Aquí hay una versión funcional de 142 bytes.
ovs
Gracias. Debe haber sido un contratiempo de cortar y pegar.
ngm
126 bytes : es posible que puedas comprimir el comentario un poco más ...
Giuseppe
Me pregunto si `\\ ˋ se simplificará o si necesita ser duplicado en los comentarios.
JayCe
@ JayCe pensarías que no necesitaría estar en los comentarios, pero prueba esto y parece que no funciona. No se porque.
ngm
2

Brain-Flak , 228 200 bytes

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

Pruébalo en línea!

Esta es una prueba de concepto. Probablemente podría ser más corto. Sin embargo, no utiliza ningún comentario.

Emite 0,0si la entrada está perfectamente emparejada y 0,1si la entrada no lo está.

Asistente de trigo
fuente
2

sed 4.2.2 , 34 bytes

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

Pruébalo en línea!

Las cadenas emparejadas dan salida vacía, las no emparejadas dan ct:

La versión palindrómica trivial está en 32 :;ss(.)\1ss;t;/./cc/./;t;1\).(;:. La solución anterior fue :;ss((..??\??))\1ss1;t;;/./cc/./t:(cambiada porque la actual abusó cmenos, editar: sí, ahora solo hay 1 carácter después de c: D)

(tenga en cuenta que ;es el separador de declaraciones)

: declara una etiqueta vacía

:t declara la etiqueta t

ss((..??\??))\1ss1es una sustitución, en sed puedes cambiar el delimitador a una sustitución, y esto es lo que hice al cambiarlo s, por lo que lo que hace es sustituir el primero (como se indica 1al final)

  • partido de ((..??\??))\1

    • . cualquier personaje
    • .?? seguido de un carácter opcional opcional
    • \?? y un opcional ?
    • seguido de lo mismo justo al lado
  • sin nada

Ahora esta sustitución está emparejada consigo misma, por lo que el ;s antes y después de que se cancele también

t y volver a la etiqueta hasta que no haya más sustituciones exitosas

/..?/if .(comodín) seguido de .?un carácter opcional coincide

  • cc cambiar el búfer a c
Kritixi Lithos
fuente
2

Brain-Flak , 112 110 108 bytes

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

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

Pruébalo en línea!

Esto se basa en mi respuesta de ¿Se corresponden los corchetes? .

Intenté no usar comentarios, pero me quedé atrapado tratando de hacer que el pop nilads ( {}) se empareje . El problema radica en que la forma más fácil de emparejar un par de corchetes es rodearlo en otro par del mismo tipo. Si bien esto es fácil para otras nilas, la {...}mónada crea bucles. Para salir del bucle, debe presionar un 0, pero una vez que haya salido del bucle, debe hacer estallar el 0, lo que agrava el problema.

La solución preparada de 66 bytes es:

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

Pruébalo en línea!

Salidas 1o 1,0si la entrada es un emparejamiento perfecto, 0,0si no.

Versión sin comentarios, 156 bytes

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

Pruébalo en línea!

Como señaló Cat Wizard, la primera respuesta no funciona para todos los intérpretes, ya que no todos manejan los #comentarios. Esta versión no contiene comentarios.

Jo King
fuente
Tenga en cuenta que esto solo funciona en el intérprete ruby ​​brainflak y, por lo tanto, no es una respuesta pura de brainflak
Wheat Wizard
@ CatWizard ¿Hay un intérprete canónico Brain-Flak? Hasta donde yo sé, Rain-Flak (Ruby) es el intérprete original. (Además, estoy trabajando en una solución sin comentarios)
Jo King
Realmente no. Rain-Flak es el intérprete original, pero su sintaxis de comentarios es única. Hace un tiempo escribimos un estándar de Brain-Flak, aunque no recuerdo dónde terminó.
Wheat Wizard
@ CatWizard terminó la versión sin comentarios
Jo King
2

Japt, 24 22 bytes

Salidas falsepara la verdad y truepara falsey.

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

Intentalo

Lanudo
fuente
Funcionaria «e"(.)%1?
Oliver
@ Oliver, eso es lo que tenía originalmente antes de que me llamaran la atención las restricciones de origen. Sin embargo, todavía estoy tratando de encontrar una manera de hacerlo funcionar «.
Shaggy
@ Oliver, no funciona , lamentablemente.
Shaggy
Sospecho que puede haber pasado por alto la parte de fuente restringida / diseño de fuente del desafío, @Oliver.
Shaggy
Lo hice ... mi mal.
Oliver
2

Brain-Flak , 96 bytes

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

Pruébalo en línea!

No genera nada si la entrada está perfectamente emparejada, y de lo 0contrario.

Versión no perfectamente emparejada (original):

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

Pruébalo en línea!

Nitrodon
fuente
2

Haskell , 66 bytes

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

Pruébalo en línea!

Cat Wizard ahorró 6 bytes.

xnor
fuente
1
66 bytes
Wheat Wizard
@ CatWizard Eso es un impresionante colapso de larga distancia.
xnor
62 bytes
Asistente de trigo
2

Agregar ++ , 146 bytes

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`

Pruébalo en línea!

Dato curioso: esto fue 272 bytes mucho antes de que se iniciara la explicación, ahora supera a Java.

Salidas Truepara cuerdas perfectamente equilibradas, y de lo Falsecontrario

Para mi gran satisfacción, esto supera la aburrida versión de palindromize en 2 bytes, para evitar que el resultado se imprima dos veces. También he tratado de tener el menor código muerto posible, sin embargo, todavía hay algunas secciones comentadas, y el código sale con un código de error de 1 , después de imprimir el valor correcto.

NB : Se solucionó un error con los BFcomandos mientras esta respuesta estaba en desarrollo.

Cómo funciona

FFsolFFFFsolSFF(S)S

Sunasisisiunaunasiunadodo[[una],[sisisi],[unauna],[si],[una],[dodo]]sol, y reemplace las sublistas con el resultado de la función.

sol2X[una][sisi][dododo]

[una][una,1]
[sisi][si,si,0 0]
[dododo][do,do,do,1]

XX>2X-2X*

sol(s)sBF^D,ff,@^^,solrr;;

FFsolFF

  • XXFF
  • yyFF
  • unauna
  • sisiyy

solXyunasisol

unasido{...}sol{...}solsolFFsol

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

que es 4 bytes más largo.

X=5 5X=15

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

X`

FFsolXXxx:?XXunaunaaa:11XXsisi

`bb
Bxx

sisiXXunauna: =1sisi: =¬¬XX

Luego ingresamos a nuestro ciclo while:

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

Un ciclo while es una construcción en Add ++: opera directamente en código, en lugar de variables. Las construcciones toman una serie de sentencias de código, separadas con ,las que operan. Las sentencias while y if también toman una condición directamente anterior a la primera, ,que consiste en una única declaración válida, como un comando infijo con variables. Una cosa a tener en cuenta: la variable activa no se puede omitir de la condición.

aa*bbunaunasisiyyFF(X)

`yy,$ff>xx

unauna

  • 1) El nuevo valor no es igual al valor anterior (bucle mientras único)
  • 2) El nuevo valor no es la cadena vacía

Uno de los mayores inconvenientes de Add ++ es la falta de declaraciones compuestas, lo que requiere tener una segunda variable de bucle. Asignamos nuestras dos variables:

unauna: =XXyy
sisi: =¬¬(yy)

Con el código

`aa,xx|yy,`bb,Byy

|B XXyyxx:yy

FFunaunasisi

unaunaX=yunaunayysisiunauna

Luego llegamos a nuestra declaración final:

O

sisi

  • unauna=1sisi=FunalsmiFunalsmi
  • unauna=Trtumisisi=FunalsmiFunalsmi
  • unauna=Funalsmisisi=TrtumiTrtumi

sisisisiTrtumiFunalsmi

Comunidad
fuente
1

JavaScript (ES6), 76 bytes

Devuelve un booleano.

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

Pruébalo en línea!

Sugerido por @Shaggy: 58 bytes devolviendo una cadena vacía para emparejar perfectamente o arrojando un error de lo contrario.

Arnauld
fuente
1
Si uno de los "valores de retorno" puede ser un error (en espera de confirmación), podría ser 66 bytes .
Shaggy
Los programas pueden salir por defecto a través del código de salida . En el caso particular de esta respuesta, las posibles salidas serían el código de salida 0 para cadenas perfectamente emparejadas y el código de salida 1 para cadenas no perfectamente emparejadas, que son dos valores distintos que cumplen los criterios; entonces el byter 58 debe ser perfectamente válido.
Sr. Xcoder
1

Lua , 178 bytes

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

Pruébalo en línea!

Si bien es una solución terriblemente larga, esto hace bastante uso de las peculiaridades específicas de Lua. Esto es en realidad un algoritmo de pila de fuerza bruta minimizado. El programa se complica por el hecho de que los patrones de Lua no permiten reemplazar pares y la expresión regular no está integrada.

Explicación:

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)
PhilipRoman
fuente
1

Gol> <> , 30 bytes

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

Pruébalo en línea!

Todo después del primero Bes un código en exceso y no se ejecuta. Una función que devuelve la parte superior de la pila como 1si la entrada fuera un emparejamiento perfecto, de lo 0contrario.

Explicación:

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
Jo King
fuente
1

Cubix , 30 bytes

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

Pruébalo en línea!

Salidas 1si la cadena está perfectamente emparejada y nada más.

Cubified

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

Simplificado

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

La lógica y la estructura general son las mismas que en la respuesta de Mnemonic, pero sin una comprobación explícita de la cadena vacía.

Nitrodon
fuente
0

Python 2 , 114 bytes

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

Pruébalo en línea!

Devoluciones Truepara cadenas perfectamente emparejadas, de lo Falsecontrario.

(¡Realmente no se verifica a sí mismo, porque (.)no coincidirá con las nuevas líneas en el código! Pero @Cat Wizard dijo que está bien, porque las nuevas líneas no son caracteres ASCII imprimibles, por lo que mi programa no necesita manejarlos).


Esta es una versión perfectamente emparejada de:

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

para lo cual una perfeccionización "más perezosa" code + '##' + f(code[::-1])daría 120 bytes. (Es decir, cambiar el nombre de las variables, etc. para introducir más pares contraídos dentro del comentario, la mitad del código guardó 6 bytes).


re.subnEs una variante poco conocida re.subque devuelve una tupla (new_string, number_of_substitutions_made). ¡Es bastante bueno para encontrar puntos de fijación de sustitución de expresiones regulares!

Lynn
fuente
0

Jalea , 26 24 22 bytes

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

Pruébalo en línea!

Extrañamente parece funcionar sin mover el código hacia atrás a un enlace no utilizado.

Devuelve 0 si la entrada está perfectamente emparejada, 1 de lo contrario.

Codigo activo:

Œ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.
dylnan
fuente
0

Adjunto , 82 bytes

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

Pruébalo en línea!

Nada increible aqui. FixpointUna función que elimina pares consecutivos.

Conor O'Brien
fuente
0

Java 8, 158 156 154 bytes

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

Devuelve un booleano ( true/ false).

-2 bytes gracias a @raznagul .

Pruébalo en línea.

Explicación:

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';'//'
Kevin Cruijssen
fuente
1
Por el cambio de nombre sa ny la adición de un segundo espacio que return s.isEmptyse puede extraer s nde la observación, el ahorro de 2 bytes en total.
raznagul