Интерпретатор brainfuck с ООП

@Eltan · Регистрация: 02.12.2021

Студворк — интернет-сервис помощи студентам

Дано следующее задание:
Требуется реализовать часть виртуальной машины языка Brainfuck: список из объектов-операций, имеющих метод .execute(), принимающий по ссылке массив памяти и номер активной ячейки. Применить абстрактный класс для задания операции.
Строго говоря, по заданию, как я понял, реализовывать работу и писать интерпретатор не нужно. Но задание показалось мне интересным, и я начал гуглить по нему разное, в итоге нашёл полноценный интерпретатор brain, но который написан без ооп

Мне захотелось совместить своё задание с найденным кодом. Это бессмысленно, но хочется - значит надо, тем более что в процессе узнал много нового.

Вот что в итоге получилось:

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
from abc import ABC, abstractclassmethod
 
class Command(ABC):
    #def execute(x, bf):
    pass
 
class next(Command):
    def execute(x, bf):
        x += 1
        bf.setdefault(x, 0)
        return x, bf
 
class prev(Command):
    def execute(x):
        x -= 1
        return x
 
class pos(Command):
    def execute(x, bf):
        bf[x] += 1
        return bf
 
class neg(Command):
    def execute(x, bf):
        bf[x] -= 1
        return bf
 
class dot(Command):
    def execute(x, bf):
        print(chr(bf[x]), end = '')
 
class comm(Command):
    def execute(x, bf):
        bf[x] = int(input('Input: '))
        return bf
 
class left_brac(Command):
    def execute(x, b, i, bl):
        if not b[x]: i = bl[i]
        return i
 
class right_brac(Command):
    def execute(b, x, i, bl):
        if b[x]: i = bl[i]
        return i
 
commands = {
            '>': next.execute, '<': prev.execute,
            '+':pos.execute, '-':neg.execute,
            '.':dot.execute, ',':comm.execute,
            '[':right_brac.execute, ']':left_brac.execute}
 
str = "++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>."
str = ''.join(c for c in str if c in commands.keys())
 
def block(code):
    opened = []
    blocks = {}
    for i in range(len(code)):
        if code[i] == '[':
            opened.append(i)
        elif code[i] == ']':
            blocks[i] = opened[-1]
            blocks[opened.pop()] = i
    return blocks
 
blocks = block(str)
x_x = i = 0
bf = {0:0}
l = len(str)
while i < l:
    c = str[i]
    if c == '<':
        x_x = commands[c](x_x)
    elif c == '>':
        x_x, bf = commands[c](x_x, bf)
 
    elif c == '+':
        bf = commands[c](x_x, bf)
 
    elif c == '-':
        bf = commands[c](x_x, bf)
    elif c == '.':
        commands[c](x_x, bf)
    elif c == ',':
        bf = commands[c]
    elif c == '[':
        i_i = commands[c](bf, x_x, i, blocks)
    elif c == ']':
        i_i = commands[c](x_x, bf, i, blocks)
 
    i += 1

И он даже что-то выводит, что - прикрепил в файле.
Так вот мой вопрос, есть ли возможность заставить этот код корректно вывести на экран "Hello World" именно с использованием классов в качестве операций брэйнфака?

Код, который брал:

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
def block(code):
    opened = []
    blocks = {}
    for i in range(len(code)):
        if code[i] == '[':
            opened.append(i)
        elif code[i] == ']':
            blocks[i] = opened[-1]
            blocks[opened.pop()] = i
    return blocks
 
def parse(code):
    return ''.join(c for c in code if c in '><+-.,[]')
 
def run(code):
    code = parse(code)
    x = i = 0
    bf = {0: 0}
    blocks = block(code)
    l = len(code)
    while i < l:
        sym = code[i]
        if sym == '>':
            x += 1
            bf.setdefault(x, 0)
        elif sym == '<':
            x -= 1
        elif sym == '+':
            bf[x] += 1
        elif sym == '-':
            bf[x] -= 1
        elif sym == '.':
            print(chr(bf[x]), end='')
        elif sym == ',':
            bf[x] = int(input('Input: '))
        elif sym == '[':
            if not bf[x]: i = blocks[i]
        elif sym == ']':
            if bf[x]: i = blocks[i]
        i += 1
 
code = input()
run(code)

@Eltan · 20.10.2022, 03:43 **[ТС]**

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
from abc import ABC, abstractclassmethod
 
class Command(ABC):
    
    #def execute(x, bf):
    pass
 
class next(Command):
    def execute(mem, dptr, memsz, bl, iptr):
        dptr = (dptr + 1) % memsz
        return dptr
 
class prev(Command):
    def execute(mem, dptr, memsz, bl, iptr):
        dptr -= 1
        return dptr
 
class pos(Command):
    def execute(mem, dptr, memsz, bl, iptr):
        mem[dptr] += 1
        return mem[dptr]
 
class neg(Command):
    def execute(mem, dptr, memsz, bl, iptr):
        mem[dptr] -= 1
        return mem[dptr]
 
class dot(Command):
    def execute(mem, dptr, memsz, bl, iptr):
        print(chr(mem[dptr]), end='')
 
class comm(Command):
    def execute(mem, dptr, memsz, bl, iptr):
            inp = input()
            mem[dptr] = ord(inp[0]) if inp else 0
 
class left_brac(Command):
    def execute(mem, dptr, bl, iptr):
        if not mem[dptr]: 
            iptr = bl[iptr]
        else:
            pass
        return iptr
 
class right_brac(Command):
    def execute(mem, dptr, bl, iptr):
        if mem[dptr]: 
            iptr = bl[iptr]
        else:
            pass
        return iptr
 
commands = {
            '>': next.execute, '<': prev.execute,
            '+':pos.execute, '-':neg.execute,
            '.':dot.execute, ',':comm.execute,
            '[':left_brac.execute, ']':right_brac.execute}
 
str = "++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>."
str = ''.join(c for c in str if c in commands.keys())
 
mem_size = 30000
memory = [0] * mem_size  
data_ptr = 0 
instr_ptr = 0 
 
def block(code):
    opened = []
    blocks = {}
    for pos, symbol in enumerate(code):
        if symbol == '[':
            opened.append(pos)
        elif symbol == ']':
            last_opened = opened.pop()
            blocks[pos] = last_opened 
            blocks[last_opened] = pos
    return blocks
 
blocks = block(str)
 
 
while instr_ptr < len(str):
    c = str[instr_ptr]
    if c == '<':
        data_ptr = commands[c](memory, data_ptr, mem_size, blocks, instr_ptr)
    elif c == '>':
        data_ptr = commands[c](memory, data_ptr, mem_size, blocks, instr_ptr)
 
    elif c == '+':
        memory[data_ptr] = commands[c](memory, data_ptr, mem_size, blocks, instr_ptr)
 
    elif c == '-':
        memory[data_ptr] = commands[c](memory, data_ptr, mem_size, blocks, instr_ptr)
    elif c == '.':
        commands[c](memory, data_ptr, mem_size, blocks, instr_ptr)
    elif c == ',':
        commands[c](memory, data_ptr, mem_size, blocks, instr_ptr)
    elif c == '[':
        instr_ptr = commands[c](memory, data_ptr, blocks, instr_ptr)
    elif c == ']':
        instr_ptr = commands[c](memory, data_ptr, blocks, instr_ptr)
 
    instr_ptr += 1

@Eltan · 20.10.2022, 09:49 **[ТС]**

Итоговый вариант, если вдруг кому-то интересно

Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
from abc import ABC, abstractclassmethod
 
class Command(ABC):
    def execute(mem, dptr):
        pass
 
class next(Command):
    def execute(mem, dptr, bl, iptr):
        dptr = (dptr + 1)
        return mem, dptr, iptr
 
class prev(Command):
    def execute(mem, dptr, bl, iptr):
        dptr -= 1
        return mem, dptr, iptr
 
class pos(Command):
    def execute(mem, dptr, bl, iptr):
        mem[dptr] += 1
        return mem, dptr, iptr
 
class neg(Command):
    def execute(mem, dptr, bl, iptr):
        mem[dptr] -= 1
        return mem, dptr, iptr
 
class dot(Command):
    def execute(mem, dptr, bl, iptr):
        print(chr(mem[dptr]), end='')
        return mem, dptr, iptr
 
class comm(Command):
    def execute(mem, dptr, bl, iptr):
            inp = input()
            mem[dptr] = ord(inp[0]) if inp else 0
 
class left_brac(Command):
    def execute(mem, dptr, bl, iptr):
        if not mem[dptr]: 
            iptr = bl[iptr]
        else:
            pass
        return mem, dptr, iptr
 
class right_brac(Command):
    def execute(mem, dptr, bl, iptr):
        if mem[dptr]: 
            iptr = bl[iptr]
        else:
            pass
        return mem, dptr, iptr
 
commands = {
            '>': next.execute, '<': prev.execute,
            '+':pos.execute, '-':neg.execute,
            '.':dot.execute, ',':comm.execute,
            '[':left_brac.execute, ']':right_brac.execute}
 
str = "++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>."
str = ''.join(c for c in str if c in commands.keys())
 
mem_size = 30000
memory = [0] * mem_size  
data_ptr = 0 
instr_ptr = 0 
 
def block(code):
    opened = []
    blocks = {}
    for pos, symbol in enumerate(code):
        if symbol == '[':
            opened.append(pos)
        elif symbol == ']':
            last_opened = opened.pop()
            blocks[pos] = last_opened 
            blocks[last_opened] = pos
    return blocks
blocks = block(str)
 
while instr_ptr < len(str):
    c = str[instr_ptr]
    memory, data_ptr, instr_ptr = commands[c](memory, data_ptr, blocks, instr_ptr)
    instr_ptr += 1

Новые блоги и статьи Все статьи Все блоги /
Midnight Chicago Blues kumehtar 24.03.2026 Такой Midnight Chicago Blues, знаешь?. . Когда вечерние улицы становятся ночными, а ты не можешь уснуть. Ты идёшь в любимый старый бар, и бармен наливает тебе виски. Ты смотришь на пролетающие. . .	Контроль уникальности заводского номера - вариант №2 Maks 24.03.2026 В отличие от предыдущего варианта добавлено прерывание циклов, также добавлены новые переменные для сохранения контекста ошибки перед прерыванием цикла: Процедура ПередЗаписью(Отказ, РежимЗаписи,. . .	SDL3 для Desktop (MinGW): Вывод текста со шрифтом TTF с помощью библиотеки SDL3_ttf на Си и C++ 8Observer8 24.03.2026 Содержание блога Финальные проекты на Си и на C++: finish-text-sdl3-c. zip finish-text-sdl3-cpp. zip	Жизнь в неопределённости kumehtar 23.03.2026 Жизнь — это постоянное существование в неопределённости. Например, даже если у тебя есть список дел, невозможно дойти до точки, где всё окончательно завершено и больше ничего не осталось. В принципе,. . .
Модель здравоСохранения: работники работают быстрее после её введения. anaschu 23.03.2026 geJalZw1fLo Корпорация до введения программа здравоохранения имела много невыполненных работниками заданий, после введения программы количество заданий выросло. Но на выплатах по больничным это. . .	Контроль уникальности заводского номера - вариант №1 Maks 23.03.2026 Алгоритм контроля уникальности заводского (или серийного) номера на примере документа выдачи шин для спецтехники с табличной частью в КА2. Данные берутся из регистра сведений, по которому настроено. . .	Хочу заставить корпорации вкладываться в здоровье сотрудников: делаю мат модель здравосохранения anaschu 22.03.2026 e7EYtONaj8Y Z4Tv2zpXVVo https:/ / github. com/ shumilovas/ med2. git	Программный отбор элементов справочника по группе Maks 22.03.2026 Установка программного отбора элементов справочника "Номенклатура" из модуля формы документа в КА2. В качестве фильтра для отбора справочника служит группа номенклатуры. Отбор по наименованию. . .