Una actividad que a veces hago cuando estoy aburrido es escribir un par de caracteres en pares coincidentes. Luego dibujo líneas (sobre las partes superiores nunca debajo) para conectar estos personajes. Por ejemplo, podría escribir y luego dibujaría las líneas como:$abcbac$

O podría escribir$abbcac$

Una vez que he dibujado estas líneas, trato de dibujar bucles cerrados alrededor de los fragmentos para que mi bucle no se cruce con ninguna de las líneas que acabo de dibujar. Por ejemplo, en el primero, el único bucle que podemos dibujar es alrededor de todo, pero en el segundo podemos dibujar un bucle alrededor de solo s (o todo lo demás)$b$

Si jugamos un poco con esto, descubriremos que algunas cadenas solo se pueden dibujar para que los bucles cerrados contengan todas o ninguna de las letras (como nuestro primer ejemplo). Llamaremos a estas cadenas cadenas bien vinculadas.

Tenga en cuenta que algunas cadenas se pueden dibujar de múltiples maneras. Por ejemplo, se puede dibujar de las dos formas siguientes (y una tercera no incluida):$bbbb$

o

Si se puede dibujar una de estas formas de modo que se pueda hacer que un bucle cerrado contenga algunos de los caracteres sin intersectar ninguna de las líneas, entonces la cadena no está bien vinculada. (entonces no está bien vinculado)$bbbb$

Tarea

Su tarea es escribir un programa para identificar cadenas que estén bien vinculadas. Su entrada consistirá en una cadena donde cada carácter aparece un número par de veces, y su salida debe ser uno de dos valores consistentes distintos, uno si las cadenas están bien vinculadas y el otro en caso contrario.

Además, su programa debe ser un significado de cadena bien vinculado

• Cada personaje aparece un número par de veces en su programa.

• Debería generar el valor verdadero cuando se pasa a sí mismo.

Su programa debe poder producir la salida correcta para cualquier cadena que conste de caracteres de ASCII imprimible o de su propio programa. Con cada personaje apareciendo un número par de veces.

Las respuestas se puntuarán como sus longitudes en bytes, siendo menos bytes una mejor puntuación.

Insinuación

Una cadena no está bien vinculada si existe una subcadena estricta contigua no vacía, de modo que cada carácter aparezca un número par de veces en esa subcadena.

Casos de prueba

abcbac -> True
abbcac -> False
bbbb -> False
abacbc -> True
abcbabcb -> True
abcbca -> False

Regex (ECMAScript 2018 o .NET), 140 126 118 100 98 82 bytes

^(?!(^.*)(.+)(.*$)(?<!^\2|^\1(?=(|(<?(|(?!\8).)*(\8|\3$){1}){2})*$).*(.)+\3$)!?=*)

Esto es mucho más lento que la versión de 98 bytes, porque ^\1queda de la búsqueda anticipada y, por lo tanto, se evalúa después. Vea a continuación un cambio simple que recupera la velocidad. Pero debido a esto, los dos TIO a continuación se limitan a completar un conjunto de casos de prueba más pequeño que antes, y el .NET es demasiado lento para verificar su propia expresión regular.

Pruébalo en línea! (ECMAScript 2018) ¡
Pruébelo en línea! (.RED)

Para eliminar 18 bytes (118 → 100), robé descaradamente una optimización realmente agradable de la expresión regular de Neil que evita la necesidad de poner una mirada hacia adelante dentro de la mirada negativa hacia atrás (produciendo una expresión regular sin restricciones de 80 bytes). Gracias Neil!

¡Eso se volvió obsoleto cuando dejó caer unos increíbles 16 bytes más (98 → 82) gracias a las ideas de jaytea que llevaron a una expresión regular sin restricciones de 69 bytes! Es mucho más lento, ¡pero eso es golf!

Tenga en cuenta que los (|(no-ops para hacer que la expresión regular esté bien vinculada tienen el resultado de hacer que se evalúe muy lentamente en .NET. No tienen este efecto en ECMAScript porque las coincidencias opcionales de ancho cero se tratan como no coincidencias .

ECMAScript prohíbe los cuantificadores de afirmaciones, por lo que esto hace que el golf sea más difícil para los requisitos de fuentes restringidas . Sin embargo, en este punto está tan bien jugado que no creo que levantar esa restricción en particular abriría más posibilidades de golf.

Sin los caracteres adicionales necesarios para que pase las restricciones ( 101 69 bytes):

^(?!(.*)(.+)(.*$)(?<!^\2|^\1(?=((((?!\8).)*(\8|\3$)){2})*$).*(.)+\3))

Es lento, pero esta edición simple (por solo 2 bytes adicionales) recupera toda la velocidad perdida y más:

^(?!(.*)(.+)(.*$)(?<!^\2|(?=\1((((?!\8).)*(\8|\3$)){2})*$)^\1.*(.)+\3))

^
(?!
    (.*)               # cycle through all starting points of substrings;
                       # \1 = part to exclude from the start
    (.+)               # cycle through all ending points of non-empty substrings;
                       # \2 = the substring
    (.*$)              # \3 = part to exclude from the end
    (?<!               # Assert that every character in the substring appears a total
                       # even number of times.
        ^\2            # Assert that our substring is not the whole string. We don't
                       # need a $ anchor because we were already at the end before
                       # entering this lookbehind.
    |                  # Note that the following steps are evaluated right to left,
                       # so please read them from bottom to top.
        ^\1            # Do not look further left than the start of our substring.
        (?=
            # Assert that the number of times the character \8 appears in our
            # substring is odd.
            (
                (
                    ((?!\8).)*
                    (\8|\3$) # This is the best part. Until the very last iteration
                             # of the loop outside the {2} loop, this alternation
                             # can only match \8, and once it reaches the end of the
                             # substring, it can match \3$ only once. This guarantees
                             # that it will match \8 an odd number of times, in matched
                             # pairs until finding one more at the end of the substring,
                             # which is paired with the \3$ instead of another \8.
                ){2}
            )*$
        )
        .*(.)+         # \8 = cycle through all characters in this substring
        # Assert (within this context) that at least one character appears an odd
        # number of times within our substring. (Outside this negative lookbehind,
        # that is equivalent to asserting that no character appears an odd number
        # of times in our substring.)
        \3             # Skip to our substring (do not look further right than its end)
    )
)

Lo escribí usando lookahead molecular ( 103 69 bytes) antes de convertirlo en lookbehind de longitud variable:

^(?!.*(?*(.+)(.*$))(?!^\1$|(?*(.)+.*\2$)((((?!\3).)*(\3|\2$)){2})*$))

^
(?!
    .*(?*(.+)(.*$))       # cycle through all non-empty substrings;
                          # \1 = the current substring;
                          # \2 = the part to exclude from the end
    (?!                   # Assert that no character in the substring appears a
                          # total even number of times.
        ^\1$              # Assert that our substring is not the whole string
                          # (i.e. it's a strict substring)
    |
        (?*(.)+.*\2$)    # \3 = Cycle through all characters that appear in this
                          # substring.
        # Assert (within this context) that this character appears an odd number
        # of times within our substring.
        (
            (
                ((?!\3).)*
                (\3|\2$)
            ){2}
        )*$
    )
)

Y para ayudar a que mi expresión regular esté bien vinculada, he estado usando una variación de la expresión regular anterior:

(?*(.+)(.*$))(?!^\1$|(?*(.)+.*\2$)((((?!\3).)*(\3|\2$)){2})*$)\1

Cuando se usa con regex -xml,rs -o, esto identifica una subcadena estricta de la entrada que contiene un número par de cada carácter (si existe). Claro, podría haber escrito un programa sin expresiones regulares para hacer esto por mí, pero ¿dónde sería la diversión en eso?

Jalea, 20 bytes

ĠẈḂẸẆṖÇ€Ạ
ĠẈḂẸ
ẆṖÇ€Ạ

Pruébalo en línea!

La primera línea se ignora. Solo está allí para satisfacer la condición de que cada personaje aparezca un número par de veces.

La siguiente línea primero Ġenruta los índices por su valor. Si luego tomamos la longitud de cada sublista en la lista resultante ( Ẉ), obtenemos el número de veces que aparece cada carácter. Para verificar si alguno de estos no es par, obtenemos el último Ḃde cada recuento y preguntamos si existe Ẹun valor verdadero (distinto de cero).

Por lo tanto, este enlace auxiliar devuelve si una subcadena no se puede marcar.

En el enlace principal, tomamos todas las subcadenas de la entrada ( Ẇ), Ṗdesactivamos la última (para que no verifiquemos si se puede encerrar en un círculo toda la cadena) y ejecutamos el enlace auxiliar ( Ç) en una €subcadena ach. El resultado es entonces si todas las Ạsubcadenas no pueden encerrarse en un círculo.

J , 34 bytes

2:@':.,|~*'>1(#.,)*/@(1>2|#/.~)\.\

Pruébalo en línea!

-8 bytes gracias a FrownyFrog

original

J , 42 bytes

(*#'.,012&|@~#')=1#.[:,([:*/0=2&|@#/.~)\.\

Pruébalo en línea!

explicación

(*#'.,012&|@~#') = 1 #. [: , ([: */ 0 = 2&|@#/.~)\.\

(*#'.,012&|@~#')                                       NB. this evaluates to 1
                                                       NB. while supplying extra
                                                       NB. chars we need.  hence...
                 =                                     NB. does 1 equal...
                   1 #.                                NB. the sum of...
                        [: ,                           NB. the flatten of...
                             (                  )\.\   NB. the verb in parens applied
                                                       NB. to every suffix of every
                                                       NB. prefix, ie, all contiguous 
                                                       NB. substrings
                             ([: */ 0 = 2&|@#/.~)      NB. def of verb in paren:
                                             /.~       NB. when we group by each
                                                       NB. distinct char...
                              [: */                    NB. is it the case that
                                                       NB. every group...
                                           @#          NB. has a length...
                                    0 = 2&|            NB. divisible by 2...

Python 3.8 (prelanzamiento) , 66 bytes

lambda l,b={id}:len({str(b:=b^{c})for(c)in l})<len(l)#,<^fmnost{}#

Pruébalo en línea!

La era de las expresiones de asignación está sobre nosotros. Con PEP 572 incluido en Python 3.8, el golf nunca será el mismo. Puede instalar la versión preliminar del desarrollador 3.8.0a1 aquí .

Las expresiones de asignación le permiten usar :=para asignar una variable en línea mientras evalúa ese valor. Por ejemplo, (a:=2, a+1)da (2, 3). Por supuesto, esto puede usarse para almacenar variables para su reutilización, pero aquí vamos un paso más allá y lo usamos como un acumulador en una comprensión.

Por ejemplo, este código calcula las sumas acumulativas [1, 3, 6]

t=0
l=[1,2,3]
print([t:=t+x for x in l])

Observe cómo con cada paso por la comprensión de la lista, la suma acumulativa taumenta xy el nuevo valor se almacena en la lista producida por la comprensión.

Del mismo modo, b:=b^{c}actualiza el conjunto de caracteres bpara alternar si incluye caracteres cy evalúa el nuevo valor de b. Por lo tanto, el código [b:=b^{c}for c in l]itera sobre caracteres cen ly se acumula el conjunto de caracteres visto un número impar de veces en cada prefijo no vacío.

Esta lista se verifica en busca de duplicados al convertirla en una comprensión establecida y ver si su longitud es menor que la de s, lo que significa que algunas repeticiones se colapsaron. Si es así, la repetición significa que en la porción de svisto entre esos momentos cada carácter encontró un número par de números, haciendo que la cadena no esté bien vinculada. Python no permite conjuntos de conjuntos por no ser compartibles, por lo que los conjuntos internos se convierten en cadenas.

El conjunto bse inicializa como argumentos opcionales y se modifica con éxito en el ámbito de la función. Me preocupaba que esto hiciera que la función no sea reutilizable, pero parece restablecerse entre ejecuciones.

Para la restricción de fuente, los caracteres no apareados se rellenan en un comentario al final. Escribir en for(c)in llugar de for c in lcancelar los padres adicionales de forma gratuita. Lo colocamos iden el conjunto inicial b, que es inofensivo ya que puede comenzar como cualquier conjunto, pero el conjunto vacío no se puede escribir {}porque Python creará un diccionario vacío. Dado que las letras iy se dencuentran entre las que necesitan emparejamiento, podemos poner la función idallí.

Tenga en cuenta que el código genera booleanos negados, por lo que se dará correctamente Falsesobre sí mismo.

Python 2 , 74 bytes

bmn0=f=lambda s,P={0},d=[]:s<" "if(P in d)else+f(s[f<s:],P^{s[0^0]},[P]+d)

Pruébalo en línea!

Itera a través de la cadena, haciendo un seguimiento Pdel conjunto de caracteres vistos un número impar de veces hasta ahora. La lista dalmacena todos los valores pasados ​​de P, y si ve el actual Pya en d, esto significa que en los caracteres vistos desde ese momento, cada carácter ha aparecido un número par de veces. Si es así, verifique si hemos pasado por toda la entrada: si lo hemos hecho, acepte porque toda la cadena está emparejada como se esperaba y, de lo contrario, rechace.

Ahora sobre la restricción de la fuente. Los personajes que necesitan emparejarse se rellenan en varios lugares inofensivos, subrayados a continuación:

bmn0=f=lambda s,P={0},d=[]:s<" "if(P in d)else+f(s[f<s:],P^{s[0^0]},[P]+d)
_____              _              _      _    _    ___        ___    

Se f<sevalúa 0mientras se empareja f, aprovechando que el nombre de la función también fse define (cuando se llama a la función). 0^0Absorbe un ^símbolo.

El 0in P={0}es lamentable: en Python se {}evalúa como un dict vacío en lugar de un conjunto vacío como queremos, y aquí podemos poner cualquier elemento que no sea de carácter y será inofensivo. Sin embargo, no veo nada de repuesto, y lo he puesto 0y duplicado bmn0, costando 2 bytes. Tenga en cuenta que los argumentos iniciales se evalúan cuando se define la función, por lo que las variables que definimos nosotros mismos no se pueden poner aquí.

Perl 6 , 76 bytes

*.comb[^*X+(^*).map(^*)].grep({$_&[&]($_)}).none.Bag{*}.none%2#*^+XBob2rec%#

Pruébalo en línea!

A Cualquiera que sea lambda que devuelva un cruce de ninguno o ninguno de los cruces que pueden ser boolificados a un valor verdadero / falso. Sin embargo, recomendaría no eliminar el ?que boolifica el resultado de retorno, de lo contrario, la salida se vuelve bastante grande .

Esta solución es un poco más compleja de lo que es necesario, debido a varias funciones implicadas ser disociados, por ejemplo .., all, >>, %%etc. sin la restricción fuente, esto podría ser 43 bytes:

*.comb[^*X.. ^*].grep(?*).one.Bag{*}.all%%2

Pruébalo en línea!

Explicación:

*.comb                     # Split the string to a list of characters
      [^*X+(^*).map(^*)]   # Get all substrings, alongside some garbage
                        .grep({$_&[&]($_)})        # Filter out the garbage (empty lists, lists with Nil values)
                                           .none                 # Are none of
                                                .Bag{*}          # The count of characters in each substring
                                                       .none%2   # All not divisible by 2

                                               #*^+XBob2rec%#    And garbage to even out character counts

Perl 5 -p, 94, 86, 78 bytes

m-.+(?{$Q|=@q&grp,$\|=$&eq$_^!grep+/^/&(@m=$g=~/\Q$_/g),($g=$&)=~/./g})(?!)-}{

salida 0 si está bien enlazado 1 de lo contrario.

78 bytes

86 bytes

94 bytes

Cómo funciona

• -pcon el }{truco final a la salida $\al final
• m-.+(?{.. })(?!)-, para ejecutar código sobre todas las subcadenas no vacías ( .+primero coincide con toda la cadena y después de ejecutar el código entre (?{.. })retrocesos debido a un error forzado(?!)
• $Q|=@q&grp, basura debido a la restricción de origen
• $\|=entero a nivel de bit o asignación, si hay casi un 1, $\será 1 (verdadero), por defecto está vacío (falso)
• $&eq$_el caso en el que el sbustring es la cadena completa se grabó en bits sin ^"ninguna ocurrencia de caracteres extraños"
• ($g=$&)=~/./gcopiar la subcadena coincidente en $g(porque se sobrescribirá después de la próxima coincidencia de expresiones regulares) y devolver la matriz de caracteres de la subcadena.
• /^/ basura que se evalúa a 1
• grep1 &(@m=$g=~/\Q$_/g),para cada carácter en la subcadena, obtenga la matriz de caracteres para que $gcoincida, la matriz en escalar evalúa su tamaño y grepfiltrar los caracteres con una ocurrencia impar 1&xes equivalente ax%2==1

Retina , 150 96 bytes

^(?!(.*)(.+)(.*)$(?<!^\2|^\1(?:(^?(?:(?!\6).)*\6){2})*(|(?!\6).)*(?!.+\6.*\3$)(.){1,}\3)(?!,<)?)

Pruébalo en línea! El enlace incluye casos de prueba, incluido él mismo. Editar: bajó un poco la expresión regular original con la ayuda de @Deadcode, luego retrocedió un poco menos de manera extravagante para mantener el diseño de origen. Explicación:

^(?!(.*)(.+)(.*)$

Afirme que no \3existe una subcadena que coincida con las siguientes restricciones.

(?<!^\2|

Afirme que la subcadena no es la cadena original completa.

^\1(?:(^?(?:(?!\6).)*\6){2})*(|(?!\6).)*(?!.+\6.*\3$)(.){1,}\3)(?!,<)?)

Afirma que no hay un carácter \6tal que:

• no aparece entre el personaje en sí (exclusivo) y el final de la subcadena
• aparece un número par de veces entre el inicio de la subcadena y sí mismo (exclusivo)

Para pasar la restricción de diseño de origen, reemplacé ((((con (?:(^?(?:(y ((con (|(. Todavía tenía una restricción fuente de ))la izquierda y los caracteres !()1<{}sobra, así que cambié una +en {1,}e insertó el inútil (?!,<)?para consumir el resto.

C # (compilador interactivo de Visual C #) , 208 206 200 198 bytes

x=>!x.GroupBy(c=>c).Any(g=>g.Count()%2>0)&!Enumerable.Repeat(x.Count,x.Count*x.Count).Where(
(l,i)=>i%l>0&!x.Skip(i/l).Take(i%l).GroupBy(c=>c).Any(g=>g.Count()%2>0)
).Any()/*>!oyAnC0EmeablR*WhiS/T*/

Pruébalo en línea!

-2 bytes gracias a @KevinCruijssen!

Finalmente lo puse por debajo de 200, por lo que podría haber terminado jugando al golf por ahora :) Terminé creando un segundo TIO para probar las cosas en función de una respuesta anterior.

Pruébalo en línea!

Cosas que hicieron difícil esta tarea:

• El operador de igualdad ==no estaba permitido
• El operador de incremento / asignación ++no estaba permitido
• La All()función Linq no estaba permitida

Código comentado a continuación:

// anonymous function that takes an IList as input
x=>
  // the first condition makes sure the string even
  // counts of each character
  !x.GroupBy(c=>c).Any(g=>g.Count()%2>0)&
  // the second condition generates all proper substrings of x
  // and tests for any that contain even character counts
  // the string length `l` is repeated `l*l` times
  !Enumerable.Repeat(x.Count,x.Count*x.Count)
    .Where((l,i)=>
      // check that the substring length is greater than 0
      i%l>0&
      // use skip/take to generate a substring
      // and check for a character count thats odd
      // negate the result meaning we have found
      // a substring that invalidates the input
      !x.Skip(i/l).Take(i%l)
        .GroupBy(c=>c).Any(g=>g.Count()%2>0)
    )
    // if any invalid substrings are found
    // then the result in invalid
    // the comment string at the end is needed
    // to make the program well-linked
    .Any()/*>!oyAnC0EmeablR*WhiS/T*/

Python 2 , 108 bytes

lambda d,e=enumerate:min(max(d[l:l+b].count(k)%2for(k)in d)for b,c in e(d[2:],2)for l,f in e(d) )#b =:x+.%2#

Pruébalo en línea!

-2 gracias a Ørjan Johansen .

Brachylog , 16 bytes

sᶠb∋p~j&sᶠb∋p~j&

Pruébalo en línea!

Imprime false.para instancias verdaderas y true.para instancias falsas. La versión TIO es demasiado lenta para manejarse sola, pero está claramente bien vinculada ya que es una cadena con caracteres únicos repetidos dos veces.

Explicación

    Input is a string: "abcacbaa"
sᶠ  Find all substrings: ["abcacbaa","abcacba","abcacb",..,"a"]
b   Behead (now the proper substrings remain): ["abcacba","abcacb",..,"a"]
∋   Take one of them: "abcacb"
p   Permute it: "abcabc"
~j  It is some string repeated twice: "abc"
&   Get the input again: "abcacbaa"
    Then repeat the above.
    If the constraints can be satisfied, the result is true, otherwise false.

05AB1E , 22 20 bytes

Œε¢Pà}KŒIKεSIS¢ÈP}àÈ

Emite 1si la cadena está bien vinculada y 0si la cadena no está bien vinculada.

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

El programa base es ŒsKεsS¢ÈP}à( 11 bytes ), que genera 0si está bien vinculado y 1si no está bien vinculado. El trailing È(is_even) es un semi-no-op que invierte la salida, 1por lo tanto, para cadenas bien vinculadas y 0para cadenas no bien vinculadas. Las otras partes son no-ops para cumplir con las reglas del desafío.

Œε¢Pà}K         # No-ops: substrings, map, count, product, maximum, close map, remove
                # Due to the last remove, we're back at the (implicit) input again
Π              # Take the substrings of the input
 IK             # Remove the input itself from that list of substrings
   ε            # Map each substring to:
    S           #  No-op: transform the substring into a list of characters
     IS         #  Get the input-string as a list of characters
       ¢        #  Count the occurrence of each character in the current substring
        È       #  Check which counts are even (1 if truthy; 0 if falsey)
         P      #  Take the product of that
          }à    # After the map: check if any are truthy by taking the maximum
            È   # Semi no-op: check if this maximum is even (0 becomes 1; 1 becomes 0)
                # (and output the result implicitly)