होल 2 - प्राइम क्विन

Question

यहां होल 1 खोजें ।

जब कोई रन बनाता है, तो अपने स्वयं के स्रोत कोड को कई बार ब्लॉक करता है। वास्तव में, इसे इसे n बार आउटपुट करना होगा, जहां n अगले प्राइम नंबर में।

मुझे लगता है कि एक उदाहरण यह सबसे अच्छा दिखाता है।

[MY QUINE][MY QUINE]
[MY QUINE][MY QUINE][MY QUINE]
[MY QUINE][MY QUINE][MY QUINE][MY QUINE][MY QUINE]
[MY QUINE][MY QUINE][MY QUINE][MY QUINE][MY QUINE][MY QUINE][MY QUINE]
[MY QUINE][MY QUINE][MY QUINE][MY QUINE][MY QUINE][MY QUINE][MY QUINE][MY QUINE][MY QUINE][MY QUINE][MY QUINE]

प्रत्येक कार्यक्रम अगले प्रमुख संख्या बार अपना आधार "ब्लॉक" (इसलिए [मेरा प्रश्न]) आउटपुट करेगा ।

यह निर्धारित करने के लिए कार्य किए गए हैं कि क्या संख्या प्रधान है, (isPrime फ़ंक्शन की तरह), या अगले प्रधानमंत्री का निर्धारण करने के लिए (जैसे nextPrime () फ़ंक्शन) की अनुमति नहीं है।

• इसका मतलब यह है कि विभाजकों की संख्या को सूचीबद्ध करने के लिए कार्यों की अनुमति नहीं है
• मुख्य कारक को लौटाने वाले कार्य वैसे ही अस्वीकृत हैं

यह एक सच्ची रानी होनी चाहिए (कुछ लीव को छोड़कर, अगला बिंदु देखें), इसलिए आपको अपना स्वयं का स्रोत कोड नहीं पढ़ना चाहिए।

क्योंकि जावा और C # जैसी भाषाएँ पहले से ही एक नुकसान में हैं, आपको पूरी तरह से काम करने वाले कोड की आवश्यकता नहीं है। अगर इसे एक फंक्शन में रखा जा सकता है (जिसे कहा जाता है) और अगली क्वीन को आउटपुट करता है, तो आप अच्छे हैं।

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

Comments

किसी ने भी 1 छेद का जवाब नहीं दिया है, इसलिए हर एक को जवाब देने वाले स्कोर को पहले छेद के लिए क्या मिलता है?

— ऑप्टिमाइज़र

आप प्रमुख कार्यों के साथ हिस्सा स्पष्ट कर सकते हैं? क्या हम उनका उपयोग कर सकते हैं या हम उनका उपयोग नहीं कर सकते?

— मार्टिन एंडर

प्राइम चेकिंग क्या मानी जाती है और क्या नहीं? यह देखते हुए कि यदि किसी प्रकार का उपयोग करके प्राइम चेकिंग का निर्माण किया जा सकता है, तो इस तरह के नियम पर्याप्त रूप से स्पष्ट नहीं हैं

— गर्वित हैकेलर

@ ऑप्टिमाइज़र: किसी को जवाब देने तक सभी को पहले छेद के लिए 0 का स्कोर होता है।

— स्ट्रेच

@StretchManiac आपको इस प्रश्न में स्पष्ट रूप से उल्लेख करना चाहिए कि दोनों प्रमुख कारक विधियों की सूची और भाजक विधियों की सूची की भी अनुमति नहीं है। कृपया अगली बार सैंडबॉक्स में प्रश्न पोस्ट करें।

— ऑप्टिमाइज़र

Answer 1

CJam, 31 बाइट्स

{'_'~]-3>U):U{)__,1>:*)\%}g*}_~

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

विचार

मौलिकता की जांच करने के लिए, हम विल्सन की प्रमेय का उपयोग करेंगे , जिसमें कहा गया है कि एक पूर्णांक n> 1 अभाज्य है यदि और केवल यदि (n - 1)! ≡ -1 (mod n) , जो सच है अगर और केवल if (n - 1)! + 1% एन == 0 ।

कोड

{                           }_~ e# Define a block and execute a copy.
                                e# The original block will be on top of the stack.
 '_'~]                          e# Push those characters and wrap the stack in an array.
      -3>                       e# Keep only the last three elements (QUINE).
         U):U                   e# Increment U (initially 0).
             {           }g     e# Do-while loop:
              )__               e# Increment the integer I on the stack (initially U).
                 ,1>            e#   Push [1 ... I-1].
                    :*          e#   Multiply all to push factorial(I-1).
                      )\%       e#   Push factorial(I-1) + 1 % I.
                                e# While the result is non-zero, repeat.
                                e# This pushes the next prime after U.
                           *    e# Repeat QUINE that many times.

Comments

आपको प्राइम ओओ

— ऑप्टिमाइज़र

याद रखना अधिक सटीक होगा। इसे विल्सन के प्रमेय के रूप में जाना जाता है।

— डेनिस

mp(प्राइम?) अब मौजूद है, इसलिए सीजेएम के नवीनतम संस्करण में, कोई इसे थोड़ा और नीचे कर सकता है।

— लिन

@Mauris यह पहले सार्वजनिक संस्करण IIRC में मौजूद था। हालांकि, सवाल प्राइम और फैक्टराइजेशन ऑपरेटरों में बनाया गया है।

— डेनिस

Answer 2

CJam, 36 35 बाइट्स

{]W="_~"]U):U{)_,{)1$\%!},,2>}g*}_~

यह निश्चित रूप से आगे गोल्फ हो सकता है।

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

{                               }_~   "Copy this code block and execute the copy";
 ]W=                                  "Take just the last element from the stack";
                                      "The other thing on stack is the block from above";
    "_~"]                             "Put "_~" on stack and wrap the 2 things in an array";
                                      "At this point, the string representation of stack"
                                      "elements is identical to the source code";
         U):U                         "Increment U and update U's value. This  variable"
                                      "actually counts the number of [Quine] blocks";
             {)_,{)1$\%!},,2>}g       "Find the next prime number"
                               *      "Repeat the array that many times, thus repeat the"
                                      "[Quine] block, the next prime times";

मार्टिन को धन्यवाद मुझे ]W=ट्रिक याद दिलाने के लिए :)

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

Answer 3

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

संपादित करें: एक प्राइम-संबंधित फ़ंक्शन के उपयोग को ठीक किया, लेकिन क्विनिंग को थोड़ा सुधार दिया।

संपादित करें: मुझे विल्सन के प्रमेय से परिचित कराने के लिए डेनिस का धन्यवाद।

1;n=If[ValueQ@n,n+1,1];StringJoin@Array[#<>ToString[1##,InputForm]<>#2&@@\("1;n=If[ValueQ@n,n+1,1];StringJoin@Array[#<>ToString[1##,InputForm]<>#\2&@@("*"&,For[i=n,Mod[++i!/i+1,i]>0,0];i]")&,For[i=n,Mod[++i!/i+1,i]>0,0];i]

यह मानता है कि क्वीन के बाद के रनों के बीच कर्नेल को छोड़ दिया जाता है (या कम से कम nरीसेट किया जाता है), क्योंकि यह चलने nके पहले उदाहरण से अपरिभाषित होने पर निर्भर करता [MyQuine]है।

यह शायद बहुत कम हो सकता है, लेकिन मुझे विशेष रूप से मैथेमेटिका में, quines के साथ बहुत अनुभव नहीं है।

यहाँ एक स्पष्टीकरण है:

1;

यह कुछ भी नहीं करता है, लेकिन अगर पिछली क्वीन के अंत में सहमति व्यक्त की जाती है, तो यह अंतिम अभिव्यक्ति के परिणाम को गुणा करता है 1(जो कि नो-ऑप है) और अर्धविराम आउटपुट को दबा देता है। यह सुनिश्चित करता है कि [MyQuine]किसी भी चीज की केवल अंतिम प्रति ।

n=If[ValueQ@n,n+1,1];

की पहली प्रति में यह इनिशियलाइज़ nकरता 1है [MyQuine]और फिर 1प्रत्येक आगे की कॉपी में इसे बढ़ाता है - यानी यह केवल यह बताता है कि इसमें कितनी प्रतियाँ हैं n।

अब आगे के लिए छोड़ें:

For[i=n,Mod[++i!/i+1,i]>0,0];i

यह विल्सन के प्रमेय का उपयोग करते हुए अगले प्रमुख को पाता है ।

StringJoin@Array[#<>ToString[1##,InputForm]<>#2&@@\("QUINE_PREFIX"*"QUINE_SUFFIX")&,NEXTPRIME[n]]

यह वास्तविक रानी है। यह NextPrime@nकोड की प्रतियां खुद बनाता है। यह भी थोड़ा अजीब है। हां, मैं दो स्ट्रिंग्स को बढ़ा रहा हूं, और कोई भी ऐसा नहीं है जिसका सार्थक परिणाम न हो। QUINE_PREFIXदो तार से पहले सभी कोड QUINE_SUFFIXशामिल हैं और दो तार के बाद सभी कोड शामिल हैं। अब आमतौर पर आप किसी सूची को तर्कों की सूची में बदलने के लिए Apply(या @@) का उपयोग करते हैं। लेकिन आप किसी भी जगह ले सकता है Headके साथ Applyजैसे गुणा -। इसलिए यह एक उत्पाद होने के बावजूद मैं इसे अभी भी अपने कार्य में दो तर्कों में बदल सकता हूं। वह कार्य करता है:

#<>ToString[1##,InputForm]<>#2

जहाँ #पहला तर्क (उपसर्ग स्ट्रिंग) #2है, दूसरा तर्क (प्रत्यय स्ट्रिंग) है, ##दोनों तर्कों का एक क्रम है। मुझे 1गुणन को संरक्षित करने के लिए पहले से तैयारी करने की आवश्यकता है - अन्यथा ##तर्क सूची में अलग हो जाएगा ToString। वैसे भी, ToString[1##,InputForm]&@@("abc"*"def")रिटर्न "abc"*"def"... बस मुझे क्या चाहिए!

मुझे लगता है कि मुझे क्वीन के आसपास की जरूरत के सभी सामानों के साथ-ए- evalआधारित क्वीन यहां अधिक उपयुक्त होगा। मैं बाद में या कल में देखूंगा।

Comments

@ मार्टिनबटनर को प्रश्न संपादित करना चाहिए

— गर्वित हेकेलर

हेह, मैं डेनिस के साथ मेरी प्रविष्टि लाने के लिए विल्सन के प्रमेय का उपयोग भी कर सकता हूं;)

— ऑप्टिमाइज़र

@ ऑप्टिमाइज़र लेकिन मेरे मामले में किसी को नाराज करने का कोई खतरा नहीं था क्योंकि मैं अब भी आप दोनों के रूप में 7 बाइट्स का इस्तेमाल कर रहा हूँ;)

— मार्टिन एंडर

@ मार्टिनबटनर मुझे पता है: यही कारण है कि मैंने इसका इस्तेमाल नहीं किया :)

— ऑप्टिमाइज़र

Answer 4

जे - 60 चार

अन्य उत्तरों की तरह अगली-प्राइम विधि का उपयोग करता है। (वह 4 p:बिट है।)

((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''

एक प्यारा थोड़ा जम्मू चाल है कि है f :gकी तरह काम करता fहै जब एक तर्क दिया जाता है और gजब दो दिए गए। इसलिए, यदि आप लिखते हैं, f :;'a'f :;'a'f :;'a'तो कहें कि वह कार्य करता है f'a';'a';'a', जो बहुत अच्छा है क्योंकि यह एक बॉक्सिंग सूची है, जिसके आइटम हैं 'a'और जिसकी लंबाई घटनाओं की संख्या है।

तो हम इसे एक तरह की चीज़ में बदल सकते हैं। fहम जिस तरह का उपयोग करते हैं (foo $~ bar), वह ऐसा प्रतीत होता है , जहां fooहम उस स्ट्रिंग भाग का निर्माण करते हैं जिसे हम बार-बार दोहराते हैं, barअगली प्राइम संख्या पाता है और इसे 60 से गुणा करता है, स्ट्रिंग की लंबाई foo।

   ((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''
((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''
   # ((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''
180
   ((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''
((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''
   # ((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''((58&$,2#{:)@;$~60*4 p:#) :;'((58&$,2#{:)@;$~60*4 p:#) :;'''
300

Comments

क्या आप नए स्पेक्स को पूरा करने के लिए अपना कोड संशोधित कर सकते हैं? अगले प्राइम को आउटपुट करने वाले तरीकों की अनुमति नहीं है। धन्यवाद।

— स्ट्रेच

Answer 5

पायथन 2.7, 214

from sys import*;R,s=range,chr(35)
def N(n):
 if n<3:return n+1
 for p in R(n+1,n+n):
    for i in R(2, p):
     if p%i==0:break
     else:return p
P=file(argv[0]).read();print(P.split(s)[0]+s)*N(P.count(chr(37)));exit(0)
#