我的 卡布列克

 

本来是很简单的东西，结果自己想快点做完，结果反而做了很久，而且做错！。。

 

做得辛辛苦苦，可惜还是没做对！

 

本来想用list的sort 帮忙实现排序的 ，后面采用手动的冒泡排序，又加上一个苦逼的算法，结果冒泡排序那块搞错了！

 

错了两次，

 

第一次：

 

		String[] bigger = sort(kabulekes,-1);
		String[] smaller = sort(kabulekes,1);

sort方法里面没有新建数组，导致bigger、smaller 是一样的值——即传值传引用的问题！

 

第二次：

//String s1 = strs[i]; -------------  这样引起问题~！

 

s1 写在第一个循环里面，导致冒泡排序实际失败。。。———— 这个好不容易才发现！ 主要还是没有深入的真正的了解冒泡排序的算法—— 或者就是忘记了！。。。

 

package test;

import java.io.IOException;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public final class Demo {


	public static void main(String[] args) {
		System.out.println("VerifyKabulekeTheorem "
				+new Demo().VerifyKabulekeTheorem(5553));
		
		System.out.println("s1.compareTo(s2)<0 "+ "6".compareTo("2"));
	}
	
	/*
	功能: 验证卡布列克运算，任意一个四位数，只要它们各个位上的数字是不全相同的，就有这样的规律：
	1.将组成该四位数的四个数字由大到小排列，形成由这四个数字构成的最大的四位数；
	2.将组成该四位数的四个数字由小到大排列，形成由这四个数字构成的最小的四位数(如果四个数字中含有0，则得到的数不足四位)；
	3.求两个数的差，得到一个新的四位数(高位0保留)。
	重复以上过程，最后得到的结果总是6174。这个数被称为卡布列克常数。

	原型：
	    int VerifyKabulekeTheorem(int m);
	输入参数：
	    int m：四位整数且各位数字不同(输入已保证)
	返回值：
	    0:整数m不是卡布列克数
	    >0: 结果为6174需要运算的次数
	*/

	public int VerifyKabulekeTheorem(int m)
	{
	    /*在这里实现功能*/
		
		if(m>999&&m<10000){
			String str = m+"";
			String[] kabulekes = new String[]{str.substring(0, 1),
					str.substring(1, 2),
					str.substring(2, 3),
					str.substring(3, 4)};
			if(kabulekes[0]==kabulekes[1]&&kabulekes[1]==kabulekes[2]
					&&kabulekes[2]==kabulekes[3]&&kabulekes[3]==kabulekes[4]) {
				return 0;
			}
			if(m==6174)return 0;
			return getKe(kabulekes);
		}

	    return 0;
	}
	
	int count = 0;
	
	private int getKe(String[] kabulekes) {
		String[] bigger = sort(kabulekes,-1);
		String[] smaller = sort(kabulekes,1);
		String[] ret = getNew(bigger, smaller);

		//System.out.println("ret "+ret[0]+ret[1]+ret[2]+ret[3]);
		
		count ++;
		if((ret[0]+ret[1]+ret[2]+ret[3]).equals("6174")) {
			return count;
		}
		return getKe(ret);
	}

	private String[] getNew(String[] bigger,String[] smaller) {
		String[] ret = new String[bigger.length];
		for (int i = 0; i < smaller.length; i++) {
			String s = smaller[i];
			String b = bigger[i];
		}
		String retStr = (Integer.valueOf(bigger[0]+bigger[1]+bigger[2]+bigger[3])-
				Integer.valueOf(smaller[0]+smaller[1]+smaller[2]+smaller[3]))+"";
		//if(retStr.equals("0"))return 0;
		if(retStr.length()==1) {
			retStr = "000"+retStr;
		}else if(retStr.length()==2) {
			retStr = "00"+retStr;
		}else if(retStr.length()==3) {
			retStr = "0"+retStr;
		}
		
		return  new String[]{retStr.substring(0, 1),
				retStr.substring(1, 2),
				retStr.substring(2, 3),
				retStr.substring(3, 4)};
	}

	private String[] sort(String[] strs,int order) {
		
		
		for (int i = 0; i < strs.length; i++) {
			//String s1 = strs[i]; -------------  这样引起问题~！
			//if(s1.equals('0'))continue;
			for (int j = i; j < strs.length; j++) {
				String s1 = strs[i];
				String s2 = strs[j];
				if(order==1){
					if(s1.compareTo(s2)>0){// ascend
						String temp = s1;
						strs[i] = s2;
						strs[j] = temp;
					}
				}else if(order==-1){
					if(s1.compareTo(s2)<0){// descend
						String temp = s1;
						strs[i] = s2;
						strs[j] = temp;
					}
				}
			}
		}
		String[] ret = new String[strs.length];
		ret[0] = strs[0];
		ret[1] = strs[1];
		ret[2] = strs[2];
		ret[3] = strs[3];
		//System.out.println(ret[0]+ret[1]+ret[2]+ret[3]);
		return ret;
	}
}

 

另一种解法

package huawei;

public class KK {
	

	public static void main(String[] args) {
		System.out.println("VerifyKabulekeTheorem "
				+new KK().VerifyKabulekeTheorem(4241));
	}
	
	public int VerifyKabulekeTheorem(int m)
	{
	    int iCount = 0;
	    while(true)
	    {
	        iCount++;
	        m = getMax(m) - getMin(m);
	        if(m == 6174)
	        {
	            return iCount;
	        }
	    }
	}
	private int getMax(int m)
	{
	    int[] iNum = new int[4];
	    for(int i=0; i<iNum.length; i++)
	    {
	        iNum[i] = m % 10;
	        m = m / 10;
	    }
	    
	    for(int i=0; i<4; i++)
	    {
	        for(int j=0; j<3-i; j++)
	        {
	            if(iNum[j] < iNum[j + 1])
	            {
	                iNum[j + 1] ^= iNum[j];
	                iNum[j] ^= iNum[j + 1];
	                iNum[j + 1] = iNum[j + 1]^iNum[j];
	            }
	        }
	    }
	    
	    return iNum[0]*1000 + iNum[1]*100 + iNum[2]*10 + iNum[3]*1;
	}
	
	private int getMin(int m)
	{
	    int[] iNum = new int[4];
        for(int i=0; i<iNum.length; i++)
        {
            iNum[i] = m % 10;
            m = m / 10;
        }
        
        for(int i=0; i<4; i++)
        {
            for(int j=0; j<3-i; j++)
            {
                if(iNum[j] > iNum[j + 1])
                {
                    iNum[j + 1] ^= iNum[j];
                    iNum[j] ^= iNum[j + 1];
                    iNum[j + 1] = iNum[j + 1]^iNum[j];
                }
            }
        }
        
        return iNum[0]*1000 + iNum[1]*100 + iNum[2]*10 + iNum[3]*1;
	}
	

}

 简单明了，而且正确！不过自己肯定写不出来，不熟悉 ^= 的用法。。