คำนิยาม

อันดับของคำถูกกำหนดให้เป็นตำแหน่งของคำเมื่อการเรียงสับเปลี่ยน (หรือการจัดเรียง) ที่เป็นไปได้ทั้งหมดของตัวอักษรถูกจัดเรียงตามลำดับตัวอักษรเช่นในพจนานุกรมไม่ว่าคำนั้นจะมีความหมายหรือไม่ก็ตาม

ให้เราพิจารณาสองคำนี้ - "สีน้ำเงิน" และ "เห็น" ก่อนอื่นเราจะเขียนตัวอักษรของคำเหล่านี้ตามลำดับตัวอักษร:

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

ทีนี้ลองดูจากทางซ้ายและค้นหาตำแหน่งของคำที่เราต้องการ เราเห็นว่าคำว่า "สีน้ำเงิน" อยู่ที่ตำแหน่งที่ 4 และ "เห็น" อยู่ที่ตำแหน่งที่ 10 ดังนั้นอันดับของคำว่า "สีน้ำเงิน" คือ 4 และของ "เห็น" คือ 10 นี่คือวิธีทั่วไปในการคำนวณอันดับของคำ ตรวจสอบให้แน่ใจว่าคุณเริ่มนับจาก 1 เท่านั้น

งาน

งานของคุณคือการเขียนรหัสเพื่อใช้คำใด ๆ ที่เป็นอินพุตและแสดงอันดับของมัน อันดับควรเป็นผลลัพธ์ ระวังคำที่มีตัวอักษรซ้ำ ๆ

ตัวอย่าง

"prime" -> 94

"super" -> 93

"bless" -> 4

"speech" -> 354

"earth" -> 28

"a" -> 1

"abcd" -> 1

"baa" -> 3    

คุณสามารถสมมติว่าอินพุตเป็นตัวพิมพ์เล็กทั้งหมดและอินพุตจะมีอักขระตัวอักษรเท่านั้น นอกจากนี้หากป้อนช่องว่างหรือสตริงที่ไม่ถูกต้องคุณอาจส่งคืนสิ่งใดก็ได้

เกณฑ์การให้คะแนน

นี่คือรหัสกอล์ฟดังนั้นรหัสที่สั้นที่สุดชนะ!

Gaiaขนาด 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 || การเรียงสับเปลี่ยนทั้งหมดของอินพุต
   {|| deduplicate
  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 ไบต์

• ขอบคุณMr. 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

ลองออนไลน์!

+6 ไบต์เนื่องจากข้อกำหนดการจัดทำดัชนี 1 รายการ :(

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 ไม่มีวิธีการในตัวที่จะคำนวณการเปลี่ยนแปลงทางคำศัพท์ต่อไปดังนั้นเราต้องทำเอง แต่เดี๋ยวก่อน ... มันสั้นกว่าที่จะทำมันด้วยฟังก์ชั่นเรียกซ้ำง่าย ๆ ที่คำนวณการเรียงสับเปลี่ยนที่เป็นไปได้ทั้งหมดในลำดับใด ๆ

Ungolfed:

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

ลองออนไลน์!

ต้องการอินพุตเป็นตัวพิมพ์ใหญ่ทั้งหมดเนื่องจาก ... มันบันทึกไบต์

โปรแกรมเต็มรูปแบบใช้การป้อนข้อมูลจากและส่งออกไปยังstdinstdout

ชื่อตัวแปร: (เรียงลำดับของโค้ดที่ไม่ถูกปรับแต่ง)

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)

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

ลองออนไลน์!

Ruby , 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-ism ที่เป็นที่นิยมซึ่งรวมถึง <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 Limited ( Exhibit Bในหน้าใบอนุญาตนี้)

โปรแกรมที่จะเข้าเป็นสตริงแล้วโปรแกรมที่เกิดขึ้นจริงจะเริ่มต้นด้วย$s $b=New-Object ...เรากำลังสร้างออบเจกต์StringBuilderใหม่ซึ่งเป็นสตริงอักขระที่ไม่แน่นอน สิ่งนี้จะช่วยให้เราจัดการกับพีชคณิตได้ง่ายขึ้น จากนั้นเราจะเรียกใช้ฟังก์ชันn(ตั้งค่า$jตามความยาวของสตริงอินพุต) sortโดยใช้-uแฟล็ก nique เอาต์พุตใช้.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)

ลองออนไลน์!