Définition

Le rang d'un mot est défini comme la position du mot lorsque toutes les permutations (ou dispositions) possibles de ses lettres sont organisées par ordre alphabétique, comme dans un dictionnaire, peu importe si les mots ont un sens ou non.

Examinons ces deux mots - «bleu» et «vu». Pour commencer, nous écririons tous les arrangements possibles des lettres de ces mots dans l'ordre alphabétique:

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

Regardons maintenant à gauche et trouvons la position des mots dont nous avons besoin. On voit que le mot "bleu" est en 4ème position et "vu" est en 10ème position. Ainsi, le rang du mot "bleu" est 4, et celui de "vu" est 10. C'est la façon générale de calculer le rang d'un mot. Assurez-vous de commencer à compter à partir de 1 seulement.

Tâche

Votre tâche consiste à écrire un code pour prendre n'importe quel mot en entrée et afficher son rang. Le rang doit être la sortie. Faites attention aux mots contenant des lettres répétées.

Exemples

"prime" -> 94

"super" -> 93

"bless" -> 4

"speech" -> 354

"earth" -> 28

"a" -> 1

"abcd" -> 1

"baa" -> 3    

Vous pouvez supposer que l'entrée est entièrement en minuscules et l'entrée ne contiendra que des caractères alphabétiques . De plus, si un espace vide ou une chaîne non valide est entré, vous pouvez renvoyer n'importe quoi.

Notation

C'est le code-golf , donc le code le plus court gagne!

Gaia , 4 octets

fuȯI

Essayez-le en ligne!

Python 3 , 71 octets

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

Essayez-le en ligne!

05AB1E , 5 octets

ϐsk>

Essayez-le en ligne! ou comme suite de tests

Explication

œ       # 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 octets

hxS{.p

Suite de tests.

Explication

hxS {.p || Programme complet.

    .p || Toutes les permutations de l'entrée.
   {|| Dédupliquer.
  S || Trier.
 x || Index de l'entrée dans cette liste.
h || Incrément.

Gelée , 5 octets

Œ!ṢQi

Essayez-le en ligne! ou voir la suite de tests

Comment ça marche

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

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

Essayez-le en ligne!

Python 3 , 73 octets

• Merci à M. Xcoder d' avoir choisi Python 3; économiser cinq octets.

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

Essayez-le en ligne!

CJam , 8 octets

q_e!\a#)

Essayez-le en ligne!

+1 octet en raison de l'exigence d'indexation 1.

Haskell , 56 octets

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

Essayez-le en ligne!

+6 octets en raison de l'exigence d'indexation 1. :(

Japt , 8 10 octets

0 indexé. Poxy, 1-indexation inutile, augmentant mon nombre d'octets de 25%!

á â n bU Ä

Essaye-le

Explication

áobtient toutes les permutations de l'entrée, âEnlève les doublons, nles trie et bobtient l'indice de la première occurrence de l'entrée, U.

J , 28 23 octets

-5 octets grâce à FrownyFrog

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

Comment ça marche?

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

Essayez-le en ligne!

Tcl, 196 octets

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 n'a pas de méthode intégrée pour calculer la prochaine permutation lexicographique, nous devons donc le faire nous-mêmes. Mais attendez ... il est plus court de le faire avec une simple fonction récursive qui calcule toutes les permutations possibles dans n'importe quel ordre.

Non golfé:

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

Solution:

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

Essayez-le en ligne!

Exemples:

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

Explication:

Générez des permutations des index de la chaîne d'entrée triée, utilisez-les pour indexer de nouveau dans la chaîne d'entrée, prenez les éléments distincts, voyez où la chaîne d'origine correspondait et ajoutez-en une.

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 octets

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

Explication:

Essayez-le en ligne.

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 octets

La première réponse qui s'exécute en temps polynomial!

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)

Essayez-le en ligne!

Exiger que l'entrée soit entièrement en majuscules, car ... elle enregistre un octet.

Programme complet, prend l'entrée stdinet la sortie de stdout.

Noms de variables: (sorte de code non golfé)

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

Malheureusement, from math import factorial as f prend exactement 1 octet de plus.

(Remarque indépendante: j'ai vérifié le Combinatorica`package de Mathematica, rien d'utile, y compris RankPermutation)

Husk , 6 octets

S€(OuP

Essayez-le en ligne! Je pense qu'il devrait y avoir un moyen d'abandonner (.

Explication:

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

Nettoyer , 113 111 octets

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

Essayez-le en ligne!

+3 octets pour gérer l'indexation 1: /

APL (Dyalog Unicode) , 33 octets (SBCS)

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

Essayez-le en ligne!

Python 3 , 105 104 103 octets

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

Essayez-le en ligne!

Rubis , 49 octets

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

Essayez-le en ligne!

JavaScript (ES6), 106 100 bytes

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]

Cas de test

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

Comment?

P () est notre fonction de permutation récursive. Mais l'objet englobant de P est également utilisé pour stocker les rangs des permutations.

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

Le code d'habillage se lit désormais comme suit:

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 octets

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

Selon ma demande, le code doit certainement être exécutable tel quel. La clause de fonction uniquement est essentiellement des ordures. : - @

Merci à ceux qui ont aimablement répondu à la question de savoir ce qui peut être découpé pour moi. Dans l'intérêt de la validité code , j'ai évité le GCC-isme populaire d'inclure <bits / stdc ++. H>, que j'ai toujours considéré comme une mauvaise triche.

Ce qui suit est ce qui reste de mon message d'origine:

Ici, il n'est pas golfé avec les en-têtes nécessaires, etc.:

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

Ce golf jusqu'à 230 octets, un tiers de ce passe- partout standard requis par chaque programme C ++. (Donc, je ne me sens pas trop mal sans le compter, mais comme je n'ai jamais vu de plainte ferme de toute façon, OP devra me dire ce qu'il préfère satisfaire "écrire un code pour prendre n'importe quel mot comme entrée" et afficher son rang. ")

Je ne suis pas sûr non plus que cela satisfasse «le rang devrait être affiché».

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

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

Essayez-le en ligne!

Octave , 43 octets

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

Essayez-le en ligne!

Perl 6 , 53 octets

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

Essayez-le en ligne!

PowerShell , 275 octets

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

Essayez-le en ligne!

Donc, c'est un bordel sanglant.

PowerShell n'a pas de permutations intégrées, donc ce code utilise l'algorithme d' ici (beaucoup joué), qui est disponible sous la licence publique limitée de Microsoft ( pièce B sur cette page de licence).

Le programme prend l'entrée $ssous forme de chaîne, puis le programme réel commence par $b=New-Object .... Nous construisons un nouvel objet StringBuilder , qui est (essentiellement) une chaîne de caractères modifiable. Cela nous permettra de gérer plus facilement les permutations. Nous appelons ensuite la fonction n(définissant en $jcours de route la longueur de la chaîne d'entrée), sortavec le -udrapeau nique la sortie, prenons le .indexOf()pour trouver la chaîne d'entrée et ajoutons1 car PowerShell est indexé zéro.

La fonction est la partie principale du programme. Il prend en entrée un nombre et chaque itération compte à rebours jusqu'à ce que nous atteignions 1(c'est-à-dire une seule lettre). Le reste de la fonction appelle essentiellement la fonction de manière récursive, prend la lettre actuelle et l'itère dans toutes les positions.

Il existe un seul bit de logique supplémentaire if($s.length-eq1){1;exit}pour prendre en compte les chaînes d'entrée de longueur en 1raison du fonctionnement de la fonction de permutations.

Pyt , 5 octets

ĐᒆỤ≥Ʃ

Explication:

            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)

Essayez-le en ligne!