स्ट्रिंग क्रमपरिवर्तन की संख्या जो पलिंड्रोम्स हैं

Question

आपका इनपुट एक स्ट्रिंग होगा जिसमें छोटे अंग्रेजी अक्षर होंगे।

आपका काम मूल स्ट्रिंग की अलग-अलग क्रमबद्धताओं की संख्या निर्धारित करना है जो एक पैलिंड्रोम हैं।

इनपुट स्ट्रिंग में 100 अक्षर हैं। लंबे समय तक स्ट्रिंग के मामले में परिणाम बहुत बड़ा हो सकता है इसलिए आउटपुट को क्रमपरिवर्तन मॉडुलो 666013 की संख्या होनी चाहिए।

उदाहरण के लिए,

cababaa -> 3

संभावित क्रमांकन हैं:

aabcbaa
abacaba
baacaab

यह कोड-गोल्फ है , इसलिए सबसे छोटा उत्तर जीतता है!

Comments

"यह देखते हुए कि स्ट्रिंग में 100 अंक हैं, परिणाम% 666013 होना चाहिए।" यदि हां, तो एक संबंधित परीक्षण मामले को शामिल करना एक अच्छा विचार होगा।

— मार्टिन एंडर

मुझे% 666013 लाइन समझ में नहीं आती है। हालांकि, यह एक आशाजनक चुनौती है, और मैं एक बार समझाने के बाद फिर से मतदान करने को तैयार हूँ।

ओह, अब यह संपादित हो गया है, मैं देख रहा हूं कि आप क्या कर रहे हैं। मुझे नहीं लगता कि यह चुनौती चुनौती देती है; यह ज्यादातर सिर्फ मनमानी-सटीक पूर्णांक के बिना भाषाओं को सजा देता है। आम तौर पर हम कुछ ऐसा करते हैं "यदि उत्तर आपकी भाषा के अनधिकृत पूर्णांक के साथ काल्पनिक संस्करण में चलाया जाए तो उत्तर सही होना चाहिए"।

यह वास्तव में अधिक परीक्षण-मामलों का उपयोग कर सकता है।

— धूम्रपान करता है

परीक्षण-मामलों के लिए सुझाव (हालांकि उन्हें सत्यापित करें): abcdabcddddd -> 120 (कोई विषम वर्ण गणना) , abcdabcdddddd -> 120 (एक विषम वर्ण गणना) , abcdabcddddddeee -> 0 (दो विषम वर्ण गणना) , aabbccddeeffgghhiijj -> 298735 (मोडुलो से प्रभावित) ।

— SMLS

Answer 1

ब्रेकीलॉग (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

Comments

मुझे निश्चित रूप से इसे लागू करने की आवश्यकता है "अद्वितीय खोजें" ...

— घातक

@ घातक: हाँ! मुझे लगता है कि "अद्वितीय गिनती" भी अक्सर चुनौतियों में पर्याप्त होती है शायद 1-बाइट प्रतिनिधित्व के लायक हो। दूसरी ओर, "modulo 666013" लगभग निश्चित रूप से नहीं; ;-)

Answer 2

05AB1E , 17 16 13 बाइट्स

जोनाथन एलन से -1 बाइट

एमिगा और अदनान से -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)

इसे ऑनलाइन आज़माएं!

Comments

सामग्री, E›jउन अंकों का प्रतिनिधित्व करती है, [14, 116, 45]जो आधार से परिवर्तित होते हैं 214, और बन जाते हैं 14*214^2 + 116*214 + 45 = 666013। मुझे पूरा यकीन नहीं है कि संदर्भ अंकों के लिए कहां है, लेकिन वे जानकारी पृष्ठ पर उनके आदेश के अनुरूप (ईश?) प्रतीत होते हैं । @ अदनान हमें प्रबुद्ध कर सकता है।

— जोनाथन एलन

@Emigna आसान जब आप भाषा जानते हैं: D

— जोनाथन एलन

आप œÙvyÂQ}O•E›j•%

— इफ

@JonathanAllan अंकों की पूरी श्रृंखला (और वर्ण) यहां पाई जा सकती है :)।

— अदनान

@ एमिग्ना की टिप्पणी पर बिल्डिंग, आप समापन ब्रैकेट को हटाकर एक और बाइट बचा सकते हैं œÙvyÂQO•E›j•%:।

— अदनान

Answer 3

पर्ल 6 , 104 108 88 84 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

मैं आसानी से सभी क्रमपरिवर्तन उत्पन्न नहीं कर सकता और उन्हें फ़िल्टर कर सकता हूं, भले ही खगोलीय रन-टाइम की अनुमति हो, क्योंकि पर्ल 6 की अंतर्निहित permutationsदिनचर्या सीधे 20 से अधिक तत्वों की सूचियों को अनुमति देने से इनकार करती है और कार्य विवरण में 100 तक के इनपुट की आवश्यकता होती है पात्र।

इसलिए इसके बजाय मैं इनपुट के अक्षर आवृत्तियों के आधार पर एक प्रत्यक्ष सूत्र का उपयोग करता हूं:

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

   एक हेल्पर फंक्शन जो किसी संख्या को आधा कर देता है और उसे निकटतम पूर्णांक तक ले जाता है, और फिर उसी का फैक्टर लेता है।

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

   इनपुट स्ट्रिंग में अक्षर आवृत्तियों को मिलाएं, और उन्हें बाकी कोड के लिए विषय बनाएं । उदाहरण के लिए abcdabcddddddयह सूची होगी (2, 2, 2, 7)।

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

   यदि एक से अधिक विषम अक्षर आवृत्ति है, तो परिणाम को शून्य से गुणा करें, क्योंकि उस स्थिति में कोई भी palindromes संभव नहीं है।

4. च (.sum) / [*] ($ _ »और च।)

   वर्णों के संभावित क्रमपरिवर्तन की संख्या की गणना करें जो प्रत्येक ताल के "एक तरफ" होगा (जो कि इनपुट पत्र आवृत्तियों को रोकने और फ़्लोरिंग द्वारा प्राप्त गुणकों के साथ एक मल्टीसेट से मेल खाता है) । उपयोग किया गया सूत्र इस PDF से है :
   (n ₁ + ... + n _k )! / (n ₁ ! ⋅ ... ⋅n _k 1)
   इनपुट पत्र आवृत्तियों के लिए जैसे, पैलिंड्रोम के एक तरफ के (2,2,2,7)अक्षर गुणकों के साथ एक गुणक बनाते हैं , और क्रमपरिवर्तन की संख्या इस प्रकार होती है ।(1,1,1,3)(1+1+1+3)! / (1!⋅1!⋅1!⋅3!) = 120

5. % 666,013

   परिणाम modulo 666013 लें।

Comments

यह देखने के लिए अच्छा है कि मेरा वैकल्पिक तरीका वैध है!

— जोनाथन एलन

Answer 4

पायथन 3, 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. मुझे ऑब्जेक्ट से तत्वों को निकालने के लिए ' स्पैट ऑपरेटर ' (वास्तविक नाम नहीं) का उपयोग करना होगा permutations(...)। अन्यथा सेट ( {...}) में केवल एक तत्व होगा, ऑब्जेक्ट स्वयं।
3. मैं एक सेट ( {...}) का उपयोग केवल अलग क्रमपरिवर्तन के अंदर रखने के लिए करता हूं ।

फ्लोरॉयड में, यह (लगभग) है z(T(a==aDKaIW(cb(L)))%666013), लेकिन इसके बजाय परिणाम को प्रिंट करता है, और कमांड लाइन के माध्यम से इनपुट लेता है।

एक बाइट को बचाने के लिए @ जोनाथन एलन को धन्यवाद ! -> importशैली बदल गई

इसे ऑनलाइन आज़माएं!

Answer 5

जेली , 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 बाइट्स है (संपादित करें: यह पीडीएफ इसकी पुष्टि करता है, स्मेल के जवाब के सौजन्य से ):

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

Comments

हाँ, यह %आधुनिक है।

— जोनाथन एलन

गाह, मैं सिर्फ के बारे में पोस्ट करने के लिए था वास्तव में इस सवाल का जवाब है, लेकिन समय में वहाँ नहीं मिला क्योंकि मैं Brachylog जवाब पहले पोस्ट की। इसमें दूसरी बात है, मुझे लगता है। स्पष्ट रूप से मुझे याद रखना चाहिए कि जेली ब्रेकीलॉग की तुलना में अधिक लोकप्रिय भाषा है और इसलिए मुझे पहले उस सबमिशन पर काम करना चाहिए।

वाह, बाइट के लिए बाइट? मेरे पास एक और 13 भी है, लेकिन लगता है कि यह थोड़ा कम कुशल है :)

— जोनाथन एलन

क्या संख्या एक अलग आधार में संकुचित है या क्या है? : पी

— यति

मेरी TIO टैब से, Œ!QŒḂ€S%“µɲ€’। यह मेरे लिए समान लग रहा है।

Answer 6

मैथेमेटिका, 46 बाइट्स

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

इनपुट के रूप में वर्णों की एक सूची लेता है।

बहुत ही अयोग्य है, क्योंकि यह वास्तव में इनपुट के सभी क्रमपरिवर्तन को उत्पन्न करता है और फिर पैलिंड्रोमिक की गणना करता है।

Comments

मुझे लगता है कि यह गलत तरीके से सकारात्मक जवाब देता है, बजाय 0अगर स्ट्रिंग में कई अक्षर विषम गुणा (जैसे "abcdabcddddddeee") होते हैं।

— ग्रेग मार्टिन

@GregMartin धन्यवाद, निश्चित। यह वैसे भी अनावश्यक रूप से जटिल था।

— मार्टिन एंडर

Answer 7

मैथमेटिका, 68 बाइट्स

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

शुद्ध फ़ंक्शन इनपुट के रूप में वर्णों की एक सूची ले रहा है और एक पूर्णांक लौटा रहा है। मार्टिन एंडर के मैथमेटिका के उत्तर के रूप में छोटा नहीं है , लेकिन फिर भी यह एक सुंदर दृष्टिकोण है, जो कि स्मल्स के पर्ल 6 के उत्तर के समान है ।

सबसे पहले, t=Last/@Tally@#/2इनपुट में सभी अलग-अलग वर्णों की संख्याओं की गणना करता है, द्वारा विभाजित 2; उसके बाद i=Floorहोने वाले किसी भी अंश को गोल कर देता है t। ध्यान दें कि इनपुट के पैलिंड्रोमिक क्रमांकन तब मौजूद होते हैं, जब मूल संख्याओं में से सबसे अधिक विषम संख्या में होता है, जब कि अधिकांश एक अंश में होता है t। हम इसके लिए t-i(एल Tr) के सभी तत्वों को जोड़कर परीक्षण कर सकते हैं : यदि उत्तर की तुलना में कम है 1, तो पैलिंड्रोमिक क्रमपरिवर्तन हैं, अन्यथा नहीं।

यदि हैं, तो iक्रमपरिवर्तन के बाएं आधे हिस्से में अलग-अलग वर्णों की गिनती का प्रतिनिधित्व करता है, जिसे मनमाने ढंग से व्यवस्थित किया जा सकता है। ऐसा करने के तरीकों की संख्या बिल्कुल Multinomialगुणांक (कुछ विशेष तथ्यों का एक भाग) है, जिसे गणितज्ञ ने अंतर्निहित किया है।

Answer 8

के, 23 बाइट्स

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

यदि ओके का उपयोग कर रहे हैं , या cmbमौजूद नहीं है, तो prmइसके बजाय का उपयोग करें cmb।

Answer 9

पायथ - 15 बाइट्स

%l{_I#.pQ666013

इसे यहाँ ऑनलाइन आज़माएँ ।

Answer 10

सी ++ 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;
}

Answer 11

रूबी, 67 57 52 59 चार

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

Comments

कोडगॉफ़ सबमिशन उचित कार्यक्रम / फ़ंक्शंस / लैम्ब्डा होना चाहिए , न कि स्निपेट्स । मैं रूबी प्रोग्रामर नहीं हूं, लेकिन मुझे लगता है कि आप इसे एक लैम्ब्डा में बदल सकते हैं ->s{ }, इसे लपेटकर , क्या आप नहीं कर सकते?

— SMLS

इसके अलावा, प्रलेखन के आधार पर , (s.size)तर्क निरर्थक नहीं है?

— SMLS

मैंने इसे रूबी 2.4 पर परीक्षण किया, और यह बिना .to_aभी काम करता है।

— SMLS

@smls रूबी 2.3.3 ( undefined method # < एन्युमरेटर ') के लिए यूआईक्यू (यूनीक) पर काम नहीं करता है , लेकिन सही यह माणिक 2.4 पर काम करता है, धन्यवाद :)

— डोरियन

क्या परिणाम लेना है mod 666013?

— NonlinearFruit

Answer 12

जाप , 20 18 बाइट्स

á f_¥Zw} l %666013

सहेजे गए 2 बाइट्स ETHproductions के लिए धन्यवाद।

इसे ऑनलाइन आज़माएं!

Comments

अच्छा, यही मैंने किया होगा। आप दो बाइट्स बचा सकते हैं f_¥Zw}, जैसा _कि इसके लिए कम हैZ{Z

— ETHproductions

á fêS â l %666013आपको एक बाइट बचा लेगा।

— पॉवेल्स

Answer 13

MATL, 13 बाइट्स

Y@Xu!"@tP=Avs

इसे MATL ऑनलाइन पर आज़माएं

व्याख्या

        % 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

Answer 14

CJam , 19 बाइट्स

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

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

क्यू! {_ W% =}%: + 666013% e # पूर्ण कार्यक्रम।
qe # सभी इनपुट प्राप्त करें।
 इ! ई # सभी अद्वितीय क्रमपरिवर्तन प्राप्त करें।
   {_W% =} ई # फ़ंक्शन यह जांचने के लिए कि क्या सूची एक पैलिंड्रोम है।
    _ ई # डुप्लीकेट टूएस।
     डब्ल्यू% ई # रिवर्स टू (पुश -1, टूएस का मॉड्यूलर इंडेक्स)।
       = e # देखें कि क्या ToS SToS के बराबर है।
         % ई # नक्शा।
          : + ई # सम (जोड़ घटाकर)।
            666013 ई # पुश 666013।
                  % ई # मोदुलो।

Answer 15

ओम, 17 बाइट्स

I⌐:_₧?¡;;¼,

स्पष्टीकरण:

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

Answer 16

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