java实现吸血鬼数字的三个想法（附官方答案）

最新推荐文章于 2024-04-18 09:39:19 发布
最新推荐文章于 2024-04-18 09:39:19 发布
阅读量564 收藏
点赞数 1
分类专栏： java 文章标签： java 吸血鬼数字 算法优化 优化
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013560932/article/details/52317784
版权

自己写了一种方法，优化过后还可以，不过取巧。网上找了两种方法，从运行时间上来看比自己的方法慢
官方的一种方法，运行时间简直快到不可思议，真没法了。
1、第一个方法（我自己写的）
从四位数入手,大量if语句，都是复制粘贴的
我自己写的方法
2、第二个方法（网上的）
从2位数入手，但缺点是需要引入java.util.Arrays
网上的
3、第三个方法（网上的）
突然发现和第二个好像一样？？但是要慢很多
网上的
4、第四个方法（官方的答案）
简直快到无解，找到了一个新的数学关系来优化！！
官方的
代码如下：

package com.thinkinjava.vampire;
import java.util.Arrays;
public class VampireNumber {
private static void showfournum1()
    {
        String string="";
        int a1,a2,a3,a4;
        int x1=0,x2=0;
        char[] ch=new char[5];
        for (int i=1260;i<=6880;i++)
        {
            if (i % 100 ==0)continue;
            string=Integer.toString(i);
            ch=string.toCharArray();
            a1=((int)(ch[0])-48);
            a2=((int)(ch[1])-48);
            a3=((int)(ch[2])-48);
            a4=((int)(ch[3])-48);
            if (a1!=0&&a3!=0)
            {
            x1=a1*10+a2;
            x2=a3*10+a4;
            if (x1*x2==i){System.out.println(i+" =  "+x1+"*"+x2);continue;}
            x1=a1*10+a4;
            x2=a3*10+a2;
            if (x1*x2==i){System.out.println(i+" =  "+x1+"*"+x2);continue;}
            }
            if (a1!=0&&a2!=0)
            {
                x1=a1*10+a3;
                x2=a2*10+a4;
                if (x1*x2==i){System.out.println(i+" =  "+x1+"*"+x2);continue;}
                x1=a1*10+a4;
                x2=a2*10+a3;
                if (x1*x2==i){System.out.println(i+" =  "+x1+"*"+x2);continue;}
            }
            if (a1!=0&&a4!=0)
            {
                x1=a1*10+a2;
                x2=a4*10+a3;
                if (x1*x2==i){System.out.println(i+" =  "+x1+"*"+x2);continue;}
                x1=a1*10+a3;
                x2=a4*10+a2;
                if (x1*x2==i){System.out.println(i+" =  "+x1+"*"+x2);continue;}             
            }


            if (a2!=0&&a3!=0)
            {
                x1=a2*10+a4;
                x2=a3*10+a1;
                if (x1*x2==i){System.out.println(i+" =  "+x1+"*"+x2);continue;}
                x1=a2*10+a1;
                x2=a3*10+a4;
                if (x1*x2==i){System.out.println(i+" =  "+x1+"*"+x2);continue;}             
            }
            if (a2!=0&&a4!=0)
            {
                x1=a2*10+a3;
                x2=a4*10+a1;
                if (x1*x2==i){System.out.println(i+" =  "+x1+"*"+x2);continue;}
                x1=a2*10+a1;
                x2=a4*10+a3;
                if (x1*x2==i){System.out.println(i+" =  "+x1+"*"+x2);continue;}             
            }
            if (a3!=0&&a4!=0)
            {
                x1=a3*10+a2;
                x2=a4*10+a1;
                if (x1*x2==i){System.out.println(i+" =  "+x1+"*"+x2);continue;}
                x1=a3*10+a1;
                x2=a4*10+a2;
                if (x1*x2==i){System.out.println(i+" =  "+x1+"*"+x2);continue;}             
            }

            }
    }
private static void showfournum2()
{
     String[] ar_str1, ar_str2;  
        int sum = 0;  
        int from;  
        int to;  
        int i_val; 
        // 双重循环穷举  
        for (int i = 10; i < 100; i++) {  
          // j=i+1避免重复  
          from = Math.max(1000 / i, i + 1);  
          to = Math.min(10000 / i, 100);  
          for (int j = from; j < to; j++) {  
            i_val = i * j;   
            if (i_val % 100 == 0 || (i_val - i - j) % 9 != 0) {  
              continue;  
            }   
            ar_str1 = String.valueOf(i_val).split("");  
            ar_str2 = (String.valueOf(i) + String.valueOf(j)).split("");  
            Arrays.sort(ar_str1);  
            Arrays.sort(ar_str2);  
            if (Arrays.equals(ar_str1, ar_str2)) {// 排序后比较,为真则找到一组  
              sum++;  
              System.out.println("第" + sum + "组: " + i + "*" + j + "=" + i_val);  
            }  
          }  
        }  
        System.out.println("共找到" + sum + "组吸血鬼数");  
}
private static void showfournum3() { //  
        for (int i = 11; i < 100; i++) {  
            for (int j = i; j < 100; j++) {  
                int k = i * j;  
                String kStr = Integer.toString(k);  
                String checkStr = Integer.toString(i) + Integer.toString(j);  
                if (kStr.length() != 4)  
                    continue;  
                char[] kChar = kStr.toCharArray();  
                char[] checkChar = checkStr.toCharArray();  
                Arrays.sort(kChar);  
                Arrays.sort(checkChar);  
                boolean isVampire = Arrays.equals(kChar, checkChar);  
                if (isVampire) {  
                    System.out.println(i + " * " + j + " = " + k);  
                }  
            }  
        }  
    }  
private static void showfournum4() { // 官方参考答案  

    int[] startDigit = new int[4];  
    int[] productDigit = new int[4];  
    for (int num1 = 10; num1 <= 99; num1++)  
        for (int num2 = num1; num2 <= 99; num2++) {  
            // Pete Hartley's theoretical result:  
            // If x·y is a vampire number then  
            // x·y == x+y (mod 9)  
            if ((num1 * num2) % 9 != (num1 + num2) % 9)  
                continue;  
            int product = num1 * num2;  
            startDigit[0] = num1 / 10;  
            startDigit[1] = num1 % 10;  
            startDigit[2] = num2 / 10;  
            startDigit[3] = num2 % 10;  
            productDigit[0] = product / 1000;  
            productDigit[1] = (product % 1000) / 100;  
            productDigit[2] = product % 1000 % 100 / 10;  
            productDigit[3] = product % 1000 % 100 % 10;  
            int count = 0;  
            for (int x = 0; x < 4; x++)  
                for (int y = 0; y < 4; y++) {  
                    if (productDigit[x] == startDigit[y]) {  
                        count++;  
                        productDigit[x] = -1;  
                        startDigit[y] = -2;  
                        if (count == 4)  
                            System.out.println(num1 + " * " + num2 + " : "  
                                    + product);  
                    }  
                }  

        } /* 
           * Output: 15 * 93 : 1395 21 * 60 : 1260 21 * 87 : 1827 27 * 81 : 
           * 2187 30 * 51 : 1530 35 * 41 : 1435 80 * 86 : 6880 
           *///:~  
}  

public static void main(String[] args) {
        long start=System.currentTimeMillis();  
          // VampireNumber.showfournum1();  
          // VampireNumber.showfournum2();  
          // VampireNumber.showfournum3();
           VampireNumber.showfournum4();
        long time=System.currentTimeMillis()-start;
        System.out.println("耗时"+time+"毫秒");

    }
}

官方答案解析：

官方的答案从两位数入手
首先剔除了((num1 * num2) % 9 != (num1 + num2) % 9)
因为假设吸血鬼数字
num=a*1000+b*100+c*10+d=(a*10+b)*(c*10+d);
num1=(a*10+b);
num2=(c*10+d);
num-num1-num2=a*990+b*99=9*(a*110+b*11)
这个数可以被9整除，也就是说吸血鬼数字被9除的余数和两个基数的和被9除的余数相等。
所以不符合这个条件的都被剔除
然后这一段

 int product = num1 * num2;  
            startDigit[0] = num1 / 10;  
            startDigit[1] = num1 % 10;  
            startDigit[2] = num2 / 10;  
            startDigit[3] = num2 % 10;  
            productDigit[0] = product / 1000;  
            productDigit[1] = (product % 1000) / 100;  
            productDigit[2] = product % 1000 % 100 / 10;  
            productDigit[3] = product % 1000 % 100 % 10;

巧妙地利用float到int的隐式转换得到了两基数的各个单个数字和两基数乘积的单个数字，放在两个数组里
然后

  for (int x = 0; x < 4; x++)  
                for (int y = 0; y < 4; y++) {  
                    if (productDigit[x] == startDigit[y]) {  
                        count++;  
                        productDigit[x] = -1;  
                        startDigit[y] = -2;  
                        if (count == 4)  
                            System.out.println(num1 + " * " + num2 + " : "  
                                    + product);  
                    }  
                }

双层循环对比数组，如果全部相同（这里指两个集合相同，不管数组索引，所以需要16次比较），则符合条件。

分析下来，官方的答案主要是巧妙地利用隐式转换得到各个位数从而节省了大量时间
我的方法是把四位数变成字符串，在变成char数组，然后取到各个位数，这样调用Integer.toString()和toCharArray()就浪费了大量时间
如果把我的

string=Integer.toString(i);
            ch=string.toCharArray();
            a1=((int)(ch[0])-48);
            a2=((int)(ch[1])-48);
            a3=((int)(ch[2])-48);
            a4=((int)(ch[3])-48);

改成

            a1=i /1000;
            a2=i %1000 /100;
            a3=i %1000 %100/10;
            a4=i%1000%100%10;

这样消耗的时间也是0毫秒，但是还是需要在循环次数上取巧。就是第一次运算，知道范围之后限定循环范围来减少循环次数
改进代码

private static void showfournum1()
    {
        String string="";
        int a1,a2,a3,a4;
        int x1=0,x2=0;
        char[] ch=new char[5];
        for (int i=1260;i<=6880;i++)
        {
            if (i % 100 ==0)continue;
            /*string=Integer.toString(i);
            ch=string.toCharArray();
            a1=((int)(ch[0])-48);
            a2=((int)(ch[1])-48);
            a3=((int)(ch[2])-48);
            a4=((int)(ch[3])-48);*/
            a1=i /1000;
            a2=i %1000 /100;
            a3=i %1000 %100/10;
            a4=i%1000%100%10;
            if (a1!=0&&a3!=0)
            {
            x1=a1*10+a2;
            x2=a3*10+a4;
            if (x1*x2==i){System.out.println(i+" =  "+x1+"*"+x2);continue;}
            x1=a1*10+a4;
            x2=a3*10+a2;
            if (x1*x2==i){System.out.println(i+" =  "+x1+"*"+x2);continue;}
            }
            if (a1!=0&&a2!=0)
            {
                x1=a1*10+a3;
                x2=a2*10+a4;
                if (x1*x2==i){System.out.println(i+" =  "+x1+"*"+x2);continue;}
                x1=a1*10+a4;
                x2=a2*10+a3;
                if (x1*x2==i){System.out.println(i+" =  "+x1+"*"+x2);continue;}
            }
            if (a1!=0&&a4!=0)
            {
                x1=a1*10+a2;
                x2=a4*10+a3;
                if (x1*x2==i){System.out.println(i+" =  "+x1+"*"+x2);continue;}
                x1=a1*10+a3;
                x2=a4*10+a2;
                if (x1*x2==i){System.out.println(i+" =  "+x1+"*"+x2);continue;}             
            }


            if (a2!=0&&a3!=0)
            {
                x1=a2*10+a4;
                x2=a3*10+a1;
                if (x1*x2==i){System.out.println(i+" =  "+x1+"*"+x2);continue;}
                x1=a2*10+a1;
                x2=a3*10+a4;
                if (x1*x2==i){System.out.println(i+" =  "+x1+"*"+x2);continue;}             
            }
            if (a2!=0&&a4!=0)
            {
                x1=a2*10+a3;
                x2=a4*10+a1;
                if (x1*x2==i){System.out.println(i+" =  "+x1+"*"+x2);continue;}
                x1=a2*10+a1;
                x2=a4*10+a3;
                if (x1*x2==i){System.out.println(i+" =  "+x1+"*"+x2);continue;}             
            }
            if (a3!=0&&a4!=0)
            {
                x1=a3*10+a2;
                x2=a4*10+a1;
                if (x1*x2==i){System.out.println(i+" =  "+x1+"*"+x2);continue;}
                x1=a3*10+a1;
                x2=a4*10+a2;
                if (x1*x2==i){System.out.println(i+" =  "+x1+"*"+x2);continue;}             
            }

            }
    }
一口快乐水
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
4位吸血鬼数字的java实现思路与实例讲解
08-26
今天小编就为大家分享一篇关于4位吸血鬼数字的java实现思路与实例讲解，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
JAVA 吸血鬼数字学习
一米阳光sky
06-08 501
什么是吸血鬼数字：吸血鬼数字是指位数为偶数的数字。可以由一对数字相乘而得到，而这对数字各包含乘积的一半位数的数字，选取的数字可以任意排序。以两个0结尾的数字是不允许的。    举例说明如下： 1260 = 21 * 60 1827 = 21 * 87 2187 = 27 * 81      我们根据通过找四位数的吸血鬼数字来分析。        首先，一个四位数的吸血鬼数字必须由两个1
java编程——吸血鬼数字（四位）
我要上天
08-16 866
从《Thinking in Java》(中文第四版)中第4章的练习10看到“吸血鬼数字”，特编程实现，以下为3种算法（针对四位数的）及其对比： 首先解释一下吸血鬼数字：吸血鬼数字是指位数为偶数的数字，可由一对数字相乘而得到，这对数字各包含乘积的一半位数的数字，以两个0结尾的数字是不允许的。  四位数吸血鬼数字示例：1260=21*60，1827=21*87，2187=27*81…… 先列出结果：一共
Java 吸血鬼数字
沉默王二
12-16 5077
很惭愧（其实没什么惭愧，水平就这样），搞了半晌才写出来了一个Java 求四位吸血鬼数字的方法
吸血鬼数字java实现案例
十一
09-26 1060
《JAVA编程思想》第4章练习题 吸血鬼数字是指位数为偶数的数字，可以由一对数字相乘而得到， 而这对数字各包含乘积的一半位数的数字，其中从最初的数字中 选取的数字可以任意排序。以两个0结尾的数字是不允许的， 例如，下列数字都是“吸血鬼”数字： 1260 = 21 * 60 　 1827 = 21 * 87 　 2187 = 27 * 81 写一个程序，找出4位数的所有吸血鬼数字 实现代码如下： public static void main(String[] args) { for (in
Java实现吸血鬼数字
11-12
Java实现吸血鬼数字的3种算法，3种算法的效率各自的比较
JAVA求吸血鬼数字
07-01
吸血鬼数字是指位数为偶数的数字，可以由一对数字相乘得到，而这...以2个0结尾的数字是不允许的，例如，下列数字都是吸血鬼数字： 1260 = 21*60 1827 =21*87 2187 =27*81 本程序就是如何找出4位数的所有的吸血鬼数字。
java 吸血鬼程序
11-21
java 吸血鬼程序 学习java必须要学习的经典案例，加油学习把
吸血鬼数字
09-25
吸血鬼数字的三种实现方法，及其运行速度。最后一种绝对的好方法。java编程吸血鬼数字答案。
java 吸血鬼数字_Thinking in Java
weixin_34010875的博客
02-16 190
4. 控制执行流程4.1 true and false所有条件语句都利用条件表达式的真假来决定执行路径4.2 if-else结构if(Boolean expression)statementelse if(Boolean expression)statementelsestatement4.3 迭代结构while(Boolean expression)statement规则在循环刚开始时会计算一次...
JAVA吸血鬼数字算法
10-30
THINK IN JAVA上的课后题，只是寻找4位数的。
Java学习——编程作业（2）吸血鬼数字
weixin_45634839的博客
03-25 227
【问题描述】 【问题描述】吸血鬼数字是指位数为偶数的数字，可以由一对数字相乘得到，这对数字各包含乘积的一半位数的数字，数字选取后可任意排序，例如： 1260=21×60 1827=21×87 2187=27×81。写出一个程序，找出4位数的所有吸血鬼数字。 【输入形式】无 【输出形式】输出所有的吸血鬼数字，数字之间已空格分隔。 【样例输入】无 【样例输出】1260 1395 1435 1530 1827 2187 6880 【问题分析】 就是将所有1000-9999的四位数，拆分成4个数字，再将
java吸血鬼数字_吸血鬼数字（java）
weixin_39943926的博客
02-18 232
*吸血鬼数字是指位数为偶数的数字，可以由一堆数字相乘而得到，而这对数字各包含乘积的一半位数的数字，其中从最初的数字中选取的数字可以任意排列。以两个0结尾的数字是不允许的例如，下列数字都是吸血鬼数字1260=21*60 1827=21*87 2187=27*81写一个程序，找出所有4位的吸血鬼数字*void test(){int count = 0,num=0;int from,to,val;for...
java 吸血鬼数字_JAVA_吸血鬼数字 多种方法实现
weixin_39872222的博客
02-12 342
packagetest4;importjava.util.Arrays;/*** 从TIJ中第4章的练习10看到“吸血鬼数字”,以下几种方法实现以及执行时间对比* 找出四位数的所有吸血鬼数字* 吸血鬼数字是指位数为偶数的数字，可以由一对数字相乘而得到，而这对数字各包含乘积的一半位数的数字，* 其中从最初的数字中选取的数字可以任意排序.* 以两个0结尾的数字是不允许的。* 例如下列数字都是吸血鬼数字...
吸血鬼数字java_Java求吸血鬼数算法(通用)
weixin_33708562的博客
02-12 282
/*吸血鬼数字是指位数为偶数的数字，可以由一* 对数字相乘而得到，而这对数字各包含乘积的一半位数的数字，* 其中从最初的数字中选取的数字可以任意排序。* 以两个0结尾的数字是不允许的。** 1994年柯利弗德·皮寇弗在Usenet社群sci.math的* 文章中首度提出吸血鬼数。后来皮寇弗将吸血鬼数* 写入他的书Keys to Infinity的第30章。** 以两个0结尾的数字是不允许的，例如，...
Java 找出四位数的所有吸血鬼数字 基础代码实例
weixin_34015336的博客
04-18 414
/** * 找出四位数的所有吸血鬼数字 * 吸血鬼数字是指位数为偶数的数字，可以由一对数字相乘而得到，而这对数字各包含乘积的一半位数的数字，其中从最初的数字中选取的数字可以任意排序. * 以两个0结尾的数字是不允许的。 * 例如下列数字都是吸血鬼数字 1260=21*60 1827=21*87 2187=27*81 ... * 比较笨的低效率的做法...
java面向对象.day21（继承02--super）
BaiZhuYuan的博客
04-14 704
super===父this===当前使用super时，首先要继承父类，其次是在子类里面才能使用super。继承父类后，运行子类时会同时调用父类的构造方法，如果要显性调用父类的构造方法必须在子类的第一行调用。单使用super()表示调用父类构造方法，单使用this()表示调用本身的构造方法。父类具有有参的构造方法时，并且没有显性无参构造方法，那么子类要使用时必须直接调用父类的有参构造方法，
【1524】java投票管理系统Myeclipse开发mysql数据库web结构java编程计算机网页项目
最新发布
qq_251836457的博客
04-18 189
2、开发环境为TOMCAT7.0,Myeclipse8.5开发，数据库为Mysql5.0，使用java语言开发。(5)投票选项管理：对投票选项信息进行添加、删除、修改和查看。(6)投票记录管理：对投票记录信息进行添加、删除、修改和查看。(1)管理员管理：对管理员信息进行添加、删除、修改和查看。(2)用户管理：对用户信息进行添加、删除、修改和查看。(3)公告管理：对公告信息进行添加、删除、修改和查看。(4)投票管理：对投票信息进行添加、删除、修改和查看。4）投票浏览查看、查看投票、投票记录。
常见Spring相关工具报错-源码分析
小百的博客
04-15 373
在 getResources 中会获取 getResources(“classpath*:” + i18n/messages + “.properties”)，但是缺少messages.properties属性文件。3️⃣ 源码分析 MessageSourceAutoConfiguration 配置类。4️⃣ 解决：补充 messages.properties 文件。
用C语言实现吸血鬼幸存者游戏代码
04-01
以下是一个用C语言实现的吸血鬼幸存者游戏的伪代码，供您参考： 1. 定义一个数组来存储吸血鬼的血量和攻击力，初始化为一定范围内的随机数。 2. 定义一个变量来表示玩家的血量，初始化为一定数值。 3. 进入游戏循环...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值