Il s'agit d'un défi de flics et de voleurs semblable à une preuve de golf . Ceci est le fil des voleurs; le fil des flics est ici .

Voleurs

Les flics publieront des systèmes de réécriture abstraits. Votre tâche consiste à casser leurs soumissions en prouvant que la chaîne cible peut ou non être atteinte à partir de la chaîne source en appliquant leurs règles de réécriture. (Vous pouvez le faire soit en publiant une séquence de règles de réécriture qui commence par la chaîne source et se termine par la cible, ou en prouvant mathématiquement que cela existe ou n'existe pas.)

Voir le fil des flics pour les détails et les définitions.

jimmy23013

Travaillons à l'envers pour celui-ci. Nous transformons d'abord les chiffres en leurs représentations binaires. Nous allons de VW626206555675126212043640270477001760465526277571600601à VW++__+_++__+____++_+_++_++_+++_++++_+__+_+_++__+___+_+____+___++++_+______+_+++___+__++++++________++++++____+__++_+_++_+_+_++__+_+++++++_++++__+++_______++______+. Ensuite, nous continuons d'appliquer l'inverse de DCW:W+et DW:W_jusqu'à ce que nous effacions tous les symboles. Notre résultat est maintenant VDCDCDDDCDDCDCDDDCDDDDDCDCDDCDDCDCDDCDCDDCDCDCDDCDCDCDCDDCDDDCDDCDDCDCDDDCDDDDCDDCDDDDDCDDDDCDCDCDCDDCDDDDDDDCDDCDCDCDDDDCDDDCDCDCDCDCDCDDDDDDDDDCDCDCDCDCDCDDDDDCDDDCDCDDCDDCDCDDCDDCDDCDCDDDCDDCDCDCDCDCDCDCDDCDCDCDCDDDCDCDCDDDDDDDDCDCDDDDDDDCW. Nous voulons maintenant faire correspondre cette chaîne VD+C+W; c'est-à-dire que nous voulons déplacer tous les Ds vers la gauche de tous les Cs. Cela peut être fait en inversant DCC:CD. Pour ce faire, nous répétons l'algorithme suivant:

1. Trouvez le premier Dqui se trouve à droite d'un bloc de Cs.
2. Déplacez le Dà gauche de ce bloc.
3. Doublez le nombre de Cs.

Grâce à quelques calculs, nous pouvons déterminer que nous nous retrouverons avec 123 Ds et 4638704741628490670592103344196019722536654143873 Cs (vous aviez raison à ce sujet ne correspond pas à une réponse SE ... Je doute que cela convienne s'il est stocké en tant qu'états de tous les atomes de la Terre combiné: P).

Si nous continuons d'appliquer l'inverse de V:VD, nous pouvons nous débarrasser de tous les Ds maintenant, alors nous le faisons VCCC.......CCCW. Nous convertissons le Vdos en YZ. Maintenant nous l'avons YZCCC.......CCCW.

Nous voulons pouvoir nous débarrasser de tous les Cs et les avoir sous la forme YAAA...AAABBB...BBBZW. Heureusement, cela peut être fait par la méthode suivante. Tout d'abord, nous appliquons YB:Yinversement 587912508217580921743211 fois pour obtenir YBBB.......BBBZCCC.......CCCW. Ensuite, nous répétons la séquence d'étapes suivante (où [?*]signifie n'importe quel nombre de ?, pas nécessairement supérieur à zéro):

1. Appliquer CZ:ZCinversement 587912508217580921743211 fois pour obtenirY[A*]BBB.......BBBCCC.......CCCZCCC.......CCCW
2. Inversez CB:BCplusieurs fois pour obtenirY[A*]BCBCBC.......BCBCBCZCCC.......CCCW
3. Appliquer inversement AZ:Zet AB:BCAplusieurs fois pour obtenirY[A*]ABBB.......BBBZCCC.......CCCW

Grâce à l'induction, nous voyons que nous pouvons déplacer la BZcombinaison jusqu'à la fin (sauf avant le W), puis le nombre de As est 1/587912508217580921743211 du nombre de Cs, nous laissant avec 7890127658096618386747843 As. Nous avons maintenant YAAA.......AAABBB.......BBBZW. Convertissez le ZWdos en a U, puis appliquez U:BUplusieurs fois l' inverse pour ne garder que 2 Bs, puis convertissez le BBUen a T, et vous avez maintenant YAAA.......AAAT. Ensuite, vous pouvez appliquer T:AAAAATplusieurs fois l' inverse pour obtenir YAAATcar le nombre de As était 3 supérieur à un multiple de 5.

Merci pour le défi!

boboquack

Pour une chaîne donnée, prenez toutes les lettres (a = 0, b = 1, c = 2), additionnez-les et prenez le modulo 3. Ensuite, aucune des règles de réécriture ne modifie cette valeur. La chaîne source a une valeur de 1 et la cible a une valeur de 2. Par conséquent, aucune combinaison de règles ne transforme la chaîne source en chaîne cible.

feersum

Ceci est un puzzle sokoban. La position de départ est:

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

La position finale est:

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

Il peut être résolu en utilisant la séquence de touches suivante:

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

Voici un programme bash qui convertit la séquence de touches en commandes sed et les applique. Les commandes sed contiennent uniquement des commandes de remplacement utilisant les règles de réécriture définies dans la réponse du flic, et des commandes d'étiquetage et de branchement qui ne modifient pas la chaîne. Il confirme que vous pouvez obtenir la chaîne cible en utilisant uniquement les règles de réécriture.

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"

Essayez-le en ligne!

Essayez-le en ligne (avec le code d'échappement supprimé)!

Pour le haut et le bas, !:wLW_ou !:_VRvest appliqué pour une fois de manière correspondante, et les règles pertinentes sont appliquées à plusieurs reprises jusqu'à ce !qu'elles apparaissent à nouveau. Pour droit, l'un de !#_:_!#et !_:_!est appliqué. Pour la gauche, l'un de _#!:#!_et _!:!_est appliqué.

Voir la sortie dans les liens pour la position après chaque mouvement.

xnor

Règle 1 x:xn Règle 2 no:oon Règle 3 nr:r Règle 4ooooooooooo:

Nous utilisons [X,Y]pour indiquer une série de Y Xs

À partir de xn[o,A]r,

1. Appliquer la règle 2 une fois que nous l'avons x[o,2]n[o,A-1]r.
2. En appliquant à nouveau la règle 2, nous avons x[o,4]n[o,A-2]r
3. En appliquant jusqu'à ce que le os entre net rdevienne 0, nous avons x[o,2*A]nr.
4. Appliquer la règle 3 une fois que nous avons x[o,2*A]r .
5. Appliquer la règle 1 une fois que nous l'avons xn[o,2*A]r.

Nous avons donc un algorithme pour générer de xn[o,A]rà xn[o,2*A]r.

À partir de xnor = xn[o,1]r, en répétant 10 fois l'algorithme - sauf dans la 10e boucle, nous nous arrêtons à l'étape 4, ayantx[o,1024]r .

En appliquant la règle 4, cela efface 1023 = 11 * 93 os, laissant xor.

VortexYT

Il n'y a aucun moyen d'éliminer Fs sans créer / utiliser d'autres caractères; ainsi, nous devons utiliser I:Fcomme dernière étape pour atteindre la cible. Aucune règle ne donne un seulI sans d'autres caractères indésirables, vous ne pouvez donc pas accéder à la chaîne cible.

De manière équivalente, si vous essayez de mapper en arrière à partir de la source, vous ne pouvez accéder Fqu'à Iavant d'avoir plus d'options.