Écrire un interprète pour 2B


12

Écrire un interprète pour 2B

J'aime le langage ésotérique 2B de David Catt , ayant la mémoire stockée dans une bande où chaque cellule est une bande d'octets séparée (la «sous-bande»). Écrivez-lui un interprète!

Spécification de langue

Les spécifications officielles peuvent être trouvées ici . Dans cette spécification, "signifie un nombre dans la plage 0-9( 0est interprété comme 10) et _signifie une chaîne de n'importe quelle longueur. Chaque cellule stocke une valeur dans la plage 0-255et le débordement / sous-débordement s'enroule comme s'il s'agissait d'un BF. (Merci @ MartinBüttner). Pour convertir du texte en nombres 0-255, utilisez des codes ASCII . Parce que je ne trouve aucun détail à ce sujet, je vais dire que la longueur de la bande doit être 255minimale, mais si vous savez le contraire, veuillez modifier.

+-------------+----------------------------------------------------------------------------------------------------------------------------------------+
| Instruction |                                                              Description                                                               |
+-------------+----------------------------------------------------------------------------------------------------------------------------------------+
| 0           | Zeroes the current cell and clears the overflow/underflow flag.                                                                        |
| {           | If the current cell is zero, jump to the matching }.                                                                                   |
| }           | A placeholder for the { instruction.                                                                                                   |
| (           | Read a byte from the input stream and place it in the current cell.                                                                    |
| )           | Write the value of the current cell to the console.                                                                                    |
| x           | Store the value of the current cell in a temporary register.                                                                           |
| o           | Write the value of the temporary register to the console.                                                                              |
| !           | If the last addition overflowed, add one to the current cell. If the last subtraction underflowed, subtract one from the current cell. |
| ?           | Performs a binary NOT on the current cell.                                                                                             |
| +"          | Adds an amount to the current cell.                                                                                                    |
| -"          | Subtracts an amount from the current cell.                                                                                             |
| ^"          | Moves the subtape up a number of times.                                                                                                |
| V"          | Moves the subtape down a number of times.                                                                                              |
| <"          | Moves the tape left a number of times.                                                                                                 |
| >"          | Moves the tape right a number of times.                                                                                                |
| :_:         | Defines a label of name _.                                                                                                             |
| *_*         | Jumps to a label of name _.                                                                                                            |
| ~_~         | Defines a function of name _.                                                                                                          |
| @_@         | Calls a function of name _.                                                                                                            |
| %           | Ends a function definition.                                                                                                            |
| #_#         | Is a comment.                                                                                                                          |
| [SPACE]     | Is an NOP.                                                                                                                             |
| [NEWLINE]   | Is treated as whitespace and removed.                                                                                                  |
| [TAB]       | Is treated as whitespace and removed.                                                                                                  |
+-------------+----------------------------------------------------------------------------------------------------------------------------------------+

Les tests

+0+0+0+0+0+0+0+2)+0+0+9)+7))+3)-0-0-0-0-0-0-0-9)+0+0+0+0+0+0+0+0+7)-8)+3)-6)-8)-7-0-0-0-0-0-0)

Devrait sortir Hello world!


+1:i:{()*i*}

Sorte de catprogramme, juste sans nouvelle ligne.


+1:loop:{@ReadChar@*loop*}@PrintHello@@WriteAll@(~ReadChar~(x-0-3<2o^1>1+1>1%~PrintHello~+0+0+0+0+0+0+0+2)-1+0+0+0)+7))+3)+1-0-0-0-0-0-0-0-0)%~WriteAll~<1x:reverse:{<1v1>1-1*reverse*}o-1:print:{-1<1)^1>1*print*}%

Devrait d'abord accepter un nom, puis, à la pression de Return, devrait sortir Hello name(où le nom est ce qui a été entré).

Le mérite de ce programme revient à David Catt .


Je travaille sur un programme de test complet.

Règles

  • Les failles standard sont interdites
  • Votre interprète doit répondre à toutes les spécifications, à l'exception des commentaires, qui ne sont pas obligatoires.

Notation

  • Il s'agit de , donc le moins d'octets gagne!
  • -10 octets si votre interprète gère les commentaires.

Classement

Voici un extrait de pile pour générer à la fois un classement régulier et un aperçu des gagnants par langue.

Pour vous assurer que votre réponse s'affiche, veuillez commencer votre réponse avec un titre, en utilisant le modèle de démarque suivant:

# Language Name, N bytes

Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores dans le titre, en les barrant. Par exemple:

# Ruby, <s>104</s> <s>101</s> 96 bytes


4
Bonne idée! Voici quelques réflexions: Veuillez définir le nombre de cellules par sous-bande et le nombre de sous-bandes que nous devrions utiliser dans nos implémentations (ou spécifier s'il doit s'agir d'une sorte d'adaptatif / infini). Comment convertir une chaîne d'entrée en nombres 0-255? Des codes ASCII peut-être?
flawr

Réponses:


4

Python2, 748 736 731 709 704 691 octets

C'était un petit défi amusant, je suis sûr que je peux rendre ce code encore plus court (peut-être que je le ferai plus tard).

from sys import*
w=stdout.write
p=open(argv[1],'r').read()
c,r,s,x,y,t,o=0,0,256,0,0,0,0
g=[[0]*s]*s
e=lambda d:p.find(d,c+1)
def h(i,j=0,k=0):global c,x,y;c+=1;n=1+(int(p[c])-1)%10;l=g[x][y]+n*i;g[x][y]=l%s;o=l/s;x=(x+n*j)%s;y=(y+n*k)%s
a="g[x][y]"
b="[p[c+1:i]]"
l={}
f={}
d={'0':a+"=0",'{':"if "+a+"<1:c=e('}')",'(':"i=stdin.read(1);"+a+"=ord(i)if i else 0",')':"w(chr("+a+"))",'x':"t="+a,'o':"w(chr(t))",'!':a+"+=o",'?':a+"=0if "+a+"else 1",'+':"h(1)",'-':"h(-1)",'^':"h(0,1)",'V':"h(0,-1)",'<':"h(0,0,-1)",'>':"h(0,0,1)",':':"i=e(':');l"+b+"=i;c=i",'*':"i=e('*');c=l"+b,'~':"i=e('~');f"+b+"=i;c=e('%')",'@':"i=e('@');r=i;c=f"+b,'%':"c=r"}
while c<len(p):
    if p[c]in d:exec d[p[c]]
    c+=1

Cette implémentation nécessite que les étiquettes et les fonctions soient déclarées (implémentées) avant d'être appelées. Il fonctionne parfaitement avec les deux tests donnés mais ne fonctionne malheureusement pas avec le programme "SayHi.2b" écrit par l'auteur du langage (même après avoir changé l'ordre de déclaration des fonctions). Je pense que ce problème pourrait être lié à la façon dont j'ai compris le système de bandes et de sous-bandes. Lorsque vous vous déplacez le long de la bande principale, la position de la sous-bande correspondante est-elle remise à 0? Pour le moment, je garde la position sur la sous-bande même lorsque je me déplace sur la bande principale.

Voici la version la plus lisible:

#!/usr/bin/python

import sys
w=sys.stdout.write
p=open(sys.argv[1],'r').read()
c,r,s,x,y,t,o=0,0,256,0,0,0,0
# c is the current index in the program string
# r is the return index (for functions)
# s is the size of the tape, subtapes and modulo for ints (max int will be 255)
# x and y are the coordinates in the grid
# t is the temporary register
# o is overflow
g=[[0]*s]*s # initialise a grid 256x256 with 0

e=lambda d:p.find(d,c+1)
def n():global c;c+=1;i=int(p[c]);return i if i>0 else 10 # get the number specified
def h(i):j=g[x][y]+i;g[x][y]=j%s;o=j/s # handle addition and substraction
def m(i,j):global x,y;x=(x+i)%s;y=(y+j)%s # move current cell

a="g[x][y]" # string of current cell
b="[p[c+1:i]]" # key for label or function
l={} # dictionary of labels
f={} # dictionary of functions
d={'0':a+"=0",
   '{':"if "+a+"<1:c=e('}')",
   '(':"i=sys.stdin.read(1);"+a+"=ord(i)if i else 0",
   ')':"w(chr("+a+"))",
   'x':"t="+a,
   'o':"w(chr(t))",
   '!':a+"+=o",
   '?':a+"=0if "+a+"else 1",
   '+':"h(n())",
   '-':"h(-n())",
   '^':"m(n(),0)",
   'V':"m(-n(),0)",
   '<':"m(0,-n())",
   '>':"m(0,n())",
   ':':"i=e(':');l"+b+"=i;c=i",
   '*':"i=e('*');c=l"+b,
   '~':"i=e('~');f"+b+"=i;c=e('%')",
   '@':"i=e('@');r=i;c=f"+b,
   '%':"c=r",
   '#':"c=e('#')"
   }

while c<len(p): # loop while c is not EOF
    # print c, p[c]
    if p[c]in d:exec d[p[c]] # execute code kept as a string
    c+=1 # increment index

Edit: Tenez compte de la gestion des commentaires (-10 octets), corrigeant une erreur d'une erreur. Cette implémentation ne prend pas en charge les appels de fonction imbriqués (je pourrais l'implémenter si c'est une fonctionnalité requise)

Edit2: modification de la fonction de gestionnaire pour effectuer l'addition, la soustraction et le mouvement des cellules. Plus de lambdas! : D (la "version plus lisible" peut être désynchronisée maintenant)

Edit3: Je viens de réaliser que la gestion des commentaires me coûte 5 octets (en tenant compte du -10). Je viens donc de le retirer, c'est dommage qu'il semble maintenant incomplet.

Edit4: définition déplacée de n de lambda à var à l'intérieur du gestionnaire h ()


avec tant de monde +a+, serait-il préférable de rejoindre a? Cela vous débarrasserait également de devoir l'affecter à une var.
Maltysen

Eh bien, sauf que je ne peux pas joindre les chaînes dans un dictionnaire dans son ensemble et cela ne vaudrait pas la peine de le faire pour chaque chaîne séparément. Assigner la chaîne à un est juste une astuce pour gagner quelques octets, rien de réellement utile pour le code.
basile-henry

Je suppose que je ne peux pas me plaindre de l'ordre des fonctions, car je ne l'ai pas spécifié, mais essayez de faire fonctionner le SayHi.2bfichier. Que se passe-t-il si elle est modifiée pour remettre la sous-bande à zéro lors d'un quart de travail?
JimBobOH
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.