정의

단어의 순위는 단어의 의미와 상관없이 사전에서와 같이 문자의 가능한 모든 순열 (또는 배열)이 사전 순으로 정렬 될 때 단어의 위치로 정의됩니다.

이 두 단어 "blue"와 "seen"을 고려해 봅시다. 우선, 우리는이 단어의 글자의 가능한 모든 배열을 알파벳 순서로 씁니다.

"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    

입력이 완전히 소문자라고 가정 할 수 있으며 입력에는 알파벳 문자 만 포함 됩니다 . 또한 공백이나 유효하지 않은 문자열을 입력하면 아무 것도 반환 할 수 있습니다.

채점

이것은 code-golf 이므로 가장 짧은 코드가 승리합니다!

가이아 , 4 바이트

fuȯI

온라인으로 사용해보십시오!

파이썬 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

파이썬 2 , 78 바이트

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

온라인으로 사용해보십시오!

파이썬 3 , 73 바이트

• Python 3을 선택해 주신 Mr. Xcoder 에게 감사드립니다 . 5 바이트 절약.

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

온라인으로 사용해보십시오!

CJam , 8 바이트

q_e!\a#)

온라인으로 사용해보십시오!

1 인덱싱 된 요구 사항으로 인해 +1 바이트

하스켈 , 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 바이트

FrownyFrog 덕분에 -5 바이트

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

자바 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`

파이썬 3 , 183 바이트

다항식으로 실행되는 첫 번째 답변!

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

클린 , 113111 바이트

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

온라인으로 사용해보십시오!

1- 인덱싱을 처리하기위한 +3 바이트 : /

APL (Dyalog Unicode) , 33 바이트 (SBCS)

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

온라인으로 사용해보십시오!

파이썬 (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)}

온라인으로 사용해보십시오!

자바 스크립트 (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]);}

필자의 요청에 따라 코드는 그대로 실행 가능해야합니다. 함수 전용 절은 기본적으로 쓰레기입니다. :-@

나를 위해 무엇을 잘라낼 수 있는지에 대해 친절하게 대답 한 사람들에게 감사합니다. 유효 의 이익을 위해 코드, 난 항상 나쁜 허점 속임수로 간주 한 <비트 / stdc ++. 시간>을 포함한 인기 GCC-주의를 피했다.

다음은 내 원래 게시물의 남은 부분입니다.

여기 에 필요한 헤더 등이 있습니다.

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

온라인으로 사용해보십시오!

펄 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 제한 공중 사용 허가서 (아래에서 사용할 수있는, (크게 golfed) 전시 B 이 라이선스 페이지).

프로그램은 입력 $s을 문자열로 취한 다음 실제 프로그램은로 시작합니다 $b=New-Object .... 우리는 새로운 StringBuilder 객체를 만들고 있는데, 이것은 본질적으로 변경 가능한 문자열입니다. 이를 통해 순열을보다 쉽게 ​​처리 할 수 ​​있습니다. 우리는 다음 함수를 호출 n(설정 $j, 입력 문자열의 길이로 길을 따라)를 sort와 -u테이크, nique 플래그 출력을 .indexOf()입력 문자열을 찾기 위해, 그리고 추가 1PowerShell을 제로 인덱스되기 때문이다.

이 기능은 프로그램의 주요 부분입니다. 숫자를 입력으로 취하고 도달 할 때까지 각 반복이 카운트 다운됩니다.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)

온라인으로 사용해보십시오!