勒让德
仅当Legendre的猜想为假（即存在整数n> 0使得在n ^ 2和（n + 1）^ 2之间没有质数）时，该语言才是图灵完备的。这种语言从Underload中获得了一些启发，尽管在某些方面与它有很大的不同。
Legendre中的程序由一系列正整数组成（特别禁止使用0，因为它实质上否定了该语言的全部用途）。每个整数对应于Legendre中的一个基本命令，或一个潜在的用户定义的命令。将其分配给哪个命令取决于其平方和下一个整数（等于OEIS序列A014085）之间的质数。
语言的命令修改了一个堆栈，该堆栈可以容纳任意大的正整数。如果堆栈保持0，则会立即删除0。详细地，这些命令是：
2（产生此命令的最小整数：1）：将程序中的下一个整数压入堆栈。
3（最小产生整数：4）：弹出栈顶的整数并执行与其关联的命令。
4（最小：6）：弹出顶部整数。如果为1，则递增堆栈中的前整数。
5（10）：交换顶部的两个堆叠项目。
6（15）：递减堆栈中的前整数。如果结果为0，则弹出0并丢弃它。
7（16）：复制堆栈中的最高整数。
8（25）：暂停执行并打印堆栈内容。
这是基本的指令集，它无法执行任何有趣的操作，更不用说循环了。但是，还有另一个命令，只有在Legendre的猜想证明为假的情况下才能访问该命令。
- 0（未知）：从堆栈中删除所有项目，并将它们组合为一个新函数，该函数将执行从堆栈原始底部开始并在顶部结束的所有命令，可作为“命令号”等于的命令来访问程序源中的下一个整数对应的一个。
如果可以以某种方式访问此命令，则该语言将成为图灵完备的，因为可以在其中模拟一台Minsky机器。
当执行命令8或到达程序结尾时，程序终止，并打印对应于堆栈上每个整数的（Unicode）字符。
范例程序
1 2 1 3 1 10 4
这个简单的程序先按数字2，然后按3，最后按10，然后再执行4（命令：3），这会弹出并执行10（命令：5），将2和3交换。
1 5 3 15 2 1 6 7
该程序演示了间接整数与命令的对应关系。首先，使用三种不同的2命令编码方式将5推入，然后推15和1。然后弹出1，结果将15递增到16，最后执行。该程序在堆栈上以数字5的两个实例结束。
1 1 1 5 ? 24 1 15 1 31 ? 31 24 31
该程序演示了0命令的用法，使用？作为占位符编号。程序首先在功能9中存储“ 1 5”，然后在10中存储“ 15 31”，然后运行功能9（使用24），该功能将5压入堆栈，并反复递减直到达到0并被删除。然后，程序停止。
明斯基机
为了将Minsky机器转换为Legendre代码，必须使用0命令。因为除非Legendre的猜想为假，否则无法访问此命令，因此我使用了占位符？代替。
请注意，所有Minsky机器指令行名称都必须具有互不相同的A014085和基本命令以及24（9）和31（10）对应的整数。
初始化：
1 1 1 1 ? 24
x INC（A / B）y：
A：
1 y 1 24 1 ? 1 6 1 1 16 1 24 ? x
B：
1 y 1 24 1 ? 1 10 1 6 1 1 16 1 10 1 24 ? x
x DEC（A / B）yz：
A：
1 4 1 10 1 15 1 10 1 31 1 1 1 10 1 z 1 1 1 16 1 24 1 31 1 ? 1 24 1 15 1 y 1 6 16 1 24 16 1 ? 1 1 16 1 10 1 1 16 1 24 ? x
B：
1 4 1 10 1 15 1 10 1 31 1 1 1 10 1 z 1 1 1 16 1 24 1 31 1 ? 1 24 1 15 1 10 1 y 1 6 16 1 24 16 1 ? 1 1 16 1 10 1 1 16 1 10 1 24 ? x
x HALT：
1 25 ? x
要创建最终程序，请附加所有部分（用x，y，z替换其对应部分）并添加单个整数以启动链中的第一条指令。如果勒让德的猜想被反例证明是错误的，这应该证明语言的图灵完备性。
口译员
该解释器是用Python（3）编写的，并且已经在上述所有三个示例上进行了测试。使用-a /-allowZero标志允许吗？要使用-f /-file可以直接从文件运行代码，而-s /-stackOut可以将堆栈输出为Python列表。如果没有给出文件，解释器将进入一种REPL模式，最好与--stackOut一起使用。
import sys
import argparse
import io
class I_need_missing(dict): #used to avoid try/except statements. Essentially a dict
def __missing__(self,key):
return None
def appropriate(integer,prev): #returns number of primes between the square of the integer given and the next
return_value = 0
if prev[integer]:
return prev[integer],prev
if integer == "?":
return 0,prev
for i in range(integer ** 2, (integer + 1) ** 2):
t = False
if i > 1:
t = True
for j in range(2,int(i ** 0.5)+1):
t = i/j != round(i/j)
if not t:
break
return_value += t
prev[integer] = return_value
return return_value,prev
def run_command(commandseries,stack,functions,prev): #Runs the appropriate action for each command.
command,prev = appropriate(commandseries.pop(0),prev)
halt = False
if command == 0: #store in given number
functions[appropriate(commandseries.pop(0),prev)[0]] = stack
stack = []
elif command == 2:#push
stack.append(commandseries.pop(0))
elif command == 3:#execute top instruction
commandseries.insert(0,stack.pop())
elif command == 4:#pop, add 1 to new top if popped value was 1
if stack.pop() == 1:
stack[-1] += 1
elif command == 5:#swap top two integers/?
stack[-1],stack[-2] = stack[-2],stack[-1]
elif command == 6:#subtract 1 from top of stack
stack[-1] -= 1
if stack[-1] == 0:
stack.pop()
elif command == 7:#duplicate top of stack
stack.append(stack[-1])
elif command == 8:#halt
halt = True
else:#run custom
try:
commandseries[0:0] = functions[command]
except TypeError:
print("Warning: unassigned function " + str(command) + " is unassigned", file = sys.stderr)
return commandseries,stack,functions,prev,halt
def main(stack,functions,prev):
#Parser for command line options
parser = argparse.ArgumentParser(description = "Interpreter for the Legendre esoteric programming language.")
parser.add_argument("-a","--allowZero", action = "store_true")
parser.add_argument("-f","--file")
parser.add_argument("-s","--stackOut", action = "store_true")
args = parser.parse_args()
allow_zero = bool(args.allowZero)
#Program decoding starts
pre = ""
if not args.file:
pre = input()
if pre == "":
return
else:
pre = open(args.file).read()
mid = pre.split()
final = []
for i in mid:
if i == "?" and allow_zero:
final.append("?")
elif i != 0 or allow_zero: #and allow_zero)
final.append(int(i))
halt = False
#Functional programming at its best
while final and not halt:
final,stack,functions,prev,halt = run_command(final,stack,functions,prev)
#Halting and output
else:
if args.stackOut:
print(stack)
else:
for i in stack:
print(i == "?" and "?" or chr(i),end = "")
print("")
if args.file or halt:
return
else:
main(stack,functions,prev)
if __name__ == '__main__':
main([],I_need_missing(),I_need_missing())