Introdução

Existem 3 pregos na parede. Você tem um pedaço de barbante fixo na moldura das duas extremidades. Para pendurar a foto, você emaranhou a corda com as unhas. Porém, antes de deixar a foto passar: Você pode prever se a imagem vai cair apenas olhando como o barbante está enrolado nas unhas?

No primeiro exemplo, a imagem não cairá. No segundo exemplo, a imagem vai cair.

Desafio

Dado o caminho da corda ao redor das Nunhas, determine se a imagem vai cair ou não. Retorne um valor verdadeiro se a imagem cair, e um valor falso caso contrário.

Detalhes

• Você pode supor que as unhas e a imagem estão dispostas em um N+1ângulo regular , com a imagem na parte inferior.
• Você pode supor que não há nós na corda, ou seja, a corda pode ser continuamente enrolada em uma das duas extremidades.
• Cada unha é enumerada no sentido horário com uma letra do alfabeto. Você pode assumir que existem no máximo 26 unhas (AZ).
• Um envoltório no sentido horário em torno de uma unha é indicado com a letra minúscula, e um envoltório no sentido anti-horário é indicado com uma letra maiúscula.

O primeiro exemplo de cima será codificado como BcA, o segundo exemplo é codificado como CAbBac.

Para o leitor inclinado: Esse problema é equivalente a determinar se um elemento do grupo livre - gerado pelo conjunto de unhas - é a identidade ou não. Isso significa que é suficiente cancelar repetidamente substrings como aAou Aaaté você atingir um ponto fixo. Se o ponto fixo for uma sequência vazia, este é o elemento neutro, caso contrário, não é.

Exemplos

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

^$

Experimente online!

Como a solução da flawr, isso exclui repetidamente os pares maiúsculos / minúsculos adjacentes e depois verifica se o resultado está vazio ou não.

Quanto à forma como se combina um par maiúsculo / minúsculo:

(.)     # 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 Octave, 82 79 77 bytes

Esta pode ser a primeira vez que eu vejo onde o MATLAB é realmente menor que o Octave (por um byte inteiro)!

Nova resposta no MATLAB:

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

Resposta na oitava:

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

Economizou três cinco bytes graças ao flawr. ~nnz(c)é menor que isempty(c)e 'Aa'é dois bytes menor que [0,32].

Experimente a versão Octave online!

Explicação:

c=input('')solicita a entrada do usuário. Definimos k='Aa'como uma matriz de caracteres.

while k++<1e5: Enquanto circuito fechado onde ambos os elementos ksão incrementados cada iteração, Aa, Bb, Cce assim por diante. O loop continuará até que seja o elemento maior 1e5, que deve ser suficientemente alto para a maioria das strings. Pode ser aumentado para 9e9sem aumentar a contagem de bytes.

Tomaremos a strrepfunção em etapas, começando do meio.

Ao usar mod(k,64), obteremos o seguinte quando chegarmos ao final do alfabeto (se convertermos knovamente em caracteres):

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

Como você pode ver, haverá alguns símbolos no meio, mas depois eles serão contidos e começarão com o alfabeto novamente, mas agora com as letras minúsculas primeiro. Esta é uma maneira muito curta de verificar ambos Aae aA.

['',65+mod(k,64)]concatena os valores numéricos da modchamada, com uma sequência vazia, convertendo os números em caracteres.

strrepé usado para remover elementos da string ce retorná-la. Ele procurará todas as ocorrências de kna sequência e a substituirá por uma sequência vazia.

Após as 1e5iterações, teremos uma sequência vazia ou uma sequência não vazia. Verificamos se há algum elemento em cuso nnz(c). Retornamos not(nnz(c)), portanto, 1se estiver vazio, e 0se houver caracteres restantes emc

Minkolang 0.15 , 30 bytes

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

Experimente aqui!

Explicação

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

A natureza toroidal de Minkolang é aproveitada aqui para eliminar a necessidade de um loop externo. A idéia geral aqui é verificar se os dois principais elementos da pilha estão separados por 32 unidades (o que significa que eles são um par maiúsculo / minúsculo) e, se estiverem, destacam os dois. Como isso é feito "em tempo real", por assim dizer, o aninhamento de pares é tratado adequadamente.

Haskell, 62 bytes

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

Experimente online

Crédito para flawr para oabs e Laikoni para o fromEnummapa .

A função auxiliar %pega uma sequência já simplificada le precede o símbolo aantes de simplificar o resultado. Se lcomeçar com o caractere inverso para a, eles serão cancelados. Caso contrário, aé simplesmente anexado. Observe que nenhuma outra simplificação é necessária nesta fase.

A função principal fprecede e simplifica cada caracter por vez, através de a foldr. Em seguida, verifica se o resultado está vazio.

Para verificar se dois caracteres são casos opostos e, portanto, deve cancelar, veja se os valores ASCII diferem em 32. Cada elemento é processado fromEnumantes de ser passado para %.

05AB1E , 17 bytes

DvADu‚øDíìvyK}}õQ

Experimente online!

Explicação

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 é apenas uma implementação ingênua que tenta repetidamente cancelar cartas adjecentes até que não haja mais alterações e, em seguida, determina o resultado disso.

Obrigado @nimi por -12 bytes e @xnor por mais -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

Experimente online! ou Verifique todos os exemplos!

Mathematica, 102 bytes

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

Função sem nome, recebendo uma sequência alfabética como entrada e retornando Trueou False.

O coração da implementação é criar uma função que exclui qualquer par de cancelamento, como "Pp"ou "gG", de uma sequência. A expressão {Join[a=Alphabet[],A=ToUpperCase@a],A~Join~a}produz um par ordenado de listas de caracteres, sendo a primeira {"a","b",...,"Z"}e a segunda {"A","B",...,"z"}. Em seguida, #<>#2&~MapThread~produz uma lista em que os elementos correspondentes dessas duas listas foram concatenados, ou seja {"aA","bB",...,"Zz"},. A expressão divertida ""|##&@@então (através da mágica da sequência de argumentos ##) produz uma lista de alternativas "" | "aA" | "bB" | ... | "Zz"; finalmente, StringDelete[...]é uma função que exclui qualquer ocorrência de qualquer uma dessas alternativas de uma string.

Agora basta aplicar repetidamente essa função à sequência de entrada até que o resultado não seja alterado, o que é realizado por ~FixedPoint~#e, em seguida, testar se o resultado é a sequência vazia ""==.

JavaScript (ES6), 73 bytes

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

Diferentemente do .NET, o JavaScript não tem como desativar a distinção entre maiúsculas e minúsculas no meio de uma correspondência. Em vez disso, precisamos encontrar todas as substrings de letras repetidas sem maiúsculas e minúsculas e excluir qualquer par incompatível de caracteres adjacentes, que neste momento deve ser um par em maiúsculas / minúsculas.

Perl, 28 bytes

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

Explicação:

O Perl permite incluir uma expressão regular gerada dinamicamente dentro de uma expressão regular padrão.

A .combina com qualquer coisa.

O (??{é o início do regex gerado.

A $&variável conterá toda a cadeia correspondente até agora, que neste caso é exatamente a que .corresponder.

O ^operador executa xor numérico ou string xor, dependendo dos valores dos operandos. Nesse caso, será a string xor.

O ' 'é apenas uma string que contém um espaço, que convenientemente possui o valor ascii (ou unicode!) De 32. Quando um espaço é xor-ed com um caractere no intervalo az ou AZ, ele muda de maiúsculas para minúsculas ou de torno versa.

O })é o fim do regex gerado.

1 while s/whatever// procurará repetidamente um padrão e o substituirá pela sequência vazia.

$_é a variável padrão. Essa variável é o que o perl faz coisas divertidas e emocionantes quando você não especifica outra variável. Aqui, estou usando-o para retornar um valor verdadeiro ou falso, pois uma string de comprimento zero é falsa e uma string de comprimento diferente de zero que não é igual a "0"verdadeira. Também estou assumindo que a string de entrada foi originalmente colocada nela.

Experimente aqui

Prolog (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).

Demora muito tempo para ser executado nos casos falsos mais longos devido ao retorno.

Experimente online!

Ungolfed

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~

Experimente online! Ou verifique todos os casos de teste (demora um pouco).

Explicação

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)

Experimente online!

Python 3 , 71 bytes

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

Experimente online!