किसी भी आकार के डेक के परफेक्ट शफल्स के लिए साइकिल की लंबाई

Question

चुनौती

कोड की सबसे छोटी राशि में:

1. किसी भी आकार n (जहां n even 2 और n सम है) के कार्ड के डेक पर एक परिपूर्ण फेरबदल के क्रमन चक्र की लंबाई की गणना करें ।
2. 2 ≤ n n 1000 ( n even) के लिए सभी चक्र लंबाई की एक तालिका आउटपुट करें ।

ध्यान दें कि एक सही फेरबदल को परिभाषित करने के दो बुनियादी तरीके हैं। नहीं है बाहर फेरबदल है, जो शीर्ष पर पहले कार्ड और तल पर पिछले कार्ड रखता है, और वहाँ में फेरबदल , जो केंद्र की ओर पहला और अंतिम कार्ड एक स्थान ले जाता है। आप चुन सकते हैं कि आप एक आउट-शफ़ल या इन-शफ़ल कर रहे हैं या नहीं; एल्गोरिथ्म दोनों के बीच लगभग समान है।

• 10-कार्ड डेक के बाहर फेरबदल : [1,2,3,4,5,6,7,8,9,10] 1, [1,6,2,7,3,8,4,9,5, 10]।
• इन-फेरबदल के 10 पत्तों का डेक: [1,2,3,4,5,6,7,8,9,10] ↦ [6,1,7,2,8,3,9,4,10, 5]।

चित्रमय उदाहरण

यहां, हम देखते हैं कि 20-कार्ड डेक पर एक आउट-शफल में 18 चरणों की एक चक्र लंबाई होती है। (यह केवल चित्रण के लिए है; आपके समाधान को ग्राफ़िकल रूप से साइकिल के उत्पादन की आवश्यकता नहीं है।) दूसरी ओर, क्लासिक 52-कार्ड डेक में केवल 8 चरणों की एक आउट-शफ़ल चक्र लंबाई है (नहीं दिखाया गया है)।

एक में फेरबदल 20 कार्ड डेक पर केवल 6 चरणों का एक चक्र की लंबाई है।

आउटपुट का सारणीबद्ध उदाहरण

आपका कार्यक्रम कुछ इसी तरह का उत्पादन करना चाहिए, हालांकि आप किसी भी सारणीबद्ध प्रारूप को चुन सकते हैं जो आपको सबसे अच्छा लगता है। यह एक फेरबदल के लिए है:

2 1
4 2
6 4
8 3
10 6
12 10
14 12
16 4
18 8
20 18
22 6
24 11
26 20
28 18
30 28
32 5
34 10
36 12
38 36
40 12
...many lines omitted...
1000 36

प्रशन

1. क्या संख्या इनपुट n और उसके चक्र गणना के बीच कोई संबंध प्रतीत होता है , जब n 2 की शक्ति है?
2. कैसे जब n 2 की शक्ति नहीं है?
3. उत्सुकता से, 1000-कार्ड डेक में केवल 36 का आउट-शफ़ल चक्र गणना होती है, जबकि 500-कार्ड डेक में 166 का आउट-शफ़ल चक्र गणना होती है। ऐसा क्यों हो सकता है?
4. वह सबसे बड़ी संख्या जो आप पा सकते हैं जिसका चक्र गणना c , n से काफी छोटा है , जिसका अर्थ है कि n / c का अनुपात अधिकतम है?

Comments

बहुत बारीकी से संबंधित।

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

हां, यह परिणाम प्रदर्शित करने के बारे में अधिक है, हालांकि। यह प्रश्न एन के किसी भी मूल्य के लिए एक तालिका बनाने के बारे में है ; यह प्रकृति में अधिक गणितीय है।

— टॉड लेहमैन

एक अच्छे समय के लिए प्रदर्शन में 6/8 चक्रों के साथ मुझे उलझन में डाल दिया :)) (मुझे लगा कि मेरी नकल गलत थी)। अंत में मैंने छवि को देखा और देखा कि यह एक 6 चक्र है, इसलिए मैंने इसे संपादित किया। मजाकिया

— गर्व हैस्केलर

@ प्राउड हैस्केलर - आह हाँ, धन्यवाद!

— टॉड लेहमैन

यह क्रम A002326 है ।

— orlp

Answer 1

हास्केल, 47 46 44 (फेरबदल में)

[[i|i<-[1..],mod(2^i)n<2]!!0|n<-[3,5..1001]]

मूल बोध यह है कि यह मापांक के गुणक समूह में 2 का क्रम है n+1।

Comments

आप हटा सकते हैं l=- अभिव्यक्ति ही पर्याप्त है। इंटरेक्टिव कमांड लाइन पर चलने पर यह एक वैध कार्यक्रम है।

— orlp

Answer 2

पायथ, 16 बाइट्स

mfq1%^2T+3yd)500

A002326 का उपयोग करते हुए इन-शफल ।

Answer 3

पायथ, 22 बाइट्स

V500,JyhNl{.u.iFc2NJUJ

इसे ऑनलाइन आज़माएँ: प्रदर्शन । 500 को छोटी संख्या से बदलें, अगर यह बहुत धीमा है।

स्पष्टीकरण:

V500                     for N in [0, 1, ..., 499]:
      yhN                   (N + 1) * 2
     J                      assign to J
           .u      JUJ      apply the following expression J times
                            to N, starting with N = [0, 1, ..., J - 1],
                            and return all intermediate results:
                c2N            split N into 2 halfs
             .iF               and interleave them
         l{                 remove duplicates and give length
    ,                       make a pair and print

Comments

यह एक तरह से पागल है कि एक अजगर समाधान जो फेरबदल और डेक की गिनती करने का वास्तविक काम करता है, जब तक कि हैस्केल समाधान केवल आधा ही होता है जो एक आसान सूत्र का उपयोग करता है तुरंत परिणाम की भविष्यवाणी करता है

— फाल्को

@ फाल्को मुझे सही पता है

— गर्वित हेकलर

@ फाल्को मैं वास्तव में मेरे जवाब को एक pyth portof करने की कोशिश की, लेकिन मैं यह नहीं कर सका कि यह कैसे करना है। इसलिए मैंने सिर्फ आधे घंटे के लिए

— अजगर के

खुशी है कि आपने कोशिश नहीं की <> <

— Falco

Answer 4

गणितज्ञ, 53 (फेरबदल)

Grid[{2#,MultiplicativeOrder[2,2#+1]}&/@Range[1,500]]

या, विरोधी नहीं है

Grid[{2 #, MultiplicativeOrder[2, 2 # + 1]} & /@ Range[1, 501]]

आउटपुट:

   2    2
   4    4
   6    3
   8    6
  10   10
  12   12
  14    4
  16    8
  18   18
  20    6
 (* digits, digits, bo bidgits, banana fana, ... *)
  498  166
  500  166
 (* skip a bit, brother ...  *)
  998   36
 1000   60

दोनों स्तंभों में प्रत्येक प्रविष्टि क्षैतिज रूप से उनके स्तंभों में केंद्रित है, लेकिन मेरे पास भिन्नात्मक रिक्त स्थान नहीं हैं  ...  यहाँ पर इसे दोहराने के लिए है।

टिप्पणियों:

• आउट-फेरबदल एक डेक पर दो कार्ड छोटे में फेरबदल है। (ध्यान दें कि आउट-शफल प्रदर्शन के दौरान पहले और आखिरी कार्ड निश्चित स्थिति में हैं।) नतीजतन, दो विकल्प समान आउटपुट सूचियों को जन्म देंगे - दूसरा कॉलम एक पंक्ति द्वारा स्थानांतरित किया जाएगा। संकेत "दो की शक्तियों" के बारे में, इन-फेरबदल दो डेक की शक्ति का पैटर्न है {2^n - 2, n}, {2^n, 2n}। (आउट-फेरबदल जोड़े के 2^nसाथ n।)
• इन-शफल उदाहरण में देखें कि 2डेक के निकटतम छोर से दूरी प्रत्येक चरण पर दोगुनी हो जाती है। {2, 4, 8, 15 = -5, -10, -20}। वास्तव में, यह हर कार्ड के लिए सही है । इसलिए हमें केवल यह जानने की जरूरत है कि कौन सी शक्ति मॉड के 2अनुरूप है जहां कार्ड की संख्या है। (ध्यान दें कि उदाहरण में, अंतिम कॉलम, कॉलम में कार्ड्स को दोगुना कर दिया जाता है , जिसका अर्थ है कि एक से अधिक कार्ड की तुलना में यह डेक में है, इस प्रकार "mod " है।) इसलिए, MultiplicationOrder []। फ़ंक्शन जाने का तरीका है (गणितज्ञ में)।1n+1n-1-20n+1
• डिफ़ॉल्ट रूप से, कोई ग्रिड [] के बजाय टेबलफ़ॉर्म [] की कोशिश करेगा, लेकिन आउटपुट समान है।

Comments

आपका उदाहरण आउटपुट गलत लगता है

— गर्वित हैकेलर

@ सर्पदंशक: इन-शफल या आउट-शफल के लिए? या तो अनुमति है। (और जैसा कि उल्लेख किया गया है, एक दूसरे के दाहिने कॉलम में सिर्फ एक पंक्ति बदलाव है।)

— एरिक टावर्स

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

— गर्वित हेकलर 17

गौरवशाली: मुझे लगता है कि "8" में मेरा उदाहरण आउटपुट टाइप किया गया है। और में और बाहर muddled - कम से कम एक बार। संपादन। लगातार बने रहने के लिए धन्यवाद। :-)

— एरिक टावर्स

Answer 5

सी, 86 (या 84)

स्कोर अनावश्यक व्हाट्सएप को शामिल करता है, जिसमें स्पष्टता शामिल है।

i,j,n;
main(){
  for(;n<1002;printf("%d %d\n",n,j),n+=2)
    for(i=n,j=1;i=i*2%(n+1),i-n;)j++;
}

यह एक इन-शफल है, जो दूसरों द्वारा इंगित किया गया है, केवल बाहर निकाले गए दोनों सिरों पर स्थिर कार्ड के साथ बाहर फेरबदल है।

जैसा कि अन्य लोगों द्वारा बताया गया है, इन-शफल में, प्रत्येक कार्ड की स्थिति हर बार दोगुनी हो जाती है, लेकिन इसे मॉडुलो लेना चाहिए n+1। मुझे अतिरिक्त कार्ड की स्थिति तालिका के बाईं ओर शून्य होने के बारे में सोचना पसंद है (आप इस बारे में भी सोच सकते हैं कि आउट-शफ़ल से दोनों स्थिर कार्ड पकड़े हुए हैं)। जाहिर है कार्ड की स्थिति हमेशा सकारात्मक होनी चाहिए, इसलिए इन-शफल मामले के लिए शून्य स्थिति हमेशा खाली रहती है।

कोड iके मूल्य के लिए initializes n। फिर यह 2 से गुणा करता है, परिणाम मोड लेता है (n+1)और यह देखने के लिए जांचता है कि क्या iअपने प्रारंभिक मूल्य पर वापस आ गया है ( i-nशून्य है।) यह jपिछले प्रत्येक को छोड़कर प्रत्येक पुनरावृत्ति के लिए वेतन वृद्धि करता है (इसलिए आवश्यकता को प्रारंभ jकरने के लिए 1.)

सिद्धांत रूप iमें, रेंज में किसी भी मूल्य के साथ हो सकता है 1..n, इसलिए जब तक कि यह एक ही नंबर के लिए intialised था अंत में तुलना की जाँच की। चुनने nका कारण यह सुनिश्चित करना था कि कार्यक्रम मामले के लिए काम करता है n==0। समस्या यह थी कि कोई भी संख्या मोडुलो (0+1)शून्य है, इसलिए लूप को इस मामले में कभी भी समाप्त नहीं किया जाता है यदि iइसे 1 जैसे स्थिरांक पर आरम्भ किया जाता है।

प्रश्न के उदाहरणों में n==2आउट फेरबदल के लिए समतुल्य मामला शामिल है , इसलिए यह व्याख्या की गई थी कि इस मामले की आवश्यकता है। यदि ऐसा नहीं है, तो दो बाइट्स को 1 n,से शुरू करके बचाया जा सकता है i, जैसा कि मान j।