यह सवाल nवें प्राइम नंबर खोजने पर एक मोड़ होगा ।

चुनौती

आपको एक प्रोग्राम लिखना होगा जो एक इनपुट लेगा n, और nवें प्राइम नंबर को आउटपुट करेगा, जिसके दशमलव प्रतिनिधित्व में nएक सबरिंग के रूप में दशमलव प्रतिनिधित्व शामिल है ।

उलझन में? यहाँ कुछ उदाहरण हैं।

n=1
Primes: 2, 3, 5, 7, 11
                    ^1 first prime that contains a 1
Output: 11

n=2
Primes: 2, 3, 5, 7, 11, 13, 17, 19, 23
        ^1                          ^2 second prime that contains a 2
Output: 23

n=3
Primes: 2, 3, 5, 7, 11, 13, 17, 19, 23
           ^1           ^2          ^3 third prime that contains a 3
Output: 23

n=10
Primes: 2, 3, 5, 7, 11, ..., 97, 101, 103, 107, 109, ..., 997, 1009, 1013, 1019, 1021, 1031, 1033
                                 ^1   ^2   ^3   ^4             ^5    ^6    ^7    ^8    ^9    ^10 tenth prime that contains a 10
Output: 1033

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

अगर कुछ गड़बड़ है, तो कृपया एक टिप्पणी छोड़ दें।

— ericw31415
स्रोत

2

क्या इसके लिए कोई OEIS है? ऐसा लगता है कि वहाँ होना चाहिए

— मेयरमोनी

@SpeedyNinja नहीं, मैंने पहले ही जाँच कर ली है।

— अदनान

05AB1E , 8 बाइट्स

कोड:

µN¹åNp*½

स्पष्टीकरण:

µ          # Run this until the counting variable has reached the input value.
 N¹å       # Check if the input number is in the range variable.
    Np     # Check if the range variable is prime.
      *    # Multiply those two numbers (which is basically an AND operator).
       ½   # If true, increment the counting variable.
           # After the loop, the stack is empty and implicitly prints N.

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं! ।

— अदनान
स्रोत

10

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

e.f&P_Z}`Q`

टेस्ट सूट ।

— Maltysen
स्रोत

8

पायथन 2, 67 65 62 बाइट्स

f=lambda n,k=0,m=2,p=1:k/n or-~f(n,k+p%m*(`n`in`m`),m+1,p*m*m)

Ideone पर इसका परीक्षण करें ।

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

हम विल्सन की प्रमेय की एक कोरोलरी का उपयोग करते हैं :

विल्सन की प्रमेय की कोरोलरी

हर समय, चर p , m - 1 के भाज्य के वर्ग के बराबर होता है ।

यदि k <n , 0k/n निकलेगा और f को पुनरावर्ती कहा जाता है। m बढ़ा हुआ है, p अद्यतन किया गया है, और k बढ़ा हुआ है यदि और केवल यदि m एक अभाज्य है जिसमें n समाहित है ।

बाद के परिणाम जोड़कर हासिल की है p%m*(`n`in`m`)करने के लिए कश्मीर । विल्सन प्रमेय की कोरोलरी द्वारा यदि m अभाज्य है, 1p%m लौटाता है , और यदि नहीं, तो यह 0 देता है ।

एक बार जब k n पर पहुंचता है , तो हमने q पाया , n ^th prime जिसमें n सम्‍मिलित है ।

हम चेक के दौरान अगली कॉल में हैं, इसलिए m = q + 1 । 1k/n लौटेगा , और बिटकॉइन ऑपरेटर हर फ़ंक्शन कॉल के लिए एक बार उस नंबर को बढ़ाएंगे । चूँकि यह q - 1 कॉल को f से बढ़ाकर m से 2 से q + 1 तक ले जाता है , f का सबसे बाहरी कॉल 1 + q - 1 = q को वापस करेगा , जैसा कि इरादा था।-~

— डेनिस
स्रोत

6

बैश, 27 बाइट्स

primes 0|grep $1|sed $1q\;d

primes bsdgames से आता है।

कमांड लाइन तर्क के रूप में इनपुट लेता है, और STDOUT पर आउटपुट देता है।

— Doorknob
स्रोत

5

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

×ÆP,³Dœṣ/Ṗµ#Ṫ

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

— डेनिस
स्रोत

4

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

Nest[NestWhile[b=NextPrime,b@#,!StringContainsQ@@ToString/@{#,a}&]&,1,a=#]&

अभी भी गोल्फ हो सकता है।

— LegionMammal978
स्रोत

यह शायद सबसे तेज़ समाधान है क्योंकि यह NextPrime का उपयोग करता है :)

4

जावा, 194 180 173 171 112 बाइट्स

कोड:

a->{int i=1,j,n,r=0;for(j=n=new Integer(a);(r+=++i>=j&(""+j).contains(""+n)?1:0)!=n;j+=j%i==0?i=1:0);return j;}

Ungolfed:

class P{
    static int i=1,j,n,r;
    public static void main(String[]s) {
        for(
                j=n=new Integer(s[0]); //executes once before first iteration
                (r+=++i>=j&(""+j).contains(""+n)?1:0)!=n; //executes on first and every iteration
                j+=j%i==0?i=1:0 //executes after first and every iteration
           ) {
            ;
        }
        System.out.print(j);
    }
}

— HopefullyHelpful
स्रोत

नमस्ते, PPCG में आपका स्वागत है! ध्यान देने योग्य दो बातें, 1. आप दो स्थानों को हटा सकते हैं P {और String[] s। और 2. आप वर्तमान में केवल आउटपुट दे रहे हैं 10, लेकिन कोड-गोल्फ चुनौती एक इनपुट लेने nऔर उस इनपुट के आधार पर उचित आउटपुट देने की थी। इसके अलावा, आपको यह दिलचस्प लग सकता है: जावा में गोल्फ के लिए टिप्स।

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

3

रूबी, 62 61 बाइट्स

->i{Prime.lazy.map(&:to_s).grep(/#{i}/).first(i)[-1]}

आवश्यक -rprimeध्वज (+8 बाइट्स)।

->i{            # lambda with one argument
Prime           # iterator over all primes
.lazy           # make the iterator lazy (can't evaluate infinite primes)
.map(&:x.to_s)  # convert the primes to strings
.grep(/#{i}/)   # find primes that regex match on the input (contain it)
.first(i)       # take the first (input) primes that satisfy this
[-1]            # take the last of those
}

— Doorknob
स्रोत

3

जूलिया, 61 60 बाइट्स

f(n,k=0,m=1)=k<n&&f(n,k+isprime(m)contains("$m","$n"),m+1)+1

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

— डेनिस
स्रोत

3

MATL , 18 बाइट्स

`@YqVGVXf?3M]NG<]&

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

व्याख्या

यह do...whileलूप का उपयोग करके क्रम उत्पन्न करता है । प्रत्येक प्राइम के लिए, स्थिति का परीक्षण किया जाता है (और प्राइम का उपभोग किया जाता है)। संतुष्ट होने पर, उस प्राइम को फिर से स्टैक पर धकेल दिया जाता है। स्टैक में तत्वों की संख्या का उपयोग इस बात के लिए किया जाता है कि हमने कितने योग्य प्राइमर पाए हैं। जब उनमें से पर्याप्त होते हैं, तो अंतिम प्रदर्शित किया जाता है।

`         % Do...while
  @       %   Push iteration index, k. Starts at 1
  YqV     %   k-th prime. Convert to string
  GV      %   Push input, n. Convert to string
  Xf      %   Find string within another
  ?       %   If non-empty
    3M    %     Push k-th prime again (increase stack size by 1)
  ]       %   End if
  NG<     %   Is stack size less than input number? If so proceeed with
          %   a new iteration; else exit do...while loop
]         % End do...while
&         % Implicitly display only top number in the stack

— लुइस मेंडो
स्रोत

2

पाइके, 15 बाइट्स

Q.fD_P.I`Q`R{(e

यहाँ कोशिश करो!

— नीला
स्रोत

1

बैश + जीएनयू कोरुटिल्स, 66 बाइट्स

@ Doorknob के समाधान के विपरीत, इस चीज़ को केवल उन चीज़ों की ज़रूरत होती है जो हर GNU / Linux पर स्थापित होती हैं:

for((n=2;;n++)){
[ `factor $n|wc -w` -eq 2 ]&&grep $1<<<$n&&exit
}

— rexkogitans
स्रोत

seq 1e20|factor|grep -Po "(?<=: )\d*$2\d$"|sed $1q\;d

— डिजिटल ट्रॉमा

@ दिगीतलत्रुमा, मेरा दिमाग इस तरह से काम नहीं करता ;-)

— rexkogitans

क्या इसे न्यूलाइन्स की जरूरत है?

— ericw31415

बाद में for((...)){, एक स्थान या नई रेखा होनी चाहिए, इसलिए यह कोई फर्क नहीं पड़ता। समापन से पहले }, एक ; या एक नई रेखा होनी चाहिए , इसलिए यह कोई फर्क नहीं पड़ता।

— रेक्सकोगिटन

1

पर्ल 6 , 41 बाइट्स

->$n {grep({.is-prime&&/$n/},2..*)[$n-1]}

स्पष्टीकरण:

-> $n { # has one parameter
  grep(
    {
      .is-prime # check that it is prime
      &&        # and
      / $n /    # that it contains the argument in the "string"
    },
    2 .. *      # for all numbers starting with 2
  )[ $n - 1 ]   # only take the $n-th one
                # ( accounting for 0 based array access )
}

परीक्षा:

#! /usr/bin/env perl6
use v6.c;
use Test;

my &prefix:<ℙ𝕟> = ->$n {grep({.is-prime&&/$n/},2..*)[$n-1]}

my @test = (
  1  => 11,
  2  => 23,
  3  => 23,
  10 => 1033,
);

plan +@test;

for @test {
  is ℙ𝕟.key, .value, .gist
}

1..4
ok 1 - 1 => 11
ok 2 - 2 => 23
ok 3 - 3 => 23
ok 4 - 10 => 1033

— ब्रैड गिल्बर्ट b2gills
स्रोत

1

जावा 8, 192 183 181 171 बाइट्स (पूरा कार्यक्रम)

interface M{static void main(String[]a){long n=new Long(a[0]),c=0,r=1,m,i;for(;c<n;c+=m>1&(r+"").contains(a[0])?1:0)for(m=++r,i=2;i<m;m=m%i++<1?0:m);System.out.print(r);}}

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

स्पष्टीकरण:

interface M{                    // Class
  static void main(String[]a){  //  Mandatory main-method
    long n=new Long(a[0]),      //   Input argument as number
         c=0,                   //   Counter, starting at 0
         r=1,                   //   Result-number, starting at 1
         m,i;                   //   Temp number
    for(;c<n;                   //   Loop as long as `c` does not equals `n`
        c+=                     //     After every iteration: increase `c` by:
           m>1                  //      If the current `r` is a prime,
           &(r+"").contains(a[0])?
                                //      and this prime contains the input `n`
            1                   //       Increase `c` by 1
           :                    //      Else:
            0)                  //       Leave `c` the same
      for(m=++r,                //    Increase `r` by 1 first with `++r`, and set `m` to it
          i=2;i<m;              //    Inner loop `i` in the range [2, `m`)
        m=m%i++<1?              //     If `m` is divisible by `i`
           0                    //      Change `m` to 0 (so it's not a prime)
          :                     //     Else:
           m);                  //      Leave `m` unchanged
    System.out.print(r);}}      //    Print `r` as result

जावा 8, 105 बाइट्स (लैम्ब्डा फंक्शन)

n->{int c=0,r=1,m,i;for(;c<n;c+=m>1&(r+"").contains(n+"")?1:0)for(m=++r,i=2;i<m;m=m%i++<1?0:m);return r;}

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

ऊपर के रूप में भी, लेकिन nपूर्णांक इनपुट के साथ और वर्बोज़ वर्ग सामान के बिना।

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

1

आप बदल सकते हैं &&के साथ &और निकालने के ?अपने regexp से।

— क्लिफरॉट

@cliffroot धन्यवाद, पोस्ट को संपादित किया। मैं हमेशा &&और &किसी कारण से भूल जाता हूँ ..

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

0

क्लोजर, 118 बाइट्स

(defn s[n](nth(filter(fn[x](if(.contains(str x)(str n))(not-any? #(=(mod x %)0)(range 2 x))))(drop 2(range)))(dec n)))

बस संख्याओं के आलसी अनंत अनुक्रम का मूल तत्व प्राप्त होता है जो प्रमुख हैं और nउनके स्ट्रिंग प्रतिनिधित्व में हैं।

आप इसे यहाँ आज़मा सकते हैं: https://ideone.com/ioBJjt

— cliffroot
स्रोत

0

दरअसल, 16 बाइट्स

;$╗`P$╜@íu`╓dP.X

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

स्पष्टीकरण:

;$╗`P$╜@íu`╓dP.X
;$╗               make a copy of n, push str(n) to reg0
   `      `╓      push the first n values where f(k) is truthy, starting with k=0:
    P$              kth prime, stringified
      ╜@íu          1-based index of n, 0 if not found
            d     remove last element of list and push it to the stack (dequeue)
             P    nth prime
              .   print
               X  discard rest of list

— मेगो
स्रोत

0

PowerShell v2 +, 108 99 बाइट्स

Ooof। किसी भी प्रकार की अंतर्निहित प्रधान गणना / जाँच की कमी वास्तव में यहाँ आहत करती है।

param($n)for(){for(;'1'*++$i-match'^(?!(..+)\1+$)..'){if("$i"-like"*$n*"){if(++$o-eq$n){$i;exit}}}}

इनपुट लेता है $n, एक अनंत for()लूप में प्रवेश करता है । प्रत्येक पुनरावृत्ति, हम forलूप के माध्यम से हर बार वेतन वृद्धि करके इसे एक प्रमुख जनरेटर में बदलने के लिए पॉवरशेल रेगेक्स प्राइम चेकर (एच / टी से मार्टिन) के चारों ओर लिपटे लूप का उपयोग करते हैं $i। (उदाहरण के लिए, बस चलने for(){for(;'1'*++$i-match'^(?!(..+)\1+$)..'){$i}}से आउटपुट 2, 3, 5, 7...अलग-अलग हो जाएगा )।

फिर एक साधारण -likeजांच यह देखने के लिए कि $nक्या कहीं $iऔर हमारे काउंटर में वृद्धि है $o। यदि हम जहां तक पहुंचे हैं $nऔर $oसमान, आउटपुट $iऔर हैं exit। अन्यथा हम forअगले प्राइम को खोजने के लिए जारी रखते हैं और प्रक्रिया दोहराते हैं।

— AdmBorkBork
स्रोत

0

एपीएल (एनएआरएस), 39 चार्ट, 78 बाइट्स

{s←⍕w←⍵⋄2{(w≤⍵)∧k←∨/s⍷⍕⍺:⍺⋄(1π⍺)∇⍵+k}1}

1 number अगला अभाज्य संख्या है ...; परीक्षा:

  f←{s←⍕w←⍵⋄2{(w≤⍵)∧k←∨/s⍷⍕⍺:⍺⋄(1π⍺)∇⍵+k}1}
  f¨1 2 3 10
11 23 23 1033

लेकिन जो पहले से ही 20 पर है वह स्टैक स्पेस से बाहर चला जाता है ... इसके बजाय नीचे यह ठीक लगता है, भले ही वह थोड़ा अधिक लंबा हो (61 वर्ण)

∇r←f w;i;k;s
r←2⋄s←⍕w⋄i←1
→0×⍳(w≤i)∧k←∨/s⍷⍕r⋄r←1πr⋄i+←k⋄→2
∇

  f¨1 2 3 10 20 100
11 23 23 1033 4201 100999

— RosLuP
स्रोत

0

++ , 36 बाइट्स जोड़ें

L,5*2^RßÞPABDBJVB]dG€Ωezß£*BZB]A1_$:

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

$i$ $i \le 25x^2$ $n$ $n$

— केर्ड सिक्काहिरिंग
स्रोत

0

जाप `-h` , 15 13 11 बाइट्स

_j ©ZsèU}jU

कोशिश करो

— झबरा
स्रोत

उस nth प्राइम को प्रिंट करें जिसमें n है

चुनौती

05AB1E , 8 बाइट्स

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

पायथन 2, 67 65 62 बाइट्स

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

बैश, 27 बाइट्स

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

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

जावा, 194 180 173 171 112 बाइट्स

रूबी, 62 61 बाइट्स

जूलिया, 61 60 बाइट्स

MATL , 18 बाइट्स

व्याख्या

पाइके, 15 बाइट्स

बैश + जीएनयू कोरुटिल्स, 66 बाइट्स

पर्ल 6 , 41 बाइट्स

स्पष्टीकरण:

परीक्षा:

जावा 8, 192 183 181 171 बाइट्स (पूरा कार्यक्रम)

जावा 8, 105 बाइट्स (लैम्ब्डा फंक्शन)

क्लोजर, 118 बाइट्स

दरअसल, 16 बाइट्स

PowerShell v2 +, 108 99 बाइट्स

एपीएल (एनएआरएस), 39 चार्ट, 78 बाइट्स

++ , 36 बाइट्स जोड़ें

जाप -h , 15 13 11 बाइट्स

जाप `-h` , 15 13 11 बाइट्स