欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

我的 卡布列克

程序员文章站 2022-06-07 19:33:10
...

 

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

 

做得辛辛苦苦,可惜还是没做对!

 

本来想用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;
	}
	

}

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