以外获得个题，希望得到大家不同的想法~~悬赏可上涨，视解题思路详细是否给币，方法简练思路清晰最高可到15币（评判标准归我想法哦）
         题1：用1、2、3、4这四个数字，用java写一个main函数打印出所有不同的排序，如：1234，1243等要求：“4”不能在第一位，“1”与“3”不能相连
       题2：用1、2、2、3、4、5这六个数字，用java写一个main函数，打印出所有不同的排列，如：512234、412345等，要求："4"不能在第三位，"3"和"5"不能相连

           请不要放百度粘帖的答案！！！:lol

随手一打标准的15个字

linp007 发表于 2015-7-24 01:11
复制粘帖也认真点好么，题目你都搞错，你写点思路也好啊

这是我自己敲的，我是刚到黑马学习的基础班学生，我自己想了一个多小时，换来的就是这个。我不会把代码发到贴吧里，只能从EditePlus里面直接粘贴出来。没想到得到的却是这种回复，不过没关系，代码是我自己写的我自己知道，我不会因为这点误解就放弃的

/*题1：用1、2、3、4这四个数字，用java写一个main函数打印出所有不同的排序，

如：1234，1243等要求：“4”不能在第一位，“1”与“3”不能相连

思路：1.肯定要用到for循环和if判断语句

      */

import java.util.*;

class  Test1

{

        public static void main(String[] args)

        {

                int sum1=0;                     //采用三层嵌套循环，四数之和为10，前面三个数确定，最后一位也可确定。

                for(int i=1;i<=3;i++)          //“4”不能在第一位，循环里面确定

                {

                        for(int j=1;j<=4;j++)

                        {

                                for(int l=1;l<=4;l++)

                                {

                                        int sum=10-i-j-l;

                                        if((i!=j && j!=l && l!=i)&&            //判断语句条件一，前三个数字不相等

                                                (i+j)!=4 &&(j+l)!=4&&(l+sum)!=4)    //判断语句条件二，3和1不在一起

                                        {

                                                    sum1=i*1000+j*100+l*10+sum;

                                                System.out.println(sum1+"");

                                        }

                                }

                        }



                }

        }

}

1. /* 题2：用1、2、2、3、4、5这六个数字，用java写一个main函数，打印出所有不同的排列，
   
2.   如：512234、412345等，要求："4"不能在第三位，"3"和"5"不能相连
   
3.   如法炮制
   
4.   */
   
5. 
   
6. class Test2
   
7. {
   
8.         public static void main(String[] args)
   
9.         {
   
10.             int sum=0;
    
11.             for(int i=1;i<6;i++)
    
12.             {
    
13.                     for(int j=1;j<6;j++)
    
14.                     {
    
15.                             for(int l=1;l<6;l++)
    
16.                             {
    
17.                                     for(int k=1;k<6;k++)
    
18.                                     {
    
19.                                             for(int n=1;n<6;n++)        //五层循环判断起来更容易些
    
20.                                             {
    
21.                                                     if(i+j+l+k+n==15&&l!=4 &&   
    
22.                                                         (i+j)!=8 && (j+l)!=8 && (l+k)!=8 &&(k+n)!=8)
    
23.                                                     {
    
24.                                                              sum=i*10000+j*1000+l*100+k*10+n;
    
25.                                                             System.out.print(sum+"\t");
    
26.                                                     }
    
27.                                             }
    
28.                                     }
    
29.                             }
    
30.                     }
    
31.             }
    
32.         }
    
33. }
    

复制代码

不知正确与否，请各位指正！运行结果如下：
12255   12345   12525   12543   12552   13155   13245   13254   14145   14154
14325   14334   14343   14514   14523   14541   15225   15234   15243   15252
15513   15522   21255   21345   21525   21543   21552   22155   22245   22254
22515   22524   22542   22551   23145   23154   23325   23334   23343   24225
24234   24243   24252   24315   24324   24333   24342   24513   24522   25125
25134   25143   25152   25215   25224   25233   25242   25251   25512   25521
31155   31245   31254   31515   31524   31542   31551   32145   32154   32325
32334   32343   32514   32523   32541   33225   33234   33243   33252   33315
33324   33333   33342   34125   34134   34143   34152   34215   34224   34233
34242   34251   34314   34323   34332   34341   34512   34521   41145   41154
41325   41334   41343   41514   41523   41541   42225   42234   42243   42252
42315   42324   42333   42342   42513   42522   43125   43134   43143   43152
43215   43224   43233   43242   43251   43314   43323   43332   43341   45114
45123   45132   45141   45213   45222   45231   51225   51234   51243   51252
51315   51324   51333   51342   51513   51522   52125   52134   52143   52152
52215   52224   52233   52242   52251   52314   52323   52332   52341   52512
52521   54114   54123   54132   54141   54213   54222   54231   54312   54321
55113   55122   55131   55212   55221

还可以直接暴力求出所有的组合再判断筛选，还有双向冒泡遍历

package test.my;

class TestA10C {
        public static void main(String[] args) {
                char[] ch = new char[] { '1', '2', '3', '4' };
                int rem = 0;
                for (int te1 = 0; te1 < ch.length; te1++) // 第一位数字，从数组的第一个字符开始直到最后一个字符
                {
                        for (int te2 = 0; te2 < ch.length; te2++) // 第二位数字，从第一个与ch[te1]不重复的字符开始直到最后一个字符
                        {
                                if (te2 != te1) {
                                        for (int te3 = 0; te3 < ch.length; te3++) {
                                                if ((te3 != te1) && (te3 != te2)) {
                                                        for (int te4 = 0; te4 < ch.length; te4++) {
                                                                if ((te4 != te1) && (te4 != te2)
                                                                                && (te4 != te3)) {
                                                                        if ((te1 != 3)
                                                                                        && !((te1 == 0 && te2 == 2)
                                                                                                        || (te2 == 0 && te1 == 2)
                                                                                                        || (te2 == 0 && te3 == 2)
                                                                                                        || (te3 == 0 && te2 == 2)
                                                                                                        || (te3 == 0 && te4 == 2) || (te4 == 0 && te3 == 2))) {
                                                                                System.out.print("  " + ch[te1]
                                                                                                + ch[te2] + ch[te3] + ch[te4]);
                                                                                rem++;
                                                                                if (rem % 5 == 0)
                                                                                        System.out.println();

                                                                        }
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }
                }
                System.out.print("\n" + rem);
        }
}

别急独角戏 发表于 2015-7-23 23:33
/**
    需求：用1、2、3、4这四个数字，用java写一个main函数打印出所有不同的排序，
          如：1234 ...

复制粘帖也认真点好么，题目你都搞错，你写点思路也好啊

/**
    需求：用1、2、3、4这四个数字，用java写一个main函数打印出所有不同的排序，
          如：1234，1243等要求：“4”不能在第一位，“1”与“3”不能相连

        思路：用for嵌套循环便利所有结果，把满足条件的打印出来

*/
class ArrayTest4
{
        public static void main(String[] args)
        {
                char[] ch=new char[]{'1','2','3','4','5'};
                int rem=0;
                for(int te1=0;te1<ch.length;te1++)                        //第一位数字，从数组的第一个字符开始直到最后一个字符
                {
                        for(int te2=0;te2<ch.length;te2++)                //第二位数字，从第一个与ch[te1]不重复的字符开始直到最后一个字符
                        {               
                                if(te2!=te1)
                                {
                                        for(int te3=0;te3<ch.length;te3++)               
                                        {               
                                                if((te3!=te1)&&(te3!=te2))
                                                {
                                                        for(int te4=0;te4<ch.length;te4++)               
                                                        {               
                                                                if((te4!=te1)&&(te4!=te2)&&(te4!=te3))
                                                                {
                                                                        for(int te5=0;te5<ch.length;te5++)               
                                                                        {               
                                                                                if((te5!=te1)&&(te5!=te2)&&(te5!=te3)&&(te5!=te4))
                                                                                {
                                                                                        if((te1!=3)&&!((te1==0&&te2==2)||(te2==0&&te3==2)||(te1==0&&te5==2)))        
                                                                                        {
                                                                                                System.out.print("  "+ch[te1]+ch[te2]+ch[te3]+ch[te4]+ch[te5]);
                                                                                                rem++;
                                                                                                if(rem%5==0)
                                                                                                        System.out.println();
                                                                                        }
                                                                                }
                                                                        }
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }
                }
                System.out.print("\n"+rem);
        }
}

/**
    需求：用1、2、3、4这四个数字，用java写一个main函数打印出所有不同的排序，
          如：1234，1243等要求：“4”不能在第一位，“1”与“3”不能相连

        思路：用for嵌套循环便利所有结果，把满足条件的打印出来

*/
class ArrayTest4
{
        public static void main(String[] args)
        {
                char[] ch=new char[]{'1','2','3','4','5'};
                int rem=0;
                for(int te1=0;te1<ch.length;te1++)                        //第一位数字，从数组的第一个字符开始直到最后一个字符
                {
                        for(int te2=0;te2<ch.length;te2++)                //第二位数字，从第一个与ch[te1]不重复的字符开始直到最后一个字符
                        {               
                                if(te2!=te1)
                                {
                                        for(int te3=0;te3<ch.length;te3++)               
                                        {               
                                                if((te3!=te1)&&(te3!=te2))
                                                {
                                                        for(int te4=0;te4<ch.length;te4++)               
                                                        {               
                                                                if((te4!=te1)&&(te4!=te2)&&(te4!=te3))
                                                                {
                                                                        for(int te5=0;te5<ch.length;te5++)               
                                                                        {               
                                                                                if((te5!=te1)&&(te5!=te2)&&(te5!=te3)&&(te5!=te4))
                                                                                {
                                                                                        if((te1!=3)&&!((te1==0&&te2==2)||(te2==0&&te3==2)||(te1==0&&te5==2)))        
                                                                                        {
                                                                                                System.out.print("  "+ch[te1]+ch[te2]+ch[te3]+ch[te4]+ch[te5]);
                                                                                                rem++;
                                                                                                if(rem%5==0)
                                                                                                        System.out.println();
                                                                                        }
                                                                                }
                                                                        }
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }
                }
                System.out.print("\n"+rem);
        }
}

linp007 发表于 2015-7-22 22:04
求个鬼的助攻，快把第一题做一下，给你十五币

我都还没学到

午夜码农 发表于 2015-7-22 22:40
差几个币就阔以申请入学考试了，兄台一个币也是币啊。。

做个题就十五，比你回复不来的快？

差几个币就阔以申请入学考试了，兄台一个币也是币啊。。

加多宝 发表于 2015-7-22 21:53
新人求助攻

求个鬼的助攻，快把第一题做一下，给你十五币

新人求助攻

段培峰 发表于 2015-7-22 20:16
吊吊的，牛人

别理他，他是个小逗比，你可以用for嵌套试试，

吊吊的，牛人

吐槽星人 发表于 2015-7-22 17:24
思路把所有的组合弄出来，我的想法是通过随机数来获取排列，然后进行遍历判断并输出
第一题
第二题

哟哟哟，你还要来扣爸爸的币

思路把所有的组合弄出来，我的想法是通过随机数来获取排列，然后进行遍历判断并输出
第一题

1. package itheima;
   
2. 
   
3. import java.util.Random;
   
4. import java.util.TreeSet;
   
5. 
   
6. /**
   
7. * 15、用1、2、3、4这四个数字，用java写一个main函数
   
8. *        打印出所有不同的排序，如：1234，1243等
   
9. *        要求：“4”不能在第一位，“1”与“3”不能相连
   
10. * @author Administrator
    
11. *
    
12. */
    
13. /*
    
14. * 思路：利用随机数将不同的组合存入TreeSet。遍历TreeSet将符合条件的组合输出
    
15. */
    
16. public class Test15 {
    
17. 
    
18.         public static void main(String[] args) {
    
19.                 //用于换行
    
20.                 int count =0;
    
21.                 Random random=new Random();
    
22.                 //用于记录随机数产生的组合
    
23.                 StringBuilder sb=new StringBuilder();
    
24.                 TreeSet<String> treeSet=new TreeSet<>();
    
25.                 //4个数的排列有24种，A(n,m)=n!/(n-m)!
    
26.                 while (treeSet.size()<24) {
    
27.                         //通过循环将不同随机数存入字符串缓冲区
    
28.                         while (sb.length()<4) {
    
29.                                 //产生一个随机数
    
30.                                 int num=random.nextInt(4)+1;
    
31.                                 count1++;
    
32.                                 //如果在字符串中找不到该随机数存入
    
33.                                 if (sb.indexOf(""+num)==-1) {
    
34.                                         sb.append(""+num);
    
35.                                 }
    
36.                         }
    
37.                         //System.out.println(sb.toString());
    
38.                         //将产生的随机数存入TreeSet
    
39.                         treeSet.add(sb.toString());
    
40.                         //清空缓存区
    
41.                         sb.delete(0, sb.length());
    
42.                         
    
43.                 }
    
44.                 //遍历TreeSet，通过条件判断输出组合
    
45.                 for (String string : treeSet) {
    
46.                         if (!string.startsWith("4")&&!string.contains("13")&&!string.contains("31")) {
    
47.                                 count++;
    
48.                                 System.out.print(string+"  ");
    
49.                                 if (count%7==0) {
    
50.                                         System.out.println();
    
51.                                 }
    
52.                         }
    
53.                 }
    
54.                 System.out.println(count);
    
55.         }
    
56. 
    
57.         
    
58. 
    
59. }
    

复制代码

第二题

1. package itheima;
   
2. 
   
3. import java.util.Random;
   
4. import java.util.TreeSet;
   
5. 
   
6. /**
   
7. *  题2：用1、2、2、3、4、5这六个数字，用java写一个main函数，
   
8. *  打印出所有不同的排列，如：512234、412345等，
   
9. *  要求："4"不能在第三位，"3"和"5"不能相连
   
10. * @author Administrator
    
11. *
    
12. */
    
13. public class Test20 {
    
14. 
    
15.         public static void main(String[] args) {
    
16.                 //用于换行
    
17.                 int count =0;
    
18.                 //统计产生了多少个随机数
    
19.                 //int count1=0;
    
20.                 Random random=new Random();
    
21.                 //用于记录随机数产生的组合
    
22.                 StringBuilder sb=new StringBuilder();
    
23.                 TreeSet<String> treeSet=new TreeSet<>();
    
24.                 //这6个数的排列有360种，n!/2
    
25.                 while (treeSet.size()<360) {
    
26.                         //通过循环将不同随机数存入字符串缓冲区
    
27.                         while (sb.length()<6) {
    
28.                                 //产生一个随机数
    
29.                                 int num=random.nextInt(6)+1;
    
30.                                 //count1++;
    
31.                                 //如果在字符串中找不到该随机数存入
    
32.                                 if (sb.indexOf(""+num)==-1) {
    
33.                                         sb.append(""+num);
    
34.                                 }
    
35.                         }
    
36.                         //System.out.println(sb.toString());
    
37.                         //将产生的随机数存入TreeSet
    
38.                         //for(int i=1;i<6;i++) {
    
39.                                 String line =sb.toString();
    
40.                                 treeSet.add(line.replace("6",""+2));
    
41.                         //}
    
42.                         //清空缓存区
    
43.                         sb.delete(0, sb.length());
    
44.                         
    
45.                 }
    
46.                 //遍历TreeSet，通过条件判断输出组合
    
47.                 for (String string : treeSet) {
    
48.                         if ((string.charAt(2)!='4')&&!string.contains("35")&&!string.contains("53")) {
    
49.                                 count++;
    
50.                                 System.out.print(string+"  ");
    
51.                                 if (count%7==0) {
    
52.                                         System.out.println();
    
53.                                 }
    
54.                         }
    
55.                 }
    
56.                 //System.out.println(count1);
    
57.                 System.out.println(count);
    
58.         }
    
59. 
    
60. }

复制代码

两个题的币不重叠，解题方法只要不相同，可重复得币

1. /*题1：用1、2、3、4这四个数字，用java写一个main函数打印出所有不同的排序，
   
2. 如：1234，1243等要求：“4”不能在第一位，“1”与“3”不能相连
   
3. 思路：1.肯定要用到for循环和if判断语句
   
4.       */
   
5. import java.util.*;
   
6. class  Test1
   
7. {
   
8.         public static void main(String[] args)
   
9.         {
   
10.                 int sum1=0;                     //采用三层嵌套循环，四数之和为10，前面三个数确定，最后一位也可确定。
    
11.                 for(int i=1;i<=3;i++)          //“4”不能在第一位，循环里面确定
    
12.                 {
    
13.                         for(int j=1;j<=4;j++)
    
14.                         {
    
15.                                 for(int l=1;l<=4;l++)
    
16.                                 {
    
17.                                         int sum=10-i-j-l;
    
18.                                         if((i!=j && j!=l && l!=i)&&            //判断语句条件一，前三个数字不相等
    
19.                                                 (i+j)!=4 &&(j+l)!=4&&(l+sum)!=4)    //判断语句条件二，3和1不在一起
    
20.                                         {
    
21.                                                     sum1=i*1000+j*100+l*10+sum;
    
22.                                                 System.out.println(sum1+"");
    
23.                                         }
    
24.                                 }
    
25.                         }
    
26. 
    
27.                 }
    
28.         }
    
29. }

复制代码

楼上的都是牛人，粗看了一眼，我的方法与各位都不一样，如果一样了，纯属巧合。下面是我的代码：