एक विकल्प से सबसे छोटा प्राइम खोजें

Question

1946 में एर्दो और कोपलैंड ने साबित किया कि एक निश्चित संख्या एक सामान्य संख्या है , अर्थात इसके दशमलव विस्तार में अंक समान रूप से वितरित किए जाते हैं।

उपयोगकर्ता अंकों के एक अनुक्रम को इनपुट करेंगे और आपको सबसे छोटा प्राइम मिलेगा जो आधार 10 में उस स्ट्रिंग को समाहित करता है।

उदाहरण:

input   -> output
"10"    -> 101
"03"    -> 103
"222"   -> 2221
"98765" -> 987659

बाइट्स में सबसे छोटा कोड जीतता है। मुझे पता है कि कुछ भाषाएं (गणितज्ञ, ऋषि, परी-जीपी ...) प्राइम्स से संबंधित अंतर्निहित कार्यों के साथ आती हैं। -50 बाइट्स यदि आपका प्रोग्राम इस तरह के कार्यों पर भरोसा नहीं करता है। कृपया इस पर धोखा देने की कोशिश न करें, अगर आपकी भाषा में पहले से ही एक बड़ा फायदा है तो बोनस का दावा न करें।

संपादित करें

नीचे कुछ टिप्पणियों के अनुसार, सबसे छोटा प्राइम जिसमें "03" शामिल है 3. क्या वास्तव में इससे कोई फर्क पड़ता है? केवल एक चीज जो मैं सोच सकता हूं वह यह है कि शायद संख्याओं को स्ट्रिंग्स की तुलना में संभालना आसान है।

"03" जैसे मामलों में पसंदीदा आउटपुट 103 होगा। हालांकि, मैं इसे आपके कार्यक्रम का मूलभूत हिस्सा नहीं मानता, इसलिए यदि आप इसे कम बाइट गिनती के लिए देते हैं, तो आप किसी भी अग्रणी शून्य को अनदेखा करने के लिए स्वतंत्र हैं।

Comments

यह एक परियोजना यूलर कार्य के लिए एक अच्छा आधार जैसा लगता है

— जॉन ड्वोरक

"03" वाला सबसे छोटा प्राइम 03 है। हो सकता है कि आपको यह स्पष्ट करते हुए एक नियम जोड़ना चाहिए कि इनपुट में अग्रणी शून्य हो सकता है लेकिन आउटपुट नहीं हो सकता है।

— लेवल रिवर सेंट

@steveverrill में 03 जैसी कोई संख्या नहीं है। यदि आपका मतलब 3 है, तो इसमें "03" शामिल नहीं है।

— जॉन ड्वोरक

@JDDvorak 03 संख्या 3 का एक वैध प्रतिनिधित्व है। (2.9 ... आवर्ती, 2 + 9/9 के बराबर, कुछ वैध प्रतिनिधित्व द्वारा भी माना जाता है।) मैं दिए गए उदाहरण से समझता हूं कि 03 स्वीकार्य नहीं है। इस सवाल के लिए प्रतिनिधित्व। यह एक महत्वपूर्ण बिंदु है, लेकिन नियमों का सामान्य दुरुपयोग देखते हुए, मुझे लगता है कि बनाने लायक है।

— लेवल रिवर सेंट

मुझे लगता है कि वाक्यांश का सबसे अच्छा तरीका यह होगा कि वह सबसे छोटी संख्या का पता लगाए, जिसे स्ट्रिंग में परिवर्तित करने पर "03" शामिल हो।

— thebluefish

Answer 1

Golfscipt, 33 32 बाइट्स = -18 स्कोर

2{:x,2>{x\%!},!!x`3$?)!|}{)}/;;x

स्पष्टीकरण:

• 2{...}{)}/- के साथ शुरू 2, जबकि कुछ सच है, ढेर के शीर्ष वृद्धि

• ;;x- द्वारा एकत्र किए गए मध्यवर्ती मूल्यों {}{}/और इनपुट को त्यागें , फिर वहां परीक्षण किया गया अंतिम मान डालें

• :x,2> - मान को स्टोर करें x , फिर से एक सूची तैयार 2करने के लिएx-1

• {x\%!},!!- वे रखें जो xविभाज्य हैं, फिर बूलियन के लिए मोटे (खाली नहीं)
• x`3?)! - टेक्स्ट फॉर्म में इनपुट देखें x ( -1यदि नहीं मिला), वेतन वृद्धि, नकार ।
• | - या

Answer 2

हास्केल कार्यक्रम, 97 वर्ण = 47 स्कोर

main=getLine>>= \i->print$head$[x|x<-[2..],all((/=0).mod x)[2..x-1],i`Data.List.isInfixOf`show x]

हास्केल फ़ंक्शन, 75 वर्ण = 25 स्कोर

p i=head$[x|x<-[2..],all((/=0).mod x)[2..x-1],i`Data.List.isInfixOf`show x]

का प्रकार pहै (Integral a, Show a) => [Char] -> a। यदि आप अपने स्वयं के अभिन्न प्रकार की आपूर्ति करते हैं, तो आप उन मूल्यों के अपने प्रतिनिधित्व में infix द्वारा देख सकते हैं। मानक Integerपूर्णांक के लिए अपेक्षित दशमलव संकेतन का उपयोग करता है।

बहुत तेज नहीं है। आउटपुट के मान (आकार नहीं) में द्विघात।

अपंग संस्करण:

import Data.List
leastPrime infix = head $ filter prime' [2..]
  where prime' x  = all (\n-> x`mod`n /= 0) [2..x-1]
                 && i `isInfixOf` show x
main = print . leastPrime =<< getLine

उदाहरण:

Prelude> let p i=head$[x|x<-[2..],all((/=0).mod x)[2..x-1],i`Data.List.isInfixOf`show x]
Prelude> p "0"
101
Prelude> p "00"
1009
Prelude> p "000" -- long pause
10007

Answer 3

जावा - 175 वर्ण।

class s{public static void main(String[]a){int i,n=2,p;for(;;){p=1;for(i=3;i<n;i++)if(n%i==0)p=0;if((n==2||p>0)&&(""+n).indexOf(a[0])>=0) {System.out.println(n);break;}n++;}}}

Comments

आप के बीच की जगह छोड़ने के द्वारा 1 चरित्र को बचा सकता है indexOf(a[0])>=0)और {System.out.println(n)।

— प्रोग्राम फॉक्स

@ProgramFOX धन्यवाद

— वाइल्डकार्ड

मुझे लगता है कि आप आसानी से अपने को बदल कर (8 के बारे में) वर्ण को बचा सकता है boolean p=trueकी तरह कुछ से int p=1और इतने पर।

— फ्लोरियन एच

एक बार में अपने सभी ints को घोषित करने से आपके कार्यक्रम का आकार और कम हो जाएगा।

— ओलिवियर ग्रेजायर 13

Answer 4

गणितज्ञ 58

(n=1;While[StringCases[ToString[p=Prime@n],#]=={},n++];p)&

---

सापेक्ष समयमेरे मैक पर (8 जीबी मेमोरी के साथ 2.6 गीगाहर्ट्ज i7)।

"01" वाले सबसे छोटे प्राइम का पता लगाएं।

AbsoluteTiming[(n = 1; While[StringCases[ToString[p = Prime@n], #] == {}, n++]; p) &["01"]]

{0.000217, 101}

---

"012345" वाले सबसे छोटे प्राइम का पता लगाएं।

AbsoluteTiming[(n = 1; While[StringCases[ToString[p = Prime@n], #] == {}, n++]; p) &["012345"]]

{5.021915, 10123457}

---

"0123456" वाले सबसे छोटे प्राइम का पता लगाएं।

AbsoluteTiming[(n = 1; While[StringCases[ToString[p = Prime@n], #] == {}, n++]; p) &["0123456"]]

{87.056245, 201234563}

Comments

आप StringFreeQइसे छोटा करने के लिए उपयोग कर सकते हैं ।

— एलेफाल्फा

Answer 5

ऋषि , ,२

इंटरैक्टिव प्रॉम्प्ट में चलता है

a=raw_input()
i=0
p=2
while a not in str(p):i+=1;p=Primes().unrank(i)
p

Primes().unrank(i)iवें अभाज्य संख्या देता है , 0 वां अभाज्य 2 है।

Answer 6

R, 56chars -50 = 6

k=2;n=scan(,"");while(!grepl(n,k)|sum(!k%%2:k)>1)k=k+1;k

स्टड के रूप में इनपुट लें। K k जब तक k एक अभाज्य है (उदाहरणों के अनुसार परीक्षण किया जाता है जिसके लिए k 2 mod से k तक शून्य हैं, इसलिए FALSE 0 के बाद से तार्किक FALSE में बदल गया है) और इसमें इनपुट के रूप में दिए गए स्ट्रिंग शामिल हैं (एक साधारण gbp के साथ परीक्षण किया गया है, यहाँ grepl चूंकि हम परिणाम के रूप में एक तार्किक चाहते हैं)।

उपयोग:

> k=2;n=scan(,"");while(!grepl(n,k)|sum(!k%%2:k)>1)k=k+1;k
1: "03"
2: 
Read 1 item
[1] 103
> k=2;n=scan(,"");while(!grepl(n,k)|sum(!k%%2:k)>1)k=k+1;k
1: "003"
2: 
Read 1 item
[1] 2003

Answer 7

शेल ऑनलाइनर (कोरुटिल्स): 45 इंच

यहां एक फ़ंक्शन को परिभाषित नहीं किया जा रहा है ... बस एक ऑनलाइनर जो एक तर्क लेता है $nऔर पूर्णांक सीमा को स्कैन करता है (वास्तव में थोड़ा कम बनाने के लिए)। 55 वर्ण संस्करण:

seq 5e9|grep $n|factor|awk '{if(NF==2)print $2}'|head -n1

यह बहुत धीमा भी नहीं है। इसके लिए में n=0123456लौटता 201234563है81.715s । यह दो स्ट्रिंग प्रोसेसर वाली लंबी पाइपलाइन के लिए प्रभावशाली रूप से तेज़ है।

दो वर्णों (53 से नीचे) और एक पाइप को हटाकर, हम इसे और भी तेज़ी से चला सकते हैं:

seq 5e9|grep $n|factor|awk '{if(NF==2){print $2;exit}}'

और अंत में, sedइसे 45 वर्णों तक नीचे लाने के लिए कुछ विज़ार्ड , हालांकि प्रिंटआउट बदसूरत है:

seq 5e9|grep $n|factor|sed -n '/: \w*$/{p;q}'

n = 000 -> 10007: 10007 (उपयोगकर्ता 0.017s)

n = 012345 -> 10123457: 10123457 (उपयोगकर्ता 7.11s)

n = 0123456 -> 201234563: 201234563 (उपयोगकर्ता 66.8s)

Answer 8

जे - 38 चार -50 = -12 पीटी

सामान्य तौर पर J में, आप primes को समर्पित बहुत ही अनुकूलित बिल्टइन का उपयोग कर रहे हैं, इसलिए मैं निष्पादन में किसी भी सुस्ती के लिए माफी नहीं मांगने जा रहा हूं।

>:@]^:(>./@(E.":)*:]=*/@(+.i.)@])^:_&2

व्याख्या की:

• >:@]^:(...)^:_&2- 2 से शुरू, (...)गलत होने तक वेतन वृद्धि ।
• (+.i.)@]- काउंटर के GCD को उससे छोटे हर पूर्णांक के साथ लें। (हम सम्मेलन GCD (X, 0) = X का उपयोग करते हैं)
• ]=*/@- इन सभी नंबरों के उत्पाद लें, और काउंटर के लिए समानता के लिए परीक्षण करें। यदि काउंटर प्राइम है, तो सूची 1s के साथ GCD को छोड़कर, सभी 1s थी; अन्यथा कम से कम एक जीसीडी होगा जो 1 से अधिक है, इसलिए उत्पाद काउंटर से अधिक होगा।
• >./@(E.":)- परीक्षण अगर काउंटर के स्ट्रिंग प्रतिनिधित्व ":( E.) में किसी भी बिंदु पर स्ट्रिंग ( ) शामिल है । >./अधिकतम कार्य है, और हम इसका उपयोग करते हैंE. मुख्य स्ट्रिंग में सबस्ट्रिंग शुरू होने पर 1 के साथ बूलियन वेक्टर देता है।
• *:- तार्किक नंद एक साथ परिणाम। यह केवल तभी गलत होगा जब दोनों इनपुट सही थे, अर्थात यदि काउंटर दोनों प्राइम थे और इसमें सबस्ट्रिंग निहित था।

उपयोग:

   >:@]^:(>./@(E.":)*:]=*/@(+.i.)@])^:_&2 '03'
103
   >:@]^:(>./@(E.":)*:]=*/@(+.i.)@])^:_&2 '713'
2713

पोस्टरिटी के लिए, यहां प्राइम बिल्डिन का उपयोग करने वाला संस्करण (30 चार्ट लंबा, लेकिन कोई बोनस नहीं):

>:@]^:(>./@(E.":)*:1 p:])^:_&2

1 p:] जीसीडी ट्रिक के बजाय, प्रीमलिटी के लिए काउंटर का परीक्षण करता है।

Answer 9

Brachylog (v2), Brachylog के एन्कोडिंग में 3 बाइट्स

ṗ≜s

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

फंक्शन सबमिशन, दाएं हाथ के तर्क से इनपुट लेना, बाएं हाथ के तर्क को म्यूट करके आउटपुट देना। (यह सामान्य Brachylog सम्मेलन के विपरीत है; अधिक चर्चा के लिए इस मेटा पोस्ट को देखें । अधिक सामान्य क्रम में तर्कों को स्वैप करने पर तीन बाइट्स खर्च होंगे।) TIO लिंक में एक आवरण है जो फ़ंक्शन को उपयुक्त कॉलिंग हस्तक्षेप और प्रिंट के साथ बुलाता है। परिणाम।

व्याख्या

ṗ≜s
 ≜   Find the integer closest to zero
ṗ      which is prime {implicit: and output it via the left argument}
  s    and which is a substring of the {right argument}

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

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

Answer 10

जावास्क्रिप्ट 83 बाइट्स = 33 स्कोर

golfed:

for(s=prompt(n=x=0);!n;x++)for(n=(''+x).match(s)?2:0;n&&n<x;n=x%n?n+1:0);alert(x-1)

अनगढ़ (थोड़ा):

s=prompt() // get the input
n = 0
for(x=0;!n;x++) // stop when n is non-zero
    if ((''+x).match(s)) { // if x matches the pattern, check if x is prime
        for(n=2;n&&n<x;)
            n = (x%n == 0) ? 0 : n+1; // if x%n is zero, x is not prime so set n=0
        // if n is non-zero here, x is prime and matches the pattern
    }
alert(x-1)

Answer 11

जावास्क्रिप्ट (Node.JS) - 93 बाइट्स = 43 अंक

l:for(i=x=process.argv[2];j=i;i++){while(--j>2)if(!(i%j*(""+i).match(x)))continue l
throw i}

समझदार चर नामों के साथ निकाले गए रूप में:

outerLoop:for (currentTry=inputNumber=process.argv[2]; primeIterator=currentTry; currentTry++ ) {
    while (--primeIterator > 2) 
        if(!(currentTry % primeIterator * (""+currentTry).match(inputNumber)))
            continue outerLoop;
    throw i
}

Answer 12

रस्ट 0.9 136 बाइट्स = 86 अंक

fn main(){
   let mut n:u32=2;
   while n.to_str().find_str(std::os::args()[1])==None ||
         range(2,n).find(|&x|n%x==0)!=None {
      n=n+1;
   }
   print!("{}",n);
}

कॉम्पैक्टनेस के बावजूद बहुत स्पष्ट है। स्ट्रिंग खोजने पर बहुत अधिक स्थान खर्च होता है। :(

यहाँ व्हॉट्सएप के बिना वर्जन (136 char)

fn main(){let mut n:u32=2;while n.to_str().find_str(std::os::args()[1])==None||range(2,n).find(|&x|n%x==0)!=None{n=n+1;}print!("{}",n);}

Answer 13

जाप, 10 बाइट्स

_j *ZsøU}a

कोशिश करो

Answer 14

साफ , 37 बाइट्स

{s:s&{s,p:s in"".p}from primes|first}

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

Answer 15

पर्ल 6 , 36 - 50 = -14 अंक

{$^a;first {/$a/&&$_%%one ^$_},2..*}

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

ध्यान $_%%one ^$_में रखते हुए केवल 2 बाइट्स की तुलना में छोटा है.is-prime , मुझे लगता है कि यह बोनस के लिए इसके लायक है। इस बार आखिरी टेस्ट केस के लिए।

स्पष्टीकरण:

{                                  }  # Anonymous code block
 $^a;                                 # Assign input to $a
     first                    ,2..*   # Find the first number
           {                 }        # Which
            /$a/                        # Contains the input
                &&                      # And
                  $_%%one ^$_           # Is prime

Comments

2 बाइट्स छोटे?

— केवल

lol @ इस सवाल का हिस्सा है जो कहता है "इस पर धोखा देने की कोशिश मत करो, अगर आपकी भाषा में पहले से ही एक बड़ा फायदा है तो बोनस का दावा न करें।"

— केवल

@ ASCII- केवल खैर, मैं अभी भी गोल्फस्क्रिप्ट द्वारा पीटा जा रहा हूं, इसलिए ... :$

— जो राजा

Answer 16

पायथन 3 , 80 79 बाइट्स - 50 = 30 29 स्कोर

%sइसके बजाय @ ASCII- केवल रचनात्मक उपयोग के लिए -1 बाइट धन्यवादstr

परीक्षण मामले "98765" की पुष्टि अभी तक नहीं की गई है क्योंकि परीक्षण के मामले की पुष्टि करने में कितना समय लग रहा है "98765" कुछ घंटों के बाद, लेकिन इसी तरह के दृष्टिकोण के साथ जो कुछ प्राणिकता परीक्षण से बचने के लिए शॉर्ट-सर्किट मूल्यांकन का उपयोग करता है। काफी तेज। वैकल्पिक रूप से, यह तेजी से ~ 2x हो सकता है यदि हम जानते हैं कि "2" कोई इनपुट नहीं है (हम किसी भी अतिरिक्त बाइट की लागत पर i=3शुरू i+=2में और लूप में सेट करके, primality के लिए नंबर की जाँच से बच सकते हैं) ।

def f(x):
 i=2
 while(x in"%s"%i)*all(i%j for j in range(2,i))-1:i+=1
 return i

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

whileस्थिति की व्याख्या ( (x in"%s"%i)*all(i%j for j in range(2,i))-1):

(x in"%s"%i): True/ 1यदि वर्तमान काउंटर में संख्याओं का वांछित अनुक्रम है; False/ 0अन्यथा।

all(i%j for j in range(2,i)): True/ 1यदि वर्तमान काउंटर हमेशा 2 (समावेशी) से किसी भी पूर्णांक से विभाजित होने पर शेष (अनन्य) है, अर्थात अभाज्य है; False/ 0अन्यथा।

*पलता दो स्थितियों एक साथ, और एक के रूप में कार्य andऑपरेटर - उत्पाद है True/ 1अगर और दोनों स्थितियों रहे हैं केवल यदि True/ 1।

-1एक के रूप में कार्य notऑपरेटर: False/ 0- 1 परिणाम में -1है, जो सच माना जाता है, जबकि True/ 1- में 1 परिणाम 0है, जो गलत माना जाता है। इस प्रकार, लूप जारी रहता है जबकि संख्या में या तो संख्याओं का वांछित अनुक्रम नहीं होता है या प्राइम नहीं होता है।

के *साथ बदलें andऔर हर चीज़ के चारों ओर कोष्ठक जोड़ें, लेकिन -1बहुत तेज़, समतुल्य समाधान के लिए (जो थोड़ा लंबा है)।

@ ASCII-only द्वारा दिए गए पायथन 2 में एक 76 बाइट - 50 = 26 स्कोर का समाधान ( ``इसके बजाय उपयोग करता है str(),)

def f(x):
 i=2
 while(x in`i`)*all(i%j for j in range(2,i))-1:i+=1
 return i

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

Comments

क्यों नहीं py2

— केवल

@ ASCII- केवल मैंने अजगर 2 का अधिक उपयोग नहीं किया है और ज्यादातर अजगर 3 का उपयोग करता हूं, इसीलिए मैं इसमें गोल्फ करता हूं। हालाँकि ऐसा लगता है कि अधिकांश समय अजगर 2 समाप्त हो जाते हैं ...

— नील ए।

आपने एक टाइपो किया, पहले एक मेंreturn I

— ASCII-only

९

— एएससीआईआई-केवल

Answer 17

जावास्क्रिप्ट, 65 - 50 = 15 अंक

x=>(f=y=>(''+y).match(x)&&(p=n=>--n<2||y%n&&p(n))(y)?y:f(y+1))(x)

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