这是一个比较有技术含量的问题！！

黑妞~

有任意一个5位数，如：34256，
把它的各位数字打乱，重新排列，就可得到一个最大的数：65432，还有一个最小的数23456。
求这两个数字的差，得：41976，
然后把这个数字再次重复上述过程（如果不足5位，则前边补0）。
如此往复，数字会落入某个循环圈（称为数字黑洞）。
比如，刚才的数字会落入：[82962, 75933, 63954, 61974] 这个循环圈。

请编写程序，找到5位数所有可能的循环圈，并输出，每个循环圈占1行。其中5位数全都相同则循环圈为 [0]，这个可以不考虑。循环圈的输出格式仿照：
[82962, 75933, 63954, 61974]
其中数字的先后顺序可以不考虑。

谁来解答！思路要清晰！！

Deathfish · Deathfish

import java.util.TreeSet;
public class Test {
public static void main(String[] args) {
// TODO Auto-generated method stub
TreeSet<String> blackHoleList = BlackHole(0, 100000);
// System.out.println(blackHoleList.size());
for (String tree : blackHoleList) {
System.out.println(tree);
}
}
/**
* 输出一个储存数字黑洞TreeSet的ArrayList
*
* @param from
* @param end
* @return
*/
public static TreeSet<String> BlackHole(int from, int end) {
TreeSet<String> blackHoleList = new TreeSet<String>();
// 建立一个角标从0-99999的boolean型数组
boolean[] numList = new boolean[end];
// 对数组进行遍历
for (int i = from; i < numList.length; i++) {
// 判断当前角标的数字是否已经在某个数字黑洞中
if (numList[i]) {
continue;
}
// 建立储存数字黑洞的TreeSet
TreeSet<Integer> numTemp = new TreeSet<Integer>();
TreeSet<Integer> numTempArray = new TreeSet<Integer>();
// 从大小为i的数字开始计算其重组后的数的最大值和最小值的差值
int reverseNum = i;
int count = 0;
// 通过while循环将遍历到的数及由其计算出的差值数存入一个TreeSet中
while (count < numTemp.size() * 2 + 1) {
// 当再次向numTemp树中存入已有的数时返回false,于是进入if区域内，将该值存入numTempArray这个TreeSet中
if (!numTemp.add(reverseNum)) {
numTempArray.add(reverseNum);
}
// 记录该值已经遍历过
numList[reverseNum] = true;
// 获取其差值数
reverseNum = cutNum(reverseNum);
count++;
}
blackHoleList.add(numTempArray.toString());
}
return blackHoleList;
}
/**
* 输入一个数输出重组后的数的最大值和最小值的差值
*
* @param num
* @return
*/
public static int cutNum(int num) {
String[] numStrList = Integer.toString(num).split("");
int[] numHash = new int[10];
for (int j = 1; j < numStrList.length; j++) {
numHash[Integer.parseInt(numStrList[j])]++;
}
int numBiggest, numSmallest;
StringBuilder numString = new StringBuilder();
for (int i = 0; i < numHash.length; i++) {
for (int k = 0; k < numHash[i]; k++) {
numString.append(i);
}
}
numSmallest = Integer.parseInt(numString.toString());
numBiggest = Integer.parseInt(numString.reverse().toString());
return numBiggest - numSmallest;
}
}

复制代码

[0]
[495]
[53955, 59994]
[6174]
[61974, 63954, 75933, 82962]
[62964, 71973, 74943, 83952]

小于5位数的结果在输出时做个判断就OK，懒得弄了。

王者之风西昆仑 · 王者之风西昆仑

吊炸天的题目

godmmm · godmmm

本帖最后由 godmmm 于 2014-12-28 23:06 编辑

花了3小时，时间有点长了，刚开始不相信答案，查了下baidu觉得差不多了！
大家给点意见！！！

import java.io.FileWriter;
import java.io.IOException;
import java.util.*;
/*数字黑洞：
有任意一个5位数，如：34256，
把它的各位数字打乱，重新排列，就可得到一个最大的数：65432，还有一个最小的数23456。
求这两个数字的差，得：41976，
然后把这个数字再次重复上述过程（如果不足5位，则前边补0）。
如此往复，数字会落入某个循环圈（称为数字黑洞）。
比如，刚才的数字会落入：[82962, 75933, 63954, 61974] 这个循环圈。
请编写程序，找到5位数所有可能的循环圈，并输出，每个循环圈占1行。其中5位数全都相同则循环圈为 [0]，这个可以不考虑。循环圈的输出格式仿照：
[82962, 75933, 63954, 61974]
其中数字的先后顺序可以不考虑。*/
/*思路： 1.遍历5位数
* 2.对5位数进行排序，用StringBuilder的反转功能，Arrays的sort功能获取最大值，最小值
* 3.计算差值，将最大值添加到list集合，原理是：list集合出现过这个最大值就会落入这两个最大值之间的循环圈；
* 4.用list集合存放最大值进行循环圈的判断，用set结合进行存放循环圈，由于第三部的算法，set集合去重复就简单了。
*注意：其实每个数都要落入一个循环圈，每个数落入的循环圈可以看你c盘下生产的"c:/digitalBlackHole.txt"文件，就是有点大，小心死机额！！！
*/
public class DigitalBlaceHole {
public static void main(String[] args) throws IOException
{
ArrayList<String> al=new ArrayList<String>();//list排序后的每个最大数，
TreeSet<String> ts=new TreeSet<String>();//set集合存放不相同的循环圈
FileWriter fw=new FileWriter("c:/digitalBlackHole.txt");//存放每个数落入的循环圈
findDigital(al,fw,ts);//调用方法
for(String s:ts)//打印循环圈
{
System.out.println(s);
}
}
public static void findDigital(ArrayList<String> al,FileWriter fw,TreeSet<String> ts) throws IOException
{
for(int x=10000;x<100000;x++)//遍历
{
al.add("num:"+x);
dudge(x,al,fw,ts);//判断方法
}
}
private static void dudge(int num,ArrayList<String> al,FileWriter fw,TreeSet<String> ts) throws IOException {
while(true)
{
StringBuilder sb=new StringBuilder();//建立字符串缓冲区
char[] buf=(num+"").toCharArray();//获取数字对应的字符数组
Arrays.sort(buf);//排序数组
String min=new String(buf);//得到最小值
String max=sb.append(min).reverse().toString();//得到最大值
int mid=Integer.parseInt(max)-Integer.parseInt(min);//获取差值
if (al.contains(max)) {//判断集合是否有这个最大数存在
int id=al.indexOf(max);//索引位置
fw.write(al.subList(id, al.size()).toString());//获取子list集合字符串兵写入文件
ts.add(al.subList(id, al.size()).toString());//获取子list集合字符串并存入set集合
al.clear();//清空集合，进行下次判断
break;
/*} else if (mid <= 0 || max.equals(min)) {//这个有点多余了，主要是每个数都要落入循环
al.clear();
break;*/
} else {
al.add(max);//没落入循环继续判断
//System.out.println(map);
dudge(mid,al,fw, ts);//递归
}
break;//最后断开
}
}
}

复制代码

运行结果：
[0]
[95553, 99954]
[96543, 97641, 98622, 97533]
[96642, 97731, 98532, 97443]
[97443, 96642, 97731, 98532]
[97533, 96543, 97641, 98622]
[97641, 98622, 97533, 96543]
[97731, 98532, 97443, 96642]
[98532, 97443, 96642, 97731]
[98622, 97533, 96543, 97641]
[99954, 95553]

七弦 · 七弦

本帖最后由七弦于 2014-6-12 19:38 编辑

参考参考吧。

import java.util.Arrays;

public class MyTest10 {

   public static void main(String args[])

   {



         int f=Sort(array(34256));

         int x=Sort(array(34256));

         for(int i=0;i<4;i++) {

         x=Sort(array(x));

            System.out.print(x+" ");

         }

   }



   static int []array(int n)

   {

         int a[]=new int[5];

         int i=0;

         int m=n;

         while(i<5)

         {

                  a=m%10;

                  if(m%10==0)

                  a=0;

                  m/=10;

                        i++;

         }

         return a;

   }

   static int Sort(int a[]){

         Arrays.sort(a);

         String min="";

         for(int i=0;i<5;i++)

         {

               min=min+String.valueOf(a);

         }

         int Min=Integer.parseInt(min);

         StringBuffer sb=new StringBuffer(min).reverse();

         String max=new StringBuffer(sb).toString();

         int Max=Integer.parseInt(max);

         int c=Max-Min;

         return c;

   }

}
复制代码

张然龙 · 张然龙

最终我们都倒在了楼主的需求上....

kongyan4696 · kongyan4696

没有完美。。

kongyan4696 · kongyan4696

import java.util.*;
/*
有些没弄完，输出有重复的。
引路深度，来确定运算层数。
Td//
*/
public class LoopQDemo2{
public static void main(String[] args){
//计算深度
int depth =5;
//存放圈
TreeSet<Integer> ts = new TreeSet<Integer>();
for(int i=10000;i<=99999;i++){
//每次都要清空
ts.clear();
//得到深度
int count = depth;
int num = i;
//加入初始数
ts.add(i);
while(count>0){
//得到最大减最小的5位数
num = getFiveSize(getMax(num)-getMin(num));
if(i==num){
//在运算深度内，若开始循环就打印圈
sop(i+"------"+ts);
}else{
//否则继续，加入数
count--;
ts.add(num);
}
}
}
}
/*
得到补齐的5位数
*/
static int getFiveSize(Integer x){
//变成字符数组起
char []cx = x.toString().toCharArray();
//不足5位
if(cx.length<5){
//后面加0
return (int)Math.pow(10,5-cx.length)*new Integer(new String(cx));
}
return new Integer(new String(cx));
}
//得到最小的数
static int getMin(Integer x){
char []cx = x.toString().toCharArray();
//排序就好了，你懂的
Arrays.sort(cx);
return new Integer(new String(cx));
}
//同上
static int getMax(Integer x){
char []cx = x.toString().toCharArray();
Arrays.sort(cx);
for(int i = 0;i<cx.length/2;i++){
char tmp = cx[i];
cx[i]= cx[cx.length-1-i];
cx[cx.length-1-i] = tmp;
}
return new Integer(new String(cx));
}
//你懂的
static void sop(Object o){
System.out.println(o);
}
/*
static int isSame(Integer x1,Integer x2){
char []cx1 = x1.toString().toCharArray();
char []cx2 = x2.toString().toCharArray();
Arrays.sort(cx1);
Arrays.sort(cx2);
return new String(cx1).compareTo(new String(cx2));
}
*/
}

复制代码

E:\Coder\cc>java LoopQDemo2
53955------[53955, 59994]
53955------[53955, 59994]
53955------[53955, 59994]
53955------[53955, 59994]
59994------[53955, 59994]
59994------[53955, 59994]
59994------[53955, 59994]
59994------[53955, 59994]
61974------[61974, 63954, 75933, 82962]
62964------[62964, 71973, 74943, 83952]
63954------[61974, 63954, 75933, 82962]
71973------[62964, 71973, 74943, 83952]
74943------[62964, 71973, 74943, 83952]
75933------[61974, 63954, 75933, 82962]
82962------[61974, 63954, 75933, 82962]
83952------[62964, 71973, 74943, 83952]

没有剔除重复的。。

将就看。。

张辉玉 · 张辉玉

进来看看，

师在飞 · 师在飞

数字黑洞，面试不会出这样的题吧{:3_55:}

superob123 · superob123

其实我就不懂为什么61974之后不继续求循环圈了

神马 · 神马

import java.io.PrintStream;
import java.lang.reflect.Array;
import java.util.*;
/**
*
有任意一个5位数，如：34256，
把它的各位数字打乱，重新排列，就可得到一个最大的数：65432，还有一个最小的数23456。
求这两个数字的差，得：41976，
然后把这个数字再次重复上述过程（如果不足5位，则前边补0）。
如此往复，数字会落入某个循环圈（称为数字黑洞）。
比如，刚才的数字会落入：[82962, 75933, 63954, 61974] 这个循环圈。
* @author JunZhu
*/
public class NumberBlackHole {
public static void main(String[] args) throws Exception{
//定义一个set用于存放所有可能的循环组合
HashSet<HashSet> al=new HashSet<HashSet>();
//把结果存入一个文件中
PrintStream ps=new PrintStream("BlackHole.txt");
//定义一个set用于存放某一个循环圈
HashSet<Integer> al2=new HashSet<Integer>();
//定义一个标志位用于判断循环的结束
boolean flag=false;
for (int i = 10000;i<100000; i++) {
for (int j = i; ; ) {
al2.add(j);
j =getMaxNum(j)-getMinNum(j);
if (al2.contains(j)&& flag==false) {
flag=true;
al2.clear();
}
if (al2.contains(j)) {
flag=false;
break;
}
}
al.add((HashSet) al2.clone());
//System.out.println(al2);
//ps.println(al2);
al2.clear();
}
Iterator it=al.iterator();
while (it.hasNext()) {
ps.println(it.next());
}
ps.close();
}
public static int getMaxNum(int a) {
int[] num=getNum(a);
int k=0;
Arrays.sort(num);
for (int i = num.length-1; i >= 0; i--) {
k=k*10+num[i];
}
return k;
}
public static int getMinNum(int a) {
int[] num=getNum(a);
int k=0;
Arrays.sort(num);
for (int i = 0; i < num.length; i++) {
k=k*10+num[i];
}
return k;
}
public static int[] getNum(int a) {
String ss=Integer.toString(a);
//判断，不足5位的话补零
int[] s=new int[5];
for (int i = 0; i < ss.length(); i++) {
s[i]=a%10;
a=a/10;
}
if (ss.length()<5) {
for (int i = ss.length(); i < 5; i++) {
s[i]=0;
}
}
return s;
}
}

复制代码

最后结果是输出到了BlackHole.txt文件中，有一个零，是例外的。一共三组。
[0]
[71973, 83952, 74943, 62964]
[53955, 59994]
[63954, 61974, 82962, 75933]

西门吹风 · 西门吹风

本帖最后由西门吹风于 2014-6-1 18:48 编辑

新手，尝试了写了一下，望大神指正

/*
1、获取任意五位数上各个位的数字并且放到数组中
2、通过对数组排升序获取最小值
3、通过对数组排降序获取最大值
4、通过最大值和最小值获取差值
5、通过差值循环，判断当前差值是否与这前的某个差值相等
1）新建一个容器用来存放差值目前只学过数组，用new in
2）用循环判断当判断当前差值是否与这前的某个差值相等
a、如果相等，打印这当前差值、与当前差值相等的差值以及它们之间的差值，
这也就是循环圈，然后跳出循环
b、如果不等，继续循环
*/
class Quan
{
public static void main(String[] args)
{
int x=34556;
getCirculation(x);
}
public static void getCirculation(int x)
{
int[] res=new int[100]; // 目前只学过数组，用这个可能不太好，不知道有没有更恰当的
boolean check=true;
int difference=getDifference(x);
for(int j=0;j<res.length-1&&check==true;difference=getDifference(difference),j++)
{
res[j]=difference;
for(int k=j-1;k>=0&&check==true;k--)
{
if(res[k]==difference)
{
System.out.print("[");
for(int a=k;a<j-1;a++)
{
System.out.print(res[a]+",");
}
System.out.print(res[j-1]+"]");
check=false;
}
}
}
}
public static int getDifference(int x) //获取差值
{
int[] arr=getArr(x);
maxSort(arr);
int max=getNumber(arr);
minSort(arr);
int min=getNumber(arr);
return (max-min);
}
public static int[] getArr(int x) //获取五位数的数组
{
int[] arr=new int[5];
for (int i=10000,j=0;i>=1;i=i/10,j++)
{
arr[j]=x/i;
x=x%i;
}
return arr;
}
public static void maxSort(int[] arr) //升序排列数组
{
for(int i=0;i<arr.length-1;i++)
{
for(int j=i+1;j<arr.length;j++)
{
if(arr[i]<arr[j])
{
int temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
}
}
}
public static void minSort(int[] arr) //降序排列数组
{
for(int i=0;i<arr.length-1;i++)
{
for(int j=i+1;j<arr.length;j++)
{
if(arr[i]>arr[j])
{
int temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
}
}
}
public static int getNumber(int[] arr) //数组转成数字
{
int num=0;
for(int i=0,temp=10000; i<arr.length;i++,temp=temp/10)
{
num=num+arr[i]*temp;
}
return num;
}
}

复制代码

GoodBoy123 · GoodBoy123

我表示连题目都没有看懂，

为了明天 · 为了明天

12楼的果然好长，看晕了。。。

yinxjfly · yinxjfly

这个问题怎么没有正解呢！
围观中！

TS__likewise · TS__likewise

不是没人能解，估计都不想敲，太长了，亲。。。。。。。。。。。
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class 数字黑洞 {
static Set<List<Integer>> sets = new HashSet<List<Integer>>();// 记录每个循环圈
static int start = 0; // 记录循环圈的开始位置

// 得到最大的数
public static int max(String s) {
      char[] c = s.toCharArray();
      Arrays.sort(c);
      StringBuffer sb = new StringBuffer(String.valueOf(c));
      return Integer.parseInt(sb.reverse().toString());
}

// 得到最小的数
public static int min(String s) {
      char[] c = s.toCharArray();
      Arrays.sort(c);
      return Integer.parseInt(String.valueOf(c));
}

// 查找是否有循环圈
public static boolean find(int n, List<Integer> lis) {
      for (int i = 0; i < lis.size(); i++) {
         if (n == lis.get(i)) {
            start = i; // 设置循环圈的开始
            return true;
         }
      }
      return false;
}

// 这个数字的五位是否都一样如:11111,22222,...
public static boolean same(int n) {
      char[] c = (String.valueOf(n)).toCharArray();
      char t = c[0];
      for (int i = 1; i < c.length; i++) {
         if (t != c) {
            return false;
         }
      }
      return true;
}

// 判断是否在sets元素里重复
public static boolean contain(List<Integer> tt) {
      boolean flag = false;
      // 从sets头到尾扫描是是否包含tt元素组
      Iterator<List<Integer>> iter = sets.iterator();
      while (iter.hasNext()) {
         if (iter.next().containsAll(tt)) {
            flag = true;
            break;
         }
      }
      return flag;
}

// 输出循环圈
public static void print() {
      Iterator<List<Integer>> iter = sets.iterator();
      while (iter.hasNext()) {
         System.out.println(iter.next());
      }
}

// 进入黑洞测试*********
public static void bl(int n, List<Integer> lis) {
      String s = String.valueOf(n);
      int a = max(s); // 得到最大的数
      int b = min(s); // 得到最小的数
      int c = a - b; // 得到五位数结果
      if (find(c, lis)) { // 找到循环圈
         List<Integer> temp = new ArrayList(); // 开辟新空间并copy记录
         temp.addAll(lis.subList(start, lis.size()));
         if (!contain(temp)) { // 去重
            sets.add(temp); // 记录一个循环圈
         }
         lis.clear(); // 清空
         return;
      }
      lis.add(c);
      bl(c, lis); // 递归探测
}

// 主函数============
public static void main(String[] args) {
      List<Integer> lis = new ArrayList(); // 保存记录
      for (int i = 10000; i < 99999; i++) {
         if (!same(i)) // 去掉不符合条件的元素:如(11111,22222,...)
            bl(i, lis); // 进入黑洞测试
      }
      print(); // 输出循环圈
}
}

七弦 · 七弦

难道这个题就没同学能写出来吗？

qiubaoyang · qiubaoyang

连题目求的是什么都不知道？？？

向前看向前走 · 向前看向前走

留下，以后看

帐号		自动登录	找回密码
密码			加入黑马

这是一个比较有技术含量的问题！！

评分

26 个回复

浏览过的版块

黑马骑士勋章