编程实现表1(L的输入-输出模式分布），证实表1的正确性

最新推荐文章于 2024-05-27 14:55:17 发布
最新推荐文章于 2024-05-27 14:55:17 发布
阅读量659 收藏
点赞数 1
分类专栏： 网络与信息安全概论 软件工程师修炼日记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kangyucheng/article/details/78730744
版权 

public class Main4 {
    //定义输入字的长度，根据题意，长度为8，也就是用8个16进制的数来表示一个字
    public static int WORD_STRING_LENGTH=8;
    //一个字占32bit，用32位二进制数来表示
    public static int BIT_LIST_LENGTH=4*WORD_STRING_LENGTH;
    //定义二进制与十进制对应的数组
    public static int PATTERN_LENGTH=16;
    public static String[] bitList={
            "0000","0001","0010","0011",
            "0100","0101","0110","0111",
            "1000","1001","1010","1011",
            "1100","1101","1110","1111"};
    public static String hexList="0123456789abcdef";

    public static void main(String[] args) {
        System.out.println("运行时间达七小时，请耐心等候…………");

        String [][] distribution=new String [PATTERN_LENGTH][PATTERN_LENGTH];
        distribution=getDistribution(PATTERN_LENGTH);
        printResult(distribution);
    }
    /*
    该方法实现线性变换模块。要求：用户输入一个用16进制表示的数字（例如 1a2b3c4d）
    程序输出相应的用16进制表示的字
     */
    private static String getResult(String str){

        int[] B=new int[BIT_LIST_LENGTH];//用于存储输入字转为二进制的数
        int[] LB=new int[BIT_LIST_LENGTH];//用于存储得到的二进制结果
        String LB_16="";//用于存储得到的十六进制结果
        //进行一次循环，将输入的十六进制的数转化为二进制的数
        for(int i=0;i<WORD_STRING_LENGTH;i++){
            int k=Integer.valueOf(str.substring(i,i+1),16);
            for(int j=0;j<4;j++){
                B[4*i+j]=bitList[k].charAt(j)-48;
            }
        }
        //进行线性变换操作
        for(int p=0;p<BIT_LIST_LENGTH;p++){
            LB[p]=B[p]^
                    B[(p+2)%BIT_LIST_LENGTH]^
                    B[(p+10)%BIT_LIST_LENGTH]^
                    B[(p+18)%BIT_LIST_LENGTH]^
                    B[(p+24)%BIT_LIST_LENGTH];
        }
        //将二进制的数转换为十六进制的数
        for(int x=0;x<WORD_STRING_LENGTH;x++){
            String temp="";
            for(int y=0;y<4;y++){
                temp+=LB[x*4+y];
            }
            LB_16+=Integer.toHexString(Integer.parseInt(temp, 2));
        }
        return LB_16;
    }
    /*
    输入两个十进制的数，返回两个十六进制的数组成的字符串
     */
    private static String getTwoHex(int i,int j){
        String str= hexList.substring(i,i+1)+hexList.substring(j,j+1);
        return str;
    }
    /*
    定义了模式函数，输入的是一个字，四个字节，八个十六进制的数，
    每两个十六进制的数为一个字节，如果两个字节的数都为0，则该字节为零
    对输入的四个字节进行判断，如果该字节为0则用一个0定义该字节，
    如果该字节不为0，则用1定义该字节
    例如输入：00001a2b ,则输出为：0011
     */
    private static String pattern(String str){
        String pat="";
        for (int i=0;i<str.length()/2;i++){
            if(str.substring(2*i,2*(i+1)).equals("00")||
                    str.substring(2*i,2*(i+1))=="00"){
                pat+="0";
            }
            else {
                pat+="1";
            }
        }
        return pat;
    }

    private static String[][] getDistribution(int n){
        long sum[]=new long[n+1];
        long count[][]=new long[n+1][n+1];
        String result[][]=new String [n+1][n+1];
        //对每一种情况进行操作，操作时候可以将情况分为4类
        for(int x=1;x<n;x++){
            int item=getItem(x);
            switch (item){
                case 1://只包含一个1的情况
                    for (int i = 0; i <16; i++) {
                        for (int j = 0; j < 16; j++) {
                            if (!(i == 0 && j == 0)){
                                sum[x]++;
                                String twoHex1 = getTwoHex(i, j);
                                String str= "000000" + twoHex1;
                                String pat=pattern(getResult(str));
                                int index=Integer.parseInt(pat, 2);
                                count[x][index]++;
                            }

                        }
                    }
                    break;
                case 2://包含两个1的情况
                    for (int i = 0; i < 16; i++) {
                        for (int j = 0; j < 16; j++) {
                            for (int k = 0; k < 16; k++) {
                                for (int l = 0; l < 16; l++) {
                                    if (!((i == 0 && j == 0) || (l == 0 && k == 0) )) {
                                        sum[x]++;
                                        String twoHex1 = getTwoHex(i, j);
                                        String twoHex2 = getTwoHex(k, l);
                                        String str = "0000" + twoHex1 + twoHex2;
                                        String pat = pattern(getResult(str));
                                        int index = Integer.parseInt(pat, 2);
                                        count[x][index]++;
                                    }
                                }
                            }
                        }
                    }
                    break;
                case 3://包含三个1的情况
                    for (int i = 0; i < 16; i++) {
                        for (int j = 0; j < 16; j++) {
                            for (int k = 0; k < 16; k++) {
                                for (int l = 0; l < 16; l++) {
                                    for (int a = 0; a < 16; a++) {
                                        for (int b = 0; b < 16; b++) {
                                            if (!((i == 0 && j == 0) || (l == 0 && k == 0) || (a == 0 && b == 0))) {
                                                sum[x]++;
                                                String twoHex1 = getTwoHex(i, j);
                                                String twoHex2 = getTwoHex(k, l);
                                                String twoHex3 = getTwoHex(a, b);
                                                String str = "00" + twoHex1 + twoHex2 + twoHex3;
                                                String pat=pattern(getResult(str));
                                                int index=Integer.parseInt(pat, 2);
                                                count[x][index]++;
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    break;
                case 4://包含四个1的情况
                    for (int i = 0; i < 16; i++) {
                        for (int j = 0; j < 16; j++) {
                            for (int k = 0; k < 16; k++) {
                                for (int l = 0; l < 16; l++) {
                                    for (int a = 0; a< 16; a++) {
                                        for (int b = 0; b< 16; b++) {
                                            for (int p = 0; p < 16; p++) {
                                                for (int q = 0; q < 16; q++) {
                                                    if (!((i == 0 && j == 0) || (l == 0 && k == 0) ||
                                                            (a == 0 && b == 0)||(p == 0 && q == 0))){
                                                        sum[x]++;
                                                        String twoHex1 = getTwoHex(i, j);
                                                        String twoHex2 = getTwoHex(k, l);
                                                        String twoHex3 = getTwoHex(a, b);
                                                        String twoHex4 = getTwoHex(p, q);
                                                        String str =  twoHex1 + twoHex2 + twoHex3+ twoHex4;
                                                        String pat=pattern(getResult(str));
                                                        int index=Integer.parseInt(pat, 2);
                                                        count[x][index]++;
                                                    }

                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    break;

            }

        }
        for(int r=0;r<=n;r++){
            for(int s=0;s<=n;s++){
                if(count[r][s]==0){
                    result[r][s]="0";
                }
                else{
                    result[r][s]=String.valueOf(count[r][s]/255)+"/"+sum[r]/255;
                }
            }
        }
        return result;
    }
    /*
    给出十进制的数，判断其四位二进制数中1的个数
     */
    private static int getItem(int x){
        String str=bitList[x];
        int count=0;
        for(int i=0;i<4;i++){
            if(str.charAt(i)=='1'){
                count++;
            }
        }
        return count;
    }

    private static void printResult(String[][] list){
        int[] sequence={0,1,2,4,8,3,5,6,9,10,12,7,11,13,14,15};
        System.out.printf("%-5s"," ");

        for(int i=1;i<list.length-1;i++){
            String str=bitList[sequence[i]];
            System.out.printf("%-20s",str);
        }
        System.out.println();
        for(int r=1;r<list.length-1;r++) {
            System.out.printf("%-5s",bitList[sequence[r]]);
            for (int s = 1; s < list.length-1; s++) {
                String str=list[sequence[r]][sequence[s]];
                System.out.printf("%-20s",str);
            }
            System.out.println();
        }
    }

}


经过A8处理器七个半小时的运行结果如图：




康雨城
关注
专栏目录
程序员修炼之路-(1)基础(下)：正确性证明
weixin_30877755的博客
03-31 483
来自《Writing Solid Code》的一则小故事，Donald Knuth在其著名的排版软件TEX的封面上写到：“I believe that the final bug in TEX was discovered and removed on November 27, 1985. But if, somehow, an error still lurks in the code, I...
32位与64位编程注意事项总结
benpaobagzb的博客
02-22 4万+
http://www.oschina.net/p/flowvisor   http://www.cnblogs.com/centimeter/articles/2395405.html   http://www.360doc.com/content/13/0520/21/7662927_286868466.shtml   http://zhidao.baidu.com/link?url
编程实现绘制表格
徐凤竹 程序人生
05-03 5519
之前只知道word等文本工具可以绘图，但只是知其然不知其所以然。下面就粗略的讲一下它的原理。首先我们要了解的是表格的绘制都是有一些制表符构成的，那么下面就简单了，我们只要知道光标是如何判断怎么来显示这些制表符的。下面是一张光标向左时要执行的逻辑判断表，以及各种制表符的ascii码值就好了，我们就可以通过编程逻辑判断，来让活动窗体按照自己的意愿绘制表格了。   光标向左时要执行的逻辑判断表
C语言中在常数后面加U、L、F的功能（转）
征心的博客
08-01 1万+
一、含义解释 U：unsigned L：long / double F：float 二、例子 #define SECONDS_PER_YEAR (365*24*60*60)UL #define PI 3.1415F #define TEST_L 100000.6283L 三、例子解释 1、C语言中，常数分为整型和浮点型。 2、...
UNIX环境高级编程（第2版）- 第1～10章
wdt3385的专栏
11-16 3905
UNIX环境高级编程（第2版）- 第1～10章 http://blog.csdn.net/yourtommy/article/details/7244660 这篇博客是我看英文版原书时，翻译成中文，并测试了书中的代码。纯粹是为了加深理解和记忆。真正想学习的，还是阅读原书（资源包含中、英文版以及相关原码）： UNIX环境高级编程第二版 第一章 UNIX系统总览 1.1
游戏编程中的人工智能技术--神经网络
wolf96的专栏
09-26 7418
原文： 游戏编程中的人工智能技术 . 神经网络入门> .  (连载之一) 用平常语言介绍神经网络 (Neural Networks in Plain English) 因为我们没有很好了解大脑，我们经常试图用最新的技术作为一种模型来解释它。在我童年的时候，我们都坚信大脑是一部电话交换机。(否则它还能是什么呢？)我当时还看到英国著名神经学家谢林顿把
BAT机器学习面试1000题系列（第1~305题）
热门推荐
结构之法 算法之道
09-28 51万+
BAT机器学习面试1000题系列 整理：July、元超、立娜、德伟、贾茹、王剑、AntZ、孟莹等众人。本系列大部分题目来源于公开网络，取之分享，用之分享，且在撰写答案过程中若引用他人解析则必注明原作者及来源链接。另，不少答案得到寒小阳、管博士、张雨石、王赟、褚博士等七月在线名师审校。 说明：本系列作为国内首个AI题库，首发于七月在线实验室公众号上：julyedulab，并部分更新...
Google C++编程风格指南1
diaoqu4574的博客
10-06 168
Google C++编程风格指南（一）：头文件 【本文】 Google C++编程风格指南（二）：作用域 Google C++编程风格指南（三）：C++ 类 Google C++编程风格指南（四）：智能指针和其他C++特性 Google C++编程风格指南（五）：命名约定 Google C++编程风格指南（六）：代码注释 Google C++编程风格指...
神经网络入门(连载1-6)
李乾文的博客
08-14 6360
神经网络入门> .  (连载之一) 用平常语言介绍神经网络 (Neural Networks in Plain English) 因为我们没有很好了解大脑，我们经常试图用最新的技术作为一种模型来解释它。在我童年的时候，我们都坚信大脑是一部电话交换机。(否则它还能是什么呢？)我当时还看到英国著名神经学家谢林顿把大脑的工
物联网网络中可解释的深度学习入侵检测An explainable deep learning-enabled intrusion detection framework in IoT networks
最新发布
风口IT猪的成长录
05-27 112
尽管可解释人工智能(XAI)领域近来备受关注，但其在网络安全应用中的实现仍需要进一步研究，以了解其在发现攻击面和向量方面的有效性。在网络防御中，特别是基于异常的入侵检测系统(IDS)，。本文提出了一种新颖的可解释的物联网（IoT）网络入侵检测框架。我们开发了一种 IDS，使用短期长记忆 (LSTM) 模型来识别网络攻击并解释模型的决策。
内存高效的迁移学习：Rep-Net特征重编程
12277Rep-Net：通过特征重编程实现李阳、阿德南·西拉吉·拉金、范德良电气，计算机和能源工程学院，亚利桑那州立大学，坦佩，AZ 85287网址：lyang166@asu.edu，asrakin@asu.edu，网址：www.example.com，dfan@asu....
量子数据：简单类型λ演算的博弈语义和量子编程的可靠性结果
理论计算机科学电子笔记270（1）（2011）41-57www.elsevier.com/locate/entcs量子数据Yannick ...给出了语义的可靠性结果关键词：游戏语义，量子编程语言，量子游戏。1引言高阶量子编程语言开发中的一个重要问题是找到
点云模型的验证和鲁棒性证明方法——3DCertify
7608点云模型TobiasLorenz*1，AnianRuoss2，Misla vBalunovic´2，Gag andeepSingh3，MartinVechev21CISPA亥姆霍兹信息安全中心2苏黎世联邦理工学院计算机科学系3伊利诺伊大学厄巴纳-香槟分校和VMware ...
掩码对应表
康雨城
09-16 9万+
在开发的过程中，掩码可以用类似255.255.255.0等方法来表示，换算为二进制就是11111111.11111111.11111111.00000000。用数字表示就是/24，代表其中有24个1。
华为鸿蒙系统初探之HUAWEI DevEco Studio Hello World
康雨城
09-17 5万+
2020年9月10日，华为鸿蒙系统升级至华为鸿蒙系统2.0版本.本文探索一下其推出的IDE
python用辗转相除法求最大公约数
康雨城
01-18 5万+
辗转相除法：（1）比较两数，并使m>n（2）将m作被除数，n做除数，相除后余数为r（3）循环判断r，若r==0，则n为最大公约数，结束循环。若r ！=0 ，执行m=n，n=r；将m作被除数，n做除数，相除后余数为r运行代码如下：num1 = int(input("请输入第一个数字：")) num2 = int(input("请输入第一个数字：")) m = max(num1, num2) n =
python开源聊天机器人ChatterBot——聊天机器人搭建、流程分析、源码分析
康雨城
09-23 2万+
ChatterBot是一个Python库，可以轻松生成对用户输入的自动响应。ChatterBot使用一系列机器学习算法来产生不同类型的响应。这使开发人员可以轻松创建聊天机器人并自动与用户进行对话。本文通过阅读chatterBot官方文档，以及阅读源代码，分析出ChatterBot的结构，画出类图。并成功在本地进行实验测试。
LL(1)语法分析：表达式文法实现与解析
实验结果的分析不仅关注正确性，还要考虑分析过程中是否遵循了LL(1)分析的原理，如是否有效消除了左递归，是否正确构建了分析表，以及分析过程是否顺利无误。 通过这次实验，学生不仅能掌握LL(1)分析的基本原理，还...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

康雨城

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值