Intro

Ci sono 3 chiodi nel muro. Hai un pezzo di corda che è fissato alla cornice con entrambe le estremità. Per appendere l'immagine, hai impigliato la corda con le unghie. Ma prima di lasciar andare l'immagine: puoi prevedere se l'immagine cadrà, semplicemente guardando come la corda è avvolta intorno alle unghie?

Nel primo esempio l'immagine non cadrà. Nel secondo esempio l'immagine cadrà.

Sfida

Dato il percorso della corda attorno alle Nunghie, determinare se l'immagine cadrà o meno. Restituisce un valore di verità se l'immagine sta per cadere e un valore di falsa in caso contrario.

Dettagli

• Puoi presumere che i chiodi e l'immagine siano disposti in un normale N+1orgonale, con l'immagine in basso.
• Puoi presumere che non ci siano nodi nella corda, cioè la corda può essere continuamente avvolta da una delle due estremità.
• Ogni unghia è elencata in senso orario con una lettera dell'alfabeto. Puoi presumere che ci siano al massimo 26 chiodi (AZ).
• Un involucro in senso orario attorno a un chiodo è indicato con la lettera minuscola, un involucro in senso antiorario è indicato con una lettera maiuscola.

Il primo esempio dall'alto verrà codificato come BcA, il secondo esempio verrà codificato come CAbBac.

Per il lettore inclinato: questo problema equivale a determinare se un elemento del gruppo libero - generato dall'insieme di chiodi - sia l'identità o meno. Ciò significa che è sufficiente annullare ripetutamente sottostringhe come aAo Aafino a quando non si raggiunge un punto fisso. Se il punto fisso è una stringa vuota, questo è l'elemento neutro, altrimenti non lo è.

Esempi

Picture will fall:
Aa
CAbBac
aBbA
DAacAaCdCaAcBCBbcaAb
ARrQqRrUuVHhvTtYyDdYyEKRrkeUWwua
AKkQqEeVvBESWwseYQqyXBbxVvPpWwTtKkVHLlWwNBbAanYYyyhWwEJZUuNnzjYyBLQqQqlEGgebeEPLlTtZzpUuevZzSsbXSGgsUuLlHhUQquPpHUuFfhTZzIitGgFAaBRrBbbYXxOoDZTDdtzVvXxUudHhOVvoUuXKkxyBEeLlbFfKkHhfVAaQqHAaJjODdoVvhSsZzMZzmPpXNBbnxBbUuSSsUuDRrdNnUusJDIiUuIidCEGgeMmcLlDPOopdTEeQqCAETtNnYyeGUuPEFfSsWwHheAaBbpgCcOHUuhAaCcoEFBbfeaFHhfcCFFffNncGFfgtjMVUuKAakvKkXxLlTMmtmOFfoUuXSsYZzLXxlyxUuRPZzTtprSsWwRrPLlpGgMmKRrDHhdRCcUurYNnKCckykXJjxWwUSsJjKkLlKkuBbBbOoWwWwIiUuPDdBbCcWHBbCFfcDdYBbLlyVvSsWGgEewCchDdYywAaJjEepPpPpQXxZzFfLGXxglNnZzYDdyqCcKWXxwXxQqXTtxkFfBSSAasTFftZzsXGgxSsLlLlbZzAaCCccXVvYyxTIiOoBbFftCVQqDdBbGgAavQqKkDPpKTCctRrkdcvAaQWOowLOolqVMmvZAaHCBbcPphIiRKkrLlzFMOomDIiXJjIixMmdNnMHhmfNTtIiKkSDdTtsVvHhnAaNSVvTUutNnXxsGIiXxPpPHhUupgNnAaAAOoaaIiHJjhVvLlnYyXxQqSsTtKJjkBbNnVvEYCcFfMHGghBbmNnEeJTtjJjWYywyeNWwDIiZYyzOodnMQqmVvCcQqxVvGNnEeNBbngVvUGgYyBbDdVvIiAAaauPpQKDdEekNnVLlvHhGSDIidPZzpsPCcpgQqKkQqNOonLlIiLlJjqPAaPXxTtppYyCPpHhCIicARBbracXxWwXEVUuUuGgZHhzBSsbvGgFfeVvxLlNKknWwBLlIibWOowNnRSsrSEeKAakOosLZzZRrHhzTtTFfUuNnOKkotXxTtla


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

Retina , 21 byte

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

^$

Provalo online!

Come la soluzione di flawr, questa elimina ripetutamente coppie adiacenti maiuscole / minuscole e quindi controlla se il risultato è vuoto o meno.

Per quanto riguarda il modo in cui uno corrisponde a una coppia maiuscola / minuscola:

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

Questa potrebbe essere la prima volta che vedo dove MATLAB è in realtà più corto di Octave (di un intero byte)!

Nuova risposta in MATLAB:

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

Risposta in Ottava:

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

Salvati tre cinque byte grazie a flawr. ~nnz(c)è più corto di isempty(c)e 'Aa'due byte più corto di [0,32].

Provalo online la versione Octave!

Spiegazione:

c=input('')chiede all'utente un input. Definiamo k='Aa'una matrice di caratteri.

while k++<1e5: While cui entrambi gli elementi in kvengono incrementati ogni iterazione, Aa, Bb, Cce così via. Il ciclo continuerà fino a quando non sarà presente l'elemento più grande 1e5, che dovrebbe essere sufficientemente alto per la maggior parte delle stringhe. Può essere aumentato 9e9senza aumentare il conteggio dei byte.

Prenderemo la strrepfunzione a passi, partendo dal centro.

Usando mod(k,64)otterremo quanto segue quando arriveremo alla fine dell'alfabeto (se riconvertiamo kin caratteri):

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

Come puoi vedere, ci saranno alcuni simboli in mezzo, ma poi si avvolgerà e ricomincerà con l'alfabeto, ma ora prima con le lettere minuscole. Questo è un modo molto breve per controllare sia Aae aA.

['',65+mod(k,64)]concatena i valori numerici da mod-call, con una stringa vuota, convertendo i numeri in caratteri.

strrepviene utilizzato per rimuovere elementi dalla stringa ce restituirla. Cercherà tutte le occorrenze di knella stringa e la sostituirà con una stringa vuota.

Dopo le 1e5iterazioni avremo una stringa vuota o una stringa non vuota. Controlliamo se ci sono elementi cnell'uso nnz(c). Torniamo not(nnz(c)), quindi 1se è vuoto e 0se ci sono caratteri rimastic

Minkolang 0,15 , 30 byte

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

Provalo qui!

Spiegazione

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 natura toroidale di Minkolang viene sfruttata qui per eliminare la necessità di un anello esterno. L'idea generale qui è di verificare se i primi due elementi dello stack sono separati da 32 unità (il che significa che sono una coppia maiuscola / minuscola) e, se lo sono, togliere entrambi. Poiché ciò avviene "in tempo reale", per così dire, la nidificazione delle coppie viene gestita correttamente.

Haskell, 62 byte

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

Provalo online

Ringraziamo Flawr per ilabs e Laikoni per la fromEnummappa .

La funzione helper %accetta una stringa già semplificata le antepone il simbolo aprima di semplificare il risultato. Se linizia con il carattere inverso a a, si annullano. Altrimenti, aè semplicemente anteposto. Si noti che non è necessaria ulteriore semplificazione in questa fase.

La funzione principale fantepone e semplifica ogni personaggio a sua volta tramite a foldr. Quindi, controlla se il risultato è vuoto.

Per verificare se due caratteri sono casi opposti e quindi devono annullare, vedere se i loro valori ASCII differiscono di 32. Ogni elemento viene elaborato fromEnumprima di essere passato a %.

05AB1E , 17 byte

DvADu‚øDíìvyK}}õQ

Provalo online!

Spiegazione

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 byte

Questa è solo un'implementazione ingenua che tenta ripetutamente di annullare le lettere adiacenti fino a quando non ci sono più cambiamenti, e quindi determina il risultato da quello.

Grazie @nimi per -12 byte e @xnor per altri -4 byte!

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

Provalo online! o Verifica tutti gli esempi!

Mathematica, 102 byte

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

Funzione senza nome che accetta una stringa alfabetica come input e che restituisce Trueo False.

Il cuore dell'implementazione è la creazione di una funzione che elimina qualsiasi coppia di annullamento, come "Pp"o "gG", da una stringa. L'espressione {Join[a=Alphabet[],A=ToUpperCase@a],A~Join~a}produce una coppia ordinata di elenchi di caratteri, il primo elenco è {"a","b",...,"Z"}e il secondo è {"A","B",...,"z"}. Quindi #<>#2&~MapThread~produce un elenco in cui sono stati concatenati gli elementi corrispondenti di questi due elenchi, ovvero {"aA","bB",...,"Zz"}. L'espressione divertente ""|##&@@quindi (attraverso la magia della sequenza degli argomenti ##) produce un elenco di alternative "" | "aA" | "bB" | ... | "Zz"; infine, StringDelete[...]è una funzione che elimina qualsiasi occorrenza di una di quelle alternative da una stringa.

Ora è sufficiente applicare ripetutamente quella funzione alla stringa di input fino a quando il risultato non cambia, cosa che viene eseguita da ~FixedPoint~#, e quindi verificare se il risultato è la stringa vuota con ""==.

JavaScript (ES6), 73 byte

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

A differenza di .NET, JavaScript non ha modo di disattivare la distinzione tra maiuscole e minuscole nel mezzo di una corrispondenza, quindi dobbiamo trovare insensibilmente tutte le sottostringhe di lettere ripetute maiuscole e quindi eliminare qualsiasi coppia non corrispondente di caratteri adiacenti, che a questo punto deve essere una coppia maiuscola / minuscola.

Perl, 28 byte

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

Spiegazione:

Perl consente di includere un'espressione regolare generata dinamicamente all'interno di un'espressione regolare standard.

L' .corrisponde a qualsiasi cosa.

Il (??{è l'inizio della regex generato.

La $&variabile conterrà l'intero testo trovato finora, che in questo caso è solo quello .abbinato.

L' ^operatore esegue xor numerico o xor stringa, a seconda dei valori degli operandi. In questo caso, sarà stringa xo.

L' ' 'è solo una stringa contenente uno spazio, che ha convenientemente ASCII (o unicode!) Valore di 32. Quando uno spazio è XOR con un carattere dell'intervallo az o AZ, cambierà da maiuscole a lettere minuscole o morsa versa.

La })è la fine della regex generato.

1 while s/whatever// cercherà ripetutamente un motivo e lo sostituirà con una stringa vuota.

$_è la variabile predefinita. Questa variabile è ciò su cui perl fa cose divertenti ed eccitanti quando non specifichi un'altra variabile. Qui lo sto usando per restituire un valore di verità o falsa, poiché una stringa di lunghezza zero è falsa e una stringa di lunghezza diversa da zero che non "0"è uguale è vera. Suppongo anche che la stringa di input sia stata originariamente inserita in essa.

Provalo qui

Prolog (SWI) , 151 byte

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

Ci vuole molto tempo per eseguire i casi falsi più lunghi a causa del backtracking.

Provalo 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 byte

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

Provalo online! Oppure verifica tutti i casi di test (ci vuole un po 'di tempo).

Spiegazione

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 byte

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

JavaScript (Node.js) , 47 byte

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

Provalo online!

Python 3 , 71 byte

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

Provalo online!