Questa è una sfida da poliziotti e ladri in qualche modo simile al golf . Questo è il filo dei ladri; il thread della polizia è qui .

Robbers

Gli sbirri pubblicheranno sistemi di riscrittura astratti. Il tuo compito è quello di decifrare i loro invii dimostrando che la stringa di destinazione può o non può essere raggiunta dalla stringa di origine applicando le loro regole di riscrittura. (Puoi farlo pubblicando una sequenza di regole di riscrittura che inizia con la stringa di origine e termina con la destinazione, o dimostrando matematicamente che ciò esiste o non esiste.)

Vedi il thread della polizia per dettagli e definizioni.

jimmy23013

Lavoriamo all'indietro per questo. Prima trasformiamo le cifre nelle loro rappresentazioni binarie. Andiamo da VW626206555675126212043640270477001760465526277571600601a VW++__+_++__+____++_+_++_++_+++_++++_+__+_+_++__+___+_+____+___++++_+______+_+++___+__++++++________++++++____+__++_+_++_+_+_++__+_+++++++_++++__+++_______++______+. Successivamente, continuiamo ad applicare l'inverso di DCW:W+e DW:W_fino a quando non cancelliamo tutti i simboli. Il nostro risultato è adesso VDCDCDDDCDDCDCDDDCDDDDDCDCDDCDDCDCDDCDCDDCDCDCDDCDCDCDCDDCDDDCDDCDDCDCDDDCDDDDCDDCDDDDDCDDDDCDCDCDCDDCDDDDDDDCDDCDCDCDDDDCDDDCDCDCDCDCDCDDDDDDDDDCDCDCDCDCDCDDDDDCDDDCDCDDCDDCDCDDCDDCDDCDCDDDCDDCDCDCDCDCDCDCDDCDCDCDCDDDCDCDCDDDDDDDDCDCDDDDDDDCW. Vogliamo ora far corrispondere questa stringa VD+C+W; cioè, vogliamo spostare tutte le Ds alla sinistra di tutte le Cs. Questo può essere fatto invertendo DCC:CD. Lo facciamo ripetendo il seguente algoritmo:

1. Trova il primo Dche si trova a destra di un blocco di Cs.
2. Spostare Da sinistra di quel blocco.
3. Raddoppia il numero di Cs.

Attraverso un po 'di matematica, possiamo determinare che finiremo con 123 se D4638704741628490670592103344196019722536654143873 Cs (avevi ragione su questo non rientrando in una risposta SE ... Dubito che si adatterebbe se conservato come stato di tutti gli atomi sulla Terra combinato: P).

Se continuiamo ad applicare il contrario di V:VD, possiamo sbarazzarci di tutte le Ds ora, quindi otteniamo VCCC.......CCCW. Convertiamo la parte Vposteriore in YZ. Adesso abbiamo YZCCC.......CCCW.

Vogliamo essere in grado di sbarazzarci di tutti Ce di averli nella forma YAAA...AAABBB...BBBZW. Fortunatamente, questo può essere fatto con il seguente metodo. In primo luogo, applichiamo inversa YB:Y587912508217580921743211 volte per ottenere YBBB.......BBBZCCC.......CCCW. Quindi, ripetiamo la seguente sequenza di passaggi (dove [?*]significa qualsiasi numero di ?, non necessariamente maggiore di zero):

1. Applicare inverso CZ:ZC587912508217580921743211 volte per ottenereY[A*]BBB.......BBBCCC.......CCCZCCC.......CCCW
2. Inverso-applicare CB:BCpiù volte per ottenereY[A*]BCBCBC.......BCBCBCZCCC.......CCCW
3. Inverso-applicare AZ:Ze AB:BCAmolte volte per ottenereY[A*]ABBB.......BBBZCCC.......CCCW

Attraverso l'induzione, vediamo che possiamo spostare la BZcombinazione fino alla fine (tranne prima del W) e quindi il numero di As è 1/587912508217580921743211 del numero di Cs, lasciandoci con 7890127658096618386747843 As. Ora abbiamo YAAA.......AAABBB.......BBBZW. Converti la parte ZWposteriore in a U, quindi applica inversa U:BUmolte volte per mantenere solo 2 se Bquindi converti BBUin a T, e ora hai YAAA.......AAAT. Quindi, è possibile applicare T:AAAAATpiù volte l' applicazione inversa YAAATperché il numero di As era 3 maggiore di un multiplo di 5.

Grazie per la sfida!

boboquack

Per una data stringa, prendi tutte le lettere (a = 0, b = 1, c = 2), riassumile e prendi il modulo 3. Quindi nessuna delle regole di riscrittura cambia quel valore. La stringa di origine ha un valore di 1 e la destinazione ha un valore di 2. Pertanto, nessuna combinazione di regole trasformerà la stringa di origine nella stringa di destinazione.

feersum

Questo è un puzzle sokoban. La posizione di partenza è:

          ___#
#___####_____#
#_#_#_##_#_!##
##______##_###
##__####_#_###
###__###__

La posizione finale è:

          ___#
#___####_____#
#_#_#_##_#_###
##____!__#_###
##__####_#_###
###__###__

Può essere risolto utilizzando la seguente sequenza di tasti:

←← → ↓↓ ← ↑ ←←←←←← ↓↓ → ↑ ← ↑↑↑ ←← ↓ → ↑ → ↓↓ →→→→→→ ↓ → ↑↑ ↓↓ ← ↓ ← ↑ → ↑ ←←← ← ↑ ←← ↓ →→→→→ ↓ →→ ↑↑ → ↑↑ ← ↓ ←← ↓↓ → ↑ ← ↑ →→ ↑ →→ ↓ ← ↓ ←← ↓↓ → ↑ ←←←←←←← ↑ ↑ ←← ↓ →→ ↓ → ↓↓ ← ↑ ← ↑ → ↑↑ ←← ↓ → ↑ → ↓↓ ← ↓ → ↑ →→→→→→ ↓↓ ← ↑ → ↑ ←←←←←← →→→ →→→ ↑↑ ← ↓ → ↓ ← ↑↑ →→ ↑ →→ ↓ ← ↓ ← → ↑↑ ← ↓ ← ↓ ↑ →→ ↓ ← ↑ ←← ↓↓↓ →→ ↑↑ ↓↓ ←← ↑↑ → ↓ ↑↑ → ↑ →→ ↓ ← ↓ ← ↓ ←← ↑↑ →→ ↑ → ↓ ← ↓↓ ←←←←← ↑ ←← ↓ →→→→→ ←←←←← ↑↑ ←← ↓ →→ ↓↓ ← ↑ →→→→

Ecco un programma bash che converte la sequenza di tasti in comandi sed e li applica. I comandi sed contengono solo la sostituzione dei comandi utilizzando le regole di riscrittura definite nella risposta del cop e comandi di etichettatura e ramificazione che non modificano la stringa. Conferma che è possibile ottenere la stringa di destinazione utilizzando solo le regole di riscrittura.

s="___##___####_____##_#_#_##_#_!####______##_#####__####_#_######__###__"
input=

while
    printf '\n%80s\n' "$s"|fold -w14
    read -n 1
    [ "$REPLY" = $'\e' ]
do
    read -n 2
    case "$REPLY" in
    [A)
        s="$(sed '
s:!:wLW_:
        :a
s:L:<<<<<<<<<<<<<:
s:#w<:w#:
s:_w<:w_:
s:_<:<_:
s:#<:<#:
s:#wW:wLX!:
s:_W:W_:
s:#W:W#:
s:_wW:!:
s:_X:X_:
s:#X:X#:
s:_wX:#:
        ta' <<<"$s")";;
    [B)
        s="$(sed '
s:!:_VRv:
        :a
s:R:>>>>>>>>>>>>>:
s:>v#:#v:
s:>v_:_v:
s:>_:_>:
s:>#:#>:
s:Vv#:!URv:
s:U_:_U:
s:U#:#U:
s:Uv_:#:
s:V_:_V:
s:V#:#V:
s:Vv_:!:
        ta' <<<"$s")";;
    [C)
        s="$(sed '
s:!#_:_!#:
        te
s:!_:_!:
        :e' <<<"$s")";;
    [D)
        s="$(sed '
s:_#!:#!_:
        te
s:_!:!_:
        :e' <<<"$s")";;
    esac
    input="$input${REPLY:1}"
done

echo "$input"

Provalo online!

Provalo online (con il codice di escape rimosso)!

Su e giù, !:wLW_oppure !:_VRvviene applicato una volta per volta, e le relative regole vengono applicate ripetutamente fino a quando non !appare di nuovo. Per diritto, uno di !#_:_!#e !_:_!viene applicato. A sinistra, uno di _#!:#!_e _!:!_viene applicato.

Vedere l'output nei collegamenti per la posizione dopo ogni spostamento.

XNOR

Regola 1 x:xn Regola 2 no:oon Regola 3 nr:r Regola 4ooooooooooo:

Usiamo [X,Y]per indicare una serie di Y Xs

A partire da xn[o,A]r,

1. Applicando la Regola 2 una volta che abbiamo x[o,2]n[o,A-1]r.
2. Abbiamo ancora una volta applicato la Regola 2 x[o,4]n[o,A-2]r
3. Applicando fino a quando la os tra ne rdiventa 0, abbiamo x[o,2*A]nr.
4. Applicando la Regola 3 una volta che abbiamo x[o,2*A]r.
5. Applicando la Regola 1 una volta che abbiamo xn[o,2*A]r.

Quindi, abbiamo un algoritmo per generare da xn[o,A]ra xn[o,2*A]r.

A partire da xnor = xn[o,1]r, ripetendo 10 volte l'algoritmo - tranne nel decimo ciclo ci fermiamo al passaggio 4, avendo x[o,1024]r.

Applicando la Regola 4, questo cancella 1023 = 11 * 93 os, lasciando xor.

VortexYT

Non è possibile eliminare Fs senza creare / utilizzare altri caratteri; quindi, dobbiamo usare I:Fcome ultimo passo per raggiungere l'obiettivo. Nessuna regola fornisce un singolo Isenza altri caratteri indesiderati, quindi non è possibile raggiungere la stringa di destinazione.

Equivalentemente, se si tenta di mappare a ritroso dalla fonte, si può ottenere solo da Fa Iprima di avere più opzioni.