Sie erhalten eine Zeichenfolge, die normale Az-Zeichen enthält. (Sie können davon ausgehen, dass dies bei jedem Test immer der Fall ist, und davon ausgehen, dass alle Buchstaben ebenfalls in Kleinbuchstaben geschrieben sind.) Sie müssen bestimmen, wie viele eindeutige Kombinationen der einzelnen Zeichen in der Zeichenfolge erstellt werden können, und diese Zahl drucken.

Doppelte Buchstaben können jedoch beim Zählen der möglichen Kombinationen ignoriert werden. Mit anderen Worten, wenn die angegebene Zeichenfolge "Hallo" ist, zählt das einfache Umschalten der Positionen der beiden ls nicht als eindeutige Phrase und kann daher nicht zur Gesamtsumme gezählt werden.

Die kürzeste Byte-Anzahl gewinnt und wir freuen uns darauf, einige kreative Lösungen in Nicht-Golf-Sprachen zu sehen!

Beispiele:

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

Python 2 , 50 48 Bytes

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

Probieren Sie es online aus!

Keine langweiligen Einbauten! Zu meiner Überraschung ist dies sogar noch kürzer als der Brute-Force-Ansatz, bei dem alle Permutationen mit berechnet itertoolsund die Länge genommen werden.

Diese Funktion verwendet die Formel

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

und berechnet es im laufenden Betrieb. Die Fakultät im Zähler wird durch Multiplikation mit len(s)in jedem Funktionsaufruf berechnet . Der Nenner ist etwas subtiler; Bei jedem Aufruf dividieren wir durch die Anzahl der Vorkommen dieses Elements in den verbleibenden Teilen der Zeichenfolge, um sicherzustellen, dass für jedes Zeichen calle Zahlen zwischen 1 und der Anzahl der Vorkommen von c(einschließlich) durch genau einmal geteilt werden. Da wir nur ganz am Ende teilen, haben wir garantiert keine Probleme mit der Standard-Bodenteilung von Python 2.

05AB1E , 3 Bytes

œÙg

Probieren Sie es online aus!

Erläuterung

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

CJam , 4 Bytes

le!,

Probieren Sie es online aus!

Erläuterung

Zeile als Zeichenfolge lesen ( l), eindeutige Permutationen als Array von Zeichenfolgen ( e!), Länge ( ,), implizite Anzeige.

R , 69 65 Bytes

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

Probieren Sie es online aus!

4 Bytes gespeichert dank Zahiro Mor in beiden Antworten.

Berechnet den Multinomialkoeffizienten direkt.

R , 72 68 Bytes

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

Probieren Sie es online aus!

Verwendet die Multinomialverteilungsfunktion von dmultinom, um den Multinomialkoeffizienten zu extrahieren.

Beachten Sie, dass der übliche (Golfspieler) aus einem unbekannten Grund x<-table(strsplit(s,""))nicht innerhalb des dmultinomAnrufs funktioniert .

JavaScript (Node.js) , 49 Byte

t=t*wird verwendet t*=, um Rundungsfehler (das Abrunden |tder Zahl) zu vermeiden, um sicherzustellen t=t*, dass alle Zwischenergebnisse (in Bezug auf den Bediener) ganze Zahlen sind.

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

Probieren Sie es online aus!

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 Bytes

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

Probieren Sie es online aus!

Gibt das Ergebnis als Singleton zurück.

Japt , 5 3 Bytes

-2 Bytes dank @Shaggy

á l

Probieren Sie es online aus!

J , 15 , 14 Bytes

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

Probieren Sie es online aus!

-1 Byte dank FrownyFrog

Gelee , 4 Bytes

Œ!QL

Probieren Sie es online aus!

Tut einfach das, was gefragt wurde: Finde Permutationen der Eingabe, eindeutige und drucke die Länge.

C # (Visual C # Interactive Compiler) , 59 Byte

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

Port von @ArBos Python 2-Antwort .

Probieren Sie es online aus.

Brachylog , 3 Bytes

pᶜ¹

Probieren Sie es online aus!

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

pᵘl macht so ziemlich genau das Gleiche.

Python 2 , 57 Bytes

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

Probieren Sie es online aus!

Selbstdokumentierend: Gibt die Länge des Satzes eindeutiger Permutationen der Eingabezeichenfolge zurück.

Python 3 , 55 Bytes

Gutschrift geht an ArBo in diesem Fall :

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

Probieren Sie es online aus!

APL (Dyalog Unicode) , 24 Bytes

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

Probieren Sie es online aus!

Einfache Dfn, nimmt eine Zeichenfolge als Argument.

Wie:

⎕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

Ruby , 41 Bytes

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

Probieren Sie es online aus!

Perl 5 , 43 Bytes

Verwendet die Methode in der Python-Antwort von @ ArBo.

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

Probieren Sie es online aus!

Perl 6 , 33 30 Zeichen ( 34 31 Bytes)

Ziemlich geradliniger WhateverBlock. combteilt den String in Buchstaben auf, permutationserhält alle möglichen Kombinationen. Aufgrund der Art und Weise Zwang Setbraucht werden joinzuerst ed ( »gilt joinfür jedes Element in der Liste).

+*.comb.permutations».join.Set

Probieren Sie es online aus!

(Die vorherige Antwort wurde verwendet .unique, Setgarantiert jedoch die Eindeutigkeit und nummeriert sie, sodass 3 gespart werden.)

K (oK) , 12 Bytes

Lösung:

#?x@prm@!#x:

Probieren Sie es online aus!

Erläuterung:

Verwendet das integrierte OK prm:

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

... die im x^/:xGrunde genommen die Permutationen von "helo"nicht erzeugen "hello", daher müssen wir die Permutationen von erzeugen 0 1 2 3 4, sie verwenden, um sie zu indizieren "hello"und dann die Anzahl der eindeutigen zu nehmen.

#?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 Bytes

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

Port von @ArBos Python 2-Antwort .
-1 Byte dank @ OlivierGrégoire, indem es iterativ statt rekursiv gemacht wird.

Probieren Sie es online aus.

Das Erzeugen aller eindeutigen Permutationen in einem Satz und das Erhalten seiner Größe würde 221 Bytes betragen :

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

Probieren Sie es online aus.

MATL , 9 Bytes

jY@XuZy1)

Probieren Sie es online aus!

Erläuterung:

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

Oktave / MATLAB, 35 Bytes

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

Anonyme Funktion, die einen Zeichenvektor verwendet und eine Zahl erzeugt.

In MATLAB kann dies auf size(unique(perms(s),'ro'),1)(33 Bytes) gekürzt werden .

Probieren Sie es online aus!

Erläuterung

@(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 Bytes

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

Probieren Sie es online aus! Verwendet die Formel von @ ArBo, wird jedoch von rechts nach links ausgewertet, da dies in ganzzahliger Arithmetik erfolgen kann, während die Größe der beteiligten unären Werte weiterhin minimiert wird. Erläuterung:

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

Zählen Sie für jedes Zeichen, wie viele Duplikate noch vorhanden sind und wie viele weitere Zeichen vorhanden sind, fügen Sie jeweils eines hinzu, um das aktuelle Zeichen zu berücksichtigen, und trennen Sie die Werte, damit wir wissen, welche geteilt und welche multipliziert werden sollen .

^
1

Stellen Sie eine 1 voran, um einen vollständigen Ausdruck zu erhalten.

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

Multiplizieren Sie wiederholt die vorletzte und drittletzte Zahl, während Sie durch die vorletzte Zahl dividieren. Dies ersetzt die letzten drei Zahlen.

1

In Dezimalzahl konvertieren.

K, 27 Bytes

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

K, 16 Bytes - keine echte Antwort

#?(999999#0N)?\:

Nehmen Sie 999999 zufällige Permutationen der Eingabezeichenfolge, nehmen Sie die eindeutige Menge davon und zählen Sie die Länge. Meistens gibt es die richtige Antwort für kurze Saiten.

Verbessert dank @Sriotchilism O'Zaic, @Selcuk

Wolfram Language (Mathematica) , 32 Bytes

Characters/*Permutations/*Length

Probieren Sie es online aus!

Erläuterung: Die /*Rechtskomposition mit wendet diese drei Operatoren nacheinander von links nach rechts auf das Funktionsargument an:

• Characters konvertiert die Eingabezeichenfolge in eine Liste von Zeichen.

• Permutations erstellt eine Liste aller eindeutigen Permutationen dieser Zeichenliste.

• Length Gibt die Länge dieser Liste eindeutiger Permutationen zurück.

Diese Methode ist für lange Zeichenfolgen sehr verschwenderisch: Die eindeutigen Permutationen werden tatsächlich aufgelistet und gezählt, anstatt a Multinomialzu verwenden, um ihre Anzahl ohne Auflistung zu berechnen.

F # (Mono) , 105 Bytes

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

Probieren Sie es online aus!

Pyth , 5 4 Bytes

l{.p

Probieren Sie es online aus!

Dies setzt voraus, dass die Eingabe ein Python-String-Literal ist. Wenn die Eingabe Rohtext sein muss, funktioniert diese 5-Byte-Version:

l{.pz

In beiden Fällen werden nur alle Permutationen der Eingabe als Liste berechnet, dedupliziert, die Anzahl der darin enthaltenen Elemente ermittelt und diese Anzahl implizit gedruckt.

-1 Byte dank @ hakr14

J , 14  13 Bytes

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

Probieren Sie es online aus!

1 Byte dank Meilen

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

PHP , 77 Bytes

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

Probieren Sie es online aus!

Dies ist im Grunde nur eine PHP-Portierung von @ ArBos gewinnender Python-Antwort, die lächerlich klüger ist als die rekursive Antwort, die ich ursprünglich hatte. Bravo!

Ohm v2 , 4 Bytes

ψD∩l

Probieren Sie es online aus!

Erläuterung

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

Stax , 3 Bytes

═1╪

Führen Sie es aus und debuggen Sie es