模拟图灵机（XN×2）

最新推荐文章于 2021-04-14 19:20:49 发布
最新推荐文章于 2021-04-14 19:20:49 发布
阅读量2.6k 收藏
点赞数 2
分类专栏： 项目练手
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MTYSYS19990212/article/details/115417694
版权

文章目录

前言

按照XN×2图灵机的规则进行算法设计，流程按照自顶向下一步走完的。

一、算法分析

（1）规则转换。
接收一个十进制数的输入，转换为二进制数在末尾添加一个‘,’号，按照0->0、1->01、,->110的规则进行数据转换。

（2）指令计算。
按照XN×2图灵机：0 0->0 0 R、0 1->1 0 R、1 0->0 1 R、1 1->11 0 R、10 0->11 1 R、11 0->0 1 STOP的指令规则在经过转换的数据上进行移动，输出已经转换成功的数据。

（3）结果输出。
按照第一步的规则对数据进行逆转换为二进制数，再转换为十进制数进行返回输出。

二、概要设计

结构设计

Coding类，包含4个成员变量，1个字典用于定义规则、2个列表用于存储二进制数据和规则转换之后的数据、1个字符串变量返回给下一层函数处理；4个成员函数，Coding（）用于数据的初始化、hex2（）将数据转换为二进制并在末尾添加‘,’、encoding（）按照规则对数据进行转换、cleardata（）重定义数据。 
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Predicate;

/**
 * @Classname Coding
 * @Description 将十进制数转化为编码后的数据
 * @Date 2021/4/2 11:26
 * @Created 30500
 */
public class Coding {
    private Map<String, String> rule;
    private List<String> coding;
    private List<String> hexNumber;
    private String strCode;
    /*
     * @Description //初始化内部成员 并对编码规则进行确定
     * @author 30500
     * @date 2021/4/2 11:40
     * @param []
     * @return
     */
    public Coding() {
        this.coding = new ArrayList<String>();
        this.hexNumber = new ArrayList<String>();
        this.strCode = "";
        this.rule = new HashMap<>();
        this.rule.put("0", "0");
        this.rule.put("1", "10");
        this.rule.put(",", "110");
    }
    /*
     * @Description //将十进制数转换为二进制数并在末尾添加’,‘
     * @author 30500
     * @date 2021/4/2 11:59
     * @param [str]
     * @return java.util.List<java.lang.String>
     */
    public List<String> hex2(Integer str){
        String temp = Integer.toBinaryString(str);
        for (int i = 0; i < temp.length(); i++) {
            this.hexNumber.add(String.valueOf(temp.charAt(i)));
        }
        this.hexNumber.add(",");
        return this.hexNumber;
    }
    /*
     * @Description //将数据进行编码转换
     * @author 30500
     * @date 2021/4/2 12:35
     * @param []
     * @return java.lang.String
     */
    public String encoding(){
        for (String str : this.hexNumber){
            this.coding.add(this.rule.get(str));
            this.strCode +=this.rule.get(str);
        }
        return this.strCode;
    }
    public void cleardata(){
        this.strCode = "";
        this.hexNumber.clear();
        this.coding.clear();
    }
}
TuringMachine类，包含6个成员变量，分别表示进行运算的数据、转换之后的二进制数据、图灵机的状态值、图灵机的输入值、索引的偏差、是否结束的标志；4个成员函数，TURingMachine（）用于初始化图灵机、setCode（）用于测试时对图灵机内部变量进行重新复制、getTURingMachine（）用于进行指令计算、conversionResult（）用于将计算后的指令再转换为十进制数据。 
/**
 * @Classname TuringMachine
 * @Description 进行XN*2运算
 * @Date 2021/4/2 12:22
 * @Created 30500
 */
public class TuringMachine {
    private StringBuilder code;
    private String BinaryCode;
    private String state;
    private String input;
    private Integer index;
    private boolean flag;
    /*
     * @Description //构造函数
     * @author 30500
     * @date 2021/4/2 20:43
     * @param [code, state, input, output]
     * @return
     */
    public TuringMachine(String code){
        this.code = new StringBuilder(code);
        this.BinaryCode = "";
        this.state = "0";
        this.input = "";
        this.index = 0;
        this.flag = true;
    }
    public void setCode(String code){
        this.code = new StringBuilder(code);
        this.BinaryCode = "";
        this.state = "0";
        this.input = "";
        this.index = 0;
        this.flag = true;
    }
    /*
     * @Description //进行XN*2预算 并返回运算结果
     * @author 30500
     * @date 2021/4/2 21:12
     * @param []
     * @return java.lang.StringBuilder
     */
    public StringBuilder getTuringMachine(){
        while (this.flag){
            this.input = String.valueOf(this.code.charAt(this.index));
            if(this.state.equals("0") && this.input.equals("0")){
                this.state = "0";
                this.code.setCharAt(this.index, '0');
                this.index++;
            }
            else if(this.state.equals("0") && this.input.equals("1")){
                this.state = "1";
                this.code.setCharAt(this.index, '0');
                this.index++;
            }
            else if(this.state.equals("1") && this.input.equals("0")){
                this.state = "0";
                this.code.setCharAt(this.index, '1');
                this.index++;
            }
            else if(this.state.equals("1") && this.input.equals("1")){
                this.state = "10";
                this.code.setCharAt(this.index, '0');
                this.index++;
            }
            else if(this.state.equals("10") && this.input.equals("0")){
                this.state = "11";
                this.code.setCharAt(this.index, '1');
                this.index++;
            }
            else if(this.state.equals("11") && this.input.equals("0")){
                this.state = "0";
                this.code.setCharAt(this.index, '1');
                this.index++;
                this.flag = false;
            }
            if(this.index >= this.code.length()){
                this.code.append("0");
            }
        }
        return this.code;
    }
    /*
     * @Description //将结果转换为十进制输出
     * @author 30500
     * @date 2021/4/3 14:13
     * @param []
     * @return java.lang.Integer
     */
    public Integer conversionResult(){
        this.index = 0;
        while (!this.flag){
            if(this.code.charAt(this.index) == '0'){
                this.BinaryCode += "0";
                this.index++;
            }
            else if(this.code.charAt(this.index) == '1' && this.code.charAt(this.index + 1) == '0'){
                this.BinaryCode += "1";
                this.index += 2;
            }
            else if(this.code.charAt(this.index) == '1' && this.code.charAt(this.index + 1) == '1') {
                this.flag = true;
            }
        }
        Integer num = Integer.parseInt(this.BinaryCode, 2);
        return num;
    }
}
Test类，只有一个静态函数入口，用于整个算法的功能测试，并将测试结果以txt文件的格式进行保存输出。 
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.util.ArrayList;
import java.util.List;

/**
 * @Classname Test
 * @Description 测试各个模块函数的正确性
 * @Date 2021/4/3 14:18
 * @Created 30500
 */
public class Test {
    public static void main(String[] args) {
        Coding demo = new Coding();                                                                 //创建编码对象
        TuringMachine turingMachine = new TuringMachine("");                                  //创建图灵机
        List<String> packet = new ArrayList<>();                                                    //存储100次的返回结果
        String temp;                                                                                //临时变量接收模块的返回值
        for (int i = 0; i < 100; i++) {                                                             //循环测试
            temp = "";
            demo.hex2(i);
            String original = demo.encoding();
            turingMachine.setCode(original);
            String change = turingMachine.getTuringMachine().toString();
            Integer result = turingMachine.conversionResult();
            temp = i + "----->" + original + "----->" + change + "----->" + result;                 //--->表示数据间的递进关系
            packet.add(temp);
            demo.cleardata();
        }
        try{
            BufferedWriter br = new BufferedWriter(new FileWriter("src/result.txt"));       //数据保存在本地
            for(int i = 0;i< packet.size();i++){
                br.write(packet.get(i)+"\n");
            }
            br.close();
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}
App类，主函数的入口类，整个程序由此开始进入。 
/**
 * @Classname App
 * @Description 程序入口类
 * @Date 2021/4/2 12:07
 * @Created 30500
 */
public class App {
    public static void main(String[] args) {
        Coding demo = new Coding();
        demo.hex2(1);
        String str = demo.encoding();
        TuringMachine turingMachine = new TuringMachine(str);
        turingMachine.getTuringMachine();
        Integer result = turingMachine.conversionResult();
        System.out.println(result);
    }
}

三、测试

分别对算法的三大功能模块进行测试，测试用例为0-99总计一百个正整数，将每个模块的记录值都返回并存储在本地的result.txt文件中，由一个for循环进行控制； 结果的验证则是由人工随机挑选数据进行计算后进行对比，还有一个重要指标就是最终的返回结果是否是输入数据的两倍计算量。 
0----->0110----->000110----->0
1----->10110----->0100110----->2
2----->100110----->01000110----->4
3----->1010110----->010100110----->6
4----->1000110----->010000110----->8
5----->10010110----->0100100110----->10
6----->10100110----->0101000110----->12
7----->101010110----->01010100110----->14
8----->10000110----->0100000110----->16
9----->100010110----->01000100110----->18
10----->100100110----->01001000110----->20
11----->1001010110----->010010100110----->22
12----->101000110----->01010000110----->24
13----->1010010110----->010100100110----->26
14----->1010100110----->010101000110----->28
15----->10101010110----->0101010100110----->30
16----->100000110----->01000000110----->32
17----->1000010110----->010000100110----->34
18----->1000100110----->010001000110----->36
19----->10001010110----->0100010100110----->38
20----->1001000110----->010010000110----->40
21----->10010010110----->0100100100110----->42
22----->10010100110----->0100101000110----->44
23----->100101010110----->01001010100110----->46
24----->1010000110----->010100000110----->48
25----->10100010110----->0101000100110----->50
26----->10100100110----->0101001000110----->52
27----->101001010110----->01010010100110----->54
28----->10101000110----->0101010000110----->56
29----->101010010110----->01010100100110----->58
30----->101010100110----->01010101000110----->60

总结

对算法设计时更一步的加深了对图灵机XN×2的指令运转的理解，熟悉其中的每一个计算步骤，了解每个数据的含义；在进行代码调试时花费较多的时间进行流程追踪，确保了程序按照预期的算法流程进行动作。

beordie.cloud
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
图灵机（XN×2）
qq_43165874的博客
03-30 1082
图灵机 一．实验目的 1.掌握图灵机的概念和基本结构，理解图灵机的基本指令和编码方式； 2.掌握图灵机的编程方法。 二．实验内容 对于任意给定的一台Turing机和任意给定的字符串w ( w不含空格)，编程模拟此Turing机的运行过程，要求输出从开始运行起的每一步骤的结果。 三．题目分析 根据如下指令给出图灵机（XN×2）在扩展的二进位上实现这个运算的指令： 00→00R， 01→10R， 10...
模拟图灵机XN*2
galaxyku的博客
04-11 229
模拟图灵机XN*2 题目 对于XN+1或XN*2图灵机进行模拟，任意给定的十进制数a，转换为收缩扩展二进制的编码，再编程模拟此Turing机的运行过程，要求输出从开始运行起的每一步骤的结果。 用C或C++或java或python语言实现程序解决问题。 1. 算法分析 首先要将输入的数先转化成二进制（用库函数可以实现），再将二进制数转换成磁带上二进制扩展码（需要自己写一个函数）。 第二要清楚图灵机XN*2的指令集，以及如何转换 0 0→0 0R 0 1→1 0R 1 0→0 1R 1 1→10 0R 10 0
模拟图灵机运算
qq_42658393的博客
06-23 758
一．实验目的 1.掌握图灵机的概念和基本结构，理解图灵机的基本指令和编码方式； 2.掌握图灵机的编程方法。 二．实验内容 对于任意给定的一台Turing机和任意给定的字符串w ( w不含空格)，编程模拟此Turing机的运行过程，要求输出从开始运行起的每一步骤的结果。 三．算法构造 1.将输入的十进制数转为二进制串 2.将二进制串转化为图灵机可识别的数字串（判断两0之间几个1而得出的字符串其实就...
模拟图灵机XN×2
泥煤少年的博客
04-12 270
1.算法分析 （1）将十进制数转换为二进制数 接收一个十进制数的输入，转换为二进制数在末尾添加一个‘,’号，按照规则进行数据转换。 编码转换规则：0→0；1→10；, →110; （2）将二进制数转换为收缩扩展二进制的编码 处理方法： 内态为0，输入为0→内态为0，输出为0，右移； 内态为0，输入为1→内态为1，输出为0，右移； 内态为1，输入为0→内态为0，输出为1，右移； 内态为1，输入为1→内态为10，输出为0，右移； 内态为...
图灵机XN*2
jinyiY的博客
03-31 670
一、题目分析 模拟图灵机，对于任意给定的一台Turing机和任意给定的字符串w ( w不含空格)，编程模拟此Turing机的运行过程，要求输出从开始运行起的每一步骤的结果此报告是运用图灵机的基本指令和编程方法实现XN2。 二、算法构造 1.算法理解： 图灵机在扩展二进制位实现（XN2）的运算指令： 00→00R, 01→10R, 10→01R, 11→100R, 100→111R, 110→01S...
模拟图灵机（XNx2）
清举的博客
03-22 1015
一.实验题目 模拟图灵机（XN×2）的运行过程 二．实验内容 对于任意给定的一台Turing机和任意给定的字符串w ( w不含空格)，编程模拟此Turing机的运行过程，要求输出从开始运行起的每一步骤的结果。 三．算法构造 1.根据提示输入一个十进制整数 2.将十进制数转换成二进制数 a.定义一个数组来存储转换结果 b.循环将整数进行除2取余数，余数存储到数组中。 c.当整数整除为0时，结束循环 ...
##模拟图灵机 XN*2的运算
mql6767521的博客
04-14 404
##模拟图灵机 XN*2的运算（文末源代码） 题目要求： 对XN*2图灵机进行模拟，任意给定的十进制数a，转换为收缩扩展二进制的编码，再编程模拟此Turing机的运行过程，要求输出从开始运行起的每一步骤的结果。 用C或C++或java或python语言实现程序解决问题。 1.程序风格良好(使用自定义注释模板) 2.提供友好的输入输出，并进行输入数据的正确性验证。 2.算法分析 对XN2图灵机进行模拟，给定一个任意的十进制数，首先应该将十进制数用二进制表示出来，将二进制数转换为收缩扩展二进制的编码；根
Java语言实现：模拟图灵机 XN*2
qq_55671711的博客
04-12 212
模拟图灵机 XN*2题目1. 算法分析(1)图灵机XN*2在扩展二进位上实现运算指令为：(2)2.1输入一个整数，通过String c=transform(a)将其转化为二进制编码并存入c中。2.概要设计3.源代码4.测试5.调试6.心得体会 题目 对于XN+1或XN*2图灵机进行模拟，任意给定的十进制数a，转换为收缩扩展二进制的编码，再编程模拟此Turing机的运行过程，要求输出从开始运行起的每一步骤的结果。 1. 算法分析 (1)图灵机XN*2在扩展二进位上实现运算指令为： 0 0->0 0 R
图灵机XN*2的实现
m0_54068753的博客
04-14 450
图灵机XN*2的实现@TOC 内容: 步骤： 算法分析 图灵机主要是十进制数转化为二进制数，在拓展二进制数，再通过“规则”进行实现XN*2 (1).设计函数change（）将输入的字符串转化为二进制字符串 public class text{ public static String change(int x) { //String data1 = String.valueOf(data) String n=Integer.toBinaryString(x); //将数值x转换为二进制字符串
模拟图灵机----XN*2
STAR
03-22 403
一、题目分析 1.题目要求：输入一个数，通过模拟图灵机程序，输出它的二倍 2.图灵机指令：XN*2 0 0 —> 0 0 R 0 1 —> 1 0 R 1 0 —> 0 1 R 1 1 —> 10 0 R 10 0 —> 11 1 R 11 0 —> 0 1 STOP 3.数据转换处理 例如：输入3 (1)转换为二进制数：11 (2)转化二进制数：011， (...
图灵机XN*2进行模拟
qq_54275829的博客
04-13 267
图灵机XN*2进行模拟 基本要求： 对于XN*2图灵机进行模拟，任意给定的十进制数a，转换为收缩扩展二进制的编码，再编程模拟此Turing机的运行过程，要求输出从开始运行起的每一步骤的结果。 算法分析 （1）二进制编码转换。 接收一个十进制数的输入，转换为二进制数，按照0->0、1->01的规则进行数据替换，最后在末尾添加一个‘110’。 （2）图灵机XN*2指令计算： 0 0 ->0 0 R, 0 1 ->1 0 R, 1 0 ->0 1 R, 1 1 ->10 0
Java实现XN*2图灵机的模拟
m0_48733520的博客
04-10 445
题目描述： 对于XN*2图灵机进行模拟，任意给定的十进制数，转换为收缩扩展二进制的编码，再编程模拟此Turing机的运行过程，要求输出从开始运行起的每一步骤的结果。用C或C++或Java或Python语言实现程序解决问题。 要求：1. 程序风格良好（使用自定义注释模板）； 2. 提供友好的输入输出，并进行输入数据的正确性验证。 算法分析： 1. 将十进制数转换为二进制数； 2. 将二进制数转换为收缩...
Java实现图灵机XNx2
MR_GXF的博客
03-23 1164
题目要求 程序实现图灵机XNx2的功能。 1.程序风格良好(使用自定义注释模板) 2.提供友好的输入输出，并进行输入数据的正确性验证。 语言环境： eclipse java 算法设计 程序代码 Number类 import java.util.Scanner; //Number类用来存放用户输入的数，以及二进制数和二进制编码的转换。 class Number { private int...
模拟图灵机
qq_56360710的博客
04-12 280
模拟图灵机 对于XN+1或XN*2图灵机进行模拟 一、内容: 对于XN+1或XN*2图灵机进行模拟，任意给定的十进制数a，转换为收缩扩展二进制的编码，再编程模拟此Turing机的运行过程，要求输出从开始运行起的每一步骤的结果。 二、步骤： 1.算法分析： （1）XN*2的转换规则00->00R 01->10R 10->01R 11->100R 100->111R 110->01STOP左边加粗的表示纸带上此时的数，右边加粗的表示将现在的数改成这个数。左边未加粗的
模拟图灵机运行过程，实现XN*2
c2607119981的博客
03-22 1409
一，题目分析： 模拟图灵机的运算过程，运用图灵机的基本指令和编码方式实现XN*2。 二，算法构造： 图灵机在扩展二进制位实现（XN*2）的运算指令： 00→00R, 01→10R, 10→01R, 11→100R, 100→111R, 110→01STOP。 算法思路： 1，输入一个十进制，将十进制转化成二进制； 2，将二进制转化成图灵机扩展的二进制编码； 3，通过图灵机...
模拟图灵机XN乘2的过程
Java—wang的博客
04-01 492
一、问题描述 JAVA实现模拟图灵机实现自然数乘2的过程。 二、算法构造 编码规则： 0→0； 1→10； , →110; 处理方法： 内态为0，输入为0→内态为0，输出为0，右移； 内态为0，输入为1→内态为1，输出为0，右移； 内态为1，输入为0→内态为0，输出为1，右移； 内态为1，输入为1→内态为10，输出为0，右移； 内态为10，输入为0→内态为11，输出为1，右移； 内态为11，输入为0→内态为0，输出为1，STOP； 三、流程设计 四、算法实现 TuLing类 /** * @a
C语言实现图灵机（XN*2）运算过程。
qq_42504734的博客
03-22 2562
程序设计上机作业 题目：C语言实现图灵机（XN*2）运算过程。 要求：输入十进制数，转换成图灵机进行运算的二进制形式，然后根据语句命令进行运算，输出每一步的运算结果，最终输出计算结果（十进制）。 分析： （1）首先将十进制数转换成二进制数保存在数组b[]中 （2）然后将二进制数转换成图灵机进行运算的二进制数，保存在数组c[]中 （3）通过命令进行运算后输出得到的图灵机二进制 （4）然...
java实现图灵机模型（XN*2）
包包的博客
03-17 1171
一、算法介绍 Java实现XN2,该图灵机模型指令如下* &amp;amp;nbsp; &amp;amp;nbsp; &amp;amp;nbsp;(其中未加粗正体的是当前内态，斜体加粗为输入态，R代表右移，STOP代表停止) 1. 0 ***0*** --&amp;amp;gt; 0 ***0***，R 2. 0 ***1*** --&amp;amp;gt; 1 ***0***，R 3. 1 ***0*** --&amp;amp;gt;
图灵机与计算理论：模拟与停机问题解析
"本文主要介绍了什么是模拟，以及与图灵机和计算问题的相关知识。文章首先通过生活中的例子解释模拟的概念，即通过建立对应关系复制另一事物的行为。接着，文章探讨了图灵机，它是计算理论的基础，用小虫的比喻帮助...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值