您的输入将是由小英文字母组成的字符串。

您的任务是确定作为回文的原始字符串的不同排列的数量。

输入字符串最多包含100个字母。在较长的字符串的情况下，结果可能会很大，因此输出应为模数666013的排列数。

例如，

cababaa -> 3

可能的排列是：

aabcbaa
abacaba
baacaab

这是代码高尔夫球，所以最短的答案会成功！

Brachylog（2），15个字节

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

在线尝试！

说明

{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字节

乔纳森·艾伦的-1个字节

Emigna和Adnan的-3个字节

œÙvyÂQO•E›j•%

说明：

œÙ                # 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)

在线尝试！

Perl 6的，104 108 88 84个字节

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

在线尝试！

怎么运行的

即使允许运行天文数字，我也无法轻松生成所有排列并对其进行过滤，因为Perl 6的内置permutations例行处理拒绝排列超过20个元素的列表，并且任务描述最多需要输入100个字符。

因此，我改用基于输入字母频率的直接公式：

1. 我的＆f = {[*] 1 .. $ _ div 2}

   一个将数字减半并将其四舍五入为最接近的整数，然后将其阶乘的辅助函数。

2. .comb.Bag {*}。＆{};

   计算输入字符串中的字母频率，并使其成为其余代码的主题。例如，输入abcdabcdddddd将是列表(2, 2, 2, 7)。

3. （2> .grep（*％2））*

   如果出现一个以上的奇数字母频率，则将结果乘以零，因为在这种情况下不可能有回文。

4. f（.sum）/ [*]（$ _»。＆f）

   计算将在每个回文的“一侧”上的字符的可能排列的数量（这对应于具有通过对输入字母频率进行减半和底数运算而获得的多重性的多重集）。使用的公式来自此PDF：
   （n ₁ + ... + n _k）！/（N ₁！⋅...⋅n _ķ 1）
   ，例如，对于输入的字母频率(2,2,2,7)，上的字母一个回文形式与多重一个多重的侧(1,1,1,3)，和排列的数目是如此(1+1+1+3)! / (1!⋅1!⋅1!⋅3!) = 120。

5. ％666013

   将结果取模666013。

Python3，81 个 80字节

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

这是我能想到的最短的时间。不知道排列是否可以更容易地生成...

说明

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.

笔记

1. 该检查a==a[::-1]返回一个布尔值，但是sum(...)函数隐式将其强制转换为整数（0或1）并进行求和。
2. 我必须使用“ splat运算符 ”（不是真实名称）从object中提取元素permutations(...)。否则，set（{...}）将只包含一个元素，即对象本身。
3. 我使用set（{...}）仅保留内部的不同排列。

在Floroid中，这几乎是（）z(T(a==aDKaIW(cb(L)))%666013)，但是打印结果，并通过命令行输入。

感谢@Jonathan Allan节省了一个字节！->改变了import风格

在线尝试！

果冻，13 个字节

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

在线尝试！

怎么样？

蛮力。

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

我相信那这将更有效地做到这一点，但它是30个字节（编辑：此PDF似乎也印证了它，礼貌的SML的答案）：

Ñ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个字节

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

将字符列表作为输入。

效率极低，因为它实际上会生成输入的所有排列，然后计算回文数。

Mathematica，68个字节

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

接受字符列表作为输入并返回整数的纯函数。虽然不像Martin Ender的Mathematica答案那么短，但是它仍然是一种可爱的方法，似乎与smls的Perl 6答案相同。

首先，t=Last/@Tally@#/2计算输入中所有不同字符的计数，除以2; 然后i=Floor四舍五入出现在中的任何分数t。请注意，当原始计数中最多有一个奇数时，即当中最多有一个小数时，输入的回文排列正好存在t。我们可以通过简单地将t-i（使用Tr）的所有元素加起来进行测试：如果答案小于1，则有回文排列，否则就没有。

如果存在，则i表示排列左半部分中不同字符的计数，可以任意排列。精确的处理方法就是MultinomialMathematica内置的系数（某些阶乘的商）。

k，23个字节

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

如果使用oK或cmb不存在，请使用prm代替cmb。

Pyth-15个字节

%l{_I#.pQ666013

在这里在线尝试。

C ++ 14，161字节

如未命名的lambda，假设输入是类似的std::string，并通过引用参数返回。

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

脱胶和用法：

#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个字符

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

Japt，20 18字节

á f_¥Zw} l %666013

由于ETHproductions，节省了2个字节。

在线尝试！

MATL，13个字节

Y@Xu!"@tP=Avs

在MATL Online上尝试

说明

        % 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个字节

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

在线尝试！

说明：

qe！{_ W％=}％：+ 666013％e＃完整程序。
qe＃获取所有输入。
 !！e＃获取所有唯一排列。
   {_W％=} e＃用于检查列表是否是回文的函数。
    _ e＃重复的ToS。
     W％e＃反向ToS（推-1，ToS的模块化索引）。
       = e＃检查ToS是否等于SToS。
         ％e＃地图。
          ：+ e＃Sum（加减）。
            666013 e＃按666013。
                  ％e＃模数。

欧姆，17个字节

I⌐:_₧?¡;;¼,

说明：

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

PHP，182字节

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

在线版本

分解

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