ए मैपिंग ऑफ प्राइम्स

Question

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

मानचित्रण

जहाँ कारकों के साथ संख्या n पर विचार करें । फिर:

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

नियम

• आप इस कार्य को करने के लिए एक पूर्ण कार्यक्रम या एक कार्य लिख सकते हैं।
• अनुक्रम के रूप में पहचानने योग्य आउटपुट किसी भी प्रारूप में हो सकता है।
• प्राइम फैक्टराइजेशन, प्राइमलिटी टेस्टिंग आदि के लिए बिल्ट-इन की अनुमति है ।
• मानक खामियों को अस्वीकार कर दिया जाता है।
• आपके कार्यक्रम को मेरी मशीन पर 10 मिनट के भीतर अंतिम परीक्षण के मामले को पूरा करना होगा।
• यह कोड-गोल्फ है, इसलिए सबसे छोटा कोड जीतता है!

परीक्षण के मामलों

• 10: {{},{{}},{}}
• 21: {{{}},{},{{}}}
• 42: {{{}},{},{{}},{}}
• 30030: {{{}},{{}},{{}},{{}},{{}},{}}
• 44100: {{{{}}},{{{}}},{{{}}},{},{}}
• 16777215: {{{{}}},{{}},{{}},{},{{}},{{}},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{{}}}
• 16777213: पास्टबीन

Comments

एक ही आउटपुट, अल्पविराम के बिना, अभी भी अनुक्रम के रूप में पहचानने योग्य है ?

— डेनिस

@ डेनिस हां, आप कोष्ठक द्वारा बता सकते हैं।

— लीजनमोनमल 978

कैसे नंबर 1 के बारे में

— अकांगका

ऊह, वह {} है।

— अकांगका

क्या यह एक स्वीकार्य आउटपुट प्रारूप होगा? CJam खाली सूचियों और खाली तारों के बीच अंतर नहीं करता है, इसलिए यह एक नेस्टेड सरणी का प्रतिनिधित्व करने का प्राकृतिक तरीका है।

— डेनिस

Answer 1

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

L+'MhMtbmYhbL&JPby/LJf}TPTSeJ

प्रदर्शन

यह एक फ़ंक्शन को परिभाषित करता है ', जो वांछित मानचित्रण करता है।

एक सहायक कार्य, yमैपिंग को पुनरावर्ती रूप से एक प्रमुख अपघटन देता है। आधार मामले और प्रधान अपघटन में किया जाता है '।

Answer 2

CJam, 51 48 44 42 41 39 34 33 31 बाइट्स

{mf_W=)1|{mp},\fe=(0a*+{)J}%}:J

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

3 बाइट बंद करने के लिए @ मार्टिनबटनर को धन्यवाद!

3 बाइट को बंद करने के लिए @PeterTaylor को धन्यवाद और 1 और के लिए मार्ग प्रशस्त!

कम से कम मेरे कंप्यूटर पर, प्रोग्राम को चलाने की तुलना में फ़ाइल डाउनलोड करने में अधिक समय लगता है ...

आई / ओ

यह एक नामित फ़ंक्शन है जो STDIN से पॉप और पूर्णांक बनाता है और बदले में एक सरणी को धक्का देता है।

चूंकि सीजेएम खाली सरणियों और खाली तारों के बीच अंतर नहीं करता है - एक स्ट्रिंग बस एक सूची है जिसमें केवल वर्ण होते हैं -, स्ट्रिंग प्रतिनिधित्व इस तरह दिखाई देगा:

[[""] "" [""] ""]

निम्नलिखित का उल्लेख करते हुए, नेस्टेड सरणी

[[[]] [] [[]] []]

सत्यापन

$ wget -q pastebin.com/raw.php?i=28MmezyT -O test.ver
$ cat prime-mapping.cjam
ri
  {mf_W=)1|{mp},\fe=(0a*+{)J}%}:J
~`
$ time cjam prime-mapping.cjam <<< 16777213 > test.out

real    0m25.116s
user    0m23.217s
sys     0m4.922s
$ diff -s <(sed 's/ //g;s/""/{}/g;y/[]/{}/' < test.out) <(tr -d , < test.ver)
Files /dev/fd/63 and /dev/fd/62 are identical

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

{                           }:J  Define a function (named block) J.
 mf                              Push the array of prime factors, with repeats.
   _W=                           Push a copy and extract the last, highest prime.
      )1|                        Increment and OR with 1.
         {mp},                   Push the array of primes below that integer.

                                 If 1 is the highest prime factor, this pushes
                                 [2], since (1 + 1) | 1 = 2 | 1 = 3.
                                 If 2 is the highest prime factor, this pushes
                                 [2], since (2 + 1) | 1 = 3 | 1 = 3.
                                 If p > 2 is the highest prime factor, it pushes
                                 [2 ... p], since (p + 1) | 1 = p + 2, where p + 1
                                 is even and, therefor, not a prime.

              \fe=               Count the number of occurrences of each prime
                                 in the factorization.

                                 This pushes [0] for input 1.

                  (              Shift out the first count.
                   0a*           Push a array of that many 0's.
                      +          Append it to the exponents.

                                 This pushes [] for input 1.

                       {  }%     Map; for each element in the resulting array:
                                   Increment and call J.

Comments

ब्लेम

— पास्टेबिन

mf e=जब मैंने सैंडबॉक्स में सवाल किया था तो मैंने एक पवित्रता परीक्षा दी थी, लेकिन मैंने जो सुधार नहीं किया था, मैंने पाया है कि आपने जो प्रयोग नहीं किया है, वह है (0a*+- ट्विस के लिए मैपिंग करना ri{}sa2*{mf_W=){mp},\fe=(0a*+0j\{)j}%*}j। और साथ ही एक बहुत बड़ा सुधार है जो मैं आपको कुछ घंटों का हेडस्टार्ट दूंगा ...

— पीटर टेलर

@PeterTaylor गोल्फ और संकेत के लिए धन्यवाद।

— डेनिस

हां, आउटपुट प्रतिनिधित्व को बदलना वास्तव में बड़ा सुधार था। आधार मामले को संभालने का एक बेहतर तरीका है, जो मैंने अभी-अभी पाया है, लेकिन आपके समाधान को हराने के लिए मुझे आपके दो विचारों का उपयोग करना है:{mf_W=)1|{mp},\fe=(0a*+{)J}%}:J

— पीटर टेलर

@PeterTaylor वह एक जादुई 1|। एक बार फिर धन्यवाद!

— डेनिस

Answer 3

गणितज्ञ, 88 बाइट्स

f@1={};f@n_:=f/@Join[1+{##2},1&~Array~#]&@@SparseArray[PrimePi@#->#2&@@@FactorInteger@n]

Comments

— अनिर्दिष्ट आंतरिकों