C:数字排列
(输入文件: C.in 输出文件: estdout. pc2)

小明最近对数字的排列产生了强烈的兴趣，他想将任意6个连续一位整数按照每行3个

的方式排列成两行，使得这些数据满足条件: 6个数字各不相同，并且上面的数据比下面的

大、左边的数据比右边的大。请你设计程字帮助小明解决这个数字排列问题，求出数字排列

的具体排列方式。
输入数据:
第一行输入一个整数n表示测试案例的个数。此后的每行输入一个数据表示本测试案例

6个连续一位整数的起始数据，当输入的起始数据不能保证连续的6个数据都是1位数时，

显示出Out of data Space!的提示信息。
输出数据:
对应每个测试的起始数据，输出以其为首的连续六个数据的排列方式		和排列种数
样例输入:
2

7

-3
数样例输出:
Out of data space!

2	0	-2

1	-1	-3

2	1	-2

0	-1	3

2	0	-1

1	-2	-3

2	1	-1

0	-2	-3

2	1	0

-1	-2	-3

Java代码：
public class Main {

	@SuppressWarnings("resource")
	public static void main(String[] args) {
		int n,t;
		Scanner input = new Scanner(System.in);
		n = input.nextInt();
		for(int i = 0; i < n; i++) {
			t = input.nextInt();
			if(t >= -9 && t <= 4) {
				show(t);
			}else {
				System.out.println("Out of data Space!");
			}
		}
	}

	/*
	 * 2	0	-2 			5 3 1
	 * 1	-1	-3			4 2 0
	 * 
	 * 2	1	-2			5 4 1
	 * 0	-1	-3			3 2 0
	 * 
	 * 2	0	-1			5 3 2
	 * 1	-2	-3			4 1 0
	 * 
	 * 2	1	-1			5 4 2
	 * 0	-2	-3			3 1 0
	 * 
	 * 2	1	0			5 4 3
	 * -1	-2	-3			2 1 0
	 */
	private static void show(int n) {
		int[] arr = new int[6];
		for(int i = 0; i < 6; i++) {
			arr[i] = n++;
		}
//		for(int i = 0; i < arr.length; i++) {
//			System.out.print(arr[i]+" ");
//		}
		System.out.println(arr[5]+" "+arr[3]+" "+arr[1]);
		System.out.println(arr[4]+" "+arr[2]+" "+arr[0]);
		
		System.out.println(arr[5]+" "+arr[4]+" "+arr[1]);
		System.out.println(arr[3]+" "+arr[2]+" "+arr[0]);
		
		System.out.println(arr[5]+" "+arr[3]+" "+arr[2]);
		System.out.println(arr[4]+" "+arr[1]+" "+arr[0]);
		
		System.out.println(arr[5]+" "+arr[4]+" "+arr[2]);
		System.out.println(arr[3]+" "+arr[1]+" "+arr[0]);
		
		System.out.println(arr[5]+" "+arr[4]+" "+arr[3]);
		System.out.println(arr[2]+" "+arr[1]+" "+arr[0]);
	}

}

建表语句点击详见
– 查询每门课程的平均成绩，结果按平均成绩降序排列，平均成绩相同时，按课程编号升序排列

SELECT 

c.c_id,
c.c_name,
AVG(sc.s_score) 

FROM course c
INNER JOIN score sc ON sc.c_id=c.c_id  
GROUP BY c.c_id ORDER BY AVG(sc.s_score) DESC,c.c_id ASC

一、圆排列简介
圆排列简单来说，就是排列的数围成了一个圈，如下图：


二、圆排列数
假设总共有$n$个数，圆排列数为$x$，先给出结论：

$x = \frac{A_n^n}{n}=(n-1)!$
下面简单说明一下原因：
首先对于$n$个数的直线排列肯定是$A_n^n$。那么为什么要除$n$呢？看下图：


对于一个排列$1、2、3、4$来说，由于排列的数围成了一个圆，所以将其旋转一次，使得$4$在最上方，在我们日常生活中看来，这显然属于一种排列，无非是不同的方向看过去罢了。同样的，$3$、$2$在上方也是如此。
对于一个$n$个数的排列来说，可以旋转$n$次，每个排列都是$n$次重复。所以要除以$n$。

题目描述：给出一个不含重复数字的排列，求这些数字的所有排列按字典序排序后该排列的编号。其中，编号从1开始。
样例：例如，排列 [1,2,4] 是第 1 个排列。



关于“字典序”和排列的相关基础概念请翻看我之前的博客（详见：点击打开链接），在这篇博客里面我还写了是如何求取一个排列的下一个排列的，如果这些内容你不清楚的话，请先打开链接回看，然后再来做这道题，因为很多内容我会当做你已经很了解字典序，故省略。
好了，这道题的意思是求一个排列的序号。那么我们先写出一个全排列，看看这些排列的规律：
比如，数字1, 2, 3构成的全排列如下：
1, 2, 3
1, 3, 2
2, 1, 3
2, 3, 1
3, 1, 2
3, 2, 1
根据之前我讲的字典序的规律（还是在博文：点击打开链接 中），我们可以发现，一个排列的顺序首先跟他的第一个字符是有关系的。第一个字符越大，其顺序越靠后。比如，上面的排列，现实两个1打头的，再是两个2打头的，最后是两个3打头的。
所以，如果我们知道了一个排列，就可以通过这个规律找到在他之前，比他打头的元素小的排列有多少个。这个与他的打头元素在所有元素中的顺序有关。
比如，现在要求排列2, 1, 4是第几个排列。首先2排在数字[1, 2, 4]（升序排列）的第二位，他前面的元素只有1个，那么他前面的这些元素这个元素打头的排列有多少呢？我们可以用 x * (n - 1)! 表示。其中，x为某个排列首元素在所有元素组成的升序中前面的元素个数，n表示所有元素的个数。放到例子里，x = 1, n = 3
首元素处理完毕之后，用同样的逻辑处理第二个元素，有 x * (n - 2)!个排列在这个排列之前，但是需要注意的是这里的x表示的是整个数组中，排除第一位元素之后，小于第二位元素的所有元素的个数。拿2, 1, 4来说，x = 0
然后，再处理第三个，第四个。。。。一直到最后一个。最后将这些数相加就是这个排列之前的排列数，因为求的是第几个排列，所以再加1即可。


感觉没说清楚，举个例子吧：求排列 6, 8, 4, 7, 3, 2 是第几个排列：
1. 处理6：3 * (6 -1)! = 360
2. 处理8：4 * (6 - 2)! = 96
3. 处理4：2 * (6 - 3)! = 12
4. 处理7：2 * (6 - 4)! = 4
5. 处理3：1 * (6 - 5)! = 1
6. 处理2：0 * (6 - 6)! = 0
将上面的数字加和：360 + 96 + 12 + 4 + 1 + 0 = 473
再加1，得到474
所以，排列 6, 8, 4, 7, 3,
 2为第474个排列。 
代码如下：

class Solution:
    # @param {int[]} A an integer array
    # @return {long} a long integer
    def permutationIndex(self, A):
        n = len(A)
        order = sorted(A)
        result = 0
        i = 0
        while i < n:
            temp = self.fact(n - i - 1) * order.index(A[i])
            order.remove(A[i])
            result += temp
            i += 1
        return result + 1

    def fact(self, num):
        if num == 0:
            return 0
        result = 1
        for i in range(1, num + 1):
            result *= i
        return result
        # Write your code here
第二个函数fact()用于计算阶乘。