Introducción

Hay 3 clavos en la pared. Tienes un trozo de cuerda que se fija al marco con ambos extremos. Para colgar la imagen, enredaste la cuerda con las uñas. Pero antes de dejar ir la imagen: ¿Puedes predecir si la imagen se va a caer, solo mirando cómo se enrolla la cuerda alrededor de las uñas?

En el primer ejemplo, la imagen no se caerá. En el segundo ejemplo, la imagen se va a caer.

Reto

Dado el camino de la cuerda alrededor de las Nuñas, determine si la imagen se va a caer o no. Devuelva un valor verdadero si la imagen va a caer, y un valor falso de lo contrario.

Detalles

• Puede suponer que las uñas y la imagen están organizadas en una forma regular N+1, con la imagen en la parte inferior.
• Puede suponer que no hay nudos en la cuerda, es decir, la cuerda se puede desenrollar continuamente desde uno de los dos extremos.
• Cada clavo se enumera en sentido horario con una letra del alfabeto. Puede suponer que hay como máximo 26 uñas (AZ).
• Una envoltura en sentido horario alrededor de un clavo se denota con la letra minúscula, una envoltura en sentido antihorario se denota con una letra mayúscula.

El primer ejemplo de arriba se codificará como BcA, el segundo ejemplo se codifica como CAbBac.

Para el lector inclinado: este problema es equivalente a determinar si un elemento del grupo libre , generado por el conjunto de clavos, es la identidad o no. Esto significa que es suficiente cancelar repetidamente subcadenas como aAo Aahasta que haya alcanzado un punto fijo. Si el punto fijo es una cadena vacía, este es el elemento neutral, de lo contrario no lo es.

Ejemplos

Picture will fall:
Aa
CAbBac
aBbA
DAacAaCdCaAcBCBbcaAb
ARrQqRrUuVHhvTtYyDdYyEKRrkeUWwua
AKkQqEeVvBESWwseYQqyXBbxVvPpWwTtKkVHLlWwNBbAanYYyyhWwEJZUuNnzjYyBLQqQqlEGgebeEPLlTtZzpUuevZzSsbXSGgsUuLlHhUQquPpHUuFfhTZzIitGgFAaBRrBbbYXxOoDZTDdtzVvXxUudHhOVvoUuXKkxyBEeLlbFfKkHhfVAaQqHAaJjODdoVvhSsZzMZzmPpXNBbnxBbUuSSsUuDRrdNnUusJDIiUuIidCEGgeMmcLlDPOopdTEeQqCAETtNnYyeGUuPEFfSsWwHheAaBbpgCcOHUuhAaCcoEFBbfeaFHhfcCFFffNncGFfgtjMVUuKAakvKkXxLlTMmtmOFfoUuXSsYZzLXxlyxUuRPZzTtprSsWwRrPLlpGgMmKRrDHhdRCcUurYNnKCckykXJjxWwUSsJjKkLlKkuBbBbOoWwWwIiUuPDdBbCcWHBbCFfcDdYBbLlyVvSsWGgEewCchDdYywAaJjEepPpPpQXxZzFfLGXxglNnZzYDdyqCcKWXxwXxQqXTtxkFfBSSAasTFftZzsXGgxSsLlLlbZzAaCCccXVvYyxTIiOoBbFftCVQqDdBbGgAavQqKkDPpKTCctRrkdcvAaQWOowLOolqVMmvZAaHCBbcPphIiRKkrLlzFMOomDIiXJjIixMmdNnMHhmfNTtIiKkSDdTtsVvHhnAaNSVvTUutNnXxsGIiXxPpPHhUupgNnAaAAOoaaIiHJjhVvLlnYyXxQqSsTtKJjkBbNnVvEYCcFfMHGghBbmNnEeJTtjJjWYywyeNWwDIiZYyzOodnMQqmVvCcQqxVvGNnEeNBbngVvUGgYyBbDdVvIiAAaauPpQKDdEekNnVLlvHhGSDIidPZzpsPCcpgQqKkQqNOonLlIiLlJjqPAaPXxTtppYyCPpHhCIicARBbracXxWwXEVUuUuGgZHhzBSsbvGgFfeVvxLlNKknWwBLlIibWOowNnRSsrSEeKAakOosLZzZRrHhzTtTFfUuNnOKkotXxTtla


Picture will not fall:
A
BcA
ABCD
aBaA
bAaBcbBCBcAaCdCaAcaCAD
ARrQqRrUatuVHhvTYyDdYyEKRrkeUAua
AEEeQqNneHhLlAIiGgaECXxcJjZzeJFfVWwDdKkvYWwyTJjtCXxANIinaXWwxcTWwtUuWwMmTBbVWIiFLlWwZzfwPLlEepvWZzwKkEYEeWXxwySXTtEexRIiNBbnWAaTtQqNnBMSsWwOombwWwPVPpGPpgYyvDdpBbrQqHhUusKRrDAVvadLlWwOZzokGJCXSSssXxxJPpGIigZzjJjLlOoNRrnPpcMZzmjgJjNDEeQqWKkNTtnSswIidCcnYBGgbyJSsjPpIiMmMmMmSNnWVvwZzIQqLXHhxTPptlisOoeTtTtYMmVvPpyKNnMFfmkXxSVvsCGJjXxgXYJPpjWwQIiXxqyDdxFfDdAaRNnJjrctHBbZzhEQqMmeCcRBbrGgAaAaJNnRrYyWwSDdVvsJOojQGgWWwIBbiwRrqJjjWwOoFPMmDdRrQOoqNnRrDPJjpMmdPpGFfVvWUuwgpWCcNnPpwfUXCcZzJjUSsuXxxUuuRGgHhrSQqJjOosMMTtmHhmKkXxDdLlWwjSUuAaMmKYyksZzVvPZzVEeVvvHhZZOozBbzMmZCczYyGgISsiQqpXxMmXxEMmeRrAGgaGgMOGgomZFfDdzSSssBGPpgbTtBbOoRWWwGgLJjlEeGgLDdRrUulNnZzJjJjUKkuXxFfwATtaZzLVvlWwSsMmrBAaELleGBLFflbgHhbIFfiBbPpTWZzwKkKLASsaTJYyjtBbBbWwIiZCcWwzIiZLlUTtuBbYyBbIizTJjtLTtDOOoBbodBbllSsUGgLlAKkauYykUuUNnPpuDFfAaLNVvnVvlHhdMmBAaBbIiVRrGWOoPpwgWXwKkvJjOoTtYCUucVGgYyLlVvFfvRrMmySsDdbtICZzcNnINSOosDQAaXoxRGgKkrqdZznDdXxZzMGgmiJjNnACcMQqmaNnWZzUOuwTVvAJjSsaRrGgSsTtOMmRroVvRrtAVGgvMmaINniDGCcOogRrWwMVvYFfyTtmTtVvOoOIiodRrGgAxaSsGgiJja

Retina , 21 bytes

+`(.)(?!\1)(?i)\1

^$

Pruébalo en línea!

Al igual que la solución de flawr, esto simplemente elimina repetidamente pares mayúsculas / minúsculas adyacentes y luego verifica si el resultado está vacío o no.

En cuanto a cómo uno coincide con un par mayúscula / minúscula:

(.)     # Match and capture a letter.
(?!\1)  # Ensure that the next character is not the same, to avoid matching
        # "aa" and "AA".
(?i)    # Turn on case-insensitivity.
\1      # Match the backreference. In .NET, when using case insensitivity,
        # backreferences also get case-insensitive, so this *can* still match
        # iff the cases of the two letters are different.

MATLAB, 76 bytes Octava, 82 79 77 bytes

¡Esta podría ser la primera vez que veo que MATLAB es en realidad más corto que Octave (en un byte completo)!

Nueva respuesta en MATLAB:

c=input('');k='Aa';while k<1e5,k=k+1;c=strrep(c,65+mod(k,64),'');end;~nnz(c)

Respuesta en octava:

c=input('');k='Aa';while k++<1e5,c=strrep(c,['',65+mod(k,64)],'');end;~nnz(c)

Guardado tres cinco bytes gracias a flawr. ~nnz(c)es más corto que isempty(c), y 'Aa'es dos bytes más corto que [0,32].

¡Pruébelo en línea en la versión Octave!

Explicación:

c=input('')pide al usuario su aporte. Lo definimos k='Aa'como una matriz de caracteres.

while k++<1e5: Mientras bucle donde ambos elementos en kse incrementan cada iteración, Aa, Bb, Ccy así sucesivamente. El bucle continuará hasta que el elemento más grande sea 1e5, que debería ser lo suficientemente alto para la mayoría de las cadenas. Se puede aumentar 9e9sin aumentar el recuento de bytes.

Tomaremos la strrepfunción en pasos, comenzando desde el medio.

Al usar mod(k,64), obtendremos lo siguiente cuando lleguemos al final del alfabeto (si volvemos a convertir los kcaracteres):

ans = Yy
ans = Zz
ans = [{
ans = \|
ans = ]}
ans = ^~
ans = _
ans = `�
ans = aA
ans = bB

Como puede ver, habrá algunos símbolos en el medio, pero luego se ajustará y comenzará con el alfabeto nuevamente, pero ahora con las letras minúsculas primero. Esta es una forma muy corta de verificar ambos Aay aA.

['',65+mod(k,64)]concatena los valores numéricos de la modllamada, con una cadena vacía, convirtiendo los números en caracteres.

strrepse utiliza para eliminar elementos de la cadena cy devolverlo. Buscará todas las apariciones de kla cadena y la reemplazará con una cadena vacía.

Después de las 1e5iteraciones, tendremos una cadena vacía o una cadena no vacía. Verificamos si hay elementos en el cuso nnz(c). Volvemos not(nnz(c)), por lo tanto, 1si está vacío, y 0si quedan caracteres enc

Minkolang 0.15 , 30 bytes

od4&x,N.I1=$6&d3~c-$~48*=,2&xx

Pruébalo aquí!

Explicación

od                            Take character from input and duplicate it
  4&                          If top of stack is truthy, jump 4 spaces
    x                         Dump top of stack
     ,                        NOT top of stack
      N.                      Output as number and stop

    I1=                       1 if stack has 1 element, 0 otherwise
       $6&                    If top of stack is truthy, jump 16 spaces (to the beginning)
          d3~c                Duplicate top two items of stack, in reversed order
              -               Subtract
               $~             Absolute value
                 48*          Push 32
                    =,        0 if top two items are equal, 1 otherwise
                      2&xx    If top of stack is truthy, dump two elements from top

La naturaleza toroidal de Minkolang se aprovecha aquí para eliminar la necesidad de un bucle externo. La idea general aquí es verificar si los dos elementos superiores de la pila están separados por 32 unidades (lo que significa que son un par mayúscula / minúscula), y si lo están, desactívelos. Como esto se hace "en tiempo real", por así decirlo, la anidación de pares se maneja correctamente.

Haskell, 62 bytes

a%l|b:t<-l,abs(a-b)==32=t|1>0=a:l
f=null.foldr((%).fromEnum)[]

Pruébalo en línea

Crédito a flawr para elabs y Laikoni para el fromEnummapa .

La función auxiliar %toma una cadena ya simplificada ly antepone el símbolo aantes de simplificar el resultado. Si lcomienza con el carácter inverso a a, se cancelan. De lo contrario, asimplemente se antepone. Tenga en cuenta que no se necesita más simplificación en esta etapa.

La función principal fantecede y simplifica cada personaje a su vez a través de a foldr. Luego, verifica si el resultado está vacío.

Para verificar si dos caracteres son casos opuestos y, por lo tanto, deben cancelarse, vea si sus valores ASCII difieren en 32. Cada elemento se procesa fromEnumantes de pasar a %.

05AB1E , 17 bytes

DvADu‚øDíìvyK}}õQ

Pruébalo en línea!

Explicación

Dv                 # input number of times do:
  A                # push lowercase alphabet
   Du              # push uppercase alphabet
     ‚ø            # zip the alphabets together (['aA', ..., 'zZ'])
       Díì         # prepend a copy with each element reversed ('Aa' ...)
          v        # for each pair in the resulting list
           yK      # remove it from the accumulated string (starts as input)
             }}    # end loops
               õQ  # check result for equality to empty string

Haskell , 98 97 85 81 bytes

Esta es solo una implementación ingenua que intenta repetidamente cancelar las letras adyacentes hasta que no haya más cambios, y luego determina el resultado a partir de eso.

¡Gracias @nimi por -12 bytes y @xnor por otros -4 bytes!

o=fromEnum
r(a:b:l)|abs(o a-o b)==32=l|1>0=a:r(b:l)
r x=x
f=null.until((==)=<<r)r

Pruébalo en línea! o Verifique todos los ejemplos!

Mathematica, 102 bytes

""==StringDelete[""|##&@@#<>#2&~MapThread~{Join[a=Alphabet[],A=ToUpperCase@a],A~Join~a}]~FixedPoint~#&

Función sin nombre que toma una cadena alfabética como entrada y devuelve Trueo False.

El corazón de la implementación es crear una función que elimine cualquier par de cancelación, como "Pp"o "gG", de una cadena. La expresión {Join[a=Alphabet[],A=ToUpperCase@a],A~Join~a}produce un par ordenado de listas de caracteres, siendo la primera lista {"a","b",...,"Z"}y el segundo ser {"A","B",...,"z"}. Entonces #<>#2&~MapThread~produce una lista donde se han concatenado los elementos correspondientes de estas dos listas, es decir, {"aA","bB",...,"Zz"}. La expresión divertida ""|##&@@entonces (a través de la magia de la secuencia de argumentos ##) produce una lista de alternativas "" | "aA" | "bB" | ... | "Zz"; finalmente, StringDelete[...]es una función que elimina cualquier aparición de cualquiera de esas alternativas de una cadena.

Ahora es suficiente aplicar repetidamente esa función a la cadena de entrada hasta que el resultado no cambie, lo que se logra con ~FixedPoint~#, y luego probar si el resultado es la cadena vacía con ""==.

JavaScript (ES6), 73 bytes

f=(s,t=s.replace(/(.)\1+/gi,s=>s.replace(/(.)(?!\1)./,'')))=>s==t?!s:f(t)

A diferencia de .NET, JavaScript no tiene forma de desactivar la distinción entre mayúsculas y minúsculas en el medio de una coincidencia, por lo que tenemos que encontrar todas las subcadenas de letras repetidas entre mayúsculas y minúsculas, y luego eliminar cualquier par de caracteres adyacentes que no coincidan, lo que en este punto debe ser un par mayúscula / minúscula.

Perl, 28 bytes

1 while s/.(??{$&^' '})//;$_

Explicación:

Perl permite incluir una expresión regular generada dinámicamente dentro de una expresión regular estándar.

Las .coincide con cualquier cosa.

El (??{es el comienzo de la expresión regular generada.

La $&variable contendrá toda la cadena coincidente hasta ahora, que en este caso es lo que .coincida.

El ^operador realiza xor numérico o xor de cadena, dependiendo de los valores de los operandos. En este caso, será la cadena xor.

El ' 'es solo una cadena que contiene un espacio, que convenientemente tiene el valor ascii (o unicode!) De 32. Cuando un espacio se corrige con un carácter en el rango az o AZ, cambiará de mayúscula a minúscula o tornillo de banco viceversa

El })es el final de la expresión regular generada.

1 while s/whatever// buscará repetidamente un patrón y lo reemplazará con la cadena vacía.

$_es la variable por defecto. Esta variable es sobre lo que Perl hace cosas divertidas y emocionantes cuando no especificas otra variable. Aquí lo estoy usando para devolver un valor verdadero o falso, ya que una cadena de longitud cero es falsa y una cadena de longitud distinta de cero que no es igual "0"es verdadera. También estoy asumiendo que la cadena de entrada se colocó originalmente en ella.

Pruébalo aquí

Prólogo (SWI) , 151 bytes

f(S):-S="";string_code(I,S,X),string_code(J,S,Y),J is I+1,32is abs(X-Y),B is J+1,sub_string(S,0,I,_,T),sub_string(S,B,_,0,U),string_concat(T,U,V),f(V).

Toma mucho tiempo correr en los casos falsos más largos debido al retroceso.

Pruébalo en línea!

Sin golf

f(S):-                       The string S corresponds to a falling picture if:
  S="";                      S is the empty string, or...
  string_code(I,S,X),        X is the character code at some index I
  string_code(J,S,Y),        Y is the character code at some index J
  J is I+1,                  J is I+1
  32 is abs(X-Y),            X and Y differ by 32 (difference between lower/upper case)
  B is J+1,                  ...
  sub_string(S,0,I,_,T),     ...
  sub_string(S,B,_,0,U),     ...
  string_concat(T,U,V),      ...
  f(V).                      The concatenation of the substrings before and after 
                             the letters X and Y corresponds to a falling picture.

MATL , 20 bytes

t"[]yd|32=fX<tQh(]n~

Pruébalo en línea! O verifique todos los casos de prueba (lleva un tiempo).

Explicación

t       % Input string implicitly. Duplicate
"       % Do as many times as input size
  []    %   Push empty array
  y     %   Duplicate current string onto the top
  d|    %   Absolute consecutive differences
  32=   %   Convert to true if 32, false otherwise
  fX<   %   Index of first occurrence of true, or empty of all false
  tQ    %   Duplicate, add 1. This gives the next index, or empty
  h     %   Concatenate. Gives the two consecutive indices of letters
        %   to be removed, or empty
  (     %   Assign an empty array to those positions, i.e. delete them
]       % End
n~      % Number of elements, negate

Mathematica, 65 bytes

(ToCharacterCode@#//.{x___,y_,z_,w___}/;Abs[y-z]==32:>{x,w})=={}&

JavaScript (Node.js) , 47 bytes

x=>![...x].reduce(x=>x.replace(/(.)\1/gi,''),x)

Pruébalo en línea!

Python 3 , 71 bytes

s=input()
for i in s*len(s):s=s.replace(i+i.swapcase(),'')
print(not s)

Pruébalo en línea!