定义

单词的等级定义为当单词的所有可能排列（或排列）按字母顺序排列（例如在字典中）时的位置，无论单词是否有意义。

让我们考虑这两个词-“蓝色”和“可见”。首先，我们将按字母顺序写出这些单词的字母的所有可能排列：

"blue": "belu","beul","bleu","blue","buel","bule","eblu","ebul","elub","elbu","eubl",
        "eulb","lbeu","lbue","lebu","leub","lube","lueb","ubel","uble","uebl","uelb",
        "ulbe","uleb"
"seen": "eens","eesn","enes","ense","esen","esne","nees","nese","nsee","seen",
        "sene","snee"

现在让我们从左边看，找到所需单词的位置。我们看到单词“ blue”在第4位，“ seen”在第10位。因此，单词“ blue”的等级为4，“ seen”的等级为10。这是计算单词等级的一般方法。确保仅从1开始计数。

任务

您的任务是编写代码，以将任何单词作为输入并显示其排名。排名应该是输出。小心包含重复字母的单词。

例子

"prime" -> 94

"super" -> 93

"bless" -> 4

"speech" -> 354

"earth" -> 28

"a" -> 1

"abcd" -> 1

"baa" -> 3    

您可以假定输入完全是小写，并且输入将仅包含字母字符。另外，如果输入空格或无效字符串，则可能返回任何内容。

计分

这是代码高尔夫球，因此最短的代码获胜！

盖亚 4字节

fuȯI

在线尝试！

Python 3，71个字节

lambda s:sum(t<=(*s,)for t in{*permutations(s)})
from itertools import*

在线尝试！

05AB1E，5个字节

ϐsk>

在线尝试！ 或作为测试套件

说明

œ       # get permutations of input
 ê      # sort and remove duplicates
  s     # swap input to top of stack
   k    # get index of input in the list
    >   # increment

Pyth，6个字节

hxS{.p

测试套件。

说明

hxS {.p || 完整程序。

    .p || 输入的所有排列。
   {|| 重复数据删除。
  S || 分类。
 x || 输入到此列表的索引。
h || 增量。

果冻，5个字节

Œ!ṢQi

在线尝试！或查看测试套件

怎么运行的

Œ!ṢQi - Main link. Argument: s (string)      e.g. 'baa'
Œ!    - All permutations                          ['baa', 'baa', 'aba', 'aab', 'aba', 'aab']
  Ṣ   - Sort                                      ['aab', 'aab', 'aba', 'aba', 'baa', 'baa']
   Q  - Deduplicate                               ['aab', 'aba', 'baa']
    i - 1-based index of s                        3

Python 2，78个字节

lambda s:-~sorted(set(permutations(s))).index(tuple(s))
from itertools import*

在线尝试！

Python 3，73个字节

• 感谢Xcoder先生选择了Python 3；节省五个字节。

lambda s:-~sorted({*permutations(s)}).index((*s,))
from itertools import*

在线尝试！

CJam，8个字节

q_e!\a#)

在线尝试！

由于有1个索引，因此需要+1个字节。

Haskell，56个字节

import Data.List
elemIndex<*>([]:).nub.sort.permutations

在线尝试！

由于需要1个索引，因此需要+6个字节。:(

Japt，8个10字节

0索引。Poxy，不必要的1分度，使我的字节数增加了25％！

á â n bU Ä

测试一下

说明

á获取输入的所有排列，â删除重复项，对其进行n排序，并b获取第一次出现的输入的索引U。

J，28 23字节

-5字节归功于FrownyFrog

1+/:~@~.@(A.~i.@!@#)i.]

怎么运行的？

                      ] - the argument
         (A.~      )    - permutations in the 
             i.@!@#     - range 0 to factorial of the arg. length
  /:~@~.@               - remove duplicates and sort
                    i.  - index of arg. in the sorted list
1+                      - add 1 (for 1-based indexing)

在线尝试！

Tcl，196个字节

proc p {a p} {if {$a eq {}} {lappend ::p $p} {while {[incr n]<=[llength $a]} {p [lreplace $a $n-1 $n-1] $p[lindex $a $n-1]}}}
p [split $argv ""] ""
puts [expr [lsearch [lsort -unique $p] $argv]+1]

Tcl没有内置的方法来计算下一个词典编排，因此我们必须自己做。但是等等... 用一个简单的递归函数来完成它要短一些，该递归函数可以按任何顺序计算所有可能的排列。

取消高尔夫：

# Compute all possible permutations of the argument list
# Puts the result in ::all_permutations
proc generate_all_permutations {xs {prefixes ""}} {
  if {$xs eq {}} {
    lappend ::all_permutations $prefixes
  } else {
    while {[incr n] <= [llength $xs]} {
      generate_all_permutations [lreplace $xs $n-1 $n-1] $prefixes[lindex $xs $n-1]
    } 
  }
}

# Get our input as command-line argument, turn it into a list of letters
generate_all_permutations [split $argv ""]

# Sort, remove duplicates, find the original argument, and print its 1-based index
puts [expr [lsearch [lsort -unique $all_permutations] $argv]+1]

K（oK），23 18字节

解：

1+*&x~/:?x@prm@<x:

在线尝试！

例子：

1+*&x~/:?x@prm@<x:"seen"
10
1+*&x~/:?x@prm@<x:"blue"
4

说明：

生成排序后的输入字符串的索引的排列，使用它们重新索引到输入字符串，进行区分，查看原始字符串在哪里匹配，然后添加一个。

1+*&x~/:?x@prm@<x: / the solution
                x: / save input string as x
               <   / return indices when sorting x ascending
           prm@    / apply (@) function prm
         x@        / index into x with these permutations
        ?          / distinct (remove duplicates)
    x~/:           / apply match (~) between x and each-right (/:)
   &               / return indexes where true (ie the match)
  *                / take the first one
1+                 / add 1 due to 1-indexing requirement

Java 8，211字节

import java.util.*;TreeSet q=new TreeSet();s->{p("",s);return-~q.headSet(s).size();}void p(String p,String s){int l=s.length(),i=0;if(l<1)q.add(p);for(;i<l;p(p+s.charAt(i),s.substring(0,i)+s.substring(++i,l)));}

说明：

在线尝试。

import java.util.*;        // Required import for TreeSet

TreeSet q=new TreeSet();   // Sorted Set on class-level

s->{                       // Method with String parameter and integer return-type
  p("",s);                 //  Save all unique permutations of the String in the sorted set
  return-~q.headSet(s).size();}
                           //  Return the 0-indexed index of the input in the set + 1

void p(String p,String s){ // Separated method with 2 String parameters and no return-type
  int l=s.length(),        //  The length of the String `s`
      i=0;                 //  Index integer, starting at 0
  if(l<1)                  //  If String `s` is empty
    q.add(p);              //   Add `p` to the set
  for(;i<l;                //  Loop from 0 to `l` (exclusive)
    p(                     //   Do a recursive call with:
      p+s.charAt(i),       //    `p` + the character at the current index of `s` as new `p`
      s.substring(0,i)+s.substring(++i,l)));}
                           //    And `s` minus this character as new `s`

Python 3中，183 ×182字节

在多项式时间内运行的第一个答案！

a=[*map(ord,input())]
f=lambda x:x and x*f(x-1)or 1
c=[0]*98
for C in a:c[C]+=1
l=len(a)
F=f(l)
for i in c:F//=f(i)
r=1
for x in a:F//=l;l-=1;r+=sum(c[:x])*F;F*=c[x];c[x]-=1
print(r)

在线尝试！

要求输入全部为大写，因为...它保存一个字节。

完整程序，从输入stdin和输出到stdout。

变量名称：（某种不匹配的代码）

a : permu
f : factorial
c : count_num
C : char
l : n_num_left
F : factor
r : result

不幸的是，from math import factorial as f还要多占用1个字节。

（无关的注解：我检查了Combinatorica`Mathematica 的软件包，没有用，包括RankPermutation）

外壳，6个字节

S€(OuP

在线尝试！我觉得应该有办法下降(。

说明：

 €     -- return index of the input 
S (    -- in the list generated by applying the following functions to the input:
     P -- permutations
    u  -- remove duplicates
   O   -- sort

干净，113个 111字节

import StdEnv,StdLib
?s=elemIndex s[[]:removeDup(foldr(\a b=sort[insertAt i a x\\x<-b,i<-[0..length x]])[[]]s)]

在线尝试！

+3个字节来处理1索引：/

APL（Dyalog Unicode），33字节（SBCS）

⎕CY'dfns'
{∪⊃∘(⍵[⍋⍵])¨¨↓pmat≢⍵}⍳⊂

在线尝试！

Python 3中，105个 104 103字节

f=lambda s:s==s*2or f(s[1:])+sum(f(sorted(s[:s.index(c)]+s[s.index(c)+1:])[::-1])for c in{*s}if c<s[0])

在线尝试！

红宝石，49字节

->w{c=w.chars
1+c.sort.permutation.uniq.index(c)}

在线尝试！

JavaScript（ES6）， 106个 100字节

w=>(P=(a,s)=>a[0]?a.map((_,i)=>P(b=[...a],s+b.splice(i,1))):P[s]=P[s]||++k)[P([...w].sort(),k=''),w]

测试用例

let f =

w=>(P=(a,s)=>a[0]?a.map((_,i)=>P(b=[...a],s+b.splice(i,1))):P[s]=P[s]||++k)[P([...w].sort(),k=''),w]

console.log(f("prime"))  // 94
console.log(f("super"))  // 93
console.log(f("bless"))  // 4
console.log(f("speech")) // 354
console.log(f("earth"))  // 28
console.log(f("a"))      // 1
console.log(f("abcd"))   // 1
console.log(f("baa"))    // 3

怎么样？

P（）是我们的递归置换函数。但是P的包围对象也用于存储排列的秩。

P = (a, s) =>               // given an array of letters a[] and a string s
  a[0] ?                    // if a[] is not empty:
    a.map((_, i) =>         //   for each entry at position i in a[]:
      P(                    //     do a recursive call to P() with:
        b = [...a],         //       a copy b[] of a[], with a[i] removed
        s + b.splice(i, 1)  //       the extracted letter appended to s
      )                     //     end of recursive call
    )                       //   end of map()
  :                         // else:
    P[s] = P[s] || ++k      //   if P[s] is not already defined, set it to ++k

包装代码现在显示为：

w =>                        // given the input word w
  P[                        // return the permutation rank for w
    P(                      //   initial call to P() with:
      [...w].sort(),        //     the lexicographically sorted letters of w
      k = ''                //     s = k = '' (k is then coerced to a number)
    ),                      //   end of call
    w                       //   actual index used to read P[]
  ]                         // end of access to P[]

C ++，230字节

#include<algorithm>
#include<iostream>
#include<string>
using namespace std;void R(string s){int n=1;auto p=s;sort(begin(p),end(p));do if(p==s)cout<<n;while(++n,next_permutation(begin(p),end(p)));}int main(int n,char**a){R(a[1]);}

按照我的要求，代码绝对需要按原样执行。仅函数子句基本上是垃圾。：-@

谢谢那些亲切回答可以为我解决的问题的人。为了有效代码，我避免了流行的GCC主义，包括<bits / stdc ++。h>，我一直认为这是一个坏的漏洞。

以下是我原始帖子的其余内容：

这里没有必要的标题，等等：

#include <algorithm>
#include <iostream>
#include <string>
using namespace std;

void R( string s )
{
  int n = 1;
  auto p = s;
  sort( begin(p), end(p) );
  do if (p == s) cout << n;
  while (++n, next_permutation( begin(p), end(p) ));
}

int main( int n, char** a )
{
  R( a[1] );
}

压缩到230字节，是每个文件要求的标准样板的三分之一 C ++程序。（因此，我不算不算难过，但是由于我从未见过任何坚定的抱怨，OP必须告诉我他更希望满足“编写代码以接受任何单词作为输入并显示其排名。”）

我也不确定这是否满足“应该输出等级”。

Perl 5，98 + 3（-pF）= 101字节

$"=',';@a=grep{++$k{$_}<=1&&"@F"eq join$",sort/./g}sort glob"{@F}"x(@F=sort@F);1while!/$a[$\++]/}{

在线尝试！

八度，43字节

@(s)find(all(unique(perms(s),'rows')==s,2))

在线尝试！

Perl 6、53字节

{1+first :k,$_,.comb.permutations».join.unique.sort}

在线尝试！

PowerShell，275字节

param($s)function n($a){if($a-eq1){return}0..($a-1)|%{n($a-1);if($a-eq2){$b.ToString()}$p=($j-$a);[char]$t=$b[$p];for($z=($p+1);$z-lt$j;$z++){$b[($z-1)]=$b[$z]}$b[($z-1)]=$t}}if($s.length-eq1){1;exit}$b=New-Object Text.StringBuilder $s;(n($j=$s.length)|sort -u).indexOf($s)+1

在线尝试！

因此，这真是一团糟。

PowerShell没有内置的排列，因此此代码使用此处的算法（大量使用），该算法在Microsoft受限公共许可证下（此许可页面上的附件B）可用。

该程序将输入$s作为字符串，然后实际程序以开头$b=New-Object ...。我们正在构造一个新的StringBuilder对象，该对象（本质上）是可变的字符串。这将使我们能够更轻松地处理排列。然后，我们调用函数n（将其设置$j为输入字符串的长度），sort并使用-unique标志将其输出，然后使用.indexOf()来查找输入字符串，然后添加1因为PowerShell的索引为零。

该功能是程序的主要部分。它以数字作为输入，并且每次迭代都会递减计数，直到达到1（即，一个字母）。该函数的其余部分基本上以递归方式调用该函数，并获取当前字母并遍历每个位置。

由于置换功能的工作原理，因此还有一点额外的逻辑if($s.length-eq1){1;exit}来说明长度的输入字符串1。

Pyt，5 个字节

ĐᒆỤ≥Ʃ

说明：

            Implicit input
Đ           Duplicate input
 ᒆ         Get list of all permutations of input
  Ụ         Get unique permutations
   ≥        Does each permutation come before or is equal to the input?
    Ʃ       Sum of result of previous step (converts booleans to ints)

在线尝试！