"प्रमुख पात्रों" का उपयोग किए बिना प्रमुख संख्याओं का पता लगाना


21

आपका कार्य, यदि आप इसे स्वीकार करना चुनते हैं, तो एक प्रोग्राम / फ़ंक्शन लिखना है जो एक पूर्णांक एन को इनपुट के रूप में स्वीकार करता है । कार्यक्रम / फ़ंक्शन को पहले N अभाज्य संख्याओं की सूची को आउटपुट / वापस करना चाहिए । लेकिन यहाँ पकड़ है: आपको अपने कोड में प्रमुख पात्रों का उपयोग करने की अनुमति नहीं है । एक प्रमुख चरित्र एक चरित्र है जिसका यूनिकोड कोड बिंदु एक प्रमुख संख्या है। मुद्रण योग्य ASCII रेंज में, ये हैं:

%)+/5;=CGIOSYaegkmq

लेकिन नियम आपके कोड का उपयोग करने पर गैर- ASCII वर्णों पर भी लागू होता है।

  • एक वैध इनपुट एक पूर्णांक N है जहाँ 0 <N <= T , जहाँ आप T चुन सकते हैं , लेकिन इसे 10000 से अधिक या बराबर होना चाहिए। T का परिमित होना आवश्यक नहीं है।
  • अमान्य इनपुट (गैर-पूर्णांक, पूर्णांक सीमा से बाहर) के लिए, एक अपवाद या आउटपुट / रिटर्न नथिंग / शून्य फेंक दें।
  • इनपुट के रूप में प्रमुख / अनुगामी व्हाट्सएप के साथ एक पूर्णांक अमान्य माना जाता है।
  • +इनपुट के रूप में हस्ताक्षर के रूप में एक पूर्णांक अमान्य माना जाता है।
  • इनपुट के रूप में अग्रणी शून्य के साथ एक पूर्णांक वैध माना जाता है।
  • यदि आपकी भाषा आपको इनपुट के रूप में पहले से ही पार्स किए गए पूर्णांक को पास करने की अनुमति देती है, तो उपरोक्त पार्सिंग नियम (सीमा एक को छोड़कर) लागू नहीं होते हैं, क्योंकि इंट पहले से ही पार्स है।
  • इनपुट हमेशा बेस -10 है।
  • बिल्ट-इन प्राइम जनरेटर और प्राइमलिटी टेस्टर्स का उपयोग (इसमें प्राइम फैक्टराइज़ेशन फ़ंक्शंस शामिल हैं) की अनुमति नहीं है।
  • स्रोत प्रतिबंध यूनिकोड वर्णों पर लगाया गया है, लेकिन यदि आप चाहें तो स्कोर के लिए बाइट की गिनती दूसरे एन्कोडिंग में हो सकती है।
  • आउटपुट में एक एकल अनुगामी न्यूलाइन हो सकती है, लेकिन इसकी आवश्यकता नहीं है।
  • यदि आप एक स्ट्रिंग के रूप में अभाज्य संख्या सूची को आउटपुट / वापस करते हैं, तो प्रत्येक अभाज्य संख्या को एक या कई गैर-अंक चार (s) द्वारा सीमांकित किया जाना चाहिए। आप चुन सकते हैं कि आप किस परिसीमन का उपयोग करते हैं।
  • यह एक चुनौती है, जो बाइट्स जीत में सबसे छोटा कोड है।

अपने कोड को सत्यापित करने के लिए स्निपेट को स्टैक करें

आप यह सत्यापित करने के लिए नीचे दिए गए स्टैक स्निपेट का उपयोग कर सकते हैं कि आपके कोड में प्रमुख वर्ण नहीं हैं:

var primes=[],max=10000;for(var i=2;i<=max;i++){primes.push(i);}for(var N=2;N<Math.sqrt(max);N++){if(primes.indexOf(N)===-1){continue;}primes=primes.filter(function (x){return x===N||x%N!==0;});}function setText(elem,text){var z=('innerText' in elem)? 'innerText' : 'textContent';elem[z]=text;}function verify(inputCode,resultSpan){var invalidChars=[];var success=true;for(var i=0;i<inputCode.length;i++){var cc = inputCode.charCodeAt(i);if (cc>max){setText(resultSpan,"Uh oh! The char code was bigger than the max. prime number calculated by the snippet.");success = false;break;}if (primes.indexOf(cc)!==-1){invalidChars.push(inputCode[i]);}}if (invalidChars.length===0&&success){setText(resultSpan, "Valid code!");}else if(success) {  var uniqueInvalidChars = invalidChars.filter(function (x, i, self){return self.indexOf(x)===i;});setText(resultSpan, "Invalid code! Invalid chars: " + uniqueInvalidChars.join(""));    }}document.getElementById("verifyBtn").onclick=function(e){e=e||window.event;e.preventDefault();var code=document.getElementById("codeTxt").value;verify(code,document.getElementById("result"));};
Enter your code snippet here:<br /><textarea id="codeTxt" rows="5" cols="70"></textarea><br /><button id="verifyBtn">Verify</button><br /><span id="result"></span>


10
यह बहुत क्रूर है जो ;प्रतिबंधित हो जाता है ...
ʇǝɥʇıʎu Febs

यदि प्रायोगिक परीक्षकों की अनुमति नहीं है, तो मुख्य कारक कार्यों के बारे में क्या।
माल्टेनसेन

@ मेन्टीसेन प्राइम फैक्टराइजेशन फ़ंक्शंस से, आप बहुत तेज़ी से देख सकते हैं कि कोई नंबर प्राइम है या नहीं, इसलिए मुझे लगता है कि यह अस्वीकृत है। मैं स्पष्ट कर दूंगा।
प्रोग्राम फॉक्स

क्या हमें इन अवैध इनपुटों में से कुछ को बाहर निकालने के लिए अनिवार्य है? उदाहरण के लिए, यदि हमारी भाषा का स्ट्रिंग-> int फ़ंक्शन एक अग्रणी की अनुमति देता है +, तो इसे मैन्युअल रूप से बाहर फेंकने के लिए आवश्यक होना निराशाजनक लगता है।
रनर १२

11
मैं इस बारे में सभी उत्साहित हो गया और एक समाधान पर शुरू हुआ, फिर एहसास हुआ कि बंद परियों को बंद कर दिया गया है। खैर, मैं बाहर हूं।
एलेक्स ए।

जवाबों:


10

CJam, 19 18 30 34 33 19 17 21 20 बाइट्स

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

{_3\#,2>__ff*:~-<N*}

यह शायद मेरे द्वारा लागू किए गए सबसे भयानक अयोग्य एल्गोरिदम में से एक है। लेकिन मैंने इसे आकार के लिए किया!

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

मेरा एल्गोरिथ्म 3 inputवें शक्ति को बढ़ाकर शुरू होता है , जो inputकि इनपुट वैध है, तो -th प्राइम से बड़ा नंबर देने की गारंटी है। फिर 2 से इस संख्या के पूर्णांक की एक सूची उत्पन्न होती है, जो कि उन सभी अभाज्य संख्याओं को शामिल करने के लिए पर्याप्त बड़ी स्वाथ है। मिश्रित संख्या से छुटकारा पाने के लिए ... आह ... हम प्रत्येक जोड़ीदार उत्पाद की एक सूची बनाते हैं, जो कि सभी समग्र संख्याओं को 4 से कुछ मूर्खतापूर्ण बड़े मूल्य, हमारे उद्देश्यों के लिए पर्याप्त रूप से उत्पन्न करना चाहिए। फिर यह मूल सूची से प्रत्येक तत्व को हटाने की बात है जो इस समग्र सूची में है, इसे पहले inputतत्वों तक नीचे ट्रिम कर रहा है , और तत्वों को न्यूलाइन वर्ण के साथ जोड़ रहा है।

एल्गोरिदम को किसी भी इनपुट के लिए काम करना चाहिए । हालाँकि, दुभाषिया / कंप्यूटर में पर्याप्त मेमोरी है या नहीं, यह एक अन्य प्रश्न है, क्योंकि इनपुट के संबंध में समय और स्थान की आवश्यकताएं बहुत अधिक हैं। इसलिए यदि ऑनलाइन इंटरप्रेटर के लिए इनपुट 5 से बड़ा है या ऑफलाइन के लिए लगभग 8 है, तो उस प्रश्न का उत्तर शायद नहीं है।


3
हे, 17 साल की उम्र में आपके उत्तर में बाइट्स की एक प्रमुख संख्या है।
कोरी ओगबर्न

आपको एक की आवश्यकता क्यों है S*?
jimmy23013

@ user23013 एल्गोरिदम के माध्यम से 1 से कम अमान्य इनपुट्स अभी भी खाली सूची का उत्पादन करते हैं। लेकिन यह उनके लिए एक कानूनी आउटपुट नहीं है, इसलिए मैं इन अवैध इनपुटों के लिए खाली आउटपुट का उत्पादन करने के लिए रिक्त स्थान के साथ सूची तत्वों में शामिल होता हूं।
रनर १२

1
मैंने इस पर ध्यान दिया है, Sएक प्रमुख चरित्र नहीं है?
ज़ाचारि

यह एक प्रमुख चरित्र है। मुझे पता है कि मुझे यह कहने में 2 साल से अधिक की देर हो चुकी है, लेकिन यह जवाब अमान्य
Zacharý

8

जावा। 474 बाइट्स

i\u006dport j\u0061v\u0061.util.*\u003bvoid b(int b\u0029{Lon\u0067 c\u003d2L,d,f[]\u003d{}\u003bfor(f\u003dArr\u0061ys.copy\u004ff(f,b\u0029,Arr\u0061ys.fill(f,0L\u0029\u003bb-->0\u003b\u0029for(d\u003d0L\u003bf[b]<1\u003bf[b]\u003dd<1?c:f[b],d\u003d0L,c\u002b\u002b\u0029for(lon\u0067 h:f\u0029d\u003dh>0&&c\u002fh*h\u003d\u003dc?1:d\u003bj\u0061v\u0061x.x\u006dl.bind.JAXB.un\u006d\u0061rsh\u0061l(""\u002bArr\u0061ys.\u0061sList(f\u0029,Lon\u0067.cl\u0061ss\u0029\u003b}

फ़ंक्शन तर्क के माध्यम से इनपुट लेता है, फेंके गए अपवाद के माध्यम से आउटपुट।

इंडेंट:

i\u006dport j\u0061v\u0061.util.*\u003b
void b(int b\u0029{
    Lon\u0067 c\u003d2L,d,f[]\u003d{}\u003b
    for(f\u003dArr\u0061ys.copy\u004ff(f,b\u0029,Arr\u0061ys.fill(f,0L\u0029\u003bb-->0\u003b\u0029
        for(d\u003d0L\u003bf[b]<1\u003bf[b]\u003dd<1?c:f[b],d\u003d0L,c\u002b\u002b\u0029
            for(lon\u0067 h:f\u0029
                d\u003dh>0&&c\u002fh*h\u003d\u003dc?1:d\u003b
    j\u0061v\u0061x.x\u006dl.bind.JAXB.un\u006d\u0061rsh\u0061l(""\u002bArr\u0061ys.\u0061sList(f\u0029,Lon\u0067.cl\u0061ss\u0029\u003b
}

हटाए गए पात्र:

import java.util.*;
void b(int b){
    Long c=2L,d,f[]={};
    for(f=Arrays.copyOf(f,b),Arrays.fill(f,0L);b-->0;)
        for(d=0L;f[b]<1;f[b]=d<1?c:0,d=0L,c++)
            for(long h:f)
                d=h>0&&c/h*h==c?1:d;
    javax.xml.bind.JAXB.unmarshal(""+Arrays.asList(f),Long.class);
}

स्पष्टीकरण:

Long c,d,f[]={};                                                //Initialize variables.

for(f=java.util.Arrays.copyOf(f,b),Arrays.fill(f,0L);b-->0;)
    f=java.util.Arrays.copyOf(f,b),Arrays.fill(f,0L)            //Initialize f to an array of 0's.
                                                     b-->0      //Iterate over the first b primes.

for(d=0L;f[b]<1;f[b]=d<1?c:0,d=0L,c++)
    d=0L                        d=0L                            //Initialize d to 0.
         f[b]<1                      c++                        //Increment c while the b'th prime is 0.
                f[b]=d<1?c:0                                    //If d = 0, the b'th prime = c, else continue.

for(long h:f)                                                   //Iterate over all found primes.

d=h>0&&c/h*h==c?1:d;
  h>0                                                           //Ignore non-found primes.
       c/h*h==c                                                 //Equivalent to c%h==0
               ?1:d                                             //If h is prime and c is divisible by h, d = 1. Otherwise d stays unchanged.

javax.xml.bind.JAXB.unmarshal(""+Arrays.asList(f),Long.class)   //Print solution to stderr
javax.xml.bind.JAXB.unmarshal(                   ,Long.class)   //Prints what's contained to stderr.
                                 Arrays.asList(f)               //Convert f to list.
                              ""+                               //Convert to string.

मेरे मूल समाधान ने एक returnबयान का उपयोग किया । StackOverflow पर यह प्रश्न पूछने के बाद , पुन: पत्र प्राइम लेटर्स का उपयोग किए बिना आउटपुट / रिटर्न का एक तरीका प्रदान करने के लिए पर्याप्त था।

हमेशा की तरह, सुझावों का स्वागत है :)


3
+1। यह वास्तव में आप और rgettman को पता लगाने के लिए कठिन होना था। बहुत प्रभावशाली। :)
टीएनटी

5

रूबी, 74

->n,*o{o<<[2..n*n][0].find{|x|!o.find{|y|1.>x.^y.*x.div y}}until o[n-1]
o}

स्पष्टीकरण:

*oएक खाली आउटपुट सरणी को इनिशियलाइज़ करता है। जब तक यह nआइटम नहीं है, तब तक हम सबसे छोटी संख्या> = 2 पाते हैं, जो वर्तमान में किसी भी आइटम को विभाजित नहीं करता है o, फिर इसे जोड़ें o। विभाजन के लिए परीक्षण करने के लिए, yikes। सभी अच्छे ऑपरेटरों को रोक दिया गया है, और मैं भी उपयोग नहीं कर सकता divmod। सबसे अच्छा मैं देख सकता था का उपयोग करना है x.div y, जो x को y से विभाजित करता है और नीचे राउंड करता है, फिर उस y से फिर से गुणा करता है। यदि यह x के बराबर है, तो कोई गोलाई नहीं थी, इसलिए y x को विभाजित करता है। 1.>x.^एक समानता परीक्षण है, यह जाँचना कि क्या Xor का परिणाम 0. है। .प्रत्येक ऑपरेटर से पहले है क्योंकि आप .-free ऑपरेटर कॉल और कोष्ठक-मुक्त विधि कॉल को मिक्स नहीं कर सकते ।

संपादित करें: मेरे द्वारा यह पोस्ट किए जाने के बाद रेंज-चेकिंग विनिर्देश जोड़े गए, मुझे लगता है। पालन ​​करने के लिए 79 वर्णों की आवश्यकता होती है:

->n,*o{o<<[*2..-~n*n].find{|x|!o.find{|y|1.>x.^y.*x.div y}}until o[n-1]||n<1
o}

4

CJam, 38 37 30 बाइट्स

{_~2#,2>\{(\{1$37c~},\p}*'<(~}

इसे यहाँ आज़माएँ

मुझे लगता है कि यह किसी भी गैर-नकारात्मक एन (यानी टी अनंत है) के लिए सभी नियमों और कार्यों का पालन करना चाहिए । हालांकि यह बहुत ही अक्षम है, इसलिए इसे बड़ी संख्या के लिए प्रयास न करें।

यह एक ब्लॉक है - (अनाम) फ़ंक्शन के लिए निकटतम चीज़ - जो स्टैक पर पूर्णांक की अपेक्षा करता है, सभी प्राइम संख्याओं को प्रिंट करता है और इसके इनपुट के बिना स्टैक को छोड़ देता है। सभी अमान्य इनपुट के लिए यह या तो एक त्रुटि फेंक देगा या कुछ भी नहीं प्रिंट करेगा।

अधिकांश कोड इनपुट सत्यापन है, इसके बाद एराटोस्थनीज की छलनी है। मुझे केवल 3 स्थानों पर इनपुट प्रतिबंध के आसपास काम करने की आवश्यकता थी:

  • )CJam में वेतन वृद्धि है। मुझे एक बार इसकी आवश्यकता थी, लेकिन इसे ~(बिटवाइज़ पूरक) के साथ बदल सकता था क्योंकि मैं वैसे भी संख्याओं को चुकता कर रहा था।
  • %मोडुलो है। मैं 37c~इसके बजाय का उपयोग कर रहा हूँ , जो पहले चरित्र बनाता है %और फिर eval है। इससे कोड बहुत धीमा हो जाता है।
  • ;स्टैक से एक तत्व को पॉप और डिस्क्राइब करता है। मुझे अंत में ऐसा करने की जरूरत है। इसके बजाय मैं उपयोग कर रहा हूं '<(~जो चरित्र <को आगे बढ़ाता है, इसे घटाता है और इसे बढ़ाता है।

मुझे लगा कि, सभी इनपुट पार्सिंग नियमों को देखते हुए, हमें पहले से ही पार्स किए गए पूर्णांक में लेने की अनुमति नहीं है।
रनवीर १२

@ Runer112 हमें "एक फ़ंक्शन जो एक पूर्णांक स्वीकार करता है" लिखने की अनुमति है। "एक फ़ंक्शन जो पूर्णांक के स्ट्रिंग प्रतिनिधित्व को स्वीकार नहीं करता है"।
मार्टिन एंडर

3

बैश + कोरुटिल्स, 227 बाइट्स

printf -vb br`dc<<<Di14B8209P`
printf -vc -- $[$1-0]
[ "${1#$c}" -o $c -lt 1 ]||{
for i in {2..104729}
{
for f in `jot $[i-1] $[i-1] 1`
{
[ 0 -lt `dc<<<"$i $f~p"` ]||$b
}
[ $f -lt 2 ]&&printf $i\ &&: $[c--]
[ $c -lt 1 ]&&$b
}
}

यह काफी मुश्किल था। कुछ चीजें जो मैं भाग गया:

  • अधिकांश लूप ( whileऔर until) अनुपयोगी होते हैं क्योंकि वे सबसे पास होते हैं doneजो एक शेल कीवर्ड है और एक चर विस्तार का परिणाम नहीं हो सकता है (जब तक कि evalइसका उपयोग नहीं किया जाता है, लेकिन यह भी बाहर है)। केवल प्रयोग करने योग्य पाश है for/ inजो की अनुमति देता है {/ }के बजाय do/ donefor (( ; ; ))यह भी उपयोग करने योग्य नहीं है।
  • = बाहर है, इसलिए हमें चर असाइन करने का एक और तरीका चाहिए। printf -vइसके लिए अच्छा है।
  • हम जानते हैं कि p (10000) 104729 है, इसलिए बाहरी लूप के लिए संभावित प्राइम के लिए हम बस 2 से 104729 तक लूप कर सकते हैं और एक बार हम पर्याप्त प्राइम तोड़ सकते हैं
  • jotआंतरिक लूप में संभावित कारकों की सूची तैयार करता है। यदि एक संभावित कारक एक संभावित प्राइम को विभाजित करता है, तो यह प्राइम नहीं है और हम जल्दी बाहर निकल जाते हैं
  • सौभाग्य breakसे एक शेल बिलिन है और एक कीवर्ड नहीं है, इसलिए विस्तार के परिणामस्वरूप उत्पन्न हो सकता है। dcआधार संख्या को बाइटस्ट्रीम में परिवर्तित करता है eak
  • यह जांचने के लिए कि क्या कोई संभावित कारक संभावित प्राइम को विभाजित करता है, हम सामान्य /या %शेल अंकगणितीय ऑपरेटरों का उपयोग नहीं कर सकते हैं । तो यह dcs ~ऑपरेटर के लिए आउटसोर्स किया जाता है , जो भागफल को बढ़ाता है और स्टैक पर शेष रहता है।
  • -lt - से कम - केवल प्रयोग करने योग्य शेल तुलना ऑपरेटर है।
  • echoआउटपुट के लिए कोई उपयोग नहीं है। printfजब तक हम बचते हैं तब तक काम करता है%

इनपुट सत्यापन अधिकार प्राप्त करना थोड़ा दर्द है। यह अमान्य इनपुट के मामले में कुछ भी नहीं देता है।

आउटपुट:

$ ./primenoprime.sh 10
2 3 5 7 11 13 17 19 23 29 $ 

3

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

\n->[fst c|c<-zip[p|p<-[2..],not$or[b>p-1&&b-1<p|b<-[u*v|u<-[2..p-1],v<-[2..p-1]]]][1..n]]

यह एक अनाम फ़ंक्शन है जो nइनपुट के रूप में पूर्णांक लेता है ।

यह कैसे काम करता है: [p|p<-[2..],not$or[b>p-1&&b-1<p|b<-[u*v|u<-[2..p-1],v<-[2..p-1]]]]( हास्केल विकी पर प्राइम नंबर वन-लाइनर्स का पहला उदाहरण, लेकिन elemफ़ंक्शन को प्रतिस्थापित किया गया) के साथ एक अनंत सूची है।zipजोड़े की सूची बनाने के 1लिए संख्याओं के साथ । Seq निकालें। नंबर, फिर से। परिणाम लंबाई के primes की एक सूची है । n(prime, seq. number)n


1

जंग, 64897 बाइट्स

|n|println!{"{:?}",&[2,3,6-1,7,11,13,17,19,23,29,31,37,41,43,47,60-7,0x3b,61,67,71,73,79,83,89,97,101,103,107,109,113,127,131,137,139,149,0x97,0x9d,163,167,173,179,181,191,193,197,199,211,223,227,229,233,239,241,0xfb,0x101 ...}

(वर्ण सीमा के कारण कोड छीन लिया गया, पूर्ण समाधान के कारण यहाँ )

मुख्य प्रतिबंध के कारण निम्नलिखित जंग सुविधाएँ अनुपलब्ध हो जाती हैं:

  • फ़ंक्शन कॉल, क्योंकि उन्हें ') की आवश्यकता होती है
  • नियमित रूप से बाइंडिंग, क्योंकि उन्हें आवश्यकता होती है (ई)
  • मैक्रो परिभाषाएँ, उन्हें मैक्रो-नियमों की आवश्यकता होती है! (ए, ई, एम)
  • मैच विवरण, उन्हें मैच की आवश्यकता होती है (ए, एम) और => (=)
  • उत्परिवर्तन, क्योंकि यह हमेशा म्यूट कीवर्ड (एम) के साथ पेश किया जाता है।
  • वापसी (ई), ब्रेक (ए, ई), जारी (ई)
  • और (ई)

आप तकनीकी रूप से क्या उपयोग कर सकते हैं:

  • अगर। लेकिन इसके बिना, वे अभिव्यक्ति के संदर्भ में बेकार हैं, इसलिए केवल साइड इफेक्ट्स के लिए अच्छा है।
  • मैक्रो। प्रिंट की तरह मानक मैक्रोज़! आमतौर पर इसके बाद (), लेकिन इसके बजाय {} या [] का उपयोग करना वास्तव में कानूनी है। इसके बिना, कार्य असंभव होगा।
  • बंद, सबसे संकीर्ण अर्थों में। आप उन्हें (आवश्यकता) नहीं कह सकते हैं या उन्हें बाँध सकते हैं (अनुमति देने की आवश्यकता है), लेकिन आप एकल गैर-पुनरावर्ती को परिभाषित कर सकते हैं। इसके बिना, कार्य स्पष्ट रूप से असंभव हो जाएगा।
  • structs।
  • छोरों के लिए। ये आशाजनक हैं, क्योंकि वे वास्तव में चर बंधन की अनुमति देते हैं, और वे एक पुनरावृत्ति लेते हैं, जिसे अभी भी सीमा सिंटैक्स के साथ परिभाषित किया जा सकता है। इटरेटर भी एक अभिव्यक्ति हो सकती है।
  • बिल्ट ऑपरेटर, +,% और / को छोड़कर। शॉर्ट-सर्कुलेटिंग लॉजिकल ऑपरेटर्स आशाजनक लगते हैं।

मैं बस इन उपकरणों के साथ कुछ भी ट्यूरिंग-पूरा नहीं कर सका। मुझे माफ कर दो। सभी को छोड़ दिया गया था, जिसमें पहले 10000 10000, 5 की सफाई शामिल थी। कम से कम आप इसे स्लाइस कर सकते हैं और एक वैध समाधान हो सकता है, सबसे संकीर्ण अर्थों में संभव है।

मैं ट्यूरिंग टारपीट डाइविंग (या रस्ट पर!) के विशेषज्ञों को बहुत पसंद करूंगा, अगर मैं कुछ बेहतर कर सकता था तो मुझे बताएं!


1

जीएनयू एपीएल, 75 68 67 65 59 56 55 वर्ण

⎕IOहोना ही चाहिए 1

∇z←p n
z←2,j←3
j←j--2
→2×⍳∨⌿1>z|j
z←z,j
→2×⍳n>⍴z
z←n↑z∇

मैं इस महीने बाद वापस आया और मुझे एहसास हुआ कि मेरे पास एक अतिरिक्त जगह है!


क्या यह एपीएल एन्कोडिंग या यूटीएफ -8 में है? यदि आप इसे एपीएल एन्कोडिंग में परिवर्तित करते हैं (और यह वैध है) तो यह बाइट्स में बहुत छोटा होगा।
NoOneIsHere

UTF-8। हाँ, लेकिन उन कम चरित्र बिंदुओं पर, वहाँ और अधिक होने जा रहे हैं।
23

सटीक होने के लिए, इसे अब एपीएल में गिना जाता है, लेकिन स्रोत पर प्रतिबंध यूनिकोड है। (मुझे एहसास हुआ कि गैर-यूनिकोड बाइट काउंट की अनुमति दी गई है)
ज़ाचारि

0

Pyth - 12 बाइट्स

अगर # प्राइम है तो यह देखने के लिए pyth के प्राइम फैक्टराइज़ेशन फंक्शन का उपयोग करता है। उपयोग!tPT है जो मेरे जवाब में मुझे मिलियन समस्याओं के तहत primes के लिए सुझाया गया है।

<f!tPTr2^T6Q

चूंकि फ़िल्टर केवल n और पहले n के तहत प्राइम के लिए काम करता है, इसलिए मैंने सिर्फ 10,000 के लिए pi (x) के व्युत्क्रम को देखा और 104,000 मिला, इसलिए मैं 10⁶ के तहत primes का उपयोग करता हूं और पहले n प्राप्त करता हूं। यह वास्तव में नहीं चलता है, इसलिए आपको 1000 के नीचे n के ^T6साथ बदलने ^T3और प्रतिबंधित करने का परीक्षण करना चाहिए । स्टड और आउटपुट से स्टडआउट तक इनपुट।

<          Q     Slice first n
f     r2^T6      filter on range 2->10⁶
 !               Logical not (gives true if tail is empty)
  t              Tail (all but first, so gives empty if prime fact is len 1)
   PT            Prime factorization of filter var (len 1 if num is prime)

5
नियमों से: "बिल्ट-इन प्राइम जनरेटर और प्राइमलिटी टेस्टर का उपयोग करने की अनुमति नहीं है।"
रनर ११

@ Runer112 हाँ, लेकिन यह एक मौलिक परीक्षक नहीं है, प्रधान कारक है, नियमों की सीमा पर है। मुझे शायद पूछना चाहिए कि क्या इसकी अनुमति है।
माल्टेनसेन

@Maltysen "बिल्ट-इन प्राइम जनरेटर और प्राइमलिटी टेस्टर्स का उपयोग (इसमें प्राइम फैक्टराइजेशन फ़ंक्शंस शामिल हैं) की अनुमति नहीं है" - मुझे बहुत स्पष्ट लगता है।
डिजिटल ट्रामा

4
इस उत्तर के पोस्ट किए जाने के बाद @DigitalTrauma ने स्पष्टीकरण "(इसमें प्राइम फैक्टराइज़ेशन फ़ंक्शंस शामिल हैं") जोड़ा गया था।
मार्टिन एंडर

मार्टिनबटनर ट्रू। मुझे लगता है कि यह @ ProgramFOX'es विवेक तक है।
डिजिटल ट्रामा
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.