Turing Machine Simulator

15

Écrivez un simulateur de machine de Turing .

Pour plus de simplicité, nous pouvons supposer que les états sont des nombres entiers, des symboles comme des caractères, un symbole vide est égal à un espace blanc

5-tuple sous forme d'état actuel, symbole d'entrée, état suivant, symbole de sortie, direction (gauche ou droite) la commande n'est pas obligatoire mais spécifiez si vous la permutez

La machine doit s'arrêter lorsqu'un état inconnu est atteint, aucune autre condition d'arrêt n'est autorisée.

La bande est infinie dans les deux sens et vous pouvez toujours lire un caractère vide.

Entrée: la bande initiale, un état initial et un programme. vous êtes libre de lire les données de n'importe où dans le format que vous aimez

Sortie: la bande après l'exécution du programme

Obligatoire: un exemple de programme qui s'exécute au-dessus de votre simulateur

C'est un code-colf donc le code le plus court l'emporte.

Je publierai une implémentation et quelques exemples de programmes dans les prochaines heures.

code-golf  interpreter 
— Marco Martinelli
source
4
— sergiol

Réponses:

2

GolfScript, 92 caractères

~:m;n\+{:^.n?)>1<]m{2<1$=},.{~2>~^n/~1>[@\+]n*1$%n/~\1$1<+[\1>.!{;" "}*]n*\%@}{;;^0}if}do n-

La machine Turing dans GolfScript est devenue beaucoup plus longue que prévu. Je joue toujours avec différentes représentations de la bande.

La première ligne de l'entrée est l'état d'origine, la deuxième ligne la bande initiale, suivie d'un tableau de transitions (avec l'état actuel de l'ordre, le symbole d'entrée, l'état suivant, la direction, le symbole de sortie).

Exemple (également disponible en ligne )

> 0
> '101'
> [[0 '0' 0 1 '0']
>  [0 '1' 0 1 '1']
>  [0 ' ' 1 -1 ' ']
>  [1 '0' 2 1 '1']
>  [1 '1' 3 -1 '0']
>  [3 '0' 2 1 '1']
>  [3 ' ' 2 1 '1']
>  [3 '1' 3 -1 '0']] 

110
— Howard
source
vous avez battu mon implémentation sed par un caractère, il est temps de voir si je peux faire mieux
— Geoff Reedy
7

GNU sed avec -r- 133 117 111 93 caractères

Oui, sed est complet. GNU sed et -r(regexps étendus) ne servent qu'à enregistrer quelques caractères, ce n'est qu'un petit changement pour fonctionner avec POSIX sed.

:s
s/^(.*@)(.*)>(.)(.*#\1\3([^@]*@)(..))/\5\2\6>\4/
T
s/(..)l>|r>/>\1/
s/>@/@> /
s/>#/> #/
bs

Le format d'entrée est 

[initial state]@[non-empty tape with > marking head position]#[state]@[input symbol][next state]@[output symbol][direction l or r]#...

Les délimiteurs @, #et le caractère de tête >ne peuvent pas être utilisés comme un symbole sur la bande. Les étiquettes d'état ne peuvent pas contenir @ >ou #.

Il exécutera tous les programmes en entrée, un par ligne

Exemples:

Marco est un n b n programme

Contribution

0@>aaabbb#0@a1@ r#0@ 4@ r#1@a1@ar#1@b1@br#1@ 2@ l#2@b3@ l#2@a5@al#3@b3@bl#3@a3@al#3@ 0@ r#4@ 5@Tr

Production

5@    T>  #0@a1@ r#0@ 4@ r#1@a1@ar#1@b1@br#1@ 2@ l#2@b3@ l#2@a5@al#3@b3@bl#3@a3@al#3@ 0@ r#4@ 5@Tr

Bonjour de Marco! programme

Contribution

0@> #0@ 1@Hr#1@ 2@er#2@ 3@lr#3@ 4@lr#4@ 5@or#5@ 6@!r

Production

6@Hello!> #0@ 1@Hr#1@ 2@er#2@ 3@lr#3@ 4@lr#4@ 5@or#5@ 6@!r
— Geoff Reedy
source
7

Je suis donc un peu en retard, mais je pensais juste laisser ça ici ...

Machine de Turing Simuler une machine de Turing: 370 octets?

Ici, j'utilise la structure utilisée par Turing dans son article de 1936. J'utilise un symbole = un octet, y compris les m-configs et les opérations.

╔═══════════════╦═══════╦═══════════════════╦═══════════════╗
║    m-config    ║ Symbol ║     Operations      ║ Final m-config ║
╠═══════════════╬═══════╬═══════════════════╬═══════════════╣
║ currentCommand ║ Any    ║ L                   ║ currentCommand ║
║                ║ *      ║ MR                  ║ readCommand    ║
╠----------------╬--------╬---------------------╬----------------╣
║ nextCommand    ║ Any    ║ L                   ║ nextCommand    ║
║                ║ *      ║ E  R  R  R  P* R    ║ readCommand    ║
╠----------------╬--------╬---------------------╬----------------╣
║ readCommand    ║ P      ║ R                   ║ readCommandP   ║
║                ║ M      ║ R                   ║ readCommandM   ║
║                ║ G      ║ R                   ║ readCommandG   ║
║                ║ E      ║ R                   ║ MHPNone        ║
╠----------------╬--------╬---------------------╬----------------╣
║ readCommandP   ║ 0      ║                     ║ MHP0           ║
║                ║ 1      ║                     ║ MHP1           ║
║                ║ e      ║                     ║ MHPe           ║
║                ║ x      ║                     ║ MHPx           ║
║                ║ None   ║                     ║ MHPNone        ║
╠----------------╬--------╬---------------------╬----------------╣
║ readCommandM   ║ R      ║                     ║ MHMR           ║
║                ║ L      ║                     ║ MHML           ║
╠----------------╬--------╬---------------------╬----------------╣
║ readCommandG   ║ 1      ║                     ║ G2<1           ║
║                ║ 2      ║                     ║ G2<2           ║
║                ║ 3      ║                     ║ G2<3           ║
║                ║ 4      ║                     ║ G2<4           ║
║                ║ 5      ║                     ║ G2<5           ║
╠----------------╬--------╬---------------------╬----------------╣
║ G2<1           ║ int(1) ║ L  P@ R  R  R  P* R ║ GTS            ║
║                ║ <      ║                     ║ G21            ║
║                ║ *      ║ E  L                ║ G2<1           ║
║                ║ @      ║ E  L                ║ G2<1           ║
║                ║ Any    ║ L                   ║ G2<1           ║
╠----------------╬--------╬---------------------╬----------------╣
║ G2<2           ║ int(2) ║ L  P@ R  R  R  P* R ║ GTS            ║
║                ║ <      ║                     ║ G22            ║
║                ║ *      ║ E  L                ║ G2<2           ║
║                ║ @      ║ E  L                ║ G2<2           ║
║                ║ Any    ║ L                   ║ G2<2           ║
╠----------------╬--------╬---------------------╬----------------╣
║ G2<3           ║ int(3) ║ L  P@ R  R  R  P* R ║ GTS            ║
║                ║ <      ║                     ║ G23            ║
║                ║ *      ║ E  L                ║ G2<3           ║
║                ║ @      ║ E  L                ║ G2<3           ║
║                ║ Any    ║ L                   ║ G2<3           ║
╠----------------╬--------╬---------------------╬----------------╣
║ G2<4           ║ int(4) ║ L  P@ R  R  R  P* R ║ GTS            ║
║                ║ <      ║                     ║ G24            ║
║                ║ *      ║ E  L                ║ G2<4           ║
║                ║ @      ║ E  L                ║ G2<4           ║
║                ║ Any    ║ L                   ║ G2<4           ║
╠----------------╬--------╬---------------------╬----------------╣
║ G2<5           ║ int(5) ║ L  P@ R  R  R  P* R ║ GTS            ║
║                ║ <      ║                     ║ G25            ║
║                ║ *      ║ E  L                ║ G2<5           ║
║                ║ @      ║ E  L                ║ G2<5           ║
║                ║ Any    ║ L                   ║ G2<5           ║
╠----------------╬--------╬---------------------╬----------------╣
║ G21            ║ int(1) ║ L  P@ R             ║ GTS            ║
║                ║ Any    ║ R                   ║ G21            ║
╠----------------╬--------╬---------------------╬----------------╣
║ G22            ║ int(2) ║ L  P@ R             ║ GTS            ║
║                ║ Any    ║ R                   ║ G22            ║
╠----------------╬--------╬---------------------╬----------------╣
║ G23            ║ int(3) ║ L  P@ R             ║ GTS            ║
║                ║ Any    ║ R                   ║ G23            ║
╠----------------╬--------╬---------------------╬----------------╣
║ G24            ║ int(4) ║ L  P@ R             ║ GTS            ║
║                ║ Any    ║ R                   ║ G24            ║
╠----------------╬--------╬---------------------╬----------------╣
║ G25            ║ int(5) ║ L  P@ R             ║ GTS            ║
║                ║ Any    ║ R                   ║ G25            ║
╠----------------╬--------╬---------------------╬----------------╣
║ GTS            ║ ^      ║ R                   ║ TS             ║
║                ║ Any    ║ R                   ║ GTS            ║
╠----------------╬--------╬---------------------╬----------------╣
║ TS             ║ 0      ║                     ║ RL0            ║
║                ║ 1      ║                     ║ RL1            ║
║                ║ e      ║                     ║ RLe            ║
║                ║ x      ║                     ║ RLx            ║
║                ║ None   ║                     ║ RLNone         ║
╠----------------╬--------╬---------------------╬----------------╣
║ RL0            ║ @      ║ R  R                ║ GTS0           ║
║                ║ Any    ║ L                   ║ RL0            ║
╠----------------╬--------╬---------------------╬----------------╣
║ RL1            ║ @      ║ R  R                ║ GTS1           ║
║                ║ Any    ║ L                   ║ RL1            ║
╠----------------╬--------╬---------------------╬----------------╣
║ RLe            ║ @      ║ R  R                ║ GTSe           ║
║                ║ Any    ║ L                   ║ RLe            ║
╠----------------╬--------╬---------------------╬----------------╣
║ RLx            ║ @      ║ R  R                ║ GTSx           ║
║                ║ Any    ║ L                   ║ RLx            ║
╠----------------╬--------╬---------------------╬----------------╣
║ RLNone         ║ @      ║ R  R                ║ GTSNone        ║
║                ║ Any    ║ L                   ║ RLNone         ║
╠----------------╬--------╬---------------------╬----------------╣
║ GTS0           ║ 0      ║ R  P*  R            ║ readCommand    ║
║                ║ Any    ║ R                   ║ GTS0           ║
╠----------------╬--------╬---------------------╬----------------╣
║ GTS1           ║ 1      ║ R  P*  R            ║ readCommand    ║
║                ║ Any    ║ R                   ║ GTS1           ║
╠----------------╬--------╬---------------------╬----------------╣
║ GTSe           ║ e      ║ R  P*  R            ║ readCommand    ║
║                ║ Any    ║ R                   ║ GTSe           ║
╠----------------╬--------╬---------------------╬----------------╣
║ GTSx           ║ x      ║ R  P*  R            ║ readCommand    ║
║                ║ Any    ║ R                   ║ GTSx           ║
╠----------------╬--------╬---------------------╬----------------╣
║ GTSNone        ║ _      ║ R  P*  R            ║ readCommand    ║
║                ║ Any    ║ R                   ║ GTSNone        ║
╠----------------╬--------╬---------------------╬----------------╣
║ MHP0           ║ ^      ║ R                   ║ Print0         ║
║                ║ Any    ║ R                   ║ MHP0           ║
╠----------------╬--------╬---------------------╬----------------╣
║ MHP1           ║ ^      ║ R                   ║ Print1         ║
║                ║ Any    ║ R                   ║ MHP1           ║
╠----------------╬--------╬---------------------╬----------------╣
║ MHPe           ║ ^      ║ R                   ║ Printe         ║
║                ║ Any    ║ R                   ║ MHPe           ║
╠----------------╬--------╬---------------------╬----------------╣
║ MHPx           ║ ^      ║ R                   ║ Printx         ║
║                ║ Any    ║ R                   ║ MHPx           ║
╠----------------╬--------╬---------------------╬----------------╣
║ MHPNone        ║ ^      ║ R                   ║ PrintNone      ║
║                ║ Any    ║ R                   ║ MHPNone        ║
╠----------------╬--------╬---------------------╬----------------╣
║ MHMR           ║ ^      ║ R  R                ║ MHR            ║
║                ║ Any    ║ R                   ║ MHMR           ║
╠----------------╬--------╬---------------------╬----------------╣
║ MHML           ║ ^      ║ L                   ║ MHL            ║
║                ║ Any    ║ R                   ║ MHML           ║
╠----------------╬--------╬---------------------╬----------------╣
║ Print0         ║ ^      ║ R                   ║ Print0         ║
║                ║ None   ║ P0                  ║ nextCommand    ║
║                ║ Any    ║ E                   ║ Print0         ║
╠----------------╬--------╬---------------------╬----------------╣
║ Print1         ║ ^      ║ R                   ║ Print1         ║
║                ║ None   ║ P1                  ║ nextCommand    ║
║                ║ Any    ║ E                   ║ Print1         ║
╠----------------╬--------╬---------------------╬----------------╣
║ Printx         ║ ^      ║ R                   ║ Printx         ║
║                ║ None   ║ Px                  ║ nextCommand    ║
║                ║ Any    ║ E                   ║ Printx         ║
╠----------------╬--------╬---------------------╬----------------╣
║ Printe         ║ ^      ║ R                   ║ Printe         ║
║                ║ None   ║ Pe                  ║ nextCommand    ║
║                ║ Any    ║ E                   ║ Printe         ║
╠----------------╬--------╬---------------------╬----------------╣
║ PrintNone      ║ ^      ║ R                   ║ PrintNone      ║
║                ║ None   ║                     ║ nextCommand    ║
║                ║ Any    ║ E                   ║ PrintNone      ║
╠----------------╬--------╬---------------------╬----------------╣
║ MHL            ║ ^      ║ R  R                ║ MHL            ║
║                ║ [      ║                     ║ SBL            ║
║                ║ Any    ║ L  P^ R  R  E       ║ nextCommand    ║
╠----------------╬--------╬---------------------╬----------------╣
║ MHR            ║ ^      ║ R  R                ║ MHR            ║
║                ║ ]      ║                     ║ SBR            ║
║                ║ None   ║ P^ L  L  E          ║ nextCommand    ║
╠----------------╬--------╬---------------------╬----------------╣
║ SBR            ║ ]      ║ E  R  R  P]         ║ currentCommand ║
╠----------------╬--------╬---------------------╬----------------╣
║ SBL            ║ ]      ║ R                   ║ SBLE           ║
║                ║ Any    ║ R                   ║ SBL            ║
╠----------------╬--------╬---------------------╬----------------╣
║ SBLE           ║ [      ║                     ║ currentCommand ║
║                ║ None   ║ L                   ║ SBLE           ║
║                ║ Any    ║ E  R  R  P] L       ║ SBLE           ║
╚═══════════════╩═══════╩═══════════════════╩═══════════════╝

Voici un des exemples de Turing du papier ci-dessus pour ma machine:

['<', None, 1, '0', None, 'P', 'e', None, 'M', 'R', None, 'P', 'e', None, 'M', 'R', None, 'P', '0', None, 'M', 'R', None, 'M', 'R', None, 'P', '0', None, 'M', 'L', None, 'M', 'L', None, 'G', '2',
                      '1', None, 'P', 'e', None, 'M', 'R', None, 'P', 'e', None, 'M', 'R', None, 'P', '0', None, 'M', 'R', None, 'M', 'R', None, 'P', '0', None, 'M', 'L', None, 'M', 'L', None, 'G', '2',
                      'e', None, 'P', 'e', None, 'M', 'R', None, 'P', 'e', None, 'M', 'R', None, 'P', '0', None, 'M', 'R', None, 'M', 'R', None, 'P', '0', None, 'M', 'L', None, 'M', 'L', None, 'G', '2',
                      'x', None, 'P', 'e', None, 'M', 'R', None, 'P', 'e', None, 'M', 'R', None, 'P', '0', None, 'M', 'R', None, 'M', 'R', None, 'P', '0', None, 'M', 'L', None, 'M', 'L', None, 'G', '2',
                      '_', None, 'P', 'e', None, 'M', 'R', None, 'P', 'e', None, 'M', 'R', None, 'P', '0', None, 'M', 'R', None, 'M', 'R', None, 'P', '0', None, 'M', 'L', None, 'M', 'L', None, 'G', '2',

             None, 2, '1', None, 'M', 'R', None, 'P', 'x', None, 'M', 'L', None, 'M', 'L', None, 'M', 'L', None, 'G', '2',
                      '0', None, 'G', '3',

             None, 3, '0', None, 'M', 'R', None, 'M', 'R', None, 'G', '3',
                      '1', None, 'M', 'R', None, 'M', 'R', None, 'G', '3',
                      '_', None, 'P', '1', None, 'M', 'L', None, 'G', '4',

             None, 4, 'x', None, 'E', 'E', None, 'M', 'R', None, 'G', '3',
                      'e', None, 'M', 'R', None, 'G', '5',
                      '_', None, 'M', 'L', None, 'M', 'L', None, 'G', '4',

             None, 5, '0', None, 'M', 'R', None, 'M', 'R', None, 'G', '5',
                      '1', None, 'M', 'R', None, 'M', 'R', None, 'G', '5',
                      'e', None, 'M', 'R', None, 'M', 'R', None, 'G', '5',
                      'x', None, 'M', 'R', None, 'M', 'R', None, 'G', '5',
                      '_', None, 'P', '0', None, 'M', 'L', None, 'M', 'L', None, 'G', '2',
        None, '[', '^', None, ']', None]

Essayez-le en ligne! (Utilise Python 3 comme interprète) --Edit: Je viens de vérifier le TIO, et il ne semble pas vraiment fonctionner correctement ... Essayez-le sur votre machine locale et cela devrait (espérons-le) fonctionner. C'est le mien.

— bendl
source
Aucun mal intentionné, il suffit d'aligner les bordures sur la table.
— Greg Bacon
@GregBacon Aucune infraction prise ... peut-être y a-t-il une différence entre la façon dont les différents ordinateurs rendent les blocs de code, mais votre modification a rendu l'alignement bien pire sur mon écran d'édition ... Je suis sûr que cela semblait bien quand vous avez suggéré la modification; Je ne sais pas quel est le problème
— bendl
3

APL (110)

(Ce n'est même pas si court ...)

0(''⍞){×⍴X←0~⍨⍺∘{x y S T s m t←⍺,⍵⋄S T≡x,⊃⊃⌽y:s,⊂(⊃y){m:(¯1↓⍺)(⍵,⍨¯1↑⍺)⋄(⍺,⊃⍵)(1↓⍵)}t,1↓⊃⌽y⋄0}¨⍵:⍵∇⍨⊃X⋄,/⊃⌽⍺}⎕

Il lit deux lignes à partir du clavier: la première est le programme et la seconde est la bande initiale.

Le format est

(in-state in-tape out-state movement out-tape)

et ils devraient tous être sur la même ligne. «Mouvement» est 0 pour se déplacer vers la droite et 1 pour se déplacer vers la gauche.

Exemple de programme (les sauts de ligne sont insérés pour plus de clarté, ils doivent tous être sur une seule ligne.)

(0 ' ' 1 0 '1')
(0 '1' 0 0 '1')
(1 '1' 1 0 '1')
(1 ' ' 2 1 ' ')
(2 '1' 3 1 ' ')

Le programme ajoute deux nombres unaires ensemble, par exemple:

in:  1111 111
out: 1111111

Exemple 2 (adapté du programme d'incrémentation binaire de l'entrée de Marco Martinelli):

(0 '0' 0 0 '0')
(0 '1' 0 0 '1')
(0 ' ' 1 1 ' ')
(1 '0' 2 0 '1')
(1 '1' 3 1 '0')
(3 '0' 2 0 '1')
(3 ' ' 2 0 '1')
(3 '1' 3 1 '0')
— marinus
source
Comment puis-je l'essayer? J'utilise Linux et j'ai essayé avec aplus mais cela ne fonctionne pas (jeton non défini :(). Quel interprète / compilateur dois-je essayer?
— Marco Martinelli
J'utilise Dyalog APL. Je ne suis pas au courant d'utiliser des fonctions spécifiques à Dyalog mais A + n'est pas complètement la même chose. Il y a une version gratuite de Dyalog mais c'est seulement pour Windows. (Il peut fonctionner sous Wine mais il utilise sa propre méthode de saisie pour que vous puissiez taper APL.) Si vous lancez Dyalog, entrez / collez simplement le code APL (sur une ligne), puis le programme de la machine Turing (sur une deuxième ligne ), puis la bande initiale (sur la troisième ligne).
— marinus
ok, je vais essayer ça, merci
— Marco Martinelli
3

Python, 101 189 152 142 142

a=dict(zip(range(len(b)),b))
r=eval(p)
i=s=0
while 1:
 c=a.get(i,' ')
 s,m,a[i]=r[s,c]
 if 0==m:exit([x[1]for x in sorted(a.items())])
 i=i+m

b et p sont les entrées, b est la bande initiale, p code les règles en tant que (représentation sous forme de chaîne) d'un dicton de (dans l'état, dans la bande) tuple vers (hors état, déplacement de la tête, hors bande) tuple . Si le déplacement est 0, le programme se termine, 1 est le déplacement vers la droite et -1 est le déplacement vers la gauche.

b="aaba"

p="""{(0, 'a'): (1, 1, 'a'),
      (0, 'b'): (0, 1, 'b'),
      (1, 'a'): (1, 1, 'a'),
      (1, 'b'): (0, 1, 'b'),
      (1, ' '): (1, 0, 'Y'),
      (0, ' '): (0, 0, 'N')}"""

Cet exemple de programme teste si la dernière lettre de la chaîne (avant la bande vide) est «a», si c'est le cas, il écrit «Y» à la fin de la chaîne (premier espace vide).

Modifier 1:

Modification de la bande pour qu'elle soit représentée comme dictée, car cela semblait être le moyen le plus court d'écrire une structure de données extensible. L'avant-dernière ligne la transforme principalement en une forme lisible pour la sortie.

Modifier 2:

Merci à Strigoides pour de nombreuses améliorations.

Modifier 3:

Je l'avais fait inutilement pour que 0 comme sortie laisse la place telle qu'elle est. J'ai supprimé cela car nous pouvons toujours écrire la sortie de la même manière que l'entrée.

— shiona
source
Je ne pense pas que ce soit une solution valable car dans votre implémentation, la bande est limitée. De cette façon, vous devez connaître à l'avance la consommation de mémoire de votre programme. Et il y a des problèmes de déplacement à gauche. Astuce: une bande peut être faite à partir de deux piles modifiées dans lesquelles vous pouvez toujours faire apparaître un symbole vierge.
— Marco Martinelli
Ah, c'est vrai. Désolé, je n'ai pas trop réfléchi.
— shiona
Uhm .. afaik la bande est infinie dans les deux sens et vous pouvez toujours lire un caractère vide. Je le préciserai dans la réponse.
— Marco Martinelli
Vous aviez raison (nous avions eu des règles plus strictes dans nos exercices). J'ai corrigé au moins certains des défauts.
— shiona
Vous pouvez supprimer l'espace dans la première ligne, r=0;s=0devenir r=s=0(et le point-virgule à la fin de cette ligne n'est pas nécessaire), vous pouvez supprimer la fonction w, car elle n'est pas utilisée, les crochets peuvent être supprimés (s,m,t)=r[s,c], le bloc try/ exceptpeut être raccourci en utilisant dict.get; c=a.get(i,' '), puisqu'il mvaut 0 ou 1, vous pouvez l'utiliser if m-1:et vous pouvez raccourcir votre map()appel en le convertissant en une liste de compréhension.
— Strigoides
3

Postscript (205) (156) (150) (135)

<<
>>begin
/${stopped}def([){add dup{load}${exit}if}def
0 A{1 index{load}${pop( )}if
get{exec}${exit}if}loop
3{-1[pop}loop{1[print}loop

C'est probablement de la triche, mais la table de transition contient du code pour effectuer les transitions. Et puisque la bande est représentée par un mappage d'entiers en entiers, j'ai représenté les états comme un mappage de noms vers des dictionnaires afin que la bande et le programme coexistent dans le même dictionnaire anonyme.

Économies supplémentaires en rendant tous les noms d'état exécutables, afin qu'ils se chargent automatiquement .

Non golfé avec le programme "Hello" intégré. 52 caractères supplémentaires achètent une boucle pour lire la bande depuis stdin.Courez avec gsnd -q tm.ps.

%!
<<
    /A<<( ){dup(H)def 1 add B}>>
    /B<<( ){dup(e)def 1 add C}>>
    /C<<( ){dup(l)def 1 add D}>>
    /D<<( ){dup(l)def 1 add E}>>
    /E<<( ){dup(o)def 1 add F}>>
>>begin %ds: int-keys=tape name-keys=prog
0 A %pos state
{ %loop
    1 index{load}stopped{pop( )}if  %pos state tape(pos)
    get    {exec}stopped{exit  }if  %new-pos new-state
} loop
% Loop from tape position 0 to left until left tape end is found
0{                                  %pos
  -1 add                            %new-pos
  dup{load}stopped{exit}if          %new-pos tape(new-pos)
  pop                               %new-pos tape(new-pos)
}loop
% Move to the right and print all chars until right end is hit
{                                   %pos
  1 add                             %new-pos
  dup{load}stopped{exit}if          %new-pos tape(new-pos)
  print                             %new-pos tape(new-pos)
}loop

Le format de tableau est donc 

/in-state<<in-tape{dup out-tape def movement add out-state}
           in-tape2{dup out-tape2 def movement2 add out-state2}>>

où in-stateest un nom, in-tapeet out-tapesont des caractères (c'est-à-dire des entiers ou des expressions qui produisent des entiers), movementest -1pour gauche ou 1pour droite, et out-stateest un nom exécutable . Les in-tapetransitions multiples pour le même état doivent être combinées comme ci-dessus.

— luser droog
source
Un autre problème est qu'il n'y a aucune disposition pour découvrir quelle partie de la bande est intéressante. Ça va coûter un peu pour faire un currentdict{search-for-min-and-max}forall juggle-params-for-for. :(
— luser droog
J'ai essayé le mien, mais c'était bien au-delà de votre concision. Mais j'ai suggéré quelques améliorations à votre code.
— Thomas W.
BTW, qu'en est-il de la bande initiale? J'ai supprimé la ligne commentée du code non golfé car cela ne semblait pas faire le travail. ("0 not" renvoie -1, donc pas d'itération de la boucle)
— Thomas W.
Excellentes améliorations! ... À propos du code de bande initial, je pense que je l'ai mal tapé dans mon carnet. SB 0 1 0 not{(%stdin)(r)file read not{exit}if def}for. Je ne sais pas pourquoi j'ai pensé que je pourrais m'en tirer en omettant cela de la version golfée. : P
— luser droog
Oh, attends, -1! Alors 0 notdevrait l'être 16#7fffffff. Pardon. Ah! c'est pourquoi il a été commenté! Il est sorti directement du cahier, n'a pas été testé et j'ai coupé tous les commentaires sans regarder quand je l'ai joué au golf. Ne le dites pas au gars de Python! : P
— luser droog
2

C (pas encore joué au golf)

Je suppose que je ne peux pas gagner avec ça, c'était quand même amusant de le faire fonctionner. Cela est encore plus vrai maintenant que ce vraiment fait le travail. :)

Sauf que c'est seulement infini dans une direction. Je suppose qu'il a également besoin d'une bande négative. Soupir....

Le négatif n'était pas si mal. Nous entrelacons les deux côtés comme des chances égales. La complication est maintenant qu'il doit afficher la bande dans un ordre séquentiel , car le fichier lui-même est maintenant brouillé. Je pense que c'est une modification légitime. Turing lui-même a simplifié de cette façon.

#include<stdio.h>
int main(int c, char**v){
    int min=0,max=0;
    int pos=0,qi;sscanf(v[1],"%d",&qi);
    FILE*tab=fopen(v[2],"r");
    FILE*tape=fopen(v[3],"r+");
    setbuf(tape,NULL);
    do {
        min = pos<min? pos: min;
        max = pos>max? pos: max;
        fseek(tape,(long)(abs(pos)*2)-(pos<0),SEEK_SET);
        int c = fgetc(tape), qt=qi-1,qr;
        fseek(tape,(long)(abs(pos)*2)-(pos<0),SEEK_SET);
        char x = c==EOF?' ':c, xt=x-1,xr,d[2];
        if (x == '\n') x = ' ';
printf("%d '%c' %d (%d)\n", qi, x, pos, (int)ftell(tape));
        while((qt!=qi)||(xt!=x)){
            fscanf(tab, "%d '%c' %d '%c' %1[LRN]", &qt, &xt, &qr, &xr, d);
            if (feof(tab)){
                goto HALT;
            }
printf("%d '%c' %d '%c' %s\n", qt, xt, qr, xr, d);
        }
        qi=qr;
        rewind(tab);
        fputc(xr,tape);
        pos+=*d=='L'?-1:*d=='R'?1:0;
    } while(1);
HALT:
printf("[%d .. %d]:\n", min, max);
    for (pos = min; pos <= max; pos++){
        fseek(tape,(long)(abs(pos)*2)-(pos<0),SEEK_SET);
        //printf("%d ",pos);
        putchar(fgetc(tape));
        //puts("");
    }
    return qi;
}

Et voici le test:

522(1)04:33 AM:~ 0> cat bab.tm
0 'a' 0 'b' R
0 'b' 0 'a' R
523(1)04:33 AM:~ 0> echo aaaaa > blank; make tm ; tm 0 bab.tm blank; echo; cat blank
make: `tm' is up to date.
0 'a' 0 (0)
0 'a' 0 'b' R
0 'a' 1 (2)
0 'a' 0 'b' R
0 'a' 2 (4)
0 'a' 0 'b' R
0 ' ' 3 (6)
0 'a' 0 'b' R
0 'b' 0 'a' R
[0 .. 3]:
bbbÿ
babab

Le programme sort la bande dans un ordre séquentiel, mais le fichier représente les côtés négatifs et positifs entrelacés.

— luser droog
source
Il y a des problèmes avec votre implémentation. Essayez ce programme qui permute a et b 0 'a' 0 'b' R; 0 'b' 0 'a' Ravec l'entrée aaa la sortie est bab au lieu de bbb. Et il y a des problèmes de déplacement à gauche.
— Marco Martinelli
Merci pour l'attention! La mise à jour corrige les deux, je pense (j'espère).
— luser droog
euh .. toujours en train de faire du bab
— Marco Martinelli
oui, mais cette fois c'est correct! 'aaa' correspond aux positions [0, -1,1] sur la bande. Mais la sortie qui devrait montrer cela a clairement besoin de travail.
— luser droog
1

Groovy 234 228 154 153 149 139 124

n=[:];i=0;t={it.each{n[i++]=it};i=0};e={p,s->a=p[s,n[i]?:' '];if(a){n[i]=a[1];i+=a[2];e(p,a[0])}else n.sort()*.value.join()}

Formaté pour la lisibilité

n=[:];
i=0;
t={it.each{n[i++]=it};i=0};
e={p,s->
    a=p[s,n[i]?:' '];
    if(a){
        n[i]=a[1];
        i+=a[2];
        e(p,a[0])
    }else n.sort()*.value.join()
}

t est la fonction qui définit la bande e est la fonction qui évalue le programme

Exemple 1 - Imprimez "Bonjour!" sur la bande :)

t('')
e([[0,' ']:[1,'H',1],
   [1,' ']:[2,'e',1],
   [2,' ']:[3,'l',1],
   [3,' ']:[4,'l',1],
   [4,' ']:[5,'o',1],
   [5,' ']:[6,'!',1]],0)

Exemple 2 - Laissez un T sur la bande si la chaîne initiale est sous la forme d'un n b n , arrêtez sinon.

t('aaabbb')
e([[0,'a']:[1,' ',1],
   [0,' ']:[4,' ',1],
   [1,'a']:[1,'a',1],
   [1,'b']:[1,'b',1],
   [1,' ']:[2,' ',-1],
   [2,'b']:[3,' ',-1],
   [2,'a']:[5,'a',-1],
   [3,'b']:[3,'b',-1],
   [3,'a']:[3,'a',-1],
   [3,' ']:[0,' ',1],
   [4,' ']:[5,'T',1]],0)

Exemple 3 - Incrément d'un nombre binaire

t('101')
e([[0,'0']:[0,'0',1],
   [0,'1']:[0,'1',1],
   [0,' ']:[1,' ',-1],
   [1,'0']:[2,'1',1],
   [1,'1']:[3,'0',-1],
   [3,'0']:[2,'1',1],
   [3,' ']:[2,'1',1],
   [3,'1']:[3,'0',-1]],0)

dans les exemples 1 signifie déplacer vers la droite et -1 signifie déplacer vers la gauche

— Marco Martinelli
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.