本来是很简单的东西,结果自己想快点做完,结果反而做了很久,而且做错!。。
做得辛辛苦苦,可惜还是没做对!
本来想用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;
}
}
简单明了,而且正确!不过自己肯定写不出来,不熟悉 ^= 的用法。。