การพิจารณาว่าภาษานั้นมีความสมบูรณ์แบบหรือไม่นั้นสำคัญมากเมื่อออกแบบภาษา มันเป็นงานที่ค่อนข้างยากสำหรับภาษาเขียนโปรแกรมที่มีความลึกลับจำนวนมากที่เริ่มต้นด้วย ทำให้ภาษาการเขียนโปรแกรมบางอย่างยากที่จะพิสูจน์ว่าทัวริงสำเร็จแม้แต่นักคณิตศาสตร์ที่ดีที่สุดในโลกก็ยังไม่สามารถพิสูจน์ได้ด้วยวิธีใด งานของคุณคือการประดิษฐ์และใช้ภาษาที่มีความสมบูรณ์ทัวริงอาศัยอยู่กับปัญหาที่ยังไม่แก้ที่สำคัญในวิชาคณิตศาสตร์

กฎระเบียบ

• ปัญหาที่คุณเลือกจะต้องมีการโพสต์อย่างน้อย 10 ปีที่ผ่านมาและจะต้องมีการแก้ไขในขณะที่โพสต์ของคำถามนี้ มันอาจจะคาดเดาใด ๆ ที่สามารถพิสูจน์ได้ในวิชาคณิตศาสตร์ไม่ได้เป็นเพียงคนหนึ่งที่ระบุไว้บนหน้าวิกิพีเดีย

• คุณต้องระบุข้อมูลจำเพาะของภาษาและการใช้งานในภาษาที่มีอยู่

• ภาษาการเขียนโปรแกรมจะต้องทัวริงสมบูรณ์ถ้าหากการคาดเดาถือ (หรือถ้าและเฉพาะในกรณีที่การคาดเดาไม่ได้ถือ)

• คุณต้องมีหลักฐานว่าทำไมทัวริงถึงสมบูรณ์หรือไม่สมบูรณ์ตามการคาดเดาที่เลือก คุณอาจเข้าใช้หน่วยความจำที่ไม่ได้ จำกัด เมื่อเรียกใช้โปรแกรมแปลหรือรวบรวม

• เนื่องจากเรามีความกังวลเกี่ยวกับ Turing ครบถ้วน I / O ไม่จำเป็นต้องใช้ แต่เป้าหมายคือการทำให้ภาษาที่น่าสนใจที่สุดดังนั้นมันอาจช่วย

• นี่คือการประกวดความนิยมดังนั้นคำตอบที่ได้คะแนนมากที่สุดจะเป็นฝ่ายชนะ

เกณฑ์เป้าหมาย

คำตอบที่ดีควรทำอย่างไร? ต่อไปนี้คือสิ่งที่ต้องมองหาเมื่อลงคะแนน แต่ไม่จำเป็นต้องใช้เทคนิค

• มันไม่ควรเป็นภาษาที่ใช้ง่าย การเปลี่ยนภาษาที่มีอยู่ให้เหมาะสมกับข้อกำหนดนั้นเป็นสิ่งที่ดี แต่การแก้ไขในสภาพนั้นไม่ได้รับการสนับสนุนเนื่องจากมันน่าเบื่อ ตามที่กล่าวโดยais523ใน Nineteeth Byte:

  ฉันชอบที่จะทำให้ลูกเล่นของ esolangs อบเข้ากับภาษาให้แน่นยิ่งขึ้น

• มันควรจะน่าสนใจเป็นภาษาลึกลับแบบสแตนด์อโลน

Legendre

ภาษานี้เป็นเพียงการทำให้ทัวริงสมบูรณ์หากว่าการคาดการณ์ของเลอช็องดร์เป็นเท็จเท่านั้นนั่นคือมีจำนวนเต็ม n> 0 ซึ่งไม่มีช่วงใดระหว่าง n ^ 2 และ (n + 1) ^ 2 ภาษานี้ใช้แรงบันดาลใจบางอย่างจาก Underload แม้ว่าในบางแง่มันแตกต่างจากมันมาก

โปรแกรมในเลอช็องดร์ประกอบไปด้วยชุดของจำนวนเต็มบวก (0 เป็นสิ่งต้องห้ามโดยเฉพาะอย่างยิ่งเพราะมันขัดแย้งกับวัตถุประสงค์ทั้งหมดของภาษา) จำนวนเต็มแต่ละค่าสอดคล้องกับคำสั่งพื้นฐานใน Legendre หรือที่ผู้ใช้กำหนด คำสั่งใดที่มันถูกกำหนดให้เป็นไปตามจำนวนของช่วงเวลาระหว่างสแควร์และจำนวนเต็มถัดไป (เทียบเท่ากับลำดับ OEIS A014085 )

คำสั่งของภาษาปรับเปลี่ยนสแต็กซึ่งสามารถเก็บจำนวนเต็มบวกที่มีขนาดใหญ่โดยพลการ หากสแต็กถือ 0 เสมอ 0 จะถูกลบออกทันที รายละเอียดคำสั่งคือ:

• 2 (จำนวนเต็มที่น้อยที่สุดที่ผลิตคำสั่งนี้: 1): กดจำนวนเต็มถัดไปในโปรแกรมลงบนสแต็ก

• 3 (จำนวนเต็มที่น้อยที่สุด: 4): แสดงจำนวนเต็มสูงสุดบนสแต็กและเรียกใช้คำสั่งที่เกี่ยวข้อง

• 4 (เล็กที่สุด: 6): แสดงจำนวนเต็มสูงสุด ถ้าเป็น 1 ให้เพิ่มจำนวนเต็มสูงสุดลงบนสแต็ก

• 5 (10): สลับรายการสแต็คสองอันดับแรก

• 6 (15): ลดจำนวนเต็มสูงสุดในกอง หากผลลัพธ์เป็น 0 ให้เปิด 0 และทิ้งมัน

• 7 (16): ทำซ้ำจำนวนเต็มสูงสุดบนสแต็ก

• 8 (25): หยุดการประมวลผลและพิมพ์เนื้อหาสแต็ก

นี่เป็นชุดคำสั่งพื้นฐานที่ไม่สามารถทำอะไรที่น่าสนใจได้ อย่างไรก็ตามมีคำสั่งอื่นซึ่งสามารถเข้าถึงได้ก็ต่อเมื่อการคาดเดาของเลอช็องดร์เป็นเท็จ

• 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

โปรแกรมนี้แสดงให้เห็นถึงการใช้งานของการโต้ตอบจดหมายเลขจำนวนเต็มถึงคำสั่งทางอ้อม อย่างแรกคือผลัก 5 แล้ว 15 และ 1 โดยใช้วิธีการเข้ารหัสที่แตกต่างกันสามวิธี จากนั้น 1 จะถูกตอกและเป็นผลให้ 15 เพิ่มขึ้นเป็น 16 และดำเนินการในที่สุด โปรแกรมลงท้ายด้วยสองอินสแตนซ์ของหมายเลข 5 บนสแต็ก

1 1 1 5 ? 24 1 15 1 31 ? 31 24 31

โปรแกรมนี้แสดงให้เห็นถึงการใช้คำสั่ง 0 ใช้? เป็นหมายเลขตัวยึดตำแหน่ง โปรแกรมจะจัดเก็บ '1 5' เป็นครั้งแรกในฟังก์ชัน 9 จากนั้น '15 31 'ใน 10 ก่อนที่จะเรียกใช้ฟังก์ชัน 9 (ใช้ 24) ซึ่งผลัก 5 ลงบนสแต็กและลดลงซ้ำ ๆ จนกระทั่งถึง 0 และถูกลบออก . จากนั้นโปรแกรมจะหยุด

เครื่อง Minsky

ในการแปลงเครื่อง Minsky เป็นรหัส Legendre ต้องใช้คำสั่ง 0 เนื่องจากคำสั่งนี้ไม่สามารถเข้าถึงได้เว้นแต่ว่าการคาดการณ์ของเลอช็องดร์จะเป็นเท็จฉันได้ใช้ตัวยึดตำแหน่งหรือไม่ แทน.

โปรดทราบว่าชื่อบรรทัดคำสั่งเครื่อง Minsky ทั้งหมดต้องมีจำนวนเต็มที่มีความสอดคล้อง A014085 ที่แตกต่างกันจากกันและคำสั่งพื้นฐานเช่นเดียวกับ 24 (9) และ 31 (10)

1 1 1 1 ? 24

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

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

1 25 ? x

ในการสร้างโปรแกรมสุดท้ายให้ผนวกทุกส่วน (ด้วย x, y, z แทนที่ด้วยคู่หูของพวกเขา) และเพิ่มจำนวนเต็มเดียวเพื่อเริ่มคำสั่งแรกในห่วงโซ่ สิ่งนี้ควรพิสูจน์ความสมบูรณ์ของภาษาทัวริงในกรณีที่การคาดเดาของเลอช็องดร์ถูกพิสูจน์ว่าเป็นเท็จ

ล่าม

ล่ามนี้เขียนใน Python (3) และได้รับการทดสอบกับตัวอย่างทั้งสามด้านบน ใช้แฟล็ก -a / - อนุญาตศูนย์เพื่ออนุญาตหรือไม่ จะใช้ไฟล์ -f / - เพื่อเรียกใช้รหัสโดยตรงจากไฟล์และ -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())

สหภาพปิด

ภาษาการเขียนโปรแกรมนี้เป็นทัวริงที่สมบูรณ์ถ้าหากการคาดเดาชุดปิดสหภาพไม่ถูกต้อง

การควบคุม

รายการคำสั่ง:
x ++ การเพิ่ม x (INC)
x-- ลดลง x (DEC)
j (x, y) เพิ่มชุดคำสั่ง x ถ้า y เป็น 0 ถึงจุดสิ้นสุดของคิวคำสั่ง

ตัวแปรทั้งหมดถูกเตรียมใช้งานเป็น 0

วากยสัมพันธ์

โปรแกรมถูกเขียนเป็นชุดของชุดคำสั่ง
Command1 Command2 Command3 ...
Command1 Command2
...

สำหรับการพิจารณาว่าโปรแกรมถูกปิดหรือไม่สหภาพแต่ละชุดจะมีเพียงบัญชีสำหรับรายการคำสั่งต่าง ๆ ที่อยู่ในชุด
j (x, y)! = j (a, b)
+ (x)! = + (y)

หากประเภทคำสั่งใด ๆ (+, -, j) ปรากฏในชุดอย่างน้อยครึ่งหนึ่งจะไม่ทำอะไรเลย

โปรแกรมสามารถจบหากไม่มีคำแนะนำในตอนท้ายของคิวคำสั่ง

ลูปไม่สิ้นสุดรวมถึงลูปว่างสามารถทำได้โดยใช้ j (x, y)

ล่าม

function union_arrays (x, y) {
  var obj = {};
  for (var i = x.length-1; i >= 0; -- i)
     obj[x[i]] = x[i];
  for (var i = y.length-1; i >= 0; -- i)
     obj[y[i]] = y[i];
  var res = [];
  for (var k in obj) {
    res.push(obj[k]);
  }
  return res;
}



function runCode(){
  var inputBox=document.getElementById("code");
  input=inputBox.value;
  input=input.split("\n").map(a=>a.split(" "));



  input=input.filter(x=>x.filter(y=>y.length>0).length>0);
  for(i=0;i<input.length;i++){
    for(j=0;j<input[i].length;j++){
      switch(input[i][j][0]){
        case"j":
          eval(input[i][j].split(",")[0].slice(2)+"=0;"+input[i][j].split(",")[1].slice(0,-1)+"=0")
          break;
        default:
          eval(input[i][j].slice(0,1)+"=0");
          break;
      }
    }
  }

  counts=[0,0,0];
  for(i=0;i<input.length;i++){
    count=[0,0,0];
    for(j=0;j<input[i].length;j++){
      switch(input[i][j][0]){
        case"j":
          count[2]=1;
          break;
        default:
          if(input[i][j][1]=="+"){
            count[0]=1;
          }
          else{
            count[1]=1;
          }
        break;
      }
    }
    for(j=0;j<3;j++){
      counts[j]+=count[j];
    }
  }
  for(i=0;i<input.length-1;i++){
    for(j=i+1;j<input.length;j++){
      valid=0;
      union=union_arrays(input[i],input[j]);
      for(k=0;k<input.length;k++){
        if(union_arrays(input[k],[]).sort().join("")==union.sort().join("")){
          valid=1;
        }
      }
      if(!valid){
        break;
      }
    }
    if(!valid){
      break;
    }
  }
  console.log(valid)
  var queue=[]
  if(valid){
    queue.push(input[0]);
    while(queue.length){
      for(i=0;i<queue[0].length;i++){
        if(queue[0][i][0]=="j"&&counts[2]<input.length/2){
          eval("if("+queue[0][i].split(",")[1].slice(0,-1)+"===0&&input["+queue[0][i].split(",")[0].slice(2)+"])queue.push(input["+queue[0][i].split(",")[0].slice(2)+"])");
        }
        if(queue[0][i][1]=="+"&&counts[0])
          eval(queue[0][i]);
        if(queue[0][i][1]=="-"&&counts[1])
          eval(queue[0][i]);
      }
      queue=queue.splice(0,1);
    }
  }
}

<input type="text" id="code" value=""/>
<button onClick="runCode()">Submit</button>

<p class=results></p>

ทัวริงสมบูรณ์

หากทั้งสามคำสั่ง j (x, y), การเพิ่มขึ้นหรือลดลงคำสั่งทั้งหมดที่มีอยู่ดังนั้นเครื่อง Minsky สามารถจำลอง

ชุดใด ๆ ที่มีเฉพาะ j (x, y) ซึ่งเข้าถึงได้โดยใช้ j (x, y) คือ HALT
x ++ คือ INC
x-- คือ DEC
j (x, y) คือ JZ

หากการปิดการรวมกันแบบปิดถูกต้องคำสั่งอย่างน้อยหนึ่งในสามคำสั่งจะถูกปิดการใช้งานเสมอทำให้ภาษานี้ไม่สามารถทำการทัวริงได้

เฉพาะแฟร์มาต์

ภาษาใช้งานได้กับสองเทปที่ไม่มีที่สิ้นสุดซึ่งแต่ละตำแหน่งของเทปสามารถเก็บจำนวนเต็มได้ เทปทั้งสองเต็มไปด้วย-1เมื่อเริ่มต้น นอกจากนี้ยังมีหัวเทปสองหัวที่เริ่มต้นที่ตำแหน่ง 0 บนเทปทั้งสอง

ล่ามจะอ่านอินพุตก่อนและเก็บค่าไว้ในเทป (ข้อมูล) แรกเริ่มต้นที่ตำแหน่ง 0

จากนั้นมันจะอ่านโปรแกรมที่ให้มา สำหรับทุกหมายเลขที่พบมันจะตรวจสอบก่อนว่ามูลค่านั้นเป็นแฟร์มาต์ไพร์มหรือไม่ ถ้าใช่มันจะเขียนไปยังเทป (คำสั่ง) ที่สองซึ่งแฟร์มาต์เป็นหลักมิฉะนั้นจะเขียน-1ลงในเทปคำแนะนำ

ตรวจสอบค่าที่ตัวชี้คำแนะนำจากนั้นทำสิ่งใดสิ่งหนึ่งต่อไปนี้:

• -1 หรือน้อยกว่า: ออกจากโปรแกรม
• 0: ย้ายตำแหน่งเทปข้อมูลหนึ่งไปทางซ้าย เลื่อนตำแหน่งเทปคำสั่งหนึ่งไปทางขวา
• 1: ย้ายตำแหน่งเทปข้อมูลหนึ่งไปทางขวา เลื่อนตำแหน่งเทปคำสั่งหนึ่งไปทางขวา
• 2: เพิ่มค่าที่ตำแหน่ง data data เลื่อนตำแหน่งเทปคำสั่งหนึ่งไปทางขวา
• 3: ลดค่าที่ตำแหน่ง data data เลื่อนตำแหน่งเทปคำสั่งหนึ่งไปทางขวา
• 4: ถ้าค่าที่ตำแหน่งเทปข้อมูลปัจจุบันเป็นศูนย์แล้วย้ายเทปการเรียนการสอนทางด้านขวาจนกว่าจะถึงทั้งการจับคู่5(หรือขนาดใหญ่) 0มูลค่าในเทปการเรียนการสอนหรือสิ่งที่มีขนาดเล็กกว่า หากเป็น5(หรือใหญ่กว่า) ให้เลื่อนตัวชี้คำสั่งไปทางขวาอีกครั้งถ้ามันเล็กกว่า0แล้วออกจากโปรแกรม หากค่าตำแหน่งเทปข้อมูลปัจจุบันไม่เป็นศูนย์เพียงเลื่อนเทปคำแนะนำหนึ่งไปทางขวา
• 5หรือมากกว่า: เลื่อนตัวชี้การเรียนการสอนไปทางซ้ายจนกว่าจะถึงที่สอดคล้องกันค่าหรือคุณพบสิ่งที่น้อยกว่า4 0ในกรณีหลังให้ออกจากโปรแกรม

(โดยการจับคู่5(หรือมากกว่า) และ4ค่าหมายความว่าในขณะที่ค้นหาค่าที่เหมาะสมในเทปคำสั่งทุกครั้งที่พบค่าเดียวกันกับคำสั่งเริ่มต้น (อย่างใดอย่างหนึ่ง5(หรือมากกว่า) หรือ4) ก็จะต้องข้ามจำนวนที่เหมาะสม ของค่าอื่น ๆ ( 4หรือ( หรือ5(หรือมากกว่า) ตามลำดับ) ในการค้นหา)

วนซ้ำจนกว่าคำสั่งจะบอกว่าคุณต้องออกจากโปรแกรม

เมื่อโปรแกรมออกให้ส่งออกค่าบนเทปข้อมูลจากตำแหน่ง0จนกระทั่งตำแหน่งเทปแรกที่มี-1ค่า

พิสูจน์

โปรดทราบว่าภาษานั้นจับคู่กับล่าม Brainfuck ของ IO ที่F_5ไม่ต้องใช้ภาษาซึ่งจะต้องมีการวนซ้ำที่เหมาะสม

อย่างไรก็ตามขึ้นอยู่กับการคาดเดาของแฟร์มาต์มีเพียง 5 ครั้งแฟร์มาต์ ( F_0- F_4) หากF_5มีอยู่ภาษาทัวริงที่สมบูรณ์แบบที่เรารู้ว่า Brainfuck ทัวริงสมบูรณ์ อย่างไรก็ตามหากไม่มีF_5คุณจะไม่สามารถทำได้ทั้งการแยกหรือการวนซ้ำการล็อกคุณเข้าสู่โปรแกรมที่ง่ายมาก

การดำเนินงาน

(ทดสอบด้วยทับทิม 2.3.1)

#!/usr/bin/env ruby
require 'prime'

CHEAT_MODE = false
DEBUG_MODE = false
NUM_CACHE = {}

def determine_number(n)
  return n.to_i if CHEAT_MODE
  n = n.to_i
  -1 if n<3

  return NUM_CACHE[n] if NUM_CACHE[n]

  i = 0

  loop do
    num = 2**(2**i) + 1
    if num == n && Prime.prime?(n)
      NUM_CACHE[n] = i
      break
    end
    if num > n
      NUM_CACHE[n] = -1
      break
    end
    i += 1
  end

  NUM_CACHE[n]
end

data_tape = Hash.new(-1)
instruction_tape = Hash.new(-1)

STDIN.read.each_char.with_index { |c,i| data_tape[i] = c.ord }
File.read(ARGV[0]).split.each.with_index do |n,i|
  instruction_tape[i] = determine_number(n)
end

data_pos = 0
instruction_pos = 0

while instruction_tape[instruction_pos] >= 0
  p data_tape, data_pos, instruction_tape, instruction_pos,'------------' if DEBUG_MODE

  case instruction_tape[instruction_pos]
  when 0 then data_pos -= 1; instruction_pos += 1
  when 1 then data_pos += 1; instruction_pos += 1
  when 2 then data_tape[data_pos] += 1; instruction_pos += 1
  when 3 then data_tape[data_pos] -= 1; instruction_pos += 1
  when 4 then
    if data_tape[data_pos] == 0
      count = 1
      instruction_pos += 1
      while count>0 && instruction_tape[instruction_pos] >= 0
        count += 1 if instruction_tape[instruction_pos] == 4
        count -= 1 if instruction_tape[instruction_pos] >= 5
        instruction_pos += 1
      end
      break if count != 0
    else
      instruction_pos += 1
    end
  else
    count = 1
    instruction_pos -= 1
    while count>0 && instruction_tape[instruction_pos] >= 0
      count += 1 if instruction_tape[instruction_pos] >= 5
      count -= 1 if instruction_tape[instruction_pos] == 4
      instruction_pos -= 1 if count>0
    end
    break if count != 0
  end
end

data_pos = 0

while data_tape[data_pos] >= 0
  print data_tape[data_pos].chr
  data_pos += 1
end

ตัวอย่าง:

สิ่งนี้จะเขียนH(ย่อมาHello World!) ไปที่หน้าจอด้วยการขึ้นบรรทัดใหม่:

17 17 17 17 17 17 17 17 17 17
17 17 17 17 17 17 17 17 17 17
17 17 17 17 17 17 17 17 17 17
17 17 17 17 17 17 17 17 17 17
17 17 17 17 17 17 17 17 17 17
17 17 17 17 17 17 17 17 17 17
17 17 17 17 17 17 17 17 17 17
17 17 17
5
17 17 17 17 17 17 17 17 17 17
17

บันทึกเป็นexample.fermatและเรียกใช้งานเช่นนี้ (หมายเหตุ: คุณจำเป็นต้องมีอินพุต):

$ echo -n '' | ./fermat.rb example.fermat

ตัวอย่างถัดไปนี้จะทำรูปแบบซีซาร์แบบง่าย ๆ โดยการเพิ่มแต่ละค่าของอินพุตโดยหนึ่ง เห็นได้ชัดว่าคุณต้องแทนที่?ด้วยไพรม์แฟร์ 5

17 65537 5 17 ? 257

คุณสามารถลองใช้งานได้โดยเปิดใช้งานโหมดโกงและใช้2 4 1 2 5 3เป็นซอร์สโค้ด:

$ echo 'Hello' | ./fermat.rb example2_cheat.fermat

นกนางแอ่น w / Coconut v2

เนื่องจากเวอร์ชันก่อนหน้ามีข้อผิดพลาดซึ่งทำให้การแข่งขันนี้ไม่ถูกต้องและฉันไม่ต้องการให้ upvotes จากเวอร์ชันก่อนหน้าสำหรับรุ่นนี้ซึ่งแตกต่างอย่างมากรุ่นนี้จึงถูกส่งเป็นโพสต์ใหม่

ภาษานี้ไม่ทัวริงที่สมบูรณ์หากCollatz Conjectureสามารถพิสูจน์ได้สำหรับจำนวนเต็มบวกทั้งหมด มิฉะนั้นภาษาทัวริงจะสมบูรณ์

ภาษานี้ถูกตามออกของพระคาร์ดินัล

ขั้นแรกให้ contVal ของโปรแกรมคำนวณโดยใช้สูตร
contVal = ผลรวม (ผลรวม (ค่า ASCII ของแถว) * 2 ^ (หมายเลขแถว -1)

ถัดไป 2 นกนางแอ่นที่มุ่งหน้าไปในทิศทางตรงกันข้ามจะถูกสร้างขึ้นในแต่ละ A หรือ E และคำสั่งการเลี้ยวตามเงื่อนไขทั้งหมดถูกตั้งค่าให้รอการเริ่มต้น
นกนางแอ่นที่สร้างขึ้นที่ E นั้นมุ่งหน้าไปทางซ้าย / ขวาและนกนางแอ่นที่สร้างที่ A นั้นจะมุ่งหน้าขึ้น / ลง

ในที่สุดรหัสจะดำเนินการตามขั้นตอนจนกว่าพอยน์เตอร์ทั้งหมดจะถูกลบหรือ contVal ได้ลดลงไปหนึ่ง

ในแต่ละขั้นตอนหาก contVal% 2 == 0 มันจะถูกหารด้วย 2 มิฉะนั้นจะถูกคูณด้วยสามและเพิ่มขึ้นทีละหนึ่ง

คำสั่ง:

0: ตั้งค่าเป็น 0
+: เพิ่มค่าโดย 1
>: เปลี่ยนทิศทางเป็นขวา
v: เปลี่ยนทิศทางเป็นลง
<: เปลี่ยนทิศทางเป็นซ้าย
^: เปลี่ยนทิศทางเป็นซ้าย
R: ตัวชี้ที่ตามมาหลังจากตัวชี้แรกเปรียบเทียบกับค่าของ ตัวชี้แรก ถ้าเท่ากับให้ตรงไปทางอื่นให้เลี้ยวขวา
L: พอยน์เตอร์ที่ตามมาหลังจากตัวชี้แรกเปรียบเทียบกับค่าของตัวชี้แรก ถ้าเท่ากันให้เลี้ยวตรงไปทางอื่นเลี้ยวซ้าย
E: ทำซ้ำตัวชี้ แต่มุ่งหน้าไปในทิศทางซ้ายและขวา
A: ทำซ้ำตัวชี้ แต่มุ่งหน้าไปตามทิศทางขึ้นและลง
? : ลบตัวชี้หากค่าเป็น 0

function runCode(){
  var inputBox=document.getElementById("code");
  input=inputBox.value;
  area=input.split('\n');
  width=0;
  height=area.length;
  for(i=0;i<height;i++){
    width=Math.max(width,area[i].length);
  }
  //Determine the endurance of the swallows
  contVal=0;
  for(i=0;i<height;i++){
    for(j=0;j<area[i].length;j++){
      contVal+=((j+1)<<i)*area[i].charCodeAt(j);
    }
  }
  //Spawn the African and European swallows and initialize the conditionals
  pointerList=[];
  condList=[];
  for(i=0;i<height;i++){
    for(j=0;j<area[i].length;j++){
      if(area[i][j]=='A'){
        pointerList.push([i,j,0,0]);
        pointerList.push([i,j,2,0]);
      }
      if(area[i][j]=='E'){
        pointerList.push([i,j,1,0]);
        pointerList.push([i,j,3,0]);
      }
      if(area[i][j]=='R'||area[i][j]=='L'){
        condList.push([i,j,-1]);
      }
    }
  }
  output='';
  while(1){
    for(i=0;i<pointerList.length;i++){
      switch (pointerList[i][2]){
        case 0:
          pointerList[i][1]++;
          break;
        case 1:
          pointerList[i][0]++;
          break;
        case 2:
          pointerList[i][1]--;
          break;
        case 3:
          pointerList[i][0]--;
          break;
      }
      if(pointerList[i][1]<0||pointerList[i][0]<0||pointerList[i][0]>=height||pointerList[i][1]>=area[pointerList[i][0]].length){
        pointerList.splice(i,1);
      }
      else{
        switch(area[pointerList[i][0]][pointerList[i][1]]){
          case "+":
            pointerList[i][3]++;
            break;
          case "0":
            pointerList[i][3]=0;
            break;  
          case ">":
            pointerList[i][2]=1;
            break;
          case "v":
            pointerList[i][2]=2;
            break;
              case "<":
            pointerList[i][2]=3;
            break;
          case "^":
            pointerList[i][2]=0;
            break;
          case "R":
            for(j=0;j<condList.length;j++){
              if(pointerList[i][0]==condList[j][0]&&pointerList[i][1]==condList[j][1]){
                if(condList[j][2]==-1){
                  condList[j][2]=pointerList[i][3];
                  pointerList.splice(i,1);
                }
                else{
                  if(pointerList[i][3]!=condList[j][2]){
                    pointerList[i][2]=(pointerList[i][2]+1)%4;
                  }
                }
              }
            }
            break;
          case "L":
            for(j=0;j<condList.length;j++){
              if(pointerList[i][0]==condList[j][0]&&pointerList[i][1]==condList[j][1]){
                if(condList[j][2]==-1){
                  condList[j][2]=pointerList[i][3];
                  pointerList.splice(i,1);
                }
                else{
                  if(pointerList[i][3]!=condList[j][2]){
                    pointerList[i][2]=(pointerList[i][2]+3)%4;
                  }
                }
              }
            }
            break;
          case "A":
            pointerList.push([pointerList[i][0],pointerList[i][1],0,pointerList[i][3]]);
            pointerList.push([pointerList[i][0],pointerList[i][1],2,pointerList[i][3]]);
            break;
          case "E":
            pointerList.push([pointerList[i][0],pointerList[i][1],1,pointerList[i][3]]);
            pointerList.push([pointerList[i][0],pointerList[i][1],3,pointerList[i][3]]);
            break;
          case "?":
            pointerList.splice(i,1);
        }
      }
    }
    if(contVal%2===0){
      contVal=contVal/2;
    }
    else{
      contVal=contVal*3+1;
    }
    if(!pointerList.length||contVal==1){
      break;
    }
  }
  console.log(output);
}

<input type="text" id="code" value=""/>
<button onClick="runCode()">Submit</button>

<p class=results></p>

คำอธิบาย:

หาก Collatz Conjecture สามารถพิสูจน์ได้สำหรับจำนวนเต็มบวกทั้งหมดระยะเวลาของโปรแกรมใด ๆ ที่ทำงานในภาษานี้มี จำกัด เนื่องจาก contVal จะรวมกันเป็น 1 เสมอดังนั้นจะสิ้นสุดโปรแกรม

มิฉะนั้นฉันก็ต้องพิสูจน์ว่าภาษานี้สามารถใช้ฟังก์ชั่นต่อไปนี้

เพิ่ม: ซึ่งเป็นตัวแทนจาก +
คงที่ 0: ซึ่งเป็นตัวแทนโดย 0
เข้าถึงการศึกษา: ตัวแปรจะถูกเก็บเป็นตัวชี้ที่พวกเขาเดินทาง
concatenation คำชี้แจง: โดยการเปลี่ยนระยะทางที่เดินทางเพื่อการดำเนินงานลำดับที่การดำเนินงานจะดำเนินการสามารถเปลี่ยนแปลงได้
สำหรับวง: ในภาษานี้

E   > V
    ^+R
      +
      A

จะทำหน้าที่เป็น for for loop> นับได้สูงสุด 1 (สามารถเพิ่มโค้ดเพิ่มเติมใน loop ได้)

ในทำนองเดียวกันรหัส

Rv
^<

จะทำหน้าที่เป็นสิ่งที่ต้องทำจนกระทั่งเท่ากับค่าตามเงื่อนไขที่กำหนดไว้ในลูป R

Perfection / ความไม่สมบูรณ์

มันสนุกดี

ความสมบูรณ์แบบ / ความไม่สมบูรณ์จะสมบูรณ์ก็ต่อเมื่อมีจำนวนที่สมบูรณ์แบบไม่ จำกัด หากมีก็เรียกว่า Perfection และหากไม่มีก็จะเรียกว่า Imperfection จนกว่าความลึกลับนี้จะได้รับการแก้ไขก็ถือทั้งสองชื่อ

1+2+3=6จำนวนที่สมบูรณ์แบบเป็นจำนวนที่มีตัวหารสรุปผลไปยังหมายเลขที่ดังนั้นหกเป็นจำนวนที่สมบูรณ์แบบเพราะ

Perfection / Imperfection มีฟังก์ชั่นดังต่อไปนี้:

Perfection / Imperfection เป็นแบบสแต็กที่มีสแต็กที่ไม่มีดัชนี

คำสั่ง:

p(x, y): ผลัก x ไปยังสแต็กในตำแหน่ง yth

z(x, y): ผลัก x ไปยังสแต็กในตำแหน่ง yth กำจัดสิ่งที่เคยอยู่ในตำแหน่ง yth ไปก่อนหน้านี้

r(x): ลบไอเท็ม xth ออกจากสแต็ก

k(x): ส่งคืนรายการ xth บนสแต็ก

a(x, y): เพิ่ม x และ y เมื่อใช้กับสตริงมันจะรวมเข้าด้วยกันตามลำดับ xy

s(x, y): ลบ y จาก x ด้วยสตริงเอา len ล่าสุด (y) ออกจาก x

m(x, y): คูณ x และ y หากใช้กับสตริงให้คูณ x คูณ len y

d(x, y): หาร x ด้วย y

o(x): พิมพ์ x

i(x, y): ถ้า x ประเมินว่าเป็นจริงแล้วมันจะประมวลผลฟังก์ชัน y

n(): ส่งคืนตัวนับที่บล็อกโค้ดกำลังถูกเรียกใช้

q(): ส่งคืนความยาวของสแต็ก

t(): อินพุตของผู้ใช้

e(x, y): ถ้า x เป็นจำนวนเต็มถ้า x และ y มีค่าเท่ากันดังนั้นสิ่งนี้จะคืนค่า 1 หาก y เป็นสตริงดังนั้นมันจะได้รับความยาวของ y ถ้า x เป็นสตริงจากนั้นมันจะแปลง y เป็นสตริงและตรวจสอบว่ามันเหมือนกันหรือไม่และถ้าเป็นนั้นจะคืนค่า 1 มิฉะนั้นจะคืนค่า 0

l(x, y): ถ้า x ใหญ่กว่า y ดังนั้นมันจะคืนค่า 1 หากมีสตริงดังนั้นมันจะใช้ความยาวของสตริง

b(): หยุดโปรแกรม

c(x, y): รัน x จากนั้น y

ในการรับค่าเทียบเท่าของ Python andให้คูณค่าทั้งสองเข้าด้วยกัน สำหรับor, เพิ่มค่า, และสำหรับnot, ลบค่าจาก 1 ซึ่งจะทำงานได้ก็ต่อเมื่อค่าคือ 1 หรือ 0 ซึ่งสามารถทำได้โดยการหารตัวเลขด้วยตัวมันเอง

ชนิดข้อมูล: จำนวนเต็มและสตริง สตริงจะถูกแทนด้วย''และตัวเลขที่ไม่ใช่จำนวนเต็มทั้งหมดจะถูกปัดเศษ

ไวยากรณ์:

รหัสประกอบด้วยฟังก์ชั่นที่ซ้อนกันภายในสิบ{}วินาที {o(a(t(), t()))}ตัวอย่างเช่นโปรแกรมที่จะได้รับปัจจัยการผลิตและพิมพ์เพิ่มจะเป็น: ในพื้นหลังของโปรแกรมจะมีตัวนับที่เริ่มต้นที่ 0 และดำเนินไปทีละ 1 ทุกครั้งที่เรียกใช้งานการบล็อกรหัส บล็อกรหัสแรกทำงานที่0และอื่น ๆ เมื่อดำเนินการบล็อกรหัสสิบรายการบล็อกที่หกจะถูกดำเนินการทุกครั้งที่ตัวนับถึงจำนวนที่สมบูรณ์ คุณไม่จำเป็นต้องมีบล็อคโค้ดทั้งสิบเพื่อให้โปรแกรมทำงานได้ แต่คุณต้องมี 7 ถ้าคุณต้องการสร้างลูป {}{}{}{}{}{}{o(n())}เพื่อทำความเข้าใจวิธีการทำงานภาษานี้เรียกใช้โปรแกรมต่อไปนี้ซึ่งพิมพ์เคาน์เตอร์ทุกครั้งนับถึงจำนวนที่สมบูรณ์แบบ:

ล่ามสามารถพบได้ที่นี่: repl.it/GL7S/37 เลือก 1 และพิมพ์รหัสของคุณในเทอร์มินัลหรือวางรหัสของคุณในcode.perfectแท็บและเลือก 2 เมื่อคุณเรียกใช้ มันจะสมเหตุสมผลเมื่อคุณลอง

หลักฐานการทัวริงครบถ้วน / ขาดทัวริงครบถ้วน

ตามบทความวิศวกรรมสแต็คแลกเปลี่ยนซอฟต์แวร์ทัวริงสมบูรณ์จะต้องสามารถมีรูปแบบของการกระโดดซ้ำตามเงื่อนไขและมีวิธีการอ่านหรือเขียนหน่วยความจำ สามารถอ่าน / เขียนหน่วยความจำในรูปแบบของสแต็กและสามารถวนซ้ำได้เนื่องจากบล็อกโค้ดที่ 6 ถูกเรียกใช้งานทุกครั้งที่ตัวนับถึงจำนวนที่สมบูรณ์ หากมีจำนวนที่สมบูรณ์แบบไม่ จำกัด จำนวนก็สามารถวนซ้ำไปเรื่อย ๆ และทัวริงสมบูรณ์และมิฉะนั้นจะไม่

ตัวแปลแท็ก Cyclic Bitcoin ด้วยตนเองที่ใช้อักขระ 5 ตัว, 1 หรือ 0 เป็นอินพุต:

{p(t(),0)}{(p(t(),0)}{p(t(),0)}{p(t(),0)}{p(t(),0)}{p(0,0)}{c(i(e(k(s(q(),k(0))),0),c(r(q()),i(l(k(0),0),z(s(k(0),1),0)))),i(e(k(s(q(),k(0))),1),c(z(a(k(0),1),0),i(e(k(q()),1),p(k(s(q(),k(0))),1)))))}

สามารถขยายได้เพื่อใช้ตัวอักษรจำนวนเท่าใดก็ได้เป็นอินพุต อาจใช้อินพุตที่ไม่มีที่สิ้นสุด แต่ก็ต่อเมื่อมีตัวเลขที่สมบูรณ์แบบไม่ จำกัด !

พื้น

ภาษาการเขียนโปรแกรมนี้เป็นทัวริงที่สมบูรณ์ถ้าการคาดเดา Scholzเป็นจริง

ฉันเขียนภาษานี้เพราะ @SztupY บอกว่าจะไม่มีผลลัพธ์ใด ๆ ที่ขึ้นอยู่กับการคาดเดาว่าเป็นจริงที่จะทำให้ทัวริงสมบูรณ์

รายการคำสั่ง

+(x)      Increment x (INC)   
-(x)      Decrement x (DEC)  
j(x,y)    Jump to instruction x if y is 0 (JZ)  
x         End program (HALT) 

ด้วยคำสั่งเหล่านี้ภาษานี้สามารถจำลองเครื่อง Minsky

ล่าม

ฉันอยากจะแนะนำไม่ได้ทำงานนี้ มันใช้วิธีการที่ช้ามากเป็นพิเศษในการตรวจสอบห่วงโซ่การเพิ่ม

function runCode(){
  var inputBox=document.getElementById("code");
  input=inputBox.value;
  input=input.split(" ");
  counter=1;
  lvals=[0];

  l=(x,arr)=>{
    if(arr[x-1]){
      return arr[x-1];
    }
    minim=Number.MAX_SAFE_INTEGER;
    console.log(min);
    for(i=Math.floor(x/2);i>0;i--){
      minim=Math.min(minim,l(i,arr)+l(x-i,arr)+1);
    }
    return minim;
  };
  cont=1;
  pointer=0;
  while(cont){
    lvals[Math.pow(2,counter)-2]=l(Math.pow(2,counter)-1,lvals);
    lvals[counter-1]=l(counter,lvals);
    if(lvals[Math.pow(2,counter)-2]>n-1+lvals[counter-1]){
      break;
    }
    switch(input[pointer][0]){
      case "+":
        x=input[pointer].slice(2,-1);
        eval(x+"++")
        break;
      case "-":
        x=input[pointer].slice(2,-1);
        eval(x+"--")
        break;
      case "j":
        x=input[pointer].split(",")[0].slice(2);
        y=input[pointer].split(",")[0].slice(0,-1);
        eval("if(!"+y+")pointer="+x+"-1");
        break;
      case "x":
        cont=0;
        break;
    }
    pointer++;
    if(pointer>input.length){
      break;
    }
    counter++;
  }
}

<input type="text" id="code" value=""/>
<button onClick="runCode()">Submit</button>

<p class=results></p>

ทัวริงสมบูรณ์

ภาษาใช้ตัวนับจำนวนคำสั่งที่เรียกใช้ซึ่งตรวจสอบกับ Scholz conjecture เพื่อแก้ไขความสมบูรณ์ของภาษา

หากการคาดเดาของ Scholz เป็นจริงโปรแกรมนี้จะทำงานเหมือนกับเครื่องจักร Minsky ปกติพร้อม
เพิ่มค่า
Decrement
Jump หาก Zero
Halt

อย่างไรก็ตามหากการคาดเดาของ Scholz เป็นเท็จตัวนับจะถึงค่าที่การคาดเดาของ Scholz ไม่ถือเป็นจริงในที่สุด เมื่อภาษาได้รับการออกแบบให้ออกเมื่อถึงจำนวนที่การคาดเดาของ Scholz เป็นเท็จโปรแกรมจะออกทุกครั้งหลังจากรันคำสั่งจำนวนมาก ดังนั้นโปรแกรมทั้งหมดจะมีความยาว จำกัด เนื่องจากไม่เห็นด้วยกับข้อกำหนดสำหรับภาษาที่จะทำให้ทัวริงสมบูรณ์

"เทปไม่สามารถแก้ไขความยาวได้เนื่องจากจะไม่สอดคล้องกับคำจำกัดความที่กำหนดและจะ จำกัด ช่วงการคำนวณอย่างจริงจังซึ่งเครื่องสามารถทำงานกับของหุ่นยนต์ที่มีขอบเขต จำกัด "

ภาษาจะไม่ทัวริงสมบูรณ์หากการคาดเดาของ Scholz เป็นเท็จ

คู่หมั้นคู่หมาย

คู่หมั้น Github

readme และข้อมูลจำเพาะอยู่บน github ภายใต้ "README.txt"

โดยทั่วไปโปรแกรม Betrothed ประกอบด้วยเส้นคู่ซึ่งมีความยาวแตกต่างกันเป็นคู่แฝดคู่หรือคู่ที่ถูกหมั้นไว้ (ไม่มีรายการซ้ำเกิดขึ้น) โปรแกรมดำเนินการโดยการค้นหา "ชุดย่อยที่ยืดหยุ่นได้" ของบรรทัดแรกในคู่ภายในบรรทัดที่สอง จำนวนของเซ็ตย่อยดังกล่าวรวมกับระยะทาง levenshtein ระหว่างบรรทัดที่สองดั้งเดิมและบรรทัดที่สองโดยไม่มีเซ็ตย่อยที่สามารถกำหนดได้ให้พิจารณาคำสั่งเพื่อดำเนินการ

ฉันจะตัดตอนหลักฐานสำหรับโพสต์นี้:

V. PROOF OF TURING COMPLETENESS

Now, no language can be Turing Complete with bounded program size. Therefore, if Betrothed
is Turing Complete, it must have unbounded program size. Since the lengths of the lines of
a Betrothed program must be twin prime pairs or betrothed pairs, and since both sequences
are unproven to be infinite or finite, Betrothed has unbounded program size if and only if
there are infintie betrothed pairs, there are infinite twin prime pairs, or both.

    Next: to prove that if Betrothed has an unbounded program size, then it is Turing
Complete. I will use the op-codes from the above table to demonstrate key factors of a
Turing Complete language; they are of the form  [index]<[ld]> .

  1. Conditional goto: 6<> 5<>, or if-popjump. This can be used to form a loop.
  2. Inequality to a constant K: 10<K> 
  3. Arbitrarily large variable space: you can use some separator constant C.

    With this, I have sufficient reason to believe that Betrothed is Turing Complete.

ความเท่าเทียมกันที่เป็นมิตร

ภาษานี้จะขึ้นอยู่กับว่ามีผู้ใดเป็นตัวเลขที่เป็นมิตรกับความเท่าเทียมกันตรงข้าม

คำสั่ง

x : End program if not on top line  
+ : increment stored value  
- : decrement stored value  
{ : set next goto x value to current x value
} : goto previous x value set by {  
j : Go down one line if the special value is an amicable number and the
    parity is opposite to the matching number (loops back to top). If the
    special value is not an amicable number and not on the top line, go up
    one line.  

การควบคุมการไหล

โปรแกรมวนซ้ำจากซ้ายไปขวาก่อนวนกลับไปที่จุดเริ่มต้น หากพบ "j" จะตรวจสอบค่าเพื่อพิจารณาว่าควรเปลี่ยนแถวหรือไม่ หากตัวเลขนั้นเป็นตัวเลขที่เป็นมิตรกับการจับคู่ที่ต่างกันของการจับคู่มันจะลงหนึ่งแถว (วนกลับไปด้านบน) มิฉะนั้นถ้าตัวเลขเป็นตัวเลขที่เป็นมิตรก็จะเพิ่มขึ้นหนึ่งแถวหากยังไม่ได้อยู่ในแถวบนสุด

โปรแกรมสามารถสิ้นสุดได้หากโปรแกรมมาถึง x ในแถวใด ๆ นอกแถวบนสุด

ทัวริงสมบูรณ์

โปรแกรมนี้สามารถใช้ในการจำลองเครื่อง Minsky โดยสมมติว่ามีตัวเลขที่เป็นมิตรกับคู่ที่มีพาริตีตรงกันข้าม

j, {และ} สามารถใช้เพื่อจำลอง JZ (r, x) แม้ว่ามันจะตรวจสอบตัวเลขที่เป็นมิตรเมื่อเทียบกับศูนย์
+ คือ INC (r)
- คือ DEC (r)
x คือ HALT

หากคุณไม่สามารถออกจากแถวแรกคำสั่ง x และ} ไม่ทำอะไรเลย ส่งผลให้โปรแกรมไม่สามารถเข้าสู่สถานะ HALT ได้เว้นแต่จะเป็นโปรแกรมเปล่า ดังนั้นภายใต้คำอธิบายว่าทัวริงสมบูรณ์ต้องใช้สถานะ HALTภาษาจะทัวริงไม่สมบูรณ์

ล่าม

sumDiv=r=>{
  sum=0;
  for(i=1;i<=Math.sqrt(r)&&i!=r;i++){
    if(r%i===0){
      sum+=i+r/i;
    }
    if(i*i==r){
      sum-=i;
    }
  }
  return sum;
};
function runCode(){
  var inputBox=document.getElementById("code");
  input=inputBox.value;
  input=input.split("\n");
  val=2;
  exit=0;
  loop=0;
  for(j=0;!exit;){
    for(i=0;i<input[j].length;i++){
      if(input[j][i]=="x"&&j){
        exit=1;
        break;
      }
      else if(input[j][i]=="j"){
        if(val==sumDiv(sumDiv(val))&&val!=sumDiv(val)&&(val+sumDiv(val))%2){
          j=(j+1)%input.length;
          i--;
        }
        else if(j&&val!=sumDiv(sumDiv(val))){
          j--;
          i--;
        }
      }
      else if(input[j][i]=="+"){
        val++;
      }
      else if(input[j][i]=="-"){
        val--;
      }
      else if(input[j][i]=="{"){
        loop=i;
      }
      else if(input[j][i]=="}"&&j){
        i=loop;
      }
      if(input[j].length==i+1){
        i=-1;
      }
    }
  }
}

<input type="text" id="code" value=""/>
<button onClick="runCode()">Submit</button>

<p class=results></p>

นิวไลน์

คำเตือน: มันเป็นระเบียบและเรียบง่าย นี่เป็นภาษาแรกที่ฉันเคยเขียนและการคาดเดาเป็นภาษาเดียวที่ฉันเข้าใจ ฉันรู้ว่าผู้ใช้รายอื่นมีคำตอบนานกว่าเดิม แต่ฉันตัดสินใจที่จะเขียนสิ่งนี้ต่อไป

ในการเขียน Newline คุณต้องมีเวลาและบรรทัดใหม่ ( \n) งานนี้ออกมาจากการคาดเดาเลอช็องดร์เป็นจริง โอเปอเรเตอร์ทุกคนจะต้องตกอยู่ในตัวเลขในการคาดเดาเลอร์ที่เราเริ่มต้นด้วย n = 1 ทุกครั้งที่คุณมีโอเปอเรเตอร์คุณใช้จำนวน \ n และเสียบเข้าไปในเลอช็องดร์การคาดเดา n ต้องอยู่ข้างในดังนั้นเมื่อต้องการเริ่มต้นคุณ\n\nก็ไปที่โอเปอเรเตอร์แล้ว\nก็โอเปอเรเตอร์อื่นที่เราอยู่ที่ 3 บรรทัดใหม่ ทีนี้อันถัดไปคือ 5 เพื่อให้คุณเพิ่ม\n\nและเพิ่มโอเปอเรเตอร์เพื่อให้แน่ใจว่าบรรทัดโอเปอเรเตอร์สุดท้ายมีจำนวนบรรทัดใหม่ที่ถูกต้องซึ่งคุณอยู่ในจำนวนเฉพาะที่ตกอยู่ในการคาดเดาของเลอช็องเตร

ตัวเลข (อาเรย์) เป็นเหมือนตัวแปร ทุกครั้งที่ผู้ดำเนินการเรียกใช้ (ที่ใช้ตัวเลข) จะเพิ่มขึ้นทุกครั้ง

+ adds
- subtracts
/ divide
* multiply 
s sqrt
% mod
a push to vars
g sets stack to numbers
q pushes value of stack to numbers
i increment 
d decrement
r stops subtraction at 0
w turns back on subtraction past 0
[ starts loop
] ends loop runs until stack is 0
{ starts loop
} ends loop and loops until loops[ln] is 0
k increment loops

ตราบใดที่เรามีช่วงเวลาไม่ จำกัด ที่ปฏิบัติตามกฎนี้ภาษานี้มีเทป จำกัด

เครื่อง Minsky

\n\ng\nr\n\n[\n\nd\n\n\n\n]

มันทำงานอย่างไร:

\n\ng     # the first two newlines are to get to a prime number of newlines (2) then sets the value of stack to the first variable in the array numbers (see code in link)

\nr       # gets to the next number and makes it so subtraction stops at 0

\n\n[     # starts the loop

\n\nd     # decrements stack 

\n\n\n\n] # ends loop

ลองมันออกมาบนคานอะคาเดมี่

Taggis

Taggis เป็นภาษาที่อยู่บนพื้นฐานของระบบแท็ก

ความสมบูรณ์ของ Taggis นั้นขึ้นอยู่กับCollatz Conjecture

วากยสัมพันธ์

ไวยากรณ์ของโปรแกรม Taggis เป็นเพียงสามสาย (กฎการผลิต) ซึ่งประกอบด้วยตัวอักษรทั้งหมด a, b และ c โดยคั่นด้วยช่องว่าง

การกระทำ

สถานะโปรแกรมเดียวของ Taggis คือสตริงที่ประกอบด้วยอักขระสามตัวเดียวกัน

Taggis ใช้ระบบแท็ก TS (3, 2) ซึ่งในทุกขั้นตอนจะลบตัวอักษร 2 ตัวแรกของ "แท็ก" ปัจจุบันและตัวอักษรตัวแรกที่อยู่ในส่วนที่ลบออกนั้นจะได้รับกฎการผลิตที่สอดคล้องกันต่อท้าย สตริง

ตัวอย่างเช่นโปรแกรม Taggis bc a aaaใช้ปัญหา 3n + 1 ซึ่งการทำซ้ำจะถูกแสดงด้วยจำนวนที่สอดคล้องกันของas และขั้นตอน 3n + 1 จะถูกแทนที่ด้วย (3n + 1) / 2 [1] นำไปสู่ผลลัพธ์ของโปรแกรม:

aaa // 3
  abc
    cbc
      caaa
        aaaaa // 5
          aaabc
            abcbc
              cbcbc
                cbcaaa
                  caaaaaa
                    aaaaaaaa // 8
                      aaaaaabc
                        aaaabcbc
                          aabcbcbc
                            bcbcbcbc
                              bcbcbca
                                bcbcaa
                                  bcaaa
                                    aaaa // 4
                                      aabc
                                        bcbc
                                          bca
                                            aa // 2
                                              bc
                                                a // 1 and halt because we then begin an infinite loop
                                                 HALT

ทัวริงสมบูรณ์

แน่นอนระบบง่าย ๆ นี้อาจดูง่ายเกินไปที่จะเลียนแบบทัวริงสมบูรณ์ แต่ปรากฎว่าเครื่องทัวริงใด ๆ ที่มีสัญลักษณ์ 2 ตัว (คลาสที่มีเครื่องสากล) สามารถแปลงเป็นระบบแท็กที่มี 2 ตัวอักษรที่ถอดออกจากหัว และกฎการผลิต 32 * m ซึ่งmเป็นจำนวนของรัฐในเครื่องทัวริง

เครื่องทัวริงที่เป็นที่รู้จักน้อยที่สุดที่มีเพียง 2 สัญลักษณ์ใช้ 18 สถานะดังนั้นระบบแท็กที่สอดคล้องกันนั้นมีกฎการผลิตที่ใหญ่โต 576 [2]

อย่างไรก็ตามคลาสการคำนวณของชุดของระบบแท็กทั้งหมดที่มี 3 โปรดักชั่นและสัญลักษณ์ที่ถูกลบ 2 รายการถูกเชื่อมโยงกับ Collatz Conjecture [2] หาก Collatz Conjecture ได้รับการพิสูจน์ว่าเป็นเท็จแท็กกิสนั้นจะเป็นทัวริง มิฉะนั้นจะขึ้นอยู่กับปัญหาที่ยังไม่ได้แก้ไขอีกอันในวิชาคณิตศาสตร์หาเครื่องทัวริงที่มีขนาดเล็กกว่า

def taggis(inp, a, b, c):
    current = inp
    seen = set()
    while True:
        seen.add(tuple(current))

        yield current

        head = current[0]

        current = current[2:]

        current.extend([a, b, c][head])

        if tuple(current) in seen:
            return

def parse():
    program = input().split(" ")

    assert len(program) == 3, "There has to be exactly 3 production rules!" 

    productions = []

    for production in program:

        production = [{"a": 0, "b": 1, "c": 2}[x] for x in production]
        productions.append(production)  

    program_input = [{"a": 0, "b": 1, "c": 2}[x] for x in input()]

    k = 0   

    for step in taggis(program_input, *productions):
        print(' ' * k +''.join(['abc'[x] for x in step]))

        k += 2
    print(' ' * (k - 1) + 'HALT')

parse()

1. ซึ่งเทียบเท่ากับฟังก์ชั่น Collatz ดั้งเดิมเนื่องจาก 3n + 1 ของคี่nจะเป็นเลขคู่เสมอดังนั้นจึงสามารถใช้การหารอัตโนมัติ

2. ระบบแท็กและฟังก์ชั่นเหมือน Collatz, Liesbeth De Mol ,