用1234567七个数组成的七位数（数字不能重复使用）中，从大到小排列的第2002个数是？

Question

用1234567七个数组成的七位数（数字不能重复使用）中，从大到小排列的第2002个数是？
谁会啊

Answer 1

我的count为0表示第一个
public int getTheNum(int count) {
int theNum = 0;
int[] d = new int[7];
int j=6;
int k = 0;
int sum = 1;
for (int i = 0; i < 7; i++) { // 循环七次得出每位的数字
// 得出每次改变本位数字所能组成的数字个数,及j!
while (j > 0) {
sum *= j;
j--;
}
// K每次要取剩下数的第几个
k = 0;
while (true) {
//如果count小于0则说明本位数字已经不能再小
if (count < 0) {
//将其存个d[i]中
d[i] = k;
count += sum;
j = 6 - i - 1;
sum = 1;
k = 0;
break;
} else {
k++;
count -= sum;
}
}
}

// 将7654321存入list中方便取出对应的值
List list = new ArrayList(); for (int i = 7; i > 0; i--) {
list.add(i);
}
//得到每位数字并将其转为相应的整数
int m = 1000000;
for (int i = 0; i < 7; i++) {
int index = d[i];
//取出相应的数
d[i] = Integer.parseInt("" + list.get(index - 1));
theNum += d[i] * m;
m /= 10;
//将其移除
list.remove(index - 1); }
return theNum; }

Answer 2

格式化了下public int getTheNum(int count) {
int theNum = 0;
int[] d = new int[7];
int j=6;
int k = 0;
int sum = 1;
for (int i = 0; i < 7; i++) { // 循环七次得出每位的数字
// 得出每次改变本位数字所能组成的数字个数,及j!
while (j > 0) {
sum *= j;
j--;
}
// K每次要取剩下数的第几个
k = 0;
while (true) {
//如果count小于0则说明本位数字已经不能再小
if (count < 0) {
//将其存个d[i]中
d[i] = k;
count += sum;
j = 6 - i - 1;
sum = 1;
k = 0;
break;
} else {
k++;
count -= sum;
}
}
}

// 将7654321存入list中方便取出对应的值
List list = new ArrayList(); for (int i = 7; i > 0; i--) {
list.add(i);
}
//得到每位数字并将其转为相应的整数
int m = 1000000;
for (int i = 0; i < 7; i++) {
int index = d[i];
//取出相应的数
d[i] = Integer.parseInt("" + list.get(index - 1));
theNum += d[i] * m;
m /= 10;
//将其移除
list.remove(index - 1); }
return theNum; }

Answer 3

public int Get(int count){
int c=0;
int num=0;
     for(int i=7; i>0; i--)
     {
      for(int j=7; j>0; j--)
      {        
      for(int k=7; k>0; k--)
      {
     for(int l=7; l>0; l--)
     {
     for(int m=7; m>0; m--)
     {
     for(int n=7; n>0; n--)
     {       
     for(int p=7; p>0; p--){
     num =i*1000000+j*100000+k*10000+l*1000+m*100+n*10+p;
     String snum =Integer.toString(num);
     c++;
                            if(c==count){
                             System.out.println(snum);
                             break;
                              }
     }
     }
     }
     } 
      }
      }
     }
     return num;
}

Answer 4

本帖最后由 java2000_net 于 2009-08-28 14:27:26 编辑

  

Answer 5

public static void main(String[] args) {
int sum=0;
for (int i = 1; i <= 7; i++) {
for (int j = 1; j <= 7; j++) {
for (int k = 1; k <= 7; k++) {
for (int n = 1; n <= 7; n++) {
for (int m = 1; m <= 7; m++) {
for (int g = 1; g <= 7; g++) {
for (int h = 1; h <= 7; h++) {
if (i != j && i != k && i != n && i != m
&& i != g && i != h && j != k
&& j != n && j != m && j != g
&& j != h && k != n && k != m
&& k != g && k != h && n != m
&& n != g && n != h && m != g
&& m != h && g != h) {
sum=sum+1;
System.out.println("第"+sum+"数是： "+i + "" + j + "" + k
+ "" + n + "" + m + "" + g + ""
+ h);

}
}
}
}
}
}
}
} }第2002个数是：3652471有点麻烦了，不知有高效率的吗

Answer 6

闲来无事，把楼主心中的疑问解决一下。
/*用1234567七个数组成的七位数（数字不能重复使用）中，从大到小排列的第2002个数是？
*  本题的解法，可以用来求全排列。main方法中做了示范。
*/
import java.util.*;
public class Test{

    public static void main(String args[]) throws Exception {
     System.out.println("1～7的排列，从大到小第2002个数是：");
     System.out.println(elementNumberOfPermutation(7,2002,false));
     System.out.println("\n从大到小前10个:");
     for(int i=1;i<=10;i++){
     System.out.println(elementNumberOfPermutation(7,i,false));
     }
     System.out.println("\n从小到大前10个");
     for(int i=1;i<=10;i++){
     System.out.println(elementNumberOfPermutation(7,i,true));
     }
    }
    
    /*求长度为len的数字串的全排列中第num个数是多少？
     *@param len 数字串的长度，比如len为4，表示1~4的全排列
     *@param num 按positiveOrder指定的顺序，全排列的第num个排列。
     *@param positiveOrder  true为正序，false为逆序
     *@return 返回1~len组成的数字的全排列中，正序或逆序第num个排列。
     */
    public static  long elementNumberOfPermutation(int len,long num,boolean positiveOrder){
     if(len<0 || len>20){
     //如果用long，21!会溢出。
     throw new ArithmeticException("长度必需是大于1，小于21");
     }
    
     //把结果数字放到result这处List中：
    
     List<Integer> result=new ArrayList<Integer>();
    
     //总的排列数
     //
     long totalNumberOfPermutation=1;
    
    
     //放1～len这些数字：
     //
     List<Integer> numberList=new ArrayList<Integer>();
     for(int i=1;i<=len;i++){
     numberList.add(i);
     }
    
     //求总排列数：
     //
     for(int i=2;i<=len;i++){
     totalNumberOfPermutation*=i;
     }
     if(num<1){
     num=1;
     }
     if(num>totalNumberOfPermutation){
     num=totalNumberOfPermutation;
     }
    
     //正序和逆序不同，都按正序求。
     //
     if(!positiveOrder){
     num=totalNumberOfPermutation-num+1;
     }
    
     //除了排在最前面的数字，其余数字的总排列数，把总排序分为len组，每一组就是toalNumberPermutation个排列：
     //
     totalNumberOfPermutation/=len;
    
     //从最高位开始，依次求出每一位数字是多少。
     //
     while(num!=0){
     //求当前数字位时，要先求第num个排列在那个组中，temp表示组的序号：
     //
     int temp;
    
     //num/totalNumberOfPermutation结果就是第num个排列所在的组数（第一组为0）。
     //
     if(num%totalNumberOfPermutation==0){
     temp=(int)(num/totalNumberOfPermutation)-1;
     }else{
     temp=(int)(num/totalNumberOfPermutation);
     }
    
     //从numberList中取出当前数字位，放到结果result中，并删除之。
     //
     result.add(numberList.get(temp));
     numberList.remove(temp);
    
     //下一次分组数要减一：
     //
     len--;
     //下一次的求第num个数，要在组内求，问题变为在temp组内求第num%totalNumberOfPermutation个排列。
     //
     num=num%totalNumberOfPermutation;
     //分组中的排序总数也相应改变。
     //
     totalNumberOfPermutation/=len;
     }
    
     //当num为零时，如果numberList中还有数字，要从大到小回在结果的最后
     //
    
     for(int i=numberList.size()-1;i>=0;i--){
     result.add(numberList.get(i));
     }
    
     //把result中放的数字位，合为一个长整形数。
     //
     long resultNum=0;
     for(Integer i: result){
     resultNum=resultNum*10+i;
     }
     return resultNum;
    }
}
F:\java>java Test
1～7的排列，从大到小第2002个数是：
5236417从大到小前10个:
7654321
7654312
7654231
7654213
7654132
7654123
7653421
7653412
7653241
7653214从小到大前10个
1234567
1234576
1234657
1234675
1234756
1234765
1235467
1235476
1235647
1235674

Answer 7

前面的搞错了，正确结果是3 6 5 2 4 7 1
求解过程
1 * * * * * *  6！= 720
2 * * * * * *  6！= 720
3 1 * * * * *  5! = 120
3 2 * * * * *  5! = 120
3 4 * * * * *  5! = 120
3 5 * * * * *  5! = 120
3 6 1 * * * *  4! = 24
3 6 2 * * * *  4! = 24
3 6 4 * * * *  4! = 24
3 6 5 1 * * *  3! = 6
3 6 5 2 1 * *  2! = 2
2x720 + 4x120 + 3x24 + 6 + 2 = 2000所以第2001个数是：3 6 5 2 4 1 7
第2002个是 3 6 5 2 4 7 1