21

यह क्रम A054261 है ।

$n$ वें प्रधानमंत्री रोकथाम संख्या सबसे कम संख्या है जो पहले होता है $n$ सबस्ट्रिंग के रूप में रूढ़ अंक। उदाहरण के लिए, संख्या $235$ सबसे कम संख्या है जिसमें सबस्ट्रिंग के रूप में पहले 3 प्राइम्स शामिल हैं, जो इसे 3 जी प्राइम रोकथाम नंबर बनाता है।

यह पता लगाना तुच्छ है कि पहले चार अभाज्य संख्याएँ $2$ , $23$ , $235$ और $2357$ , लेकिन फिर यह अधिक दिलचस्प है। चूंकि अगला अभाज्य 11 है, इसलिए अगली अभाज्य संख्या $235711$ नहीं है , लेकिन यह $112357$ क्योंकि इसे संपत्ति के साथ सबसे छोटी संख्या के रूप में परिभाषित किया गया है।

हालाँकि, असली चुनौती तब सामने आती है जब आप 11. से आगे $113257$ । अगली प्राइम संख्या । ध्यान दें कि इस संख्या में, सबस्ट्रिंग 11और 13ओवरलैपिंग हैं। संख्या के 3साथ संख्या भी अतिव्यापी है 13।

यह साबित करना आसान है कि यह क्रम बढ़ रहा है, क्योंकि अगली संख्या को इसके पहले संख्या के सभी मानदंडों को पूरा करने की आवश्यकता है, और एक और विकल्प है। हालांकि, अनुक्रम सख्ती से नहीं बढ़ रहा है, जैसा कि परिणामों के लिए दिखाया गया है n=10और n=11।

इनपुट

एक एकल पूर्णांक n>0(मुझे लगता है कि आप इसे 0-अनुक्रमित भी कर सकते हैं, फिर बनाना n>=0)

उत्पादन

या तो nवें अभाज्य संख्या, या पहली nप्रधान समाख्या संख्या वाली सूची ।

अब तक मैंने जो नंबर पाए हैं, वे हैं:

 1 =>             2
 2 =>            23
 3 =>           235
 4 =>          2357
 5 =>        112357
 6 =>        113257
 7 =>       1131725
 8 =>     113171925
 9 =>    1131719235
10 =>  113171923295
11 =>  113171923295
12 => 1131719237295

ध्यान दें कि n = 10और n = 11समान संख्या हैं, क्योंकि $113171923295$ सबसे कम संख्या है जिसमें सभी संख्याएं $[2, 3, 5, 7, 11, 13, 17, 19, 23, 29]$ , लेकिन इसमें $31$ भी शामिल हैं ।

चूंकि यह कोड गोल्फ के रूप में चिह्नित है, इसलिए गोल्फिंग करें! जानवर बल समाधान की अनुमति है, लेकिन आपके कोड को सिद्धांत में किसी भी इनपुट के लिए काम करना है (इसका मतलब है कि आप पहले एन primes को संक्षिप्त नहीं कर सकते हैं)। हैप्पी गोल्फिंग!

— maxb
स्रोत

11

05AB1E , 8 बाइट्स

∞.ΔIÅpåP

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

व्याख्या

           # from
∞          # a list of infinite positive integers
 .Δ        # find the first which satisfies the condition:
       P   # all
   IÅp     # of the first <input> prime numbers
      å    # are contained in the number

— Emigna
स्रोत

क्या Pऑपरेटर संख्या में अभाज्य संख्याओं की जाँच करने के लिए एक स्पष्ट मानचित्रण बनाता है (यह जाँचने के बजाय कि संख्या primes की सरणी में है)? यह एक सुंदर समाधान है, मुझे संदेह है कि आप कम आदेशों का उपयोग करके कोई भी समाधान कर सकते हैं।

— अधिकतम

@ maxb Pउत्पाद है। यह मूल रूप से एक सूची में सभी मूल्यों को गुणा करता है। Åpपहले साथ एक सूची प्रदान करेगी nअभाज्य संख्या की राशि है, जहां nइनपुट है Iइस मामले में। åअगर वे अनंत सूची है, जहां यह दे देंगे की वर्तमान संख्या में हैं अभाज्य संख्या की इस सूची में प्रत्येक संख्या के लिए जाँच करेगा 1truthy के लिए और 0falsey के लिए। इसलिए उत्पाद मूल रूप से जांचता है कि क्या सभी सत्य हैं; यदि सभी प्राइम वर्तमान संख्या के अंदर हैं। यदि कोई 0 हैं, तो Pपरिणाम भी गलत होते हैं। लेकिन अगर सभी हैं 1, तो Pसच्चाई और -लूप में परिणाम .Δरुक जाते हैं।

— केविन क्रूज़सेन

@KevinCruijssen मैं देख रहा हूँ, स्पष्टीकरण के लिए धन्यवाद!

— मैक्स

1

नए संस्करण का उपयोग करके बहुत अच्छा समाधान! मैं साथ ही 8 बाइट्स था, लेकिन 05AB1E की विरासत संस्करण में: 1µNIÅpåP। जो लोग 05AB1E, मेरा के लिए एक स्पष्टीकरण के साथ ही पता नहीं है के लिए: 1µ- जब तक काउंटर चर 1 तक पहुँच जाता है (यह 0 पर शुरू होता है, में वृद्धि N1 से धीरे-धीरे और प्रदर्शन: NIÅpåP- जाँच करता है, तो पहले <input> के सभी अभाज्य संख्या में दिखाई देते हैं Nऔर , यदि ऐसा है, तो काउंटर चर को स्वचालित रूप से

— बढ़ाएँ

@ Mr.Xcoder: यह वास्तव में मेरा पहला संस्करण था ( Xइसके बजाय 1, कारण कारण के साथ), लेकिन मैंने इस पर स्विच कर दिया क्योंकि मुझे पहले कभी इस्तेमाल करने का मौका नहीं मिला ∞:)

— Emigna

5

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

³ÆN€ẇ€µẠ$1#

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

सरल पाशविक बल। पूरी तरह से सुनिश्चित नहीं है कि कैसे #काम करता है, इसलिए सुधार के लिए कुछ जगह हो सकती है।

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

³ÆN€ẇ€µẠ$1#    Main link. Input: Index n.
         1#    Find the first natural number N that satisfies:
³ÆN€             First n primes...
    ẇ€           ...are substrings of N
      µẠ$        All of them are true

— bubbler
स्रोत

"शर्त के साथ फ़िल्टर के तहत फिक्स्ड" "सभी के लिए सही स्थिति" के बजाय काम कर सकता है।

— user202729

2

wⱮẠ¥1#ÆN€दो बाइट बचाता है।

— डेनिस

5

जावा 8, 143 बाइट्स

n->{int r=1,f=1,c,i,j,k;for(;f>0;r++)for(i=2,f=c=n;c>0;c-=j>1?1+0*(f-=(r+"").contains(j+"")?1:0):0)for(j=i++,k=2;k<j;)j=j%k++<1?0:j;return~-r;}

इसे ऑनलाइन आज़माएं।
टिप्पणियाँ:

समय से ऊपर n=7।
पर्याप्त समय और संसाधनों को देखते हुए यह अधिकतम काम करता है n=9 आकार int(अधिकतम 2,147,483,647) की सीमा के कारण ।
- +4 बाइट्स के साथ एक में बदल रहा intहैlong , अधिकतम नीचे आउटपुट में बढ़ जाता है 9,223,372,036,854,775,807( n=20मुझे लगता है?)
- java.math.BigIntegerअधिकतम का उपयोग करके किसी भी आकार (सिद्धांत में) तक बढ़ाया जा सकता है, लेकिन यह कम से कम java.math.BigInteger' 200 बाइट्स 'के तरीकों की क्रियाशीलता के कारण होगा ।

स्पष्टीकरण:

n->{                   // Method with integer as both parameter and return-type
  int r=1,             //  Result-integer, starting at 1
      f=1,             //  Flag-integer, starting at 1 as well
      c,               //  Counter-integer, starting uninitialized
      i,j,k;           //  Index integers
  for(;f>0;            //  Loop as long as the flag is not 0 yet
      r++)             //    After every iteration, increase the result by 1
    for(i=2,           //   Reset `i` to 2
        f=c=n;         //   Reset both `f` and `c` to the input `n`
        c>0;           //   Inner loop as long as the counter is not 0 yet
        c-=            //     After every iteration, decrease the counter by:
           j>1?        //      If `j` is a prime:
            1          //       Decrease the counter by 1
            +0*(f-=    //       And also decrease the flag by:
                   (r+"").contains(j+"")?
                       //        If the result `r` contains the prime `j` as substring
                    1  //         Decrease the flag by 1
                   :   //        Else:
                    0) //         Leave the flag the same
           :           //      Else:
            0)         //       Leave the counter the same
      for(j=i++,       //    Set `j` to the current `i`,
                       //    (and increase `i` by 1 afterwards with `i++`)
          k=2;         //    Set `k` to 2 (the first prime)
          k<j;)        //    Inner loop as long as `k` is smaller than `j`
        j=j%k++<1?     //     If `j` is divisible by `k`
           0           //      Set `j` to 0
          :            //     Else:
           j;          //      Leave `j` the same
                       //    (If `j` is unchanged after this inner-most loop,
                       //     it means `j` is a prime)
  return~-r;}          //  Return `r-1` as result

— केविन क्रूज़सेन
स्रोत

5

जावास्क्रिप्ट (ईएस 6), 105 ... 92 91 बाइट्स

n=>(k=1,g=(s,d=k++)=>n?k%d--?g(s,d):g(d?s:s+`-!/${n--,k}/.test(n)`):eval(s+';)++n'))`for(;`

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

कैसे?

$n$

"-!/2/.test(n)-!/3/.test(n)-!/5/.test(n)-!/7/.test(n)-!/11/.test(n)..."

$n$

eval('for(;' + <conditions> + ';)++n')

टिप्पणी की गई

n => (                             // main function taking n
  k = 1,                           // k = current prime candidate, initialized to 1
  g = (s,                          // g = recursive function taking the code string s
          d = k++) =>              //     and the divisor d
    n ?                            // if n is not equal to 0:
      k % d-- ?                    //   if d is not a divisor of k:
        g(s, d)                    //     recursive call to test the next divisor
      :                            //   else:
        g(                         //     recursive call with s updated and d undefined:
          d ?                      //       if d is not equal to 0 (i.e. k is composite):
            s                      //         leave s unchanged
          :                        //       else (k is prime):
            s +                    //         decrement n and add to s
            `-!/${n--,k}/.test(n)` //         the next condition based on the prime k
                                   //       the lack of 2nd argument triggers 'd = k++'
        )                          //     end of recursive call
    :                              // else (n = 0):
      eval(s + ';)++n')            //   complete and evaluate the code string
)`for(;`                           // initial call to g with s = [ "for(;" ]

— Arnauld
स्रोत

4

रूबी , 58 बाइट्स

->n,i=1{i+=1until Prime.take(n).all?{|x|/#{x}/=~"#{i}"};i}

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

Brute-Force, TIO पर 7 तक काम करता है।

— किरिल एल।
स्रोत

4

अजगर , 14 बाइट्स

अत्यंत, बेहद धीमी गति से, समय के लिए बाहर $n>5$ TIO पर।

f@I`M.fP_ZQ1y`

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

f@I`M.fP_ZQ1y`     Full program. Q is the input.
f                  Find the first positive integer that fulfils the condition.
 @I`M.fP_ZQ1y`     Filtering condition, uses T to refer to the number being tested.
     .f   Q1       Starting at 1, find the first Q positive integers (.f...Q1) that
       P_Z         Are prime.
   `M              Convert all of those primes to strings.
  I                Check whether the result is invariant (i.e. doesn't change) when...
 @          y`     Intersecting this list with the powerset of T as a string.

अजगर , 15 बाइट्स

थोड़ा तेज लेकिन 1 बाइट लंबी।

f.A/L`T`M.fP_ZQ

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

f.A/L`T`M.fP_ZQ     Full program. Q is the input.
f                   Find the first positive integer that fulfils the condition.
 .A/L`T`M.fP_ZQ     Filtering condition, uses T to refer to the number being tested.
         .f   Q     Starting at 1, find the first Q positive integers (.f...Q) that
           P_Z      Are prime.
       `M           Convert all of those primes to strings.
 .A/L               And make sure that they all (.A) occur in (/L)...
     `T             The string representation of T.

— श्री Xcoder
स्रोत

3

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

³RÆNṾ€ẇ€ṾȦ
Ç1#

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

— lirtosiast
स्रोत

3

चारकोल , 42 बाइट्स

≔¹ηＷ‹ＬυＩθ«≦⊕η¿¬Φυ¬﹪ηκ⊞υη»≔¹ηＷΦυ¬№ＩηＩκ≦⊕ηＩη

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

≔¹ηＷ‹ＬυＩθ«≦⊕η¿¬Φυ¬﹪ηκ⊞υη»

पहले का निर्माण nपहले से पाया रूढ़ अंक की सभी ने सभी पूर्णांकों का परीक्षण प्रभाग द्वारा रूढ़ अंक।

≔¹ηＷΦυ¬№ＩηＩκ≦⊕η

सभी पूर्णांकों के माध्यम से लूप करें जब तक कि हम एक ऐसा न हो जाए जिसमें सभी प्राइमिंग को सबस्ट्रिंग के रूप में शामिल किया गया हो।

Ｉη

परिणाम को स्ट्रिंग और अंतर्निहित रूप से प्रिंट करें।

कार्यक्रम की गति एक बाइट की कीमत पर अंतिम के ≦⊕ηसाथ बदलकर दोगुनी की जा सकती है ≦⁺²ηलेकिन यह अभी भी गणना के लिए बहुत धीमी है n>6।

— नील
स्रोत

3

पर्ल 6 , 63 59 बाइट्स

-4 बाइट्स nwellnhof के लिए धन्यवाद

{+(1...->\a{!grep {a~~!/$^b/},(grep &is-prime,2..*)[^$_]})}

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

एक ब्रूट फोर्स सॉल्यूशन जो कि TIO पर 5 से ऊपर की संख्या के लिए है, लेकिन मुझे पूरा यकीन है कि यह सही तरीके से काम करता है। पहले पॉज़िटिव नंबर ढूँढता है जिसमें पहले nप्राइम्स होते हैं। यहाँ एक समाधान है जिसके लिए समय नहीं हैn=6 ।

स्पष्टीकरण:

{                                                             } # Anonymous code block
 first                                                    2..*  # Find the first number
       ->\a{                                            }       # Where:
            !grep     # None of
                                                   [^$_]  # The first n
                              (grep &is-prime,2..*)       # primes
                  {a~~!/$^b/},   # Are not in the current number

— मजाक कर रहा है
स्रोत

क्या आपके पास बड़ी संख्या के लिए आउटपुट को सत्यापित करने या स्पष्टीकरण जोड़ने का कोई तरीका है? मैं पर्ल में धाराप्रवाह नहीं हूं, और मैं निश्चित रूप से गोल्फ-पर्ल में धाराप्रवाह नहीं हूं । मुझे इनपुट 5 के लिए टीआईओ पर एक टाइमआउट मिलता है, इसलिए मैं वास्तव में यह सत्यापित नहीं कर सकता कि यह सिर्फ कॉन्सेप्ट नहीं है।

— अधिकतम

@ maxb मैंने एक समाधान के लिए एक लिंक जोड़ा है जो बार-बार और स्पष्टीकरण के बजाय पहले से ही primes उत्पन्न करता है।

— जो राजा

2

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

f=lambda n,x=2:x*all(i in`x`for i in g(n,2))or f(n,x+1)
def g(n,x):p=all(x%i for i in range(2,x));return[0]*n and[`x`]*p+g(n-p,x+1)

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

f समारोह है।

— आउटगोल्फर को एरिक करें
स्रोत

2

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

n=input();l=[]
P=k=1
while~-all(`x`in`k`for x in(l+[l])[:n]):P*=k*k;k+=1;l+=P%k*[k]
print k

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

— OVS
स्रोत

अगर मुझे नहीं पता होता कि आपका कोड प्राइम नंबर जनरेट करता है, तो मैं कभी भी यह पता नहीं लगा पाऊंगा कि उसने ऐसा किया। अच्छा काम!

— अधिकतम

2

एसएएस, 149 बाइट्स

data p;input n;z:i=1;a=0;v+1;do while(a<n);i+1;do j=2 to i while(mod(i,j));end;if j=i then do;a+1;if find(cat(v),cat(i))=0 then goto z;end;end;cards;

इनपुट को cards;बयान के बाद दर्ज किया जाता है , जैसे:

data p;input n;z:i=1;a=0;v+1;do while(a<n);i+1;do j=2 to i while(mod(i,j));end;if j=i then do;a+1;if find(cat(v),cat(i))=0 then goto z;end;end;cards; 
1
2
3
4
5
6
7

pपरिणाम के साथ एक डाटासेट आउटपुटvप्रत्येक इनपुट मान के लिए आउटपुट पंक्ति के साथ । तकनीकी रूप से सभी दिए गए परीक्षण-मामलों के लिए काम करना चाहिए (एसएएस में पूर्ण सटीकता के साथ अधिकतम पूर्णांक 9,007,199,254,740,992 है), लेकिन मैंने इसे n = 8 पर 5 मिनट के लिए सोचने के बाद छोड़ दिया।

स्पष्टीकरण:

data p;
input n; /* Read a line of input */

z: /* Jump label (not proud of this) */
    i=1; /* i is the current value which we are checking for primality */
    a=0; /* a is the number of primes we've found so far */
    v+1; /* v is the final output value which we'll look for substrings in */ 

    do while(a<n); /* Loop until we find the Nth prime */
        i+1; 
        do j=2 to i while(mod(i,j));end; /* Prime sieve: If mod(i,j) != 0 for all j = 2 to i, then i is prime. This could be faster by only looping to sqrt(i), but would take more bytes */
        if j=i then do; /* If i is prime (ie, we made it to the end of the prime sieve)... */
            a+1;
            if find(cat(v),cat(i))=0 then goto z; /* If i does not appear as a substring of v, then start all over again with the next v */
        end;
    end;

/* Input values, separated by newlines */
cards; 
1
2
3
4
5
6
7

— जोश एलर
स्रोत

1

हास्केल , 102 बाइट्स

import Data.List
f n|x<-[2..n*n]=[a|a<-[2..],all(`isInfixOf`show a).take n$show<$>x\\((*)<$>x<*>x)]!!0

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

स्पष्टीकरण / अनलॉक्ड

चूँकि हम पहले से ही Data.Listआयात कर चुके हैं, इसलिए हम इसका उपयोग भी कर सकते हैं: अच्छे पुराने के बजाय take n[p|p<-[2..],all((>0).mod p)[2..p-1]]हम उन सभी primes को उत्पन्न करने के दूसरे तरीके का उपयोग कर सकते हैं जिनकी हमें आवश्यकता है। अर्थात्, हम पर्याप्त मात्रा में कंपोजिट उत्पन्न करते हैं और इनका उपयोग एक साथ करते हैं (\\):

[2..n*n] \\ ( (*) <$> [2..n*n] <*> [2..n*n] )

n*nक्योंकि का उपयोग करना $\pi(n) < \frac{n^2}{\log(n^2)}$ । बाकी सिर्फ एक साधारण सूची की समझ है:

[ a | a <- [2..], all (`isInfixOf` show a) . take n $ enoughPrimes ] !!0

— ბიმო
स्रोत

1

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

अपने बेहतरीन काम से दूर, मैं उस दिन काम करने के बाद उसे पाकर बहुत खुश था। मुझे यकीन है कि मैं बाद में इसे बूस्टर से नीचे टैप करके समाप्त कर दूंगा!

_õ fj ¯U e!øZs}aUÄ

कोशिश करो - एक इनपुट के लिए चलने में 13 सेकंड लगते हैं 7, उसके बाद एक wobbly फेंकता है (मेरे लिए अपडेटेड वर्जन क्रेप्स आउट हो 5जाता है, लेकिन यह सिर्फ मेरा फोन हो सकता है)।

— झबरा
स्रोत

@ ओलिवर, हम्म ... मैं भी। जब मैंने इसे पोस्ट किया था तो यह निश्चित रूप से काम कर रहा था। बस F.h()अपने दम पर एक परीक्षण चलाया और यह टूट गया लगता है; ETH को कुछ बदलना होगा।

— झबरा

@ ओलिवर, नहीं, आखिरी प्रतिबद्ध 2 दिन पहले था इसलिए मैंने इसे पोस्ट करने के बाद कुछ भी नहीं बदला है। अजीब!

— झबरा

अब यह काम कर रहा है! ¯ \ _ (ツ) _ / ¯

— ओलिवर

@ ओलिवर, अभी भी मेरे लिए काम नहीं कर रहा है। वियरडर और वियरडर!

— झबरा

यह मेरे लिए तब से काम कर रहा है जब मैं अपने काम के कंप्यूटर से अपने घर के कंप्यूटर पर गया था। अजीब वास्तव में!

— ओलिवर

प्राइम कंटेंट नंबर (गोल्फ संस्करण)

इनपुट

उत्पादन

05AB1E , 8 बाइट्स

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

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

जावा 8, 143 बाइट्स

जावास्क्रिप्ट (ईएस 6), 105 ... 92 91 बाइट्स

कैसे?

टिप्पणी की गई

रूबी , 58 बाइट्स

अजगर , 14 बाइट्स

अजगर , 15 बाइट्स

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

चारकोल , 42 बाइट्स

पर्ल 6 , 63 59 बाइट्स

स्पष्टीकरण:

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

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

एसएएस, 149 बाइट्स

हास्केल , 102 बाइट्स

स्पष्टीकरण / अनलॉक्ड

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