Định nghĩa

Thứ hạng của một từ được định nghĩa là vị trí của từ khi tất cả các hoán vị (hoặc sắp xếp) có thể có của các chữ cái được sắp xếp theo thứ tự abc, như trong từ điển, bất kể các từ đó có ý nghĩa hay không.

Chúng ta hãy xem xét hai từ này - "màu xanh" và "nhìn thấy". Để bắt đầu, chúng tôi sẽ viết tất cả các sắp xếp có thể có của các chữ cái của các từ này theo thứ tự bảng chữ cái:

"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"

Bây giờ chúng ta hãy nhìn từ bên trái và tìm vị trí của các từ chúng ta cần. Chúng tôi thấy rằng từ "màu xanh" ở vị trí thứ 4 và "nhìn thấy" ở vị trí thứ 10. Vì vậy, thứ hạng của từ "màu xanh" là 4 và thứ hạng của "nhìn thấy" là 10. Đây là cách tính chung cho thứ hạng của một từ. Hãy chắc chắn rằng bạn bắt đầu đếm từ 1 chỉ.

Bài tập

Nhiệm vụ của bạn là viết mã để lấy bất kỳ từ nào làm đầu vào và hiển thị thứ hạng của nó. Thứ hạng nên là đầu ra. Hãy cẩn thận về các từ có chứa các chữ cái lặp đi lặp lại.

Ví dụ

"prime" -> 94

"super" -> 93

"bless" -> 4

"speech" -> 354

"earth" -> 28

"a" -> 1

"abcd" -> 1

"baa" -> 3    

Bạn có thể giả sử đầu vào hoàn toàn bằng chữ thường và đầu vào sẽ chỉ chứa các ký tự chữ cái . Ngoài ra nếu một khoảng trống hoặc một chuỗi không hợp lệ được nhập vào, bạn có thể trả lại bất cứ thứ gì.

Chấm điểm

Đây là môn đánh gôn , vì vậy đoạn mã ngắn nhất sẽ thắng!

Gaia , 4 byte

fuȯI

Hãy thử trực tuyến!

Python 3 , 71 byte

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

Hãy thử trực tuyến!

05AB1E , 5 byte

ϐsk>

Hãy thử trực tuyến! hoặc như một bộ thử nghiệm

Giải trình

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

Bình thường , 6 byte

hxS{.p

Bộ thử nghiệm.

Giải trình

hxS {.p | | Chương trình đầy đủ.

    .p | | Tất cả các hoán vị của đầu vào.
   {|| Khử trùng lặp.
  S | | Sắp xếp.
 x | | Chỉ số của đầu vào vào danh sách này.
h | | Tăng.

Thạch , 5 byte

Œ!ṢQi

Hãy thử trực tuyến! hoặc xem bộ kiểm tra

Làm thế nào nó hoạt động

Œ!Ṣ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 byte

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

Hãy thử trực tuyến!

Python 3 , 73 byte

• Cảm ơn ông Xcoder đã chọn Python 3; tiết kiệm năm byte.

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

Hãy thử trực tuyến!

CJam , 8 byte

q_e!\a#)

Hãy thử trực tuyến!

+1 byte do yêu cầu 1 chỉ mục.

Haskell , 56 byte

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

Hãy thử trực tuyến!

+6 byte vì yêu cầu lập chỉ mục 1. :

Japt , 8 10 byte

Chỉ số 0. Poxy, lập chỉ mục 1 không cần thiết, tăng 25% số byte của tôi!

á â n bU Ä

Kiểm tra nó

Giải trình

ánhận được tất cả các hoán vị của đầu vào, âloại bỏ trùng lặp, nsắp xếp chúng và blấy chỉ số của lần xuất hiện đầu tiên , U.

J , 28 23 byte

-5 byte nhờ FrownyFrog

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

Làm thế nào nó hoạt động?

                      ] - 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)

Hãy thử trực tuyến!

Tcl, 196 byte

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 không có phương pháp tích hợp để tính toán hoán vị từ vựng tiếp theo, vì vậy chúng tôi phải tự làm điều đó. Nhưng chờ đã ... nó ngắn hơn để làm điều đó với một hàm đệ quy đơn giản, tính toán tất cả các hoán vị có thể theo bất kỳ thứ tự nào.

Ung dung:

# 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 byte

Dung dịch:

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

Hãy thử trực tuyến!

Ví dụ:

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

Giải trình:

Tạo các hoán vị của các chỉ số của chuỗi đầu vào được sắp xếp, sử dụng chúng để lập chỉ mục trở lại chuỗi đầu vào, lấy các điểm khác biệt, xem nơi chuỗi gốc khớp với nhau và thêm một chuỗi.

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 byte

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)));}

Giải trình:

Hãy thử trực tuyến.

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 byte

Câu trả lời đầu tiên chạy trong thời gian đa thức!

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)

Hãy thử trực tuyến!

Yêu cầu đầu vào phải là chữ hoa, bởi vì ... nó tiết kiệm một byte.

Chương trình đầy đủ, lấy đầu vào từ stdinvà đầu ra stdout.

Tên biến: (loại mã không mã hóa)

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

Thật không may, from math import factorial as fmất chính xác thêm 1 byte.

(Lưu ý không liên quan: Tôi đã kiểm tra Combinatorica`gói Mathicala, không có gì hữu ích, kể cả RankPermutation)

Husk , 6 byte

S€(OuP

Hãy thử trực tuyến! Tôi cảm thấy nên có một cách để thả (.

Giải trình:

 €     -- 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

Sạch , 113 111 byte

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

Hãy thử trực tuyến!

+3 byte để xử lý lập chỉ mục 1: /

APL (Dyalog Unicode) , 33 byte (SBCS)

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

Hãy thử trực tuyến!

Python 3 , 105 104 103 byte

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])

Hãy thử trực tuyến!

Ruby , 49 byte

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

Hãy thử trực tuyến!

JavaScript (ES6), 106 100 byte

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]

Các trường hợp thử nghiệm

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

Làm sao?

P () là hàm hoán vị đệ quy của chúng ta. Nhưng đối tượng bao gồm của P cũng được sử dụng để lưu trữ các cấp bậc của hoán vị.

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

Mã gói bây giờ đọc là:

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 byte

#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]);}

Theo yêu cầu của tôi, mã chắc chắn cần phải được thực thi như vốn có. Mệnh đề chỉ chức năng cơ bản là rác. : - @

Cảm ơn những người vui lòng trả lời câu hỏi về những gì có thể được cắt ra cho tôi. Lợi ích của hợp lệ mã , tôi đã tránh được GCC-ism phổ biến bao gồm <bits / stdc ++. H>, mà tôi luôn coi là một lỗ hổng gian lận xấu.

Những gì tiếp theo là những gì còn lại của bài viết gốc của tôi:

Ở đây nó không được cung cấp với các tiêu đề cần thiết, vv:

#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] );
}

Đó là golf xuống tới 230 byte, một phần ba trong số các bản soạn sẵn tiêu chuẩn được yêu cầu bởi mọi chương trình C ++. (Vì vậy, tôi không cảm thấy quá tệ khi không đếm nó, nhưng vì tôi chưa bao giờ thấy một khiếu nại chắc chắn nào, OP sẽ phải cho tôi biết anh ta thích thỏa mãn điều gì khi viết mã để lấy bất kỳ từ nào làm đầu vào và hiển thị thứ hạng của nó.

Tôi cũng không chắc chắn nếu điều này thỏa mãn thì thứ hạng sẽ là đầu ra.

Perl 5 , 98 + 3 ( -pF) = 101 byte

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

Hãy thử trực tuyến!

Octave , 43 byte

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

Hãy thử trực tuyến!

Perl 6 , 53 byte

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

Hãy thử trực tuyến!

PowerShell , 275 byte

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

Hãy thử trực tuyến!

Vì vậy, đây là một mớ hỗn độn đẫm máu.

PowerShell không có bất kỳ hoán vị nào được tích hợp sẵn, vì vậy mã này sử dụng thuật toán từ đây (được đánh rất nhiều), có sẵn theo Giấy phép Công cộng của Microsoft Limited ( Triển lãm B trên trang cấp phép này).

Chương trình lấy đầu vào $slà một chuỗi, sau đó chương trình thực tế bắt đầu bằng $b=New-Object .... Chúng tôi đang xây dựng một đối tượng StringBuilder mới , về cơ bản là một chuỗi các ký tự có thể thay đổi. Điều này sẽ cho phép chúng tôi xử lý các hoán vị dễ dàng hơn. Sau đó chúng ta gọi hàm n(cài đặt$j dọc theo chiều dài của chuỗi đầu vào), sortvới -ucờ nique là đầu ra, lấy .indexOf()chuỗi tìm chuỗi đầu vào và thêm 1vì PowerShell không được lập chỉ mục.

Chức năng là phần chính của chương trình. Nó nhận đầu vào là một số và mỗi lần lặp sẽ đếm ngược cho đến khi chúng ta đạt được1 (nghĩa là một chữ cái duy nhất). Phần còn lại của hàm về cơ bản gọi đệ quy hàm cũng như lấy chữ cái hiện tại và lặp lại nó qua mọi vị trí.

Có một bit logic bổ sung if($s.length-eq1){1;exit}để tính các chuỗi đầu vào có độ dài 1do cách thức hoạt động của hàm hoán vị.

Pyt , 5 byte

ĐᒆỤ≥Ʃ

Giải trình:

            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)

Hãy thử trực tuyến!