Ti viene data una stringa, che conterrà i normali caratteri az. (Puoi presumere che questo sarà sempre il caso in qualsiasi test e supporre che anche tutte le lettere saranno minuscole). È necessario determinare quante combinazioni uniche possono essere fatte dei singoli caratteri nella stringa e stampare quel numero.

Tuttavia, le lettere duplicate possono essere ignorate nel conteggio delle possibili combinazioni. In altre parole, se la stringa fornita è "ciao", semplicemente cambiare le posizioni delle due ls non conta come una frase univoca e quindi non può essere conteggiata per il totale.

Vince il conteggio dei byte più breve, in attesa di vedere alcune soluzioni creative in lingue non golf!

Esempi:

hello -> 60
aaaaa -> 1
abcde -> 120

Python 2 , 50 48 byte

f=lambda s:s==''or len(s)*f(s[1:])/s.count(s[0])

Provalo online!

Nessun noioso built-in! Con mia sorpresa, questo è ancora più breve dell'approccio della forza bruta, calcolando tutte le permutazioni con itertoolse prendendo la lunghezza.

Questa funzione utilizza la formula

$\text{# of unique permutations} = \frac{\text{(# of elements)!}}{\prod_{\text{unique elements}}{\text{(# of occurences of that element)!}}}$

e lo calcola al volo. Il fattoriale nel numeratore viene calcolato moltiplicando per len(s)ogni chiamata di funzione. Il denominatore è un po 'più sottile; in ogni chiamata, dividiamo per il numero di occorrenze di quell'elemento in ciò che resta della stringa, assicurando che per ogni carattere c, tutti i numeri tra 1 e la quantità di occorrenze di c(compreso) saranno divisi esattamente una volta. Poiché dividiamo solo alla fine, siamo certi di non avere problemi con la divisione di default del piano di Python 2.

05AB1E , 3 byte

œÙg

Provalo online!

Spiegazione

  g  # length of the list
 Ù   # of unique
œ    # permutations
     # of the input

CJam , 4 byte

le!,

Provalo online!

Spiegazione

Leggi la riga come stringa ( l), permutazioni uniche come matrice di stringhe ( e!), lunghezza ( ,), visualizzazione implicita.

R , 69 65 byte

function(s,`!`=factorial)(!nchar(s))/prod(!table(strsplit(s,"")))

Provalo online!

4 byte salvati grazie a Zahiro Mor in entrambe le risposte.

Calcola direttamente il coefficiente multinomiale.

R , 72 68 byte

function(s,x=table(strsplit(s,"")))dmultinom(x,,!!x)*sum(1|x)^sum(x)

Provalo online!

Utilizza la funzione di distribuzione multinomiale fornita da dmultinomper estrarre il coefficiente multinomiale.

Si noti che il solito (golfista) x<-table(strsplit(s,""))non funziona all'interno della dmultinomchiamata per un motivo sconosciuto.

JavaScript (Node.js) , 49 byte

t=t*viene utilizzato invece di t*=evitare errori di arrotondamento (arrotondando per difetto |til numero) in quanto t=t*garantisce che tutti i risultati intermedi (dal punto di vista dell'operatore) siano numeri interi.

a=>[...a].map(g=x=>t=t*y++/(g[x]=-~g[x]),t=y=1)|t

Provalo online!

a=>
 [...a].map(        // Loop over the characters
  g=x=>
   t=t*             // using t*= instead may result in rounding error 
    y++             // (Length of string)!
    /(g[x]=-~g[x])  // divided by product of (Count of character)!
  ,t=y=1            // Initialization
 )
 |t

APL (Dyalog Unicode) , 14 byte

!∘⍴÷⊂×.(!∘⍴∩)∪

Provalo online!

Restituisce il risultato come singleton.

Japt , 5 3 byte

-2 byte grazie a @Shaggy

á l

Provalo online!

J , 15 , 14 byte

[:#@=i.@!@#A.]

Provalo online!

-1 byte grazie a FrownyFrog

Gelatina , 4 byte

Œ!QL

Provalo online!

Fa semplicemente quello che è stato chiesto: trova permutazioni di input, unifica e stampa la lunghezza.

C # (compilatore interattivo Visual C #) , 59 byte

f=s=>s==""?1:s.Length*f(s.Substring(1))/s.Count(c=>c==s[0])

Porta della risposta Python 2 di @ArBo .

Provalo online.

Brachylog , 3 byte

pᶜ¹

Provalo online!

       The output is
 ᶜ¹    the number of unique
p      permutations of
       the input.

pᵘl fa praticamente esattamente la stessa cosa.

Python 2 , 57 byte

lambda s:len(set(permutations(s)))
from itertools import*

Provalo online!

Auto-documentazione: restituisce la lunghezza dell'insieme di permutazioni univoche della stringa di input.

Python 3 , 55 byte

Il merito va ad ArBo su questo:

lambda s:len({*permutations(s)})
from itertools import*

Provalo online!

APL (Dyalog Unicode) , 24 byte

⎕CY'dfns'
{≢∪↓⍵[pmat≢⍵]}

Provalo online!

Dfn semplice, accetta una stringa come argomento.

Come:

⎕CY'dfns'      ⍝ Copies the 'dfns' namespace.
{≢∪↓⍵[pmat≢⍵]} ⍝ Main function
          ≢⍵   ⍝ Number of elements in the argument (⍵)
      pmat     ⍝ Permutation Matrix of the range [1..≢⍵]
    ⍵[      ]  ⍝ Index the argument with that matrix, which generates all permutations of ⍵
   ↓           ⍝ Convert the matrix into a vector of strings
  ∪            ⍝ Keep only the unique elements
 ≢             ⍝ Tally the number of elements

Rubino , 41 byte

f=->s{s.chars.permutation.to_a.uniq.size}

Provalo online!

Perl 5 , 43 byte

Utilizza il metodo nella risposta Python di @ ArBo.

sub c{!@_||@_*c(@_[1..$#_])/grep/$_[0]/,@_}

Provalo online!

Perl 6 , 33 30 caratteri ( 34 31 byte)

WhateverBlocco abbastanza dritto . combdivide la stringa in lettere, permutationsottiene tutte le possibili combinazioni. A causa del modo in cui la coercizione Setdeve essere modificata per joinprima (si »applica joina ciascun elemento nell'elenco).

+*.comb.permutations».join.Set

Provalo online!

(la risposta precedente utilizzata .uniquema Setgarantisce l'unicità e la numerazione della stessa, quindi salva 3).

K (oK) , 12 byte

Soluzione:

#?x@prm@!#x:

Provalo online!

Spiegazione:

Utilizza l'ok integrato prm:

{[x]{[x]$[x;,/x ,''o'x ^/:x;,x]}@$[-8>@x;!x;x]}

... che a causa x^/:xessenzialmente genera le permutazioni di "helo"no "hello", quindi abbiamo bisogno di generare le permutazioni di 0 1 2 3 4, usarle per indicizzare "hello"e quindi prendere il conteggio dell'unicità.

#?x@prm@!#x: / the solution
          x: / store input as x
         #   / count (#) length
        !    / range (!) 0..n
    prm@     / apply (@) to function prm
  x@         / apply permutations to input x
 ?           / take the distinct (?)
#            / count (#)

Java 8, 103 102 byte

s->{int r=1,i=s.length();for(;i>0;)r=r*i/~-s.substring(--i).split(s.charAt(i)+"",-1).length;return r;}

Porta della risposta Python 2 di @ArBo .
-1 byte grazie a @ OlivierGrégoire rendendolo iterativo anziché ricorsivo.

Provalo online.

Generare effettivamente tutte le permutazioni uniche in un set e ottenere la sua dimensione sarebbe di 221 byte :

import java.util.*;s->{Set S=new HashSet();p(s,S,0,s.length()-1);return S.size();}void p(String s,Set S,int l,int r){for(int i=l;i<=r;p(s.replaceAll("(.{"+l+"})(.)(.{"+(i++-l)+"})(.)(.*)","$1$4$3$2$5"),S,l+1,r))S.add(s);}

Provalo online.

MATL , 9 byte

jY@XuZy1)

Provalo online!

Spiegazione:

j input as string
Y@ get permutations
Xu unique members
Zy size matrix
1) first member of size matrix

Octave / MATLAB, 35 byte

@(s)size(unique(perms(s),'rows'),1)

Funzione anonima che accetta un vettore di carattere e produce un numero.

In MATLAB questo può essere ridotto a size(unique(perms(s),'ro'),1)(33 byte).

Provalo online!

Spiegazione

@(s)                                  % Anonymous function with input s
                perms(s)              % Permutations. Gives a char matrix
         unique(        ,'rows')      % Deduplicate rows
    size(                       ,1)   % Number of rows

Retina 0.8.2 , 73 byte

(.)(?=(.*?\1)*)
/1$#2$*1x1$.'$*
^
1
+`1(?=1*/(1+)x(\1)+$)|/1+x1+$
$#2$*
1

Provalo online! Utilizza la formula di @ ArBo, ma valuta da destra a sinistra in quanto ciò può essere fatto in aritmetica intera pur minimizzando la dimensione dei valori unari coinvolti. Spiegazione:

(.)(?=(.*?\1)*)
/1$#2$*1x1$.'$*

Per ogni personaggio, conta quanti duplicati restanti ci sono e quanti altri caratteri ci sono, aggiungine uno a ciascuno per prendere in considerazione il personaggio attuale e separa i valori in modo da sapere quali devono essere divisi e quali devono essere moltiplicati .

^
1

Prefisso a 1 per produrre un'espressione completa.

+`1(?=1*/(1+)x(\1)+$)|/1+x1+$
$#2$*

Moltiplicare ripetutamente l'ultimo e il terzo ultimo numero mentre si divide per il secondo ultimo numero. Questo sostituisce gli ultimi tre numeri.

1

Converti in decimale.

K, 27 byte

*/[1+!#:x]%*/{*/1+!x}'#:'x:

K, 16 byte - non una vera risposta

#?(999999#0N)?\:

Prendi 999999 permutazioni casuali della stringa di input, prendine il set unico e conta la lunghezza. La maggior parte delle volte darà la risposta giusta, per stringhe a corto raggio.

Migliorato grazie a @Sriotchilism O'Zaic, @Selcuk

Wolfram Language (Mathematica) , 32 byte

Characters/*Permutations/*Length

Provalo online!

Spiegazione: La composizione a destra con /*applica questi tre operatori uno dopo l'altro all'argomento della funzione, da sinistra a destra:

• Characters converte la stringa di input in un elenco di caratteri.

• Permutations crea un elenco di tutte le permutazioni uniche di questo elenco di caratteri.

• Length restituisce la lunghezza di questo elenco di permutazioni uniche.

Questo metodo è molto dispendioso per le stringhe lunghe: le permutazioni uniche sono effettivamente elencate e contate, invece di usare a Multinomialper calcolare il loro numero senza elencare.

F # (Mono) , 105 byte

let rec f s=if s=""then 1 else s.Length*(f(s.Substring 1))/(s|>Seq.sumBy(fun c->if c=s.[0]then 1 else 0))

Provalo online!

Pyth , 5 4 byte

l{.p

Provalo online!

Ciò presuppone che l'input sia una stringa di pitone letterale. Se l'input deve essere un testo non elaborato, questa versione a 5 byte funzionerà:

l{.pz

Ad ogni modo, calcola semplicemente tutte le permutazioni dell'input come un elenco, lo deduplica e ottiene il numero di elementi in esso, e stampa implicitamente quel numero.

-1 byte grazie a @ hakr14

J , 14  13 byte

#(%*/)&:!#/.~

Provalo online!

1 byte grazie alle miglia

#                  length
         #/.~      counts of each unique character
 (%*/)             divide left by the product of right
      &:!          after applying ! to both

PHP , 77 byte

function f($s){return!$s?:strlen($s)*f(substr($s,1))/substr_count($s,$s[0]);}

Provalo online!

Questo è fondamentalmente solo una porta PHP della risposta Python vincente di @ArBo che è ridicolmente più intelligente della risposta ricorsiva che avevo originariamente. Bravo!

Ohm v2 , 4 byte

ψD∩l

Provalo online!

Spiegazione

   l    output the lenght of
  ∩     the set intersection between
ψD      two copies of all possible permutation of input

Stax , 3 byte

═1╪

Esegui ed esegui il debug