सही और tfeL ट्रंकिटेबल प्राइम्स

Question

एक राइट truncatable प्रधानमंत्री एक प्रमुख जहां हर उपसर्ग एक प्रमुख (आधार 10 में) है। एक बाएं-ट्रंकिटेबल प्राइम बिल्कुल विपरीत है, जहां हर पोस्टफिक्स एक प्राइम है (0 से शुरू होने वाले प्राइम की अनुमति नहीं है)। ये दोनों क्रम परिमित हैं (केवल tr३ राइट-ट्रंकैटैबल्स हैं, जबकि ४२६० लेफ्ट-ट्रंकैटैबल्स हैं)।

आपको एक प्रोग्राम लिखने की ज़रूरत है जो इनपुट के रूप में एक एकल संख्या को स्वीकार करता है, और n वें सही-ट्रंकिटेबल प्राइम का उत्पादन करता है । हालाँकि, जब प्रोग्राम को पीछे की ओर पढ़ा जाता है , तो उसे n वें बाएँ-ट्रंक्यूलेटिव प्राइम का उत्पादन करना चाहिए ।

प्रोग्राम को पीछे की ओर व्यवस्थित करने के लिए, हम प्रोग्राम को शब्दों में विभाजित करते हैं, फिर शब्दों के क्रम को उल्टा करते हैं। एक शब्द में किसी भी संख्या में वर्ण शामिल हो सकते हैं।

उदाहरण के लिए, यदि निम्नलिखित आपका कार्यक्रम था:

hello world
1234567890

निम्नलिखित सभी संभव पीछे की व्यवस्था के रूप में अनुमति दी जाएगी:

प्रत्येक वर्ण पर विभाजन:

0987654321
dlrow olleh

व्हाट्सएप पर विभाजन:

1234567890
world hello

मनमाने ढंग से विभाजन (स्पष्टता के लिए जोड़े गए पाइप):

hel|lo w|orld
1|23456|7|8|90

908723456orld
1lo whel

अपने कार्यक्रम को पीछे की ओर व्यवस्थित करते समय, किसी भी अन्य वर्ण की तरह, सभी व्हाट्सएप पर विचार किया जाना चाहिए और उलटा होना चाहिए।

फॉरवर्ड टेस्ट इनपुट्स:

1:  2
2:  3
21: 379
60: 239933
83: 73939133

पिछड़े परीक्षण इनपुट:

1:    2
2:    3
39:   647
187:  29173
4260: 357686312646216567629137

कार्यक्रम उचित समय (एक मिनट से कम) में चलने में सक्षम होना चाहिए

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

Comments

नहीं। परमाणु के बाद lo wहै orld\n1। न्यूलाइन परमाणु को समाप्त नहीं करता है

— नाथन मेरिल

आह, धन्यवाद। इसे अब पा लिया है। भ्रम से बचने के लिए मेरी पिछली दो टिप्पणियों को हटा दें

— लुइस मेंडो

Answer 1

जेली , 23 23 बाइट्स

आगे

Ѷp9¶7ÆR2ĿV€$ÆPÐf$ÐĿFị@

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

शब्दों

Ñ ¶ p 9 ¶ 7ÆR2ĿV€$ÆPÐf$ÐĿFị@

पिछड़ा

7ÆR2ĿV€$ÆPÐf$ÐĿFị@¶9p¶Ñ

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

शब्दों

7ÆR2ĿV€$ÆPÐf$ÐĿFị@ ¶ 9 p ¶ Ñ

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

सभी जेली कार्यक्रमों में लिंक होते हैं (कार्यों पर जेली लेना), जिन्हें लाइनफीड या पिलरो ( ¶) द्वारा अलग किया जाता है । उनमें से अंतिम मुख्य लिंक है ; प्रोग्राम चलने पर यह स्वचालित रूप से कहा जाता है।

आगे का कार्यक्रम निम्नानुसार काम करता है।

Ñ                   Helper link. Unused.


p9                  Helper link. Take the Cartesian product with [1, ..., 9].


7ÆR2ĿV€$ÆPÐf$ÐĿFị@  Main link. Argument: n

7ÆR                 Yield all primes up to 7.
             ÐĿ     
            $ÐĿ     Combine the two quicklinks to the left into a monadic chain,
                    and call it repeatedly until the results are no longer unique.
                    Return the array of all intermediate results.
       $              Combine the two links to the left into a monadic chain.
   2Ŀ               Call the helper link on line 2.
     Ṿ€                 Eval each array in the product. This casts to string
                        before evaluating, thus concatenating both numbers.
        ÆPÐf        Filter by primality; keep only primes.
               F    Flatten the resulting array.
                ị@  Retrieve the element at index n.

पिछड़े कार्यक्रम लगभग वैसा ही करता है; केवल दो अंतर हैं।

• मुख्य लिंक अब है Ñ, जो बस इसके नीचे दिए गए लिंक (चारों ओर रैपिंग) को कॉल करता है, अर्थात, फॉरवर्ड प्रोग्राम का मुख्य लिंक।

• 9pबदले में p9उलट कार्टेसियन उत्पाद वापस करें।

Answer 2

पायथन 2, 143 139 बाइट्स

I=1
a={2}
def f(s):
 for d in'123456789':u=d[I:]+s+d*I;z=int(u);z+=z<3;z%91>0<2==pow(2,z,z)>a.add(z)<f(u)
f('')
lambda n:sorted(a)[~-n]
I=0

पांच भागों से मिलकर बनता है:

1. I=1
2. एक नई लाइन
3. a={2}…[~-n]
4. एक नई लाइन
5. I=0

इसलिए उलटफेर सिर्फ मूल्य का है I।

व्याख्या

फ़ंक्शन fवैश्विक के मान के आधार पर या तो बाएं-ट्रंकिटेबल प्राइम (LTPs) या राइट-ट्रंकिटेबल प्राइम (RTP) के लिए एक पुनरावर्ती खोज करता है I। ये मान सेट में जुड़ जाते हैं a। फिर, lambda n:sorted(a)[~-n]रिटर्न nवें एक।

आइए एक पत्ती को या तो एक एलटीपी, एक आरटीपी, कुछ गैर-शून्य अंक + एक एलटीपी, या एक आरटीपी + कुछ गैर-शून्य अंक के रूप में परिभाषित करें । ये सभी मूल्य हैं जो fकभी भी मौलिकता की जांच करना चाहते हैं।

मैंने एक फ़र्मेट छद्म क्राइम परीक्षण तैयार किया है जो सभी पत्तियों के लिए काम करता है:

      

(63973 एक कारमाइकल नंबर है ।)

यदि यह परीक्षण सही हो जाता है, तो zसेट में जोड़ा aजाना चाहिए और हमें पुन: प्राप्त करना चाहिए str(z)। कोड का जिम्मेदार बिट है:

z+=z<3;z%91>0<2==pow(2,z,z)>a.add(z)<f(u)

पहले, हम मामले से निपटना चाहते हैं z == 2। 2जब हम शुरुआत में इसे परिभाषित करते हैं तो हम इसे यहाँ चकमा देते हैं और हार्ड-कोडिंग करते हैं a! (EDIT: और कुछ भी हानिकारक नहीं होता है अगर हम भी पकड़ते हैं z == 1।) तो हम यह मान सकते हैं कि z ≥ 3अब।

मैंने कुछ "और" का अनुवाद लघु-परिचालित जंजीरों की तुलना में किया है: पहले तीन तुलनाओं को पहले सफल होना पड़ता है a.add(z)और f(u)कभी भी उनका मूल्यांकन किया जाता है। यहाँ उनकी सभी भूमिकाएँ हैं:

1. z%91>0हमारी पहली शर्त एनकोड करता है। (63973 91 से विभाज्य है, जो स्वयं एक पत्ती नहीं है, इसलिए हम इसे पहचानते हैं।)
2. 0<2हमेशा सच होता है, लेकिन पीछा करने की तुलना में कम है and।
3. 2==pow(2,z,z) हमारी दूसरी शर्त एनकोड करता है।
4. pow(2,z,z)>a.add(z)इसके अतिरिक्त ट्रिगर करता है, और हमेशा सच होता है, क्योंकि set.addरिटर्न Noneऔर पूर्णांक हमेशा से अधिक होते हैं None।
5. a.add(z)<f(u)पुनरावृत्ति को ट्रिगर करता है। इसका सत्य मूल्य महत्वहीन है।

स्वीकृतियाँ

• डेनिस ने चार बाइट ( u=[d+s,s+d][I]→ u=d[I:]+s+d*I; z==2→ z<3और मोड 91 चाल) को बचाया । धन्यवाद!