Đầu vào của bạn sẽ là một chuỗi bao gồm các chữ cái tiếng Anh nhỏ.

Nhiệm vụ của bạn là xác định số lượng hoán vị riêng biệt của chuỗi gốc là một bảng màu.

Chuỗi đầu vào có tới 100 chữ cái. Trong trường hợp chuỗi dài hơn, kết quả có thể rất lớn, do đó, đầu ra phải là số hoán vị modulo 666013.

Ví dụ,

cababaa -> 3

Các hoán vị có thể là:

aabcbaa
abacaba
baacaab

Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất sẽ thắng!

Brachylog (2), 15 byte

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

Hãy thử trực tuyến!

Giải trình

{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 byte

-1 byte từ Jonathon Allan

-3 byte từ Emigna và Adnan

œÙvyÂQO•E›j•%

Giải trình:

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

Hãy thử trực tuyến!

Perl 6 , 104 108 88 84 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Tôi không thể dễ dàng tạo ra tất cả các hoán vị và lọc chúng, ngay cả khi thời gian chạy thiên văn được cho phép, bởi vì permutationsquy trình thẳng ra thường xuyên của Perl 6 từ chối hoán vị danh sách hơn 20 yếu tố và mô tả nhiệm vụ yêu cầu đầu vào lên tới 100 nhân vật.

Vì vậy, thay vào đó tôi sử dụng một công thức trực tiếp dựa trên tần số chữ cái của đầu vào:

1. của tôi & f = {[*] 1 .. $ _ div 2}

   Hàm trợ giúp giảm một nửa số và làm tròn số đó xuống số nguyên gần nhất, sau đó lấy giai thừa của số đó.

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

   Kiểm tra tần số chữ cái trong chuỗi đầu vào và biến chúng thành chủ đề cho phần còn lại của mã. Ví dụ cho đầu vào abcdabcddddddđây sẽ là danh sách (2, 2, 2, 7).

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

   Nếu có nhiều hơn một tần số chữ cái lẻ, hãy nhân kết quả bằng 0, vì không có trường hợp nào có thể xảy ra trong trường hợp đó.

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

   Tính số lượng hoán vị có thể có của các ký tự sẽ nằm ở "một phía" của mỗi bảng màu (tương ứng với đa bội với các bội số có được bằng cách giảm một nửa và ghép các tần số chữ cái đầu vào) . Công thức được sử dụng là từ bản PDF này :
   (n ₁ + ... + n _k )! / (n ₁ ! ⋅ ... n _k 1)
   Ví dụ: đối với tần số chữ cái đầu vào (2,2,2,7), các chữ cái ở một bên của bảng màu tạo thành một bội số với bội số (1,1,1,3)và do đó số lượng hoán vị là như vậy (1+1+1+3)! / (1!⋅1!⋅1!⋅3!) = 120.

5. % 666013

   Lấy kết quả modulo 666013.

Python3, 81 80 byte

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

Đây là ngắn nhất tôi có thể đến với. Không chắc chắn nếu hoán vị có thể được tạo ra dễ dàng hơn ...

Giải trình

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.

Ghi chú

1. Kiểm tra a==a[::-1]trả về một giá trị boolean, nhưng sum(...)hàm ngầm định nó thành một số nguyên (0 hoặc 1) và tính tổng tương ứng.
2. Tôi phải sử dụng ' toán tử splat ' (không phải tên thật), để trích xuất các phần tử từ đối tượng permutations(...). Mặt khác, set ( {...}) sẽ chỉ chứa một phần tử, chính đối tượng đó.
3. Tôi sử dụng một tập hợp ( {...}) để chỉ giữ các hoán vị riêng biệt bên trong.

Trong Floroid, đây là (gần như) z(T(a==aDKaIW(cb(L)))%666013), nhưng in kết quả thay vào đó, và đưa đầu vào thông qua dòng lệnh.

Cảm ơn @Jonathan Allan vì đã tiết kiệm một byte! -> Thay đổi importphong cách

Hãy thử trực tuyến!

Thạch , 13 byte

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

Hãy thử trực tuyến!

Làm sao?

Một bác sĩ vũ phu.

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

Tôi tin rằng điều này sẽ làm điều đó hiệu quả hơn, nhưng đó là 30 byte (chỉnh sửa: pdf này dường như xác nhận nó, nhờ câu trả lời của smls ):

Ñ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.

Toán học, 46 byte

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

Đưa ra một danh sách các ký tự làm đầu vào.

Rất kém hiệu quả, bởi vì nó thực sự tạo ra tất cả các hoán vị của đầu vào và sau đó đếm những cái palindromic.

Toán học, 68 byte

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

Hàm thuần túy lấy danh sách các ký tự làm đầu vào và trả về một số nguyên. Tuy nhiên, không ngắn như câu trả lời Mathicala của Martin Ender , nhưng dù sao đó cũng là một cách tiếp cận dễ thương, dường như là cách tiếp cận giống như trong câu trả lời Perl 6 của smls .

Đầu tiên, t=Last/@Tally@#/2tính tổng của tất cả các ký tự riêng biệt trong đầu vào, chia cho 2; sau đó làm i=Floortròn bất kỳ phân số xảy ra trong t. Lưu ý rằng hoán vị palindromic của đầu vào tồn tại chính xác khi có nhiều nhất một số lẻ trong số đếm ban đầu, nghĩa là khi có nhiều nhất một phân số t. Chúng ta có thể kiểm tra điều đó bằng cách chỉ cần thêm tất cả các yếu tố của t-i(sử dụng Tr): nếu câu trả lời nhỏ hơn 1, có hoán vị palindromic, nếu không thì không.

Nếu có, thì iđại diện cho số lượng các ký tự riêng biệt ở nửa bên trái của hoán vị, có thể được sắp xếp tùy ý. Số cách để làm điều đó chính xác là Multinomialhệ số (một thương số của các yếu tố nhất định), mà Mathicala đã tích hợp sẵn.

k, 23 byte

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

Nếu sử dụng oK , hoặc cmbkhông tồn tại, sử dụng prmthay vì cmb.

Pyth - 15 byte

%l{_I#.pQ666013

Hãy thử trực tuyến tại đây .

C ++ 14, 161 byte

Vì lambda không tên, giả sử đầu vào là như thế std::stringvà trả về thông qua tham số.

#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 và cách sử dụng:

#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 ký tự

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

Japt , 20 18 byte

á f_¥Zw} l %666013

Đã lưu 2 byte nhờ vào ETHproductions.

Hãy thử trực tuyến!

MATL, 13 byte

Y@Xu!"@tP=Avs

Dùng thử tại MATL Online

Giải trình

        % 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 byte

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

Hãy thử trực tuyến!

Giải trình:

qe! {_ W% =}%: + 666013% e # Chương trình đầy đủ.
qe # Nhận tất cả đầu vào.
 e! e # Nhận tất cả các hoán vị độc đáo.
   {_W% =} e # Chức năng kiểm tra xem danh sách có phải là một bảng màu hay không.
    _ e # Nhân đôi ToS.
     W% e # Reverse ToS (Đẩy -1, chỉ số mô đun của ToS).
       = e # Kiểm tra xem ToS có bằng SToS không.
         % e # Bản đồ.
          : + e # Sum (Giảm bằng cách thêm).
            666013 e # Đẩy 666013.
                  % e # Modulo.

Ồ, 17 byte

I⌐:_₧?¡;;¼,

Giải trình:

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

PHP, 182 byte

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

Phiên bản trực tuyến

Phá vỡ

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