A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 七弦 中级黑马   /  2014-5-24 21:37  /  6633 人查看  /  26 人回复  /   1 人收藏 转载请遵从CC协议 禁止商业使用本文

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

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


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

评分

参与人数 1技术分 +1 收起 理由
黑妞~ + 1

查看全部评分

26 个回复

倒序浏览
小伙伴们!加油吧!
回复 使用道具 举报 1 0
加油,纯支持:victory:
回复 使用道具 举报 1 0
好复杂的算法
回复 使用道具 举报 1 0
想了10分钟,果断放弃。。。暂时还得充充电
回复 使用道具 举报 1 0
学习了!
回复 使用道具 举报
七弦 中级黑马 2014-5-25 19:46:57
7#
高手哪里去了!!:sleepy:
回复 使用道具 举报
七弦 中级黑马 2014-5-25 19:48:30
8#
我只想到要用到sort排序,StringBuilder容器、反转,循环。。。。
回复 使用道具 举报
留下,以后看
回复 使用道具 举报
连题目求的是什么都不知道???
回复 使用道具 举报
难道这个题就没同学能写出来吗?
回复 使用道具 举报
不是没人能解,估计都不想敲,太长了,亲。。。。。。。。。。。
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(); // 输出循环圈  
    }
}
回复 使用道具 举报
这个问题怎么没有正解呢!
围观中!
回复 使用道具 举报
12楼的果然好长,看晕了。。。
回复 使用道具 举报
我表示连题目都没有看懂,
回复 使用道具 举报
本帖最后由 西门吹风 于 2014-6-1 18:48 编辑

新手,尝试了写了一下,望大神指正
  1. /*
  2. 1、获取任意五位数上各个位的数字并且放到数组中
  3. 2、通过对数组排升序获取最小值
  4. 3、通过对数组排降序获取最大值
  5. 4、通过最大值和最小值获取差值
  6. 5、通过差值循环,判断当前差值是否与这前的某个差值相等
  7.       1)新建一个容器用来存放差值 目前只学过数组,用new in
  8.       2)用循环判断当判断当前差值是否与这前的某个差值相等
  9.            a、如果相等,打印这当前差值、与当前差值相等的差值以及它们之间的差值,
  10.                  这也就是循环圈,然后跳出循环
  11.            b、如果不等,继续循环
  12. */
  13. class  Quan
  14. {
  15.         public static void main(String[] args)
  16.         {
  17.                 int x=34556;
  18.                 getCirculation(x);
  19.         }
  20.         public static void getCirculation(int x)
  21.         {
  22.                 int[] res=new int[100];   //  目前只学过数组,用这个可能不太好,不知道有没有更恰当的
  23.                 boolean check=true;
  24.                 int difference=getDifference(x);
  25.                 for(int j=0;j<res.length-1&&check==true;difference=getDifference(difference),j++)
  26.                 {
  27.                         res[j]=difference;
  28.                         for(int k=j-1;k>=0&&check==true;k--)
  29.                         {
  30.                                 if(res[k]==difference)
  31.                                 {
  32.                                         System.out.print("[");
  33.                                         for(int a=k;a<j-1;a++)
  34.                                         {
  35.                                                 System.out.print(res[a]+",");
  36.                                         }
  37.                                         System.out.print(res[j-1]+"]");
  38.                                         check=false;
  39.                                 }
  40.                         }
  41.                 }
  42.         }
  43.         public static int getDifference(int x)    //获取差值
  44.         {
  45.                 int[] arr=getArr(x);
  46.                 maxSort(arr);
  47.                 int max=getNumber(arr);
  48.                 minSort(arr);
  49.                 int min=getNumber(arr);
  50.                 return (max-min);        
  51.         }
  52.         public static int[] getArr(int x)   //获取五位数的数组
  53.         {
  54.                 int[] arr=new int[5];
  55.                 for (int i=10000,j=0;i>=1;i=i/10,j++)
  56.                 {
  57.                         arr[j]=x/i;
  58.                         x=x%i;
  59.                 }
  60.                 return arr;
  61.         }
  62.         public static void maxSort(int[] arr)   //升序排列数组
  63.         {
  64.                 for(int i=0;i<arr.length-1;i++)
  65.                 {
  66.                         for(int j=i+1;j<arr.length;j++)
  67.                         {
  68.                                 if(arr[i]<arr[j])
  69.                                 {
  70.                                         int temp=arr[i];
  71.                                         arr[i]=arr[j];
  72.                                         arr[j]=temp;
  73.                                 }
  74.                         }
  75.                 }
  76.         }
  77.         public static void minSort(int[] arr)   //降序排列数组
  78.         {
  79.                 for(int i=0;i<arr.length-1;i++)
  80.                 {
  81.                         for(int j=i+1;j<arr.length;j++)
  82.                         {
  83.                                 if(arr[i]>arr[j])
  84.                                 {
  85.                                         int temp=arr[i];
  86.                                         arr[i]=arr[j];
  87.                                         arr[j]=temp;
  88.                                 }
  89.                         }
  90.                 }
  91.         }
  92.         public static int getNumber(int[] arr)    //数组转成数字
  93.         {
  94.                 int num=0;
  95.                 for(int i=0,temp=10000; i<arr.length;i++,temp=temp/10)
  96.                 {
  97.                         num=num+arr[i]*temp;
  98.                 }
  99.                 return num;
  100.         }
  101. }
复制代码



回复 使用道具 举报

  1. import java.io.PrintStream;
  2. import java.lang.reflect.Array;
  3. import java.util.*;

  4. /**
  5. *
  6. 有任意一个5位数,如:34256,
  7. 把它的各位数字打乱,重新排列,就可得到一个最大的数:65432,还有一个最小的数23456。
  8. 求这两个数字的差,得:41976,
  9. 然后把这个数字再次重复上述过程(如果不足5位,则前边补0)。
  10. 如此往复,数字会落入某个循环圈(称为数字黑洞)。
  11. 比如,刚才的数字会落入:[82962, 75933, 63954, 61974] 这个循环圈。
  12. * @author JunZhu
  13. */
  14. public class NumberBlackHole {
  15.         public static void main(String[] args) throws Exception{
  16.                 //定义一个set用于存放所有可能的循环组合
  17.                 HashSet<HashSet> al=new HashSet<HashSet>();
  18.                 //把结果存入一个文件中
  19.                 PrintStream ps=new PrintStream("BlackHole.txt");
  20.                 //定义一个set用于存放某一个循环圈
  21.                 HashSet<Integer> al2=new HashSet<Integer>();
  22.                 //定义一个标志位用于判断循环的结束
  23.                 boolean flag=false;
  24.                 for (int i = 10000;i<100000; i++) {
  25.                         for (int j = i; ; ) {
  26.                                 al2.add(j);
  27.                                 j =getMaxNum(j)-getMinNum(j);
  28.                                 if (al2.contains(j)&& flag==false) {
  29.                                         flag=true;
  30.                                         al2.clear();
  31.                                 }
  32.                                 if (al2.contains(j)) {
  33.                                         flag=false;
  34.                                         break;
  35.                                 }
  36.                         }
  37.                         al.add((HashSet) al2.clone());
  38.                         //System.out.println(al2);
  39.                         //ps.println(al2);
  40.                         al2.clear();
  41.                 }
  42.                 Iterator it=al.iterator();
  43.                 while (it.hasNext()) {
  44.                         ps.println(it.next());
  45.                 }
  46.                 ps.close();
  47.         }
  48.         public static int getMaxNum(int a) {
  49.                 int[] num=getNum(a);
  50.                 int k=0;
  51.                 Arrays.sort(num);
  52.                 for (int i = num.length-1; i >= 0; i--) {
  53.                         k=k*10+num[i];
  54.                 }               
  55.                 return k;
  56.         }
  57.         public static int getMinNum(int a) {
  58.                 int[] num=getNum(a);
  59.                 int k=0;
  60.                 Arrays.sort(num);
  61.                 for (int i = 0; i < num.length; i++) {
  62.                         k=k*10+num[i];
  63.                 }
  64.                 return k;
  65.         }
  66.         public static int[] getNum(int a) {
  67.                 String ss=Integer.toString(a);
  68.                 //判断,不足5位的话补零
  69.                 int[] s=new int[5];
  70.                 for (int i = 0; i < ss.length(); i++) {
  71.                         s[i]=a%10;
  72.                         a=a/10;
  73.                 }
  74.                 if (ss.length()<5) {
  75.                         for (int i = ss.length(); i < 5; i++) {
  76.                                 s[i]=0;                                                               
  77.                         }
  78.                 }
  79.                 return s;
  80.         }
  81. }
复制代码
最后结果是输出到了BlackHole.txt文件中,有一个零,是例外的。一共三组。
[0]
[71973, 83952, 74943, 62964]
[53955, 59994]
[63954, 61974, 82962, 75933]


回复 使用道具 举报
其实我就不懂为什么61974之后不继续求循环圈了
回复 使用道具 举报
数字黑洞,面试不会出这样的题吧{:3_55:}
回复 使用道具 举报
进来看看,
回复 使用道具 举报
12下一页
您需要登录后才可以回帖 登录 | 加入黑马