Este é um pouco à prova de golf -como COPS-e-ladrões desafio. Este é o fio dos ladrões; a discussão dos policiais está aqui .

Ladrões

Os policiais publicarão sistemas de reescrita abstratos. Sua tarefa é decifrar os envios, provando que a cadeia de destino pode ou não ser alcançada a partir da cadeia de origem, aplicando suas regras de reescrita. (Você pode fazer isso publicando uma sequência de regras de reescrita que começa com a cadeia de origem e termina com o destino ou provando matematicamente que isso existe ou não.)

Veja o tópico da polícia para detalhes e definições.

jimmy23013

Vamos trabalhar para trás neste. Primeiro, transformamos os dígitos em suas representações binárias. Nós vamos de VW626206555675126212043640270477001760465526277571600601para VW++__+_++__+____++_+_++_++_+++_++++_+__+_+_++__+___+_+____+___++++_+______+_+++___+__++++++________++++++____+__++_+_++_+_+_++__+_+++++++_++++__+++_______++______+. Em seguida, continuamos aplicando o inverso de DCW:W+e DW:W_até limparmos todos os símbolos. Nosso resultado é agora VDCDCDDDCDDCDCDDDCDDDDDCDCDDCDDCDCDDCDCDDCDCDCDDCDCDCDCDDCDDDCDDCDDCDCDDDCDDDDCDDCDDDDDCDDDDCDCDCDCDDCDDDDDDDCDDCDCDCDDDDCDDDCDCDCDCDCDCDDDDDDDDDCDCDCDCDCDCDDDDDCDDDCDCDDCDDCDCDDCDDCDDCDCDDDCDDCDCDCDCDCDCDCDDCDCDCDCDDDCDCDCDDDDDDDDCDCDDDDDDDCW. Agora, queremos fazer com que essa string corresponda VD+C+W; isto é, queremos mover todos os Ds para a esquerda de todos eles C. Isso pode ser feito revertendo DCC:CD. Fazemos isso repetindo o seguinte algoritmo:

1. Encontre o primeiro Dque está à direita de um bloco de Cs.
2. Mova Dpara a esquerda desse bloco.
3. Dobrar o número de Cs.

Através de algumas contas, podemos determinar que teremos 123 se D4638704741628490670592103344196019722536654143873 Cs (você estava certo sobre isso não se encaixar em uma resposta SE ... duvido que isso se encaixaria se armazenado como estados de todos os átomos da Terra combinado: P).

Se continuarmos aplicando o inverso de V:VD, podemos nos livrar de todos os Ds agora, e assim conseguiremos VCCC.......CCCW. Nós convertemos as Vcostas em YZ. Agora nós temos YZCCC.......CCCW.

Queremos ser capazes de nos livrar de todos os se Ctê-lo na forma YAAA...AAABBB...BBBZW. Felizmente, isso pode ser feito pelo seguinte método. Em primeiro lugar, aplicamos YB:Yinversamente 587912508217580921743211 vezes para obter YBBB.......BBBZCCC.......CCCW. Em seguida, repetimos a seguinte sequência de etapas (onde [?*]significa qualquer número de ?, não necessariamente maior que zero):

1. CZ:ZCAplicação inversa 587912508217580921743211 vezes para obterY[A*]BBB.......BBBCCC.......CCCZCCC.......CCCW
2. Aplique inversamente CB:BCvárias vezes para obterY[A*]BCBCBC.......BCBCBCZCCC.......CCCW
3. Aplicação inversa AZ:Ze AB:BCAmuitas vezes para obterY[A*]ABBB.......BBBZCCC.......CCCW

Por indução, vemos que podemos mover a BZcombinação até o fim (exceto antes do W) e, em seguida, o número de As é 1/587912508217580921743211 do número de Cs, deixando-nos 7890127658096618386747843 As. Agora temos YAAA.......AAABBB.......BBBZW. Converta as ZWcostas em a e U, em seguida, aplique inversamente U:BUvárias vezes para manter apenas 2 se, Bdepois converta-as BBUem a T, e agora você tem YAAA.......AAAT. Em seguida, você pode aplicar inversamente T:AAAAATvárias vezes para obter, YAAATporque o número de As era 3 maior que um múltiplo de 5.

Obrigado pelo desafio!

boboquack

Para uma determinada sequência, pegue todas as letras (a = 0, b = 1, c = 2), some-as e faça o módulo 3. Em seguida, nenhuma regra de reescrita altera esse valor. A cadeia de origem tem um valor de 1 e o destino tem um valor de 2. Portanto, nenhuma combinação de regras transformará a cadeia de origem na cadeia de destino.

feersum

Este é um quebra-cabeça sokoban. A posição inicial é:

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

A posição final é:

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

Pode ser resolvido usando a seguinte sequência de teclas:

← ← ↓↓ ← ↑ ← ↓ ← ↓ ← ↑ → ↑ ← ↑ → ↑ → ↓ → ↑ → ↓↓ → ↓ → → → → → → → → → → → ← ↑ ← ↓ → ◄ → → → → → → → ↑ → → → → → → → → → → → → → → → → → → → → ↑ ← Duplo ↓ → ← ↓ → ↓↓ ← ↑ ← ↑ → ↑↑ ← ↓ → ↑ → ↓↓ ← ↓ → → →►►►►►►►►►►►►►►►►►►►►►►►►►►►►►►►►►►►►►►►►►►►►►►►►►►►►►►►►►►►►►►►►►►►►► ↓ ↑↑ → ↑ → ← ↓ ← ↓ ← ↓ ← ↓ → ↓ → ↓ → ↓ ← ↓↓ ← ↓↓ ← ↑ →

Aqui está um programa bash que converte a sequência de teclas em comandos sed e os aplica. Os comandos sed contêm apenas comandos de substituição usando as regras de reescrita definidas na resposta do policial e comandos de rotulagem e ramificação que não modificam a sequência. Ele confirma que você pode obter a sequência de destino usando apenas as regras de reescrita.

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"

Experimente online!

Experimente online (com o código de escape removido)!

Para cima e para baixo, !:wLW_ou !:_VRvé aplicado uma vez de forma correspondente, e as regras relevantes são aplicadas repetidamente até que !apareça novamente. Para a direita, um de !#_:_!#e !_:_!é aplicado. Para a esquerda, um de _#!:#!_e _!:!_é aplicado.

Veja a saída nos links para a posição após cada movimento.

xnor

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

Usamos [X,Y]para indicar uma sequência de Y Xs

A partir de xn[o,A]r,

1. Aplicando a Regra 2 quando tivermos x[o,2]n[o,A-1]r.
2. Aplicando a Regra 2, mais uma vez, temos x[o,4]n[o,A-2]r
3. Aplicáveis até à os entre ne rse torna 0, temos x[o,2*A]nr.
4. Aplicando a Regra 3 quando tivermos x[o,2*A]r.
5. Aplicando a Regra 1 quando tivermos xn[o,2*A]r.

Portanto, temos um algoritmo para gerar de xn[o,A]rpara xn[o,2*A]r.

Começando com xnor = xn[o,1]r, repetindo 10 vezes o algoritmo - exceto no 10º loop, paramos na Etapa 4, tendo x[o,1024]r.

Aplicando a Regra 4, isso limpa 1023 = 11 * 93 os, saindo xor.

VortexYT

Não há como eliminar Fs sem criar / usar outros caracteres; portanto, devemos usar I:Fcomo o último passo para chegar ao alvo. Nenhuma regra fornece um único Isem outros caracteres indesejados, portanto, você não pode chegar à string de destino.

Da mesma forma, se você tentar mapear de trás para frente a partir da fonte, poderá ir de Faté Iantes de não ter mais opções.