Se le da una cadena, que contendrá caracteres az ordinarios. (Puede suponer que este será siempre el caso en cualquier prueba, y asumir que todas las letras también estarán en minúsculas). Debe determinar cuántas combinaciones únicas se pueden hacer de los caracteres individuales en la cadena e imprimir ese número.

Sin embargo, las letras duplicadas pueden ignorarse al contar las combinaciones posibles. En otras palabras, si la cadena dada es "hola", simplemente cambiar las posiciones de los dos ls no cuenta como una frase única y, por lo tanto, no puede contarse hacia el total.

¡El conteo de bytes más cortos gana, esperando ver algunas soluciones creativas en idiomas que no sean de golf!

Ejemplos:

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

Pruébalo en línea!

No hay complementos aburridos! Para mi sorpresa, esto es incluso más corto que el enfoque de fuerza bruta, calculando todas las permutaciones con itertoolsy tomando la longitud.

Esta función usa la fórmula

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

y lo calcula sobre la marcha. El factorial en el numerador se calcula multiplicando por len(s)en cada llamada a la función. El denominador es un poco más sutil; en cada llamada, dividimos por el número de ocurrencias de ese elemento en lo que queda de la cadena, asegurando que para cada carácter c, todos los números entre 1 y la cantidad de ocurrencias de c(inclusive) se dividirán por exactamente una vez. Como nos dividimos solo al final, tenemos la garantía de no tener ningún problema con la división de piso predeterminada de Python 2.

05AB1E , 3 bytes

œÙg

Pruébalo en línea!

Explicación

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

CJam , 4 bytes

le!,

Pruébalo en línea!

Explicación

Lea la línea como una cadena ( l), permutaciones únicas como una matriz de cadenas ( e!), longitud ( ,), visualización implícita.

R , 69 65 bytes

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

Pruébalo en línea!

4 bytes guardados gracias a Zahiro Mor en ambas respuestas.

Calcula el coeficiente multinomial directamente.

R , 72 68 bytes

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

Pruébalo en línea!

Utiliza la función de distribución multinomial proporcionada por dmultinompara extraer el coeficiente multinomial.

Tenga en cuenta que lo habitual (golfista) x<-table(strsplit(s,""))no funciona dentro de la dmultinomllamada por un motivo desconocido.

JavaScript (Node.js) , 49 bytes

t=t*se usa en lugar de t*=evitar el error de redondeo ( |tredondea el número hacia abajo) como t=t*garantía de que todos los resultados intermedios (a nivel del operador) son números enteros.

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

Pruébalo en línea!

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

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

Pruébalo en línea!

Devuelve el resultado como un singleton.

Japt , 5 3 bytes

-2 bytes gracias a @Shaggy

á l

Pruébalo en línea!

J , 15 , 14 bytes

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

Pruébalo en línea!

-1 byte gracias a FrownyFrog

Jalea , 4 bytes

Œ!QL

Pruébalo en línea!

Simplemente hace lo que se le pidió: encontrar permutaciones de entrada, uniquificar e imprimir la longitud.

C # (compilador interactivo de Visual C #) , 59 bytes

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

Puerto de la respuesta Python 2 de @ArBo .

Pruébalo en línea.

Brachylog , 3 bytes

pᶜ¹

Pruébalo en línea!

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

pᵘl hace casi exactamente lo mismo.

Python 2 , 57 bytes

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

Pruébalo en línea!

Autodocumentado: devuelve la longitud del conjunto de permutaciones únicas de la cadena de entrada.

Python 3 , 55 bytes

El crédito va a ArBo en este caso:

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

Pruébalo en línea!

APL (Dyalog Unicode) , 24 bytes

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

Pruébalo en línea!

Dfn simple, toma una cadena como argumento.

Cómo:

⎕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}

Pruébalo en línea!

Perl 5 , 43 bytes

Utiliza el método en la respuesta Python de @ ArBo.

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

Pruébalo en línea!

Perl 6 , 33 30 caracteres ( 34 31 bytes)

WhateverBloque bastante sencillo . combdivide la cadena en letras, permutationsobtiene todas las combinaciones posibles. Debido a la forma en que la coerción Setdebe ser joineditada primero (se »aplica joina cada elemento de la lista)

+*.comb.permutations».join.Set

Pruébalo en línea!

(se utilizó la respuesta anterior .uniquepero Sets garantiza la unicidad y numera la misma, por lo que ahorra 3).

K (oK) , 12 bytes

Solución:

#?x@prm@!#x:

Pruébalo en línea!

Explicación:

Utiliza el oK incorporado prm:

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

... que, debido a que x^/:xbásicamente genera las permutaciones de "helo"no "hello", por lo tanto, necesitamos generar las permutaciones de 0 1 2 3 4, usarlas para indexar "hello"y luego tomar la cuenta de lo único.

#?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, 103102 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;}

Puerto de la respuesta Python 2 de @ArBo .
-1 byte gracias a @ OlivierGrégoire haciéndolo iterativo en lugar de recursivo.

Pruébalo en línea.

En realidad, generar todas las permutaciones únicas en un conjunto y obtener su tamaño sería de 221 bytes :

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

Pruébalo en línea.

MATL , 9 bytes

jY@XuZy1)

Pruébalo en línea!

Explicación:

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

Octava / MATLAB, 35 bytes

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

Función anónima que toma un vector de caracteres y produce un número.

En MATLAB esto se puede acortar a size(unique(perms(s),'ro'),1)(33 bytes).

Pruébalo en línea!

Explicación

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

Pruébalo en línea! Utiliza la fórmula de @ ArBo, pero evalúa de derecha a izquierda, ya que esto se puede hacer en aritmética de enteros mientras se minimiza el tamaño de los valores unarios involucrados. Explicación:

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

Para cada carácter, cuente cuántos duplicados restantes hay y cuántos caracteres más hay, agregue uno a cada uno para tener en cuenta el carácter actual y separe los valores para que sepamos cuáles se deben dividir y cuáles se deben multiplicar. .

^
1

Prefije un 1 para producir una expresión completa.

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

Multiplica repetidamente el último y el tercer último número mientras divide por el segundo último número. Esto reemplaza los últimos tres números.

1

Convierte a decimal.

K, 27 bytes

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

K, 16 bytes: no es una respuesta real

#?(999999#0N)?\:

Tome 999999 permutaciones aleatorias de la cadena de entrada, tome el conjunto único de ellas y cuente la longitud. La mayoría de las veces dará la respuesta correcta, para cadenas cortas.

Mejorado gracias a @Sriotchilism O'Zaic, @Selcuk

Wolfram Language (Mathematica) , 32 bytes

Characters/*Permutations/*Length

Pruébalo en línea!

Explicación: La composición derecha con /*aplica estos tres operadores uno tras otro al argumento de la función, de izquierda a derecha:

• Characters convierte la cadena de entrada en una lista de caracteres.

• Permutations hace una lista de todas las permutaciones únicas de esta lista de caracteres.

• Length devuelve la longitud de esta lista de permutaciones únicas.

Este método es muy derrochador para cadenas largas: las permutaciones únicas se enumeran y cuentan, en lugar de usar a Multinomialpara calcular su número sin enumerar.

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

Pruébalo en línea!

Pyth , 5 4 bytes

l{.p

Pruébalo en línea!

Esto supone que la entrada es un literal de cadena de Python. Si la entrada debe ser texto sin formato, esta versión de 5 bytes funcionará:

l{.pz

De cualquier manera, solo calcula todas las permutaciones de la entrada como una lista, la deduplica y obtiene el número de elementos en ella, e imprime ese número implícitamente.

-1 byte gracias a @ hakr14

J , 14  13 bytes

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

Pruébalo en línea!

1 byte gracias a millas

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

Pruébalo en línea!

Esto es básicamente solo un puerto PHP de la respuesta ganadora de Python de @ ArBo que es ridículamente más inteligente que la respuesta recursiva que tenía originalmente. ¡Bravo!

Ohm v2 , 4 bytes

ψD∩l

Pruébalo en línea!

Explicación

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

Stax , 3 bytes

═1╪

Ejecutar y depurarlo