新人報到

manhong2112

有空寫代碼了, 而且在官網找到了3.5版的pygame, 所以把Pygame版的2048做出來了

1. import random
   
2. from copy import deepcopy as copy
   
3. 
   
4. import pygame
   
5. 
   
6. 
   
7. def calc_color(i):
   
8.     return 255 - (i ** 2 % 255)
   
9. 
   
10. 
    
11. class Game(object):
    
12.     vector = {pygame.K_w: (0, 1),
    
13.               pygame.K_s: (0, -1),
    
14.               pygame.K_a: (1, 0),
    
15.               pygame.K_d: (-1, 0)}
    
16. 
    
17.     def __init__(self):
    
18.         self.block = ([0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0])
    
19.         self.recently_block = copy(self.block)
    
20.         self.block[random.randint(0, 3)][random.randint(0, 3)] = random.choice((2, 2, 4))
    
21.         pass
    
22. 
    
23.     def next(self):
    
24.         loc_list = []
    
25.         for x in range(4):
    
26.             for y in range(4):
    
27.                 if not self.block[x][y]:
    
28.                     loc_list.append((x, y))
    
29. 
    
30.         if loc_list:
    
31.             if self.recently_block == self.block:
    
32.                 return True
    
33.         else:
    
34.             return self.movable()
    
35. 
    
36.         loc = random.choice(loc_list)
    
37.         self.block[loc[0]][loc[1]] = random.choice((2, 2, 4))
    
38.         return True
    
39.         pass
    
40. 
    
41.     def end(self):
    
42.         self.print()
    
43.         print("# END #")
    
44.         print("# Your Score is: {0} #".format(self.score()))
    
45.         input("Enter to continue...")
    
46.         exit()
    
47.         pass
    
48. 
    
49.     def move(self, direction, is_check=False):
    
50.         cache = copy(self.block)
    
51.         dx, dy = self.vector[direction]
    
52.         i = ()
    
53.         while i != cache:
    
54.             i = copy(cache)
    
55.             for x in range(3, -1, -1):
    
56.                 for y in range(3, -1, -1):
    
57.                     _x, _y = x - dx, y - dy
    
58.                     if not (0 <= _x < 4 and 0 <= _y < 4):
    
59.                         continue
    
60.                     if cache[y][x] and (not cache[_y][_x] or cache[y][x] == cache[_y][_x]):
    
61.                         cache[_y][_x] += cache[y][x]
    
62.                         cache[y][x] = 0
    
63.         if is_check:
    
64.             return cache != self.block
    
65. 
    
66.         self.recently_block = copy(self.block)
    
67.         self.block = cache
    
68.         pass
    
69. 
    
70.     def movable(self):
    
71.         for i in (pygame.K_w, pygame.K_a, pygame.K_s, pygame.K_d):
    
72.             if self.move(i, True):
    
73.                 return True
    
74.         return False
    
75.         pass
    
76. 
    
77.     def print(self, display=None, _font=None):
    
78.         if display is None or _font is None:
    
79.             for x in range(4):
    
80.                 for y in range(4):
    
81.                     print(self.block[x][y], end=' ')
    
82.                 print()
    
83.         else:
    
84.             for x in range(4):
    
85.                 for y in range(4):
    
86.                     v = self.block[x][y]
    
87.                     pygame.draw.rect(
    
88.                             display,
    
89.                             (calc_color(v ** 2), calc_color(v ** 3), calc_color(v ** 5)),  # color
    
90.                             (120 * y, 120 * x, 120, 120))  # x, y ,width, height
    
91.                     display.blit(
    
92.                             _font.render(
    
93.                                     str(v) if v != 0 else "",
    
94.                                     1,
    
95.                                     (30, 30, 30)
    
96.                             ),
    
97.                             (120 * y + 54, 120 * x + 54))
    
98.         pass
    
99. 
    
100.     def score(self):
     
101.         def _f(val, score=0):
     
102.             for i in val:
     
103.                 score += _f(i) if type(i) == list else i
     
104.             return score
     
105. 
     
106.         return _f(self.block)
     
107. 
     
108. 
     
109. pygame.init()
     
110. screen = pygame.display.set_mode((480, 480), 0, 32)
     
111. pygame.display.set_caption("2048")
     
112. 
     
113. font = pygame.font.SysFont("arial", 20)
     
114. 
     
115. game = Game()
     
116. game.print(screen, font)
     
117. 
     
118. k = ""
     
119. finish = False
     
120. 
     
121. while True:
     
122.     for event in pygame.event.get():
     
123.         if event.type == pygame.QUIT:
     
124.             pygame.quit()
     
125.             exit()
     
126.         if event.type == pygame.KEYDOWN:
     
127.             if event.key == pygame.K_ESCAPE:
     
128.                 pygame.quit()
     
129.                 exit()
     
130. 
     
131.             if event.key == pygame.K_r:
     
132.                 game.print(screen, font)
     
133.                 game = Game()
     
134.                 finish = False
     
135. 
     
136.             if finish:
     
137.                 game.print(screen, font)
     
138.                 screen.blit(font.render(
     
139.                                 "You lose, total score is {}".format(game.score()),
     
140.                                 1,
     
141.                                 (30, 30, 30)
     
142.                             ), (120, 240))
     
143.                 screen.blit(font.render(
     
144.                                 "press ESC to leave",
     
145.                                 1,
     
146.                                 (30, 30, 30)
     
147.                             ), (128, 260))
     
148.                 screen.blit(font.render(
     
149.                                 "press R to restart",
     
150.                                 1,
     
151.                                 (30, 30, 30)
     
152.                             ), (128, 280))
     
153. 
     
154.                 pygame.display.update()
     
155.                 continue
     
156. 
     
157.             k = event.key
     
158.             try:
     
159.                 game.move(k)
     
160.                 finish = not game.next()
     
161.             except KeyError:
     
162.                 continue
     
163.             finally:
     
164.                 game.print(screen, font)
     
165.                 k = ""
     
166. 
     
167.     pygame.display.update()
     

复制代码

crossin先生

manhong2112 发表于 2016-3-8 23:06
有空寫代碼了, 而且在官網找到了3.5版的pygame, 所以把Pygame版的2048做出來了

这个不错

manhong2112

Y算子 + 部分邱奇碼, 弄出來後只感覺lambda真強大...

1. Y = (lambda F: ((lambda u: u(u))(lambda f: F(lambda v: f(f)(v)))))
   
2. Y(lambda f: (lambda x: 1 if x <= 2 else f(x - 1) + f(x - 2)))(5)
   
3. Y(lambda f: (lambda x: 1 if x == 0 else x * f(x - 1)))(5)
   
4. 
   
5. TRUE = lambda t,f: t
   
6. FALSE = lambda t,f: f
   
7. IF = lambda b,t,f: b(t,f)
   
8. AND = lambda b1, b2: IF(b1, b2, FALSE)
   
9. OR = lambda b1, b2: IF(b1, TRUE, b2)
   
10. NOT = lambda b: IF(b, FALSE, TRUE)
    

复制代码

crossin先生

manhong2112 发表于 2016-4-5 21:04
Y算子 + 部分邱奇碼, 弄出來後只感覺lambda真強大...

manhong2112

簡單的lisp解釋器...

1. 
   
2. from copy import copy
   
3. 
   
4. def pick(k, e):
   
5.     try:
   
6.         return e[k]
   
7.     except Exception:
   
8.         return k
   
9. 
   
10. def put(k, v, e):
    
11.     e[k] = v
    
12.     return e
    
13. 
    
14. def put_rec(pair, e):
    
15.     for k, v in pair:
    
16.         e[k] = interp(v, e)
    
17.     return e
    
18. 
    
19. 
    
20. class Closure:
    
21.     def __str__(self):
    
22.         return "<Closure exp({}), env({})>".format(self.exp, self.env)
    
23.         pass
    
24. 
    
25.     def __init__(self, exp, env):
    
26.         self.exp = exp
    
27.         self.env = env
    
28. 
    
29. 
    
30. class quote:
    
31.     def __str__(self):
    
32.         return "<quote %s>".format(self.lst)
    
33. 
    
34.     def __init__(self, lst):
    
35.         self.lst = lst
    
36.         pass
    
37. 
    
38.     def cons(x, _quote):
    
39.         l = copy(_quote.lst[::-1])
    
40.         l.append(str(x))
    
41.         return quote(l[::-1])
    
42. 
    
43.     def car(_quote):
    
44.         return _quote.lst[0]
    
45. 
    
46.     def cdr(_quote):
    
47.         return quote(_quote.lst[1:])
    
48. 
    
49.     def pick(i, _quote):
    
50.         return _quote.lst[i + 1]
    
51. 
    
52.     def put(i, v, _quote):
    
53.         l = copy(_quote.lst[:])
    
54.         l[i] = v
    
55.         return quote(l)
    
56. 
    
57. 
    
58. def interp(scheme, env={}):
    
59.     if isinstance(scheme, str):
    
60.         if (scheme[0] == "-" and scheme[1:].isdigit()) or scheme.isdigit():
    
61.             return eval(scheme)
    
62.         if scheme == "True" or scheme == "False":
    
63.             return eval(scheme)
    
64.         return pick(scheme, env)
    
65. 
    
66.     if isinstance(scheme, list):
    
67.         v0 = interp(scheme[0], env)
    
68.         if isinstance(v0, Closure):
    
69.             return interp(v0.exp[2], put(v0.exp[1][0], interp(scheme[1], env), v0.env))
    
70. 
    
71.         if v0 in ("if", "lambda", "let"):
    
72.             return {
    
73.                 "if": lambda: interp(scheme[2 if interp(scheme[1], env) else 3], env),
    
74.                 "lambda": lambda: Closure(scheme, copy(env)),
    
75.                 "let": lambda: interp(scheme[2], put_rec(scheme[1], env))
    
76.             }[v0]()
    
77. 
    
78.         v1 = interp(scheme[1], env)
    
79.         if v0 in ("car", "cdr"):
    
80.             return {
    
81.                 "car": lambda: quote.car(v1),
    
82.                 "cdr": lambda: quote.cdr(v1)
    
83.             }[v0]()
    
84. 
    
85.         v2 = interp(scheme[2], env)
    
86.         if v0 in ("pick", "cons", "+", "-", "*", "/", "^", "=", ">", "<", "<=", ">="):
    
87.             return {
    
88.                 "pick": lambda: quote.pick(v1, v2),
    
89.                 "cons": lambda: quote.cons(v1, v2),
    
90.                 "+": lambda: v1 + v2,
    
91.                 "-": lambda: v1 - v2,
    
92.                 "*": lambda: v1 * v2,
    
93.                 "/": lambda: v1 / v2,
    
94.                 "^": lambda: v1 ** v2,
    
95.                 "=": lambda: v1 == v2,
    
96.                 ">": lambda: v1 > v2,
    
97.                 "<": lambda: v1 < v2,
    
98.                 "<=": lambda: v1 <= v2,
    
99.                 ">=": lambda: v1 >= v2
    
100.             }[v0]()
     
101. 
     
102. 
     
103. # (lambda arg exp) => Closure((lambda arg exp) env)
     
104. # (Closure(lambda env) arg)
     
105. # (quote (lst))
     
106. # (if b t f)
     
107. # (op e1 e2)
     
108. # (let ((k1 exp1) .. (kn expn)) exp)
     
109. 
     
110. # parser str to list
     
111. def parser(s):
     
112.     def _f(index):
     
113.         result = []
     
114.         t = ""
     
115.         while True:
     
116.             if s[index] == "(":
     
117.                 x, index = _f(index + 1)
     
118.                 result.append(x)
     
119.             c = s[index]
     
120.             if c == ")":
     
121.                 if t != "":
     
122.                     result.append(t)
     
123.                 return result, index + 1
     
124.             elif c == " ":
     
125.                 if t != "":
     
126.                     result.append(t)
     
127.                     t = ""
     
128.             else:
     
129.                 t += c
     
130.             index += 1
     
131.     return _f(1)[0]
     
132. 
     
133. 
     
134. print(interp(parser("(let ((abs (lambda (n) (if (< n 0) (- 0 n) n)))) (abs -5))")))
     

复制代码

manhong2112

infix 轉成 postfix

1. priority = {
   
2.     "+": 0,
   
3.     "-": 0,
   
4.     "*": 1,
   
5.     "/": 1
   
6. }
   
7. 
   
8. 
   
9. def to_postfix(expr, start=0):
   
10.     stack = []
    
11.     result = []
    
12.     buffer = ""
    
13.     i = start
    
14.     while i < len(expr):
    
15.         if expr[i].isalpha() or expr[i].isdigit():
    
16.             if expr[i].isdigit():
    
17.                 buffer += expr[i]
    
18.             else:
    
19.                 result.append(expr[i])
    
20.             i += 1
    
21.             continue
    
22.         if buffer != "":
    
23.             result.append(buffer)
    
24.             buffer = ""
    
25.         if(expr[i] == "("):
    
26.             x = to_postfix(expr, i + 1)
    
27.             result += x[0]
    
28.             i = x[1]
    
29.         elif(expr[i] == ")"):
    
30.             result += "".join(stack[::-1])
    
31.             return result, i
    
32.         else:
    
33.             if len(stack) != 0 and priority[expr[i]] < priority[stack[-1]]:
    
34.                 result += stack.pop()
    
35.             stack.append(expr[i])
    
36.         i += 1
    
37.     result.extend(stack[::-1])
    
38.     return result, i
    

复制代码

manhong2112

之前寫的一堆排序算法...

1. import random
   
2. import timeit
   
3. 
   
4. 
   
5. def printf(string, *obj):
   
6.     return print(string.format(*obj))
   
7. 
   
8. 
   
9. def bubble_sort(arr):
   
10.     arr = arr[:]
    
11.     for i in range(len(arr) - 1, 0, -1):
    
12.         for j in range(i):
    
13.             if arr[j] > arr[j + 1]:
    
14.                 arr[j], arr[j + 1] = arr[j + 1], arr[j]
    
15.     return arr
    
16. 
    
17. 
    
18. def quick_sort(arr):
    
19.     if len(arr) <= 1:
    
20.         return arr
    
21.     a = arr[0]
    
22.     b = []
    
23.     c = []
    
24.     for i in arr[1:]:
    
25.         (b if i < a else c).append(i)
    
26.     return quick_sort(b) + [a] + quick_sort(c)
    
27. 
    
28. 
    
29. def swap(arr, x, y):
    
30.     arr[x], arr[y] = arr[y], arr[x]
    
31. 
    
32. def quicksort_inplace_iter(arr):
    
33.     stack = [(0, len(arr))]
    
34.     while stack:
    
35.         s, e = stack.pop()
    
36.         s1, e1 = s, e
    
37.         if s >= e:
    
38.             continue
    
39.         i = s
    
40.         x = arr[e-1]
    
41.         while s+1 < e1:
    
42.             if arr[s] > x:
    
43.                 swap(arr, s, e1 - 1)
    
44.                 e1 -= 1
    
45.             else:
    
46.                 swap(arr, s, s1)
    
47.                 s1 += 1
    
48.             s += 1
    
49.         stack.append((i, s))
    
50.         stack.append((s+1, e))
    
51. 
    
52. def random_arr(length):
    
53.     arr = []
    
54.     for i in range(length):
    
55.         arr.append(random.randint(0, length ** 2))
    
56.     return arr
    
57. 
    
58. 
    
59. def merge_sort(arr):
    
60.     def merge(arr1, arr2):
    
61.         result = []
    
62.         i = 0
    
63.         j = 0
    
64.         while True:
    
65.             if i == len(arr1):
    
66.                 result.extend(arr2[j:])
    
67.                 break
    
68.             if j == len(arr2):
    
69.                 result.extend(arr1[i:])
    
70.                 break
    
71.             if arr1[i] < arr2[j]:
    
72.                 result.append(arr1[i])
    
73.                 i += 1
    
74.             else:
    
75.                 result.append(arr2[j])
    
76.                 j += 1
    
77.         return result
    
78. 
    
79.     length = len(arr)
    
80.     if length <= 1:
    
81.         return arr
    
82.     return arr if length <= 1 else merge(
    
83.         merge_sort(arr[:int(length / 2)]),
    
84.         merge_sort(arr[int(length / 2):]))
    
85. 
    
86. 
    
87. def select_sort(arr):
    
88.     for i in range(len(arr)):
    
89.         for j in range(i, len(arr)):
    
90.             if arr[j] < arr[i]:
    
91.                 arr[i], arr[j] = arr[j], arr[i]
    
92.     return arr
    
93. 
    
94. 
    
95. def time(fun, *arr):
    
96.     s = timeit.default_timer()
    
97.     fun(*arr)
    
98.     e = timeit.default_timer()
    
99.     return((e - s) * 1000)
    

复制代码

manhong2112

筆記本

1. import os
   
2. import math
   
3. import pickle
   
4. sum = lambda x: 0 if len(x) == 0 else x[0] + sum(x[1:])
   
5. 
   
6. 
   
7. class Reader(object):
   
8. 
   
9.     def __init__(self, path=None):
   
10.         self.Note = NoteManager.get_note(path)
    
11.         self.Note.load()
    
12.         pass
    
13. 
    
14.     def read(self):
    
15.         return self.Note.Context
    
16. 
    
17.     def write(self, context):
    
18.         self.Note.Context = context
    
19.         pass
    
20. 
    
21.     def write_line(self, context):
    
22.         self.Note.Context += context
    
23.         self.Note.Context += "\n"
    
24.         pass
    
25. 
    
26.     def append(self, context):
    
27.         self.Note.Context += context
    
28.         pass
    
29. 
    
30.     def save(self):
    
31.         with open(self.Note.nPath, "wb+") as f:
    
32.             pickle.dump((self.Note.Context, self.Note.Type), f)
    
33. 
    
34. 
    
35. class Note(object):
    
36.     storageLoc = "./note"
    
37. 
    
38.     def __init__(self, path, name, file_type="Text"):
    
39.         assert type(name) is str
    
40.         assert type(path) is str
    
41.         assert type(file_type) is str
    
42.         self.Name = name
    
43.         self.Type = file_type
    
44.         self.id = path
    
45.         self.nPath = os.path.join(self.storageLoc, path)
    
46.         self.Context = ""
    
47. 
    
48.     def load(self):
    
49.         os.makedirs(os.path.dirname(self.nPath), exist_ok=True)
    
50.         if not os.path.isfile(self.nPath):
    
51.             with open(self.nPath, "wb+") as f:
    
52.                 pickle.dump(("", self.Type), f)
    
53.         with open(self.nPath, "rb+") as f:
    
54.             self.Context, self.Type = pickle.load(f)
    
55. 
    
56. 
    
57. class NoteManager(object):
    
58.     note_pool_loc = "./NoteList.db"
    
59.     __note_pool = {}
    
60. 
    
61.     @staticmethod
    
62.     def get_note(path):
    
63.         pool, name = NoteManager.parse_path(path)
    
64.         return pool[name]["Note"]
    
65.         pass
    
66. 
    
67.     @staticmethod
    
68.     def new_note(path, name, file_type="Text"):
    
69.         n = Note(path, name, file_type)
    
70.         NoteManager.add_note(path, n)
    
71.         pass
    
72. 
    
73.     @staticmethod
    
74.     def filter(dir, f):
    
75.         assert type(dir) is str
    
76.         result = []
    
77.         pool, name = NoteManager.parse_path(dir)
    
78.         for i in pool:
    
79.             if i[-1] == "/":
    
80.                 result.extend(NoteManager.filter(dir + i, f))
    
81.             elif (pool[i]["Tag"] & f) == f:
    
82.                 result.append(dir + i)
    
83.         return sorted(result)
    
84.         pass
    
85. 
    
86.     @staticmethod
    
87.     def save():
    
88.         tmp = {}
    
89. 
    
90.         def _f(path, pool):
    
91.             for p in pool:
    
92.                 if p[-1] == "/":
    
93.                     _f(path + p, pool[p])
    
94.                 else:
    
95.                     x = pool[p]
    
96.                     tmp[p] = {"Tag": x["Tag"], "Name": x["Note"].Name}
    
97.         _f("", NoteManager.__note_pool)
    
98.         with open(NoteManager.note_pool_loc, "wb+") as f:
    
99.             pickle.dump(tmp, f)
    
100.         pass
     
101. 
     
102.     @staticmethod
     
103.     def add_note(path, note):
     
104.         pool, name = NoteManager.parse_path(path)
     
105.         pool[name] = {"Tag": 0, "Note": note}
     
106.         pass
     
107. 
     
108.     @staticmethod
     
109.     def del_note(path):
     
110.         os.remove(os.path.join(Note.storageLoc, path))
     
111.         pool, name = NoteManager.parse_path(path)
     
112.         pool.remove(name)
     
113.         pass
     
114. 
     
115.     @staticmethod
     
116.     def add_tag(path, *tag):
     
117.         pool, name = NoteManager.parse_path(path)
     
118.         t = sum(tag)
     
119.         if (pool[name]["Tag"] & t) != t:
     
120.             pool[name]["Tag"] += t
     
121. 
     
122.     @staticmethod
     
123.     def del_tag(path, *tag):
     
124.         pool, name = NoteManager.parse_path(path)
     
125.         t = sum(tag)
     
126.         if (pool[name]["Tag"] & t) == t:
     
127.             pool[name]["Tag"] -= t
     
128. 
     
129.     @staticmethod
     
130.     def get_tag(path):
     
131.         pool, name = NoteManager.parse_path(path)
     
132.         t = pool[name]["Tag"]
     
133.         tag = set({})
     
134.         while t != 0:
     
135.             x = int(math.log(t, 2))
     
136.             t -= x
     
137.             tag.add(TagManager.tag(x))
     
138.             pass
     
139.         return tag
     
140. 
     
141.     @staticmethod
     
142.     def parse_path(path):
     
143.         x = path.split("/")
     
144.         pool = NoteManager.__note_pool
     
145.         for i in x[:-1]:
     
146.             if i + "/" not in pool:
     
147.                 pool[i + "/"] = {}
     
148.             pool = pool[i + "/"]
     
149.         return pool, x[-1]
     
150. 
     
151.     if not os.path.isfile(note_pool_loc):
     
152.         with open(note_pool_loc, "wb+") as f:
     
153.             pickle.dump(__note_pool, f)
     
154.     else:
     
155.         with open(os.path.join(note_pool_loc), "rb+") as f:
     
156.             tmp = pickle.load(f)
     
157.         for i in tmp:
     
158.             x = i.split("/")
     
159.             pool = __note_pool
     
160.             for i in x[:-1]:
     
161.                 if i + "/" not in pool:
     
162.                     pool[i + "/"] = {}
     
163.                 pool = pool[i + "/"]
     
164.             name = x[-1]
     
165.             pool[name] = {"Tag": tmp[i]["Tag"],
     
166.                           "Note": Note(i, tmp[i]["Name"])}
     
167. 
     
168. 
     
169. class TagManager(object):
     
170.     tag_pool_loc = "TagList.db"
     
171.     __tag_pool = []
     
172. 
     
173.     @staticmethod
     
174.     def mk_filter(*tag):
     
175.         return sum(tag)
     
176. 
     
177.     @staticmethod
     
178.     def new_tag(tag_name):
     
179.         if tag_name not in TagManager.__tag_pool:
     
180.             TagManager.__tag_pool.append(tag_name)
     
181.         pass
     
182. 
     
183.     @staticmethod
     
184.     def tag(x):
     
185.         if type(x) is str:
     
186.             return 2**TagManager.__tag_pool.index(x)
     
187.         elif type(x) is int:
     
188.             return TagManager.__tag_pool[math.log(x, 2)]
     
189. 
     
190.     @staticmethod
     
191.     def save():
     
192.         with open(os.path.join(TagManager.tag_pool_loc), "wb+") as f:
     
193.             pickle.dump(TagManager.__tag_pool, f)
     
194.         pass
     
195. 
     
196.     if os.path.isfile(tag_pool_loc):
     
197.         with open(os.path.join(tag_pool_loc), "rb+") as f:
     
198.             __tag_pool = pickle.load(f)
     
199.     else:
     
200.         with open(os.path.join(tag_pool_loc), "wb+") as f:
     
201.             pickle.dump(__tag_pool, f)
     
202. 
     

复制代码

manhong2112

Brainfuck 解釋器(+半個編譯器)

1. 
   
2. import msvcrt
   
3. 
   
4. 
   
5. def interp(expr):
   
6.     ptr = 0
   
7.     ram = dict()
   
8.     loopStack = []
   
9.     excapingLoop = 0
   
10.     i = 0
    
11.     while(i < len(expr)):
    
12.         # print(ram, loopStack, excapingLoop)
    
13.         x = expr[i]
    
14.         if not (ptr in ram) or ram[ptr] > 127 or ram[ptr] < -128:
    
15.             ram[ptr] = 0
    
16.         if x == "[":
    
17.             if excapingLoop > 0:
    
18.                 excapingLoop += 1
    
19.             elif ram[ptr] != 0:
    
20.                 loopStack.append(i)
    
21.             else:
    
22.                 excapingLoop = 1
    
23.         elif x == "]":
    
24.             if excapingLoop > 0:
    
25.                 excapingLoop -= 1
    
26.             elif ram[ptr] != 0:
    
27.                 i = loopStack[-1]
    
28.             else:
    
29.                 loopStack.pop()
    
30.         elif excapingLoop > 0:
    
31.             pass
    
32.         elif x == "+":
    
33.             ram[ptr] += 1
    
34.         elif x == "-":
    
35.             ram[ptr] -= 1
    
36.         elif x == ">":
    
37.             ptr += 1
    
38.         elif x == "<":
    
39.             ptr -= 1
    
40.         elif x == ".":
    
41.             print(chr(ram[ptr]), end="")
    
42.             pass
    
43.         elif x == ",":
    
44.             ram[ptr] = ord(msvcrt.getch())
    
45.         i += 1
    
46. 
    
47. version = 0x01
    
48. header = [0x00, 0x10, 0x26, 0xBF, version, 0x00]
    
49. # null, id, id, ver, id, mem_len
    
50. 
    
51. 
    
52. class ID():
    
53.     START_LOOP = 0
    
54.     END_LOOP = 1
    
55.     INC = 2
    
56.     DEC = 3
    
57.     NEXT = 4
    
58.     BACK = 5
    
59.     GETC = 6
    
60.     PUTC = 7
    
61. 
    
62.     ADD = 8
    
63.     MOVE = 9
    
64. 
    
65. 
    
66. def compile(expr):
    
67.     result = header.copy()
    
68.     state = 0
    
69.     tmp = 0
    
70.     memloc = 0
    
71.     mmemloc = 0
    
72.     loopStack = []
    
73.     i = 0
    
74.     while i <= len(expr):
    
75.         # print(ram, loopStack, excapingLoop)
    
76.         if memloc > mmemloc:
    
77.             mmemloc = memloc
    
78.         x = expr[i] if i != len(expr) else 0xFF
    
79.         if state == 0:
    
80.             if x == "[":
    
81.                 loopStack.append(len(result))
    
82.                 result.append(ID.START_LOOP)
    
83.                 result.append(0)
    
84.                 if memloc == 0:
    
85.                     memloc = 1
    
86.             elif x == "]":
    
87.                 a = loopStack.pop()
    
88.                 result[a + 1] = len(result) - a - 1
    
89.                 result.append(ID.END_LOOP)
    
90.                 result.append(len(result) - a + 1)
    
91.             elif x == "+":
    
92.                 state = ID.ADD
    
93.                 tmp += 1
    
94.             elif x == "-":
    
95.                 state = ID.ADD
    
96.                 tmp -= 1
    
97.             elif x == ">":
    
98.                 state = ID.MOVE
    
99.                 tmp += 1
    
100.             elif x == "<":
     
101.                 state = ID.MOVE
     
102.                 tmp -= 1
     
103.             elif x == ".":
     
104.                 result.append(ID.PUTC)
     
105.             elif x == ",":
     
106.                 result.append(ID.GETC)
     
107.         elif state == ID.ADD:
     
108.             if x in "+-":
     
109.                 if x == "+":
     
110.                     tmp += 1
     
111.                 elif x == "-":
     
112.                     tmp -= 1
     
113.             else:
     
114.                 if tmp == 0:
     
115.                     pass
     
116.                 elif tmp == 1:
     
117.                     result.append(ID.INC)
     
118.                 elif tmp == -1:
     
119.                     result.append(ID.DEC)
     
120.                 else:
     
121.                     result.append(ID.ADD)
     
122.                     result.append(tmp)
     
123.                 state = 0
     
124.                 i -= 1
     
125.                 tmp = 0
     
126.         elif state == ID.MOVE:
     
127.             if x in "><":
     
128.                 if x == ">":
     
129.                     tmp += 1
     
130.                 elif x == "<":
     
131.                     tmp -= 1
     
132.             else:
     
133.                 if tmp == 0:
     
134.                     pass
     
135.                 elif tmp == 1:
     
136.                     result.append(ID.NEXT)
     
137.                     memloc += 1
     
138.                 elif tmp == -1:
     
139.                     result.append(ID.BACK)
     
140.                     memloc -= 1
     
141.                 else:
     
142.                     result.append(ID.MOVE)
     
143.                     result.append(tmp)
     
144.                     memloc += tmp
     
145.                 i -= 1
     
146.                 state = 0
     
147.                 tmp = 0
     
148.         i += 1
     
149.     result[5] = mmemloc
     
150.     result.append(0xFF)
     
151.     return result
     
152. 
     
153. 
     
154. class Env(object):
     
155.     def __init__(self, mem_len):
     
156.         self.data = [0] * (mem_len + 1)
     
157.         self.ptr = 0
     
158. 
     
159.     def move(self, val):
     
160.         self.ptr += val
     
161. 
     
162.     def read(self):
     
163.         return self.data[self.ptr]
     
164. 
     
165.     def write(self, val):
     
166.         self.data[self.ptr] = val if -128 <= val <= 127 else 0
     
167. 
     
168. 
     
169. def execute(compiledExpr):
     
170.     expr = compiledExpr
     
171.     i = len(header)
     
172.     env = Env(expr[5])
     
173.     while i < len(expr) - 1:
     
174.         x = expr[i]
     
175.         if x == ID.INC:
     
176.             env.write(env.read() + 1)
     
177.         elif x == ID.DEC:
     
178.             env.write(env.read() - 1)
     
179.         elif x == ID.NEXT:
     
180.             env.move(1)
     
181.         elif x == ID.BACK:
     
182.             env.move(-1)
     
183.         elif x == ID.PUTC:
     
184.             print(chr(env.read()), end="")
     
185.         elif x == ID.GETC:
     
186.             env.write(ord(msvcrt.getch()))
     
187.         else:
     
188.             if x == ID.START_LOOP and env.read() == 0:
     
189.                 i += expr[i + 1]
     
190.             elif x == ID.END_LOOP and env.read() != 0:
     
191.                 i -= expr[i + 1]
     
192.             elif x == ID.ADD:
     
193.                 env.write(env.read() + expr[i + 1])
     
194.             elif x == ID.MOVE:
     
195.                 env.move(expr[i + 1])
     
196.             i += 1
     
197.         i += 1
     
198. 
     
199. import timeit
     
200. 
     
201. 
     
202. def time(fun, *arr):
     
203.     s = timeit.default_timer()
     
204.     fun(*arr)
     
205.     e = timeit.default_timer()
     
206.     return((e - s) * 1000)
     
207. 
     
208. expr = "++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>."
     
209. cexpr = compile(expr)
     
210. 
     
211. x1, x2 = 0, 0
     
212. for i in range(0, 100):
     
213.     x1 += time(execute, cexpr)
     
214. for i in range(0, 100):
     
215.     x2 += time(interp, expr)
     
216. 
     
217. print(x1 / 100)
     
218. print(x2 / 100)
     

复制代码

Skeel

做的很好，不過請問代碼編輯器是怎麼弄出來。