吸血鬼数字检验之java实现

最新推荐文章于 2021-09-26 16:17:27 发布

JonsonJiao

最新推荐文章于 2021-09-26 16:17:27 发布

阅读量1.1k

点赞数

分类专栏： java 文章标签： java 吸血鬼数字全排列算法

本文链接：https://blog.csdn.net/tongyi55555/article/details/47083985

版权

java 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

1吸血鬼数字介绍
2实现思路
3代码实例

1、吸血鬼数字介绍

吸血鬼数字是指位数为偶数的数字，可以由一对数字相乘而得到，而这对数字各包含乘积的一半位数的数字，其中从最初的数字中选取的数字可以任意排序。–引自百度百科

　　举几个例子就明白了：
　　　1260 = 21 * 60 　1827 = 21 * 87 　2187 = 27 * 81等等
　　　
　　吸血鬼数字都是偶数位的，两个因子的组成数字都是从吸血鬼数字中得到的，且两个因子的所有数字等于吸血鬼数字中的所有数字（是完全相同，不能重复使用）。此外还有一个规定是吸血鬼数字不能是100的整数倍。

2、实现思路

首先来分析一下吸血鬼数字的必要条件：

必须是偶数位的数字，121肯定不是；
不能是100的整数倍，1000肯定不是；

这些都是吸血鬼数字的定义告诉我们的，除此之外还有哪些可以利用的条件呢？

末尾数字相乘%10等于吸血鬼数字的末尾数字，考虑到最后一位是0时，采用倒数第二个数字检验。比如上面的1827，最后一位是7，那么组成该数字的两个数字末尾乘积取模10肯定是7，1260中，两个因子的最后一位必为1或6，且1和6不能在同一个数字中。

通过上面这些条件我们就可以减少一些比较量，尤其是前两个条件，可以直接判断一些非吸血鬼数字，而第三个条件就需要进行转化和判断，尤其是遇到0结尾的数字。

如果上面三个条件都满足，就需要直接寻找两个因子来判断是否是吸血鬼数字了，

穷举法 比较简单地方式就是穷举所有可能的数字，先判断两个因子乘积是否等于该数字，等于则判断组成两个因子的数字是否与要判断的吸血鬼数字组成完全一致，只有在满足这两个条件的情况下才能进行判断该数字是吸血鬼数字。比如判断一个四位数字是否是吸血鬼数字，则需要验证所有的两位数字乘积。
排列法 我自己暂且叫这个名字吧，因为因子是吸血鬼数字的再排列，因此我们找到所有的排列形式，然后一分为二，判断前后两部分的乘积是否等于原来的数字，等于则是吸血鬼数字，反之则不是。比如1827=21*87，因此其排列是2187的形式，2187是该数字的一个排列形式，我们取到21和87进行判断就可以断定了该数字是吸血鬼数字了。

下面代码就是用排列法进行的实现，具体过程如下：

判断该数字是否是100的整数倍，是则返回false；
判断数字的位数是否是偶数，否则返回false；
寻找所有可能的末尾数字组合，如果不存在两个数字相乘取模10后等于要判断的数字末尾或倒数第二位（末尾为0时）则返回false；
获取所有可能的排列，将排列从中间截断，并比较第一部分和第二部分末尾（或只有一部分的倒数第二位）是否满足乘积取模10后等于末尾数字或倒数第二位数字（末尾为0时），满足时如果两部分的乘积等于要判断的数字，则返回true，否则返回false。

3、代码实例

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * @author jqs 吸血鬼数字识别算法
 * 
 */
public class VampireNumber {

    /**
     * 组成吸血鬼数字的第一个数字
     */
    private int sonNum1;

    /**
     * 组成吸血鬼数字的第二个数字
     */
    private int sonNum2;

    private boolean isVampireNumber = false;

    private int value;

    public int getSonNum1() {
        return sonNum1;
    }

    public void setSonNum1(int sonNum1) {
        this.sonNum1 = sonNum1;
    }

    public int getSonNum2() {
        return sonNum2;
    }

    public void setSonNum2(int sonNum2) {
        this.sonNum2 = sonNum2;
    }

    public VampireNumber(int value) {
        this.value = value;
        initSonNum();
    }

    /**
     * 判断输入的数值是否是吸血鬼数字
     */
    private void initSonNum() {
        // 以00结尾的不是
        if (value % 100 == 0) {
            setVampireNumber(false);
            return;
        }
        // 首先将数字分成n个int值，n代表value的数字长度
        String string = value + "";
        int length = string.length();
        if (length % 2 != 0) {
            // 非偶数位数一定不是
            setVampireNumber(false);
            return;
        }
        Integer[] rawNum = new Integer[length];
        for (int i = 0; i < rawNum.length; i++) {
            rawNum[i] = Integer.parseInt(string.charAt(i) + "");
        }

        // 记录该数字的最后一位不是0的值，以便于根据这个值来找可能的两个数字乘积取模10后等于该值
        boolean lastZero = rawNum[length - 1] == 0;
        int last = lastZero ? rawNum[length - 2] : rawNum[length - 1];

        // 构建两个list来存放吸血鬼数字可能的两个值的最后一位（或倒数第二位），因为吸血鬼数字的两个值的最后一位（或其中的倒数第二位）相乘必等于该值的最后一位，如果吸血鬼数字末尾是0的话，相乘必等于倒数第二位
        // 下面的两个list是成对出现的，且其index是一一对应的关系
        List<Integer> oneLastList = new ArrayList<Integer>();
        List<Integer> otherLastList = new ArrayList<Integer>();
        // 需要再检查一下任意两位相乘的情况
        for (int i = 0; i < rawNum.length; i++) {
            for (int j = i + 1; j < rawNum.length; j++) {
                if (rawNum[i] * rawNum[j] % 10 == last) { // 满足两个值相乘取模10等于last，则这两个值可能是组成吸血鬼数字的两个值中的最后一位或倒数第二位（最后一位是0的情况）
                    oneLastList.add(rawNum[i]);
                    otherLastList.add(rawNum[j]);
                }
            }
        }
        if (otherLastList.size() == 0) {
            // 找不到两个数相乘取模10等于最后一位或倒数第二位（最后一位是0的情况），直接返回，比如2220，肯定不是，2222肯定不是
            setVampireNumber(false);
            return;
        }
        fastMethod(length, rawNum, lastZero, oneLastList, otherLastList);
    }

    /**
     * 最快的判断数字是否是吸血鬼数字的方法
     * 
     * @param length
     *            数字长度
     * @param rawNum
     *            原始数字每一位组成的数组
     * @param lastZeroFlag
     *            最后以为是否是0
     * @param oneLastList
     * @param otherLastList
     */
    public void fastMethod(int length, Integer[] rawNum, boolean lastZeroFlag,
            List<Integer> oneLastList, List<Integer> otherLastList) {
        int size = oneLastList.size();
        if (lastZeroFlag) {
            for (int i = 0; i < size; i++) {
                otherLastList.add(oneLastList.get(i));
                oneLastList.add(otherLastList.get(i));
            }
        }
        int count = 0;
        int oneLast = 0;
        int otherLast = 0;
        int half = length / 2;
        // 对输入的数字进行全排列，得到所有的排列可能，并放入到这个list中。
        List<Object[]> posNumList = new ArrayList<Object[]>();
        permutation(rawNum, 0, length - 1, posNumList);
        while (count < oneLastList.size() && !isVampireNumber) {
            if (lastZeroFlag) {
                oneLast = 0;
            } else {
                oneLast = oneLastList.get(count);
            }
            otherLast = otherLastList.get(count);

            int two = 0;
            int one = 0;
            for (int m = 0; m < posNumList.size(); m++) {
                Integer[] list = (Integer[]) posNumList.get(m);
                two = 0;
                one = 0;
                // 将数组分为两半，每一半的末位为oneLast或otherLast时继续进行判断，否则continue
                if (list[length - 1] == oneLast && list[half - 1] == otherLast) {
                    two += oneLast;
                    for (int i = half; i < length - 1; i++) {
                        int tmp = 1;
                        for (int j = 0; j < length - 1 - i; j++) {
                            tmp *= 10;
                        }
                        two += list[i] * tmp;
                    }
                    one += otherLast;
                    for (int i = 0; i < half - 1; i++) {
                        int tmp = 1;
                        for (int j = 0; j < half - 1 - i; j++) {
                            tmp *= 10;
                        }
                        one += list[i] * tmp;
                    }
                } else if (list[length - 1] == otherLast
                        && list[half - 1] == oneLast) {
                    two += otherLast;
                    for (int i = half; i < length - 1; i++) {
                        int tmp = 1;
                        for (int j = 0; j < length - 1 - i; j++) {
                            tmp *= 10;
                        }
                        two += list[i] * tmp;
                    }
                    one += oneLast;
                    for (int i = 0; i < half - 1; i++) {
                        int tmp = 1;
                        for (int j = 0; j < half - 1 - i; j++) {
                            tmp *= 10;
                        }
                        one += list[i] * tmp;
                    }
                }
                if (two * one == value) {
                    isVampireNumber = true;
                    sonNum1 = one;
                    sonNum2 = two;
                    break;
                }
            }
            count++;
        }
    }

    /**
     * 耗时最短的全排列算法<br>
     * 从集合中依次选出每一个元素，作为排列的第一个元素，然后对剩余的元素进行全排列，如此递归处理，
     * 从而得到所有元素的全排列。以对字符串abc进行全排列为例，我们可以这么做：以abc为例：
     * 固定a，求后面bc的排列：abc，acb，求好后，a和b交换，得到bac
     * 固定b，求后面ac的排列：bac，bca，求好后，c放到第一位置，得到cba 固定c，求后面ba的排列：cba，cab。
     * 
     * @param str
     *            原始元素列表
     * @param first
     *            排列的起始位置
     * @param end
     *            排列的结束位置
     * @param posNumList
     *            所有的排列结果
     */
    public void permutation(Object[] str, int first, int end,
            List<Object[]> posNumList) {
        if (first == end) { // 输出一个排列方式
            Object[] result = Arrays.copyOf(str, str.length);
            posNumList.add(result);
        }

        for (int i = first; i <= end; i++) {
            swap(str, i, first);
            permutation(str, first + 1, end, posNumList); // 固定好当前一位，继续排列后面的
            swap(str, i, first);
        }
    }

    /**
     * 交换两个位置i和first的元素
     * 
     * @param str
     * @param i
     * @param first
     */
    private void swap(Object[] str, int i, int first) {
        if (str instanceof Integer[]) {
            Integer tmp;
            tmp = (Integer) str[first];
            str[first] = str[i];
            str[i] = tmp;
        } else if (str instanceof String[]) {
            String tmp;
            tmp = (String) str[first];
            str[first] = str[i];
            str[i] = tmp;
        }
    }

    public int[] getSonNum() {
        return new int[] { sonNum1, sonNum2 };
    }

    public boolean isVampireNumber() {
        return isVampireNumber;
    }

    public void setVampireNumber(boolean isVampireNumber) {
        this.isVampireNumber = isVampireNumber;
    }

    public static void main(String[] args) {
        VampireNumber vn = null;
        int count = 0;
        long l = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            vn = new VampireNumber(i);
            if (vn.isVampireNumber()) {
                System.out.println(i + "=" + vn.getSonNum1() + "*"
                        + vn.getSonNum2());
                count++;
            }
        }
        System.out.println((System.currentTimeMillis() - l) + "共计：" + count);
    }
}

测试结果：

10000以下的吸血鬼数字共7个，耗时133毫秒
1000000以下的吸血鬼数字共147个，耗时29362毫秒

详细输出如下：

找到0-10000之间所有的吸血鬼数字：
1260=21*60
1395=15*93
1435=41*35
1530=51*30
1827=87*21
2187=27*81
6880=86*80
耗时：133毫秒，找到吸血鬼数字共计：7

找到0-1000000之间所有的吸血鬼数字：
1260=21*60
1395=15*93
1435=41*35
1530=51*30
1827=87*21
2187=27*81
6880=86*80
102510=201*510
104260=401*260
105210=501*210
105264=516*204
105750=150*705
108135=135*801
110758=158*701
115672=152*761
116725=161*725
117067=167*701
118440=141*840
123354=231*534
124483=281*443
125248=152*824
125433=231*543
125460=246*510
126027=201*627
126846=261*486
129640=140*926
129775=179*725
131242=311*422
132430=323*410
133245=315*423
134725=317*425
135828=588*231
135837=351*387
136525=635*215
136948=146*938
140350=401*350
145314=414*351
146137=461*317
146952=156*942
152608=251*608
152685=585*261
153436=356*431
156240=651*240
156289=581*269
156915=165*951
162976=176*926
163944=396*414
172822=782*221
173250=750*231
174370=470*371
175329=759*231
180225=801*225
180297=897*201
182250=810*225
182650=281*650
186624=864*216
190260=906*210
192150=915*210
193257=327*591
193945=395*491
197725=719*275
201852=252*801
205785=255*807
211896=216*981
213466=341*626
215860=251*860
216733=671*323
217638=678*321
218488=248*881
226498=269*842
226872=276*822
229648=248*926
233896=338*692
241564=461*524
245182=422*581
251896=296*851
253750=350*725
254740=542*470
260338=323*806
262984=284*926
263074=602*437
284598=489*582
284760=420*678
286416=612*468
296320=926*320
304717=431*707
312475=431*725
312975=321*975
315594=534*591
319059=351*909
319536=336*951
326452=623*524
329346=342*963
329656=356*926
336550=635*530
336960=360*936
338296=392*863
341653=641*533
346968=366*948
361989=369*981
362992=392*926
365638=686*533
368550=630*585
369189=381*969
371893=383*971
378418=878*431
378450=870*435
384912=891*432
386415=831*465
392566=593*662
404968=446*908
414895=491*845
416650=641*650
416988=468*891
428980=482*890
429664=464*926
447916=476*941
456840=540*846
458640=546*840
475380=570*834
486720=624*780
489159=891*549
489955=899*545
498550=845*590
516879=681*759
529672=572*926
536539=563*953
538650=855*630
559188=588*951
567648=657*864
568750=650*875
629680=680*926
638950=650*983
673920=720*936
729688=788*926
736695=765*963
738468=876*843
769792=776*992
789525=825*957
792585=927*855
794088=984*807
809919=891*909
809964=894*906
815958=858*951
829696=896*926
841995=891*945
939658=953*986
耗时：29462毫秒，找到吸血鬼数字共计：147