【Java】【TIJ】Java实现找出4位数的所有吸血鬼数字

什么是吸血鬼数字？

吸血鬼数字是指位数为偶数的数字，可以由一对数字相乘而得到，而这对数字各包含乘积的一半位数的数字，

其中从最初的数字中选取的数字可以任意排序。以两个0结尾的数字是不允许的，

例如，下列数字都是“吸血鬼”数字：

1260 = 21 * 60

1827 = 21 * 87

2187 = 27 * 81

编程思路

第一步、首先是将给定的四位数进行分割，得到每位数字，存入一个数组中；例如，四位数“1234”，

分割成1,2,3,4四个数字存储到数组中；

第二步、将第一步分割得到的每位上的数字共4个，根据其在数组中存储的下标（分别是0,1,2,3）

进行4个数字分成两组进行排列组合，可以分为：((0,1),(2,3))，((0,2),(1,3))，((0,3),(1,2))

这里会包含一个两位数因子生成函数CombineDigit，该函数根据提供的两个数字，然后得到这两个

数字可以组合成的所有两位数，存放到数组中。

第三步、对每种组合进行判断，看是否可以组成符合“吸血鬼数字”要求的2个两位数因子A、B，

而且A * B = 原始四位数

/**
*  找出4位数的所有"吸血鬼数字"
*  Thinking in Java test 4.10
* @author:WolfOfSiberian
* @email:QuietWolf@yeah.net
*/
public class TIJ_Test4_10{
	static final int NumberDigit=4;				
	static int SplitArray[]=new int[NumberDigit];

	/**
	* 把四位数的每位数字抽取出来,保存到数组中
	* @param    FourDigit    给定的一个四位数
	* @return    void
	*/
	public static void SplitNumber(int FourDigit){
		SplitArray[0]=FourDigit%10;
		SplitArray[1]=(FourDigit/10)%10;
		SplitArray[2]=(FourDigit/100)%10;
		SplitArray[3]=(FourDigit/1000)%10;
	}

	/**
	* 对给定的2个数字组合成可能的两位数，组合后的结果存放在数组A中
	* @param    a1    分割四位数中的数字1
	* @param    a2    四位数中的另外一个位数上的数字2
	* @param    A    保存了组合成功的两位数
	* @return 返回的值是组合成功的存储在数组A中的两位数的个数
	*/
	private static int CombineDigit(int a1,int a2,int A[]){
		//如果数字都是0的话，这里直接就不符合要求，返回0
		if(a1 == 0 && a2 == 0){
			return 0;
		}
		else{
			//2个数字中有一个是0的话，考虑0是不能作为数值开头的。
			if(a1 == 0 || a2 == 0){
				A[0] = (a1 == 0) ? (a2 * 10):(a1 * 10);

				return 1;	
			}
			else{
				//如果两个数字都是非0的的话，那么这里组合成数值会有两种组合方式
				A[0] = a1 * 10 + a2;
				A[1] = a1 + a2 * 10;

				return 2;
			}
		}
	}

	/**
	* 判断当前组合下，是否存在符合"吸血鬼数字"的要求
	* 构建思路：FourDigit =? A * B
	* @param    FourDigit    给定的一个四位数，其待判断是否为"吸血鬼数字"
	* @param    Ai    Ai是数组SplitArray中的下标索引，用于构建A因子
	* @param    Aj    Aj是数组SplitArray中的下标索引，用于构建A因子
	* @param    Bi    Bi是数组SplitArray中的下标索引，用于构建B因子
	* @param    Bj    Bj是数组SplitArray中的下标索引，用于构建B因子
	* @param    reArr    该数组保存当断定给定的四位数为”吸血鬼数字"时候的A因子和B因子值
	* @return     返回true,表示当前组合下给定的四位数为"吸血鬼数字";
	*             返回false,表示当前组合下不是"吸血鬼数字"。
	* @since 1.0
	*/
	public static boolean isXXGDigitCombine(int FourDigit,int Ai,int Aj,int Bi,int Bj,int reArr[]){
	
		int A[]=new int[2];
		int B[]=new int[2];

		int lenA=CombineDigit(SplitArray[Ai],SplitArray[Aj],A);
		//A因子组合失败
		if(0 == lenA){
			return false;
		}

		int lenB=CombineDigit(SplitArray[Bi],SplitArray[Bj],B);
		//B因子组合失败
		if(0 == lenB){
			return false;
		}

		for(int i=0;i<lenA;i++){
			for(int j=0;j<lenB;j++){
				if(FourDigit == A[i] * B[j]){
					//找到符合要求的组合,保存到数组中，并返回true
					reArr[0] = A[i];
					reArr[1] = B[j];
					return true;
				}
			}
		}

		return false; 
	}

	/**
	*   判断当前组合下，是否存在符合"吸血鬼数字"的要求
	*   构建思路：FourDigit =? A * B
	* @param    FourDigit    给定的四位数
	* @param    reArr    该数组保存当断定给定的四位数为”吸血鬼数字"时候的A因子和B因子值

	* @return    返回true,表示给定的四位数为"吸血鬼数字";
	*            返回false,表示不是"吸血鬼数字"。
	* @since 1.0

	*/
	public static boolean isXXGDigit(int FourDigit,int reArr[]){
		boolean bResult=false;

		//step1 抽取给定的四位数的每位数字保存到数组中
		SplitNumber(FourDigit);
		//step2 2个2位数不考虑两位数因子中的数字的排序，一共有如下三种组合方式
		//,只要有一种组合方式符合吸血鬼数字的条件，都表示这个四位数是符合要求的。
		
		return (
                          isXXGDigitCombine(FourDigit,0,1,2,3,reArr)
                       || isXXGDigitCombine(FourDigit,0,2,1,3,reArr)
                       || isXXGDigitCombine(FourDigit,0,3,1,2,reArr) 
                       );
	}

	public static void main(String args[]){
		int reArr[]=new int[2];
		int count=0;

		for(int i=1000;i<10000;i++){
			if(TIJ_Test4_10.isXXGDigit(i,reArr)){
				count++;
				System.out.println(i+" = "+reArr[0]+" * "+reArr[1]);
			}
		}
	}
}

运行结果：

1260 = 60 * 21
1395 = 15 * 93
1435 = 35 * 41
1530 = 30 * 51
1827 = 87 * 21
2187 = 27 * 81
6880 = 80 * 86