挑战

对于给定的n个整数集，编写一个程序，该程序将输出其字典索引。

规则

• 输入只能是由空格分隔的一组唯一的非负整数。
• 您应该输出排列的字典索引（范围从0到n！-1）。
• 不能使用置换库或内置置换。
• 您可能不会生成输入的排列集或排列的任何子集来帮助您找到索引。
• 您也不能将给定的排列递增或递减到下一个/上一个（按字典顺序）排列。
• 如果您找到某种无需使用阶乘就可以完成的奖励积分（-10字节）。
• 对于n = 100，运行时间应少于1分钟
• 字节数最短的代码获胜
• 优胜者选择星期二（2014年7月22日）

有关排列的更多信息

• http://www.monkeyphysics.com/articles/read/26/numbering_permutations.html
• 排列组运算
• http://lin-ear-th-inking.blogspot.com/2012/11/enumerating-permutations-using.html

例子

0 1 2 --> 0
0 2 1 --> 1
1 0 2 --> 2
1 2 0 --> 3
2 0 1 --> 4
2 1 0 --> 5
0 1 2 3 4 5 6 7 --> 0
0 1 2 3 4 5 7 6 --> 1
0 1 2 3 4 6 5 7 --> 2
1 3 5 17        --> 0
781 780 779 13  --> 23
81 62 19 12 11 8 2 0 --> 40319
195 124 719 1 51 6 3 --> 4181

GolfScript，12（22个字符-10个奖励）

~]0\.,{.,@*\.(@$?@+\}*

不使用阶乘的奖励积分。输入必须以问题中描述的格式在STDIN上进行。您可以在线尝试代码。

CJam，31岁，有析因

q~]{__(f<0+:+\,,(;1+:**\(;}h]:+

Python 2（77 = 87-10）

p=map(int,raw_input().split())
s=0
while p:s=s*len(p)+sorted(p).index(p.pop(0))
print s

这样可读。很多内置的。哇。

我们使用这样一个事实，即排列的词典索引是该排列之上的元素的总和乘以该元素之上的元素数量的阶乘。与其逐项评估类似多项式的表达项，我们使用类似于霍纳方法的方法。

而不是循环遍历数组索引，我们重复删除列表的第一个元素并处理其余元素。该表达式sorted(p).index(p.pop(0))通过在排序后的列表中占据第一个索引的位置来计算超过第一个索引的反转次数，同时执行删除操作。

不幸的是，我不得不使用Python 2并为它增加了4个字符raw_input（尽管对于，为-1 print），因为在Python 3中map(int,...)，它会生成一个不支持列表操作的map对象，

积（13 = 23-10）

JVPwdWJ=Z+*ZlJXovNJ;J)Z

我的Python回答的端口。

Python翻译（过滤掉一些无关的内容）：

Z=0
J=rev(split(input()," "))
while J:
 Z=plus(times(Z,len(J)),index(order(lambda N:eval(N),J),J.pop()))
print(Z)

输入数字保留为字符串，但通过使用eval作为键将其按整数排序。该列表是反向的，因此pop位于前面而不是后面。

眼镜蛇-202

显然，眼镜蛇并没有真正参加这一竞赛。

class P
    var n=0
    var t=CobraCore.commandLineArgs[1:]
    def main
        .f(.t[0:0])
    def f(l as List<of String>)
        if.t.count==l.count,print if(.t<>l,'',.n+=1)
        else,for i in.t.sorted,if i not in l,.f(l+[i])

J，5个字节（15-10）

#\.#.+/@(<{.)\.

这需要O（n ²）时间，并且能够轻松处理n = 100。

用法

   f =: #\.#.+/@(<{.)\.
   f 0 1 2
0
   f 0 2 1
1
   f 1 0 2
2
   f 1 2 0
3
   f 2 0 1
4
   f 2 1 0
5
   f 0 1 2 3 4 5 6 7
0
   f 0 1 2 3 4 5 7 6
1
   f 0 1 2 3 4 6 5 7
2
   f 1 3 5 17
0
   f 781 780 779 13
23
   f 81 62 19 12 11 8 2 0
40319
   f 195 124 719 1 51 6 3
4181
   NB. A. is the builtin for permutation indexing
   timex 'r =: f 927 A. i. 100'
0.000161
   r
927

说明

#\.#.+/@(<{.)\.  Input: array P
             \.  For each suffix of P
          {.       Take the head
         <         Test if it is greater than each of that suffix
     +/@           Sum, count the number of times it is greater
#\.              Get the length of each suffix of P
   #.            Convert to decimal using a mixed radix