Sua entrada será uma sequência composta por pequenas letras em inglês.

Sua tarefa é determinar o número de permutações distintas da sequência original que são um palíndromo.

A sequência de entrada tem até 100 letras. No caso de uma sequência mais longa, o resultado pode ser muito grande, portanto a saída deve ser o número de permutações módulo 666013.

Por exemplo,

cababaa -> 3

As permutações possíveis são:

aabcbaa
abacaba
baacaab

Isso é código-golfe , então a resposta mais curta vence!

Braquilog (2), 15 bytes

{p.↔}ᶠdl%₆₆₆₀₁₃

Experimente online!

Explicação

{p.↔}ᶠdl%₆₆₆₀₁₃
{   }ᶠdl          Count (l) the number of distinct (d) results (ᶠ) obtainable by:
 p                  permuting {the input}
  .                 to produce an output
   ↔                that, if reversed, is still the output
        %₆₆₆₀₁₃   then take that number modulo 666013

05AB1E , 17 16 13 bytes

-1 byte de Jonathon Allan

-3 bytes de Emigna e Adnan

œÙvyÂQO•E›j•%

Explicação:

œÙ                # Unique permutations of [implicit] input
  vy              # For each permutation...
    ÂQ            # Check if it is a palindrome
      O           # If so, increment the counter
       •E›j•%     # Modulo 666013 (no clue why this number, or even why this rule is in place)

Experimente online!

Perl 6 , 104 108 88 84 bytes

{my &f={[*] 1..$_ div 2}
.comb.Bag{*}.&{(2>.grep(*%2))*f(.sum)/[*]($_».&f)%666013}}

Experimente online!

Como funciona

Não consigo gerar facilmente todas as permutações e filtrá-las, mesmo que sejam permitidos tempos de execução astronômicos, porque a permutationsrotina interna do Perl 6 se recusa a permutar listas de mais de 20 elementos e a descrição da tarefa exige entradas de até 100 personagens.

Então, em vez disso, uso uma fórmula direta com base nas frequências das letras da entrada:

1. meu & f = {[*] 1 .. $ _ div 2}

   Uma função auxiliar que reduz pela metade um número e o arredonda para o número inteiro mais próximo e leva o fatorial disso.

2. .comb.Bag {*}. & {};

   Registre as frequências das letras na sequência de entrada e faça do tópico para o restante do código. Por exemplo, para entrada, abcdabcddddddessa seria a lista (2, 2, 2, 7).

3. (2> .grep (*% 2)) *

   Se houver mais de uma frequência de letra ímpar, multiplique o resultado por zero, pois nesse caso não são possíveis palíndromos.

4. f (.sum) / [*] ($ _ ». & f)

   Calcule o número de permutações possíveis dos caracteres que estarão em "um lado" de cada palíndromo (o que corresponde a um multiset com as multiplicidades obtidas pela metade e somando as frequências das letras de entrada) . A fórmula usada é deste PDF :
   (n ₁ + ... + n _k )! / (n ₁ ! ⋅ ... kn _k 1)
   Por exemplo, para frequências de letras de entrada (2,2,2,7), as letras de um lado do palíndromo formam um multiset com multiplicidades (1,1,1,3), e o número de permutações é assim (1+1+1+3)! / (1!⋅1!⋅1!⋅3!) = 120.

5. % 666013

   Tome o resultado módulo 666013.

Python3, 81 80 bytes

from itertools import*
lambda s:sum(a==a[::-1]for a in{*permutations(s)})%666013

Este é o mais curto que eu pude apresentar. Não tenho certeza se as permutações podem ser geradas com mais facilidade ...

Explicação

lambda s:                       # Anonymous function taking a parameter <s>. 
    sum(                        # Sum the following terms.
        a==a[::-1]              # Check whether the permutation <a> is a palindrome,
        for a in                # for each element <a>,
        {                       # inside a set that can only contain distinct elements.
            *                   # Splat the elements of the following object:
            permutations(s)     # the permutations of the input parameter <s>.
        }                       #
    )%666013                    # Modulo the sum by 666013.

Notas

1. A verificação a==a[::-1]retorna um valor booleano, mas a sum(...)função o envolve implicitamente em um número inteiro (0 ou 1) e soma em conformidade.
2. Eu tenho que usar o ' operador splat ' (não o nome real), para extrair os elementos do objeto permutations(...). Caso contrário, o conjunto ( {...}) conteria apenas um elemento, o próprio objeto.
3. Eu uso um set ( {...}) para manter apenas permutações distintas dentro.

No Floroid, isso é (quase) z(T(a==aDKaIW(cb(L)))%666013), mas imprime o resultado e recebe entrada pela linha de comando.

Agradecemos a Jonathan Allan por salvar um byte! -> Mudou o importestilo

Experimente online!

Gelatina , 13 bytes

Œ!QŒḂ€S%“µɲ€’

Experimente online!

Quão?

Um forçador bruto.

Œ!QŒḂ€S%“µɲ€’ - Main link: string
Œ!            - all permutations
  Q           - unique
     €        - for each
   ŒḂ         - isPalindromic? (yep a built-in!)
      S       - sum
       %      - mod
        “µɲ€’ - base 250 compressed number 666013

Eu acredito que isso vai fazê-lo de forma mais eficiente, mas é 30 bytes (edit: esse pdf parece confirmar isso, cortesia de resposta das LME ):

ÑHḞµS!÷!P$ - Link 1, palindrome count: string a    e.g. 'abcabcd'
Ñ          - call the next link (2) as a monad(a)  e.g. [2, 2, 2, 1]
 H         - halve                                 e.g. [1, 1, 1, 0.5]
  Ḟ        - floor (get pair counts)               e.g. [1, 1, 1, 0]
   µ       - start a new monadic chain - call that p
    S      - sum(p)                                e.g. 3
     !     - factorial                             e.g. 6
         $ - last 2 links as a monad:
       !   -     factorial(p) (vectorises)         e.g. [1, 1, 1, 1]
        P  -     product                           e.g. 1
      :    - integer division                      e.g. 6

ĠL€ - Link 2, count characters: string a           e.g. 'abcabcd'
Ġ   - group indexes                                e.g. [[1, 4], [2, 5], [3, 6], 7]
 L€ - length of €ach                               e.g. [2, 2, 2, 1]

ÇḂS⁼LḂ$aÑ%“µɲ€’ - Main link: string a              e.g. 'abcabcd'
                - first check to see if any palindromes will be possible:
Ç               - last link (2) as a monad         e.g. [2, 2, 2, 1]
 Ḃ              - mod 2                            e.g. [0, 0, 0, 1]
  S             - sum                              e.g. 1
      $         - last two links as a monad:
    L           -     length(a string)             e.g. 7
     Ḃ          -     mod 2                        e.g. 1
   ⁼            - equal?                           e.g. 1 (1 when palindromes are possible)
       a        - and
        Ñ       - next link as a monad             e.g. 6
         %“µɲ€’ - mod 666013, as in the brute force version.

Mathematica, 46 bytes

Permutations@#~Count~_?PalindromeQ~Mod~666013&

Leva uma lista de caracteres como entrada.

Terrivelmente ineficiente, porque na verdade gera todas as permutações da entrada e depois conta as palindrômicas.

Mathematica, 68 bytes

If[i=Floor[t=Last/@Tally@#/2];Tr[t-i]<1,Multinomial@@i,0]~Mod~666013

Função pura pegando uma lista de caracteres como entrada e retornando um número inteiro. Não é tão curto quanto a resposta Mathematica de Martin Ender , mas é uma abordagem atraente, que parece ser a mesma abordagem da resposta Perl 6 do smls .

Primeiro, t=Last/@Tally@#/2calcula as contagens de todos os caracteres distintos na entrada, divididos por2 ; então i=Floorarredonda para baixo todas as frações que ocorrem t. Observe que as permutações palindrômicas da entrada existem exatamente quando existe no máximo um número ímpar entre as contagens originais, ou seja, quando há no máximo uma fração t. Podemos testar isso somando todos os elementos de t-i(using Tr): se a resposta for menor que 1, existem permutações palindrômicas, caso contrário não.

Se houver, irepresenta a contagem de caracteres distintos na metade esquerda das permutações, que podem ser organizadas arbitrariamente. O número de maneiras de fazer isso é exatamente oMultinomial coeficiente (um quociente de certos fatoriais) que o Mathematica incorporou.

k, 23 bytes

{666013!+/{x~|x}'cmb x}

Se estiver usando oK , ou cmbnão existir, use em prmvez de cmb.

Pitão - 15 bytes

%l{_I#.pQ666013

Experimente online aqui .

C ++ 14, 161 bytes

Como lambda sem nome, assumindo que a entrada é semelhante std::stringe retornando via parâmetro de referência.

#import<algorithm>
[](auto s,int&n){auto a=s.begin(),b=s.end();std::sort(a,b);n=0;do n=(n+std::equal(a,b,s.rbegin()))%666013;while(std::next_permutation(a,b));}

Ungolfed e uso:

#include<iostream>
#include<string>

#import<algorithm>
auto f=
[](auto s,int&n){
 auto a=s.begin(),b=s.end();
 std::sort(a,b);
 n=0;
 do
  n=(n+std::equal(a,b,s.rbegin()))%666013;
 while(std::next_permutation(a,b));
}
;

using namespace std;


int main(){
 string s;
 s = "cababaa";
 s = "abcdabcddddd";
 int n;
 f(s,n);
 cout << n << endl;
}

Ruby, 67 57 52 59 caracteres

->s{s.chars.permutation.uniq.count{|t|t.reverse==t}%666013}

Japonês , 20 18 bytes

á f_¥Zw} l %666013

Economizou 2 bytes graças ao ETHproductions.

Experimente online!

MATL, 13 bytes

Y@Xu!"@tP=Avs

Experimente no MATL Online

Explicação

        % Implicitly grab input as a string
Y@      % Compute all permutations of the inputs (one per row)
Xu      % Determine the unique rows
!       % Take the transpose so each permutation is a column
"       % For each unique permutation
  @     % Take this permutation
  tP=A  % Duplicate it, reverse it, and compare (yields 1 for palindrome and 0 otherwise)
  v     % Vertically concatenate the entire stack
  s     % Compute the sum of all elements
        % Implicitly end for loop and display the result

CJam , 19 bytes

qe!{_W%=}%:+666013%

Experimente online!

Explicação:

qe! {_ W% =}%: + 666013% e # Programa completo.
qe # Obtenha todas as informações.
 e! e # Obtenha todas as permutações exclusivas.
   {_W% =} e # Função para verificar se uma lista é um palíndromo.
    _ e # ToS duplicados.
     W% e # ToS reverso (Push -1, índice modular de ToS).
       = e # Verifique se ToS é igual a SToS.
         % e # Mapa.
          : + e # Sum (Reduzir por adição).
            666013 e # Pressione 666013.
                  % e # Módulo.

Ohm, 17 bytes

I⌐:_₧?¡;;¼,

Explicação:

I⌐:_₧?¡;;¼,  ■Main wire
I⌐:     ;    ■for _ in permutations(input()){
   _₧? ;     ■  if(palindrome(_)){
      ¡      ■    counter++;
       ;     ■  }
        ;    ■}
         ¼,  ■print(counter)

PHP, 182 bytes

function f($a,$b=1){return$a?f($a-1,bcmul($a,$b)):$b;}$a=count_chars($argv[1],$r=1);foreach($a as$v){$c+=$v%2?:0;$c>1?die("0"):$z+=$f=$v/2^0;$r=bcmul(f($f),$r);}echo bcdiv(f($z),$r);

Versão Online

Demolir

function f($a,$b=1){  #Factorial
    return$a?f($a-1,bcmul($a,$b)):$b;
}
$a=count_chars($argv[1],$r=1); # Array count for every char
foreach($a as$v){
    $c+=$v%2?:0; # counter mod 2 ==1
    $c>1?die("0"):$z+=$f=$v/2^0; # end program if there are 2 chars which cannot divide by 2
    $r=bcmul(f($f),$r);
}
echo bcdiv(f($z),$r);