입력은 작은 영어 문자로 구성된 문자열입니다.

당신의 임무는 회문 인 원래 문자열의 별개의 순열 수를 결정하는 것입니다.

입력 문자열은 최대 100 자입니다. 더 긴 문자열의 경우 결과가 매우 클 수 있으므로 출력은 순열 수 모듈로 666013이어야합니다.

예를 들어

cababaa -> 3

가능한 순열은 다음과 같습니다.

aabcbaa
abacaba
baacaab

이것은 code-golf 이므로 가장 짧은 답변이 이깁니다!

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 바이트

Jonathon Allan에서 -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)

온라인으로 사용해보십시오!

펄 (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)) *

   홀수 문자 빈도가 둘 이상인 경우 회문이 불가능하므로 결과에 0을 곱하십시오.

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

   각 회 문의 "한쪽"에있을 문자의 가능한 순열 수를 계산합니다 (입력 문자 빈도를 반으로 줄임으로써 다중성을 갖는 다중 집합에 해당) . 사용 된 공식은 이 PDF의 것입니다 :
   (n ₁ + ... + n _k )! / (n은 ₁ ! ⋅ ⋅n ... _K (1))
   예 : 문자 입력 주파수에 대해 (2,2,2,7), 문자에 하나 개 회문 형태와 다중성 MULTISET 측면 (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 operator ' 를 사용해야 합니다 permutations(...). 그렇지 않으면 집합 ( {...})에는 하나의 요소 인 개체 자체 만 포함됩니다.
3. {...}내부에 고유 한 순열 만 유지하기 위해 집합 ( )을 사용합니다 .

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.

수학, 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. 입력의 회문 치환은 원래 카운트 중 홀수가 최대 1 개일 때, 즉에 최대 1 개의 분수가있을 때 정확하게 존재합니다 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 바이트

명명되지 않은 람다처럼 입력을 가정 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;
}

루비, 67 57 52 59 자

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

apt , 20 18 바이트

á f_¥Zw} l %666013

ETH 프로덕션 덕분에 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 # Reverse 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);