नकारात्मक आदेश पूर्णांक चुनौती है, लेकिन यह प्राइम टाइम है!

Question

Im इस सवाल के बारे में बात कर रहा है , अगर आप थोड़ा भ्रमित हैं, तो इसे देख लें।

मुख्य कार्य

आपका काम घटते क्रम में, पूर्णांक को आउटपुट करना है, लेकिन आपके द्वारा हिट किए जाने वाले अधिकतम पूर्णांक को बढ़ाना 1 (इस प्रश्न के लिए, 1 को एक प्रमुख संख्या माना जाएगा) । हालांकि यह पहले प्रश्न से अलग नहीं है, यहाँ मुश्किल हिस्सा आता है: सभी आउटपुट किए गए नंबर केवल primes हो सकते हैं । ये बिना किसी रिक्त स्थान या न्यूलाइन्स के एक ही तार में एक साथ फंसे रहेंगे। आपका इनपुट भी एक प्राइम नंबर होगा ।

उदाहरण:

1
21
321
5321
75321
1175321
Valid output:
1213215321753211175321

इनपुट

आपका कोड केवल एक इनपुट ले सकता है: मुद्रित किया जाने वाला उच्चतम प्राइम। यह इनपुट कहीं से भी आ सकता है (ग्राफिकल, एसटीडीआईएन)। आपको आश्वासन दिया जाता है कि इनपुट एक अभाज्य संख्या है।

उत्पादन

आपको परिणामी संख्या को आउटपुट करना होगा। आप इस संख्या को नीचे रख कर प्राप्त कर सकते हैं, केवल संख्या की गणना करें यदि यह एक प्रमुख है, तो सभी परिणामों को एक साथ एक संख्या से कनेक्ट करें। अंतिम संख्या "पंक्ति" (जैसे 7, 5, 3, 2, 1) को पूरी तरह से प्रिंट करना होगा। जब तक यह पठनीय हो, आउटपुट कुछ भी (संख्या, तार, चित्रमय) हो सकता है। आपके परीक्षण मामलों की जाँच के लिए एक ही रेगेक्स पैटर्न लागू होता है:

^(\D*(\d)+\D*|)$

यदि आपका आउटपुट इस पैटर्न से मेल नहीं खाता है, तो आपका कोड अमान्य है।

नियम

• इनपुट को प्राइम होने का आश्वासन दिया गया है, जब तक आप चाहते / न चाहें, त्रुटि हैंडलिंग को शामिल न करें।
• आउटपुट केवल एक पूर्ण-कनेक्टेड संख्या हो सकती है, इसलिए किसी भी चीज़ से विभाजित नहीं होती है, यहां तक ​​कि नई भी नहीं।
• आपके एल्गोरिथ्म को Nदिखने के पहले उदाहरण (उदाहरण के लिए, 17में 1175321) की जांच नहीं करनी चाहिए , बल्कि Nवास्तविक संख्या के पहले उदाहरण के लिए ।
• आपके इनपुट को सकारात्मक होने का आश्वासन दिया गया है, जब तक आप चाहते / न चाहें तब तक हैंडलिंग न जोड़ें।

परीक्षण के मामलों

Input: -2, 0
Output: Any, or none (number isn't positive)

Input: 9
Output: Any, or none (number isn't prime)

Input: 1
Output: 1

Input: 7
Output: 121321532175321

Input: 23
Output: 1213215321753211175321131175321171311753211917131175321231917131175321

विजेता

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

Comments

मैं चुनौती को बदलने का सुझाव नहीं दूंगा, लेकिन मुझे नहीं लगता कि 1यह एक प्रमुख परिभाषा है।

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

1. एक परीक्षण मामले के बाद 1सीधे उस कल्पना का खंडन करता है, जो " आश्वासन " देती है कि इनपुट नंबर एक प्रमुख होगा। 2. आउटपुट कल्पना में कई विरोधाभास और अस्पष्टताएँ हैं। " अंतिम संख्या" पंक्ति "(उदाहरण 7, 5, 3, 2, 1) को पूरी तरह से प्रिंट करना होगा " - तो क्या अन्य नहीं? " आपके परीक्षण के मामलों की जाँच के लिए एक ही रेगेक्स पैटर्न लागू होता है ", लेकिन " आउटपुट केवल पूर्ण-कनेक्टेड संख्या हो सकती है, इसलिए रेगेक्स में कुछ भी विरोधाभास नहीं है "। लेकिन रेगेक्स वैसे भी स्पष्ट रूप से सुस्त है क्योंकि यह खाली स्ट्रिंग की अनुमति देता है, और ऐसा कोई इनपुट नहीं है जो इसे दे सके।

— पीटर टेलर

1. " एक एकल अनुगामी न्यूलाइन की अनुमति है। " रेगेक्स पैटर्न के साथ निरर्थक / असंगत है जो किसी भी संख्या में अनुगामी पात्रों की अनुमति देता है । 2. इंट्रो वाक्य " आपका कार्य पूर्णांक आउटपुट के लिए है " यह भ्रामक है क्योंकि आप बाद में एकल संख्या को आउटपुट करने के लिए कहते हैं। 3. अनुक्रम और आउटपुट की पूरी व्याख्या भ्रमित कर रही है - लोगों को मूल रूप से रिवर्स-इंजीनियर का मतलब है कि आप उदाहरणों (अनुक्रम लिस्टिंग और परीक्षण मामलों) का अध्ययन करके क्या मतलब है। अंतिम चुनौती में भी ये मुद्दे थे, और मैंने उन्हें वहां एक सुझाव दिया जिसमें

— उन्होंने

मनमाने ढंग से 1 प्राइम बनाने की बात क्या है?

— Xanderhall

नकारात्मक क्रम पूर्णांक चुनौती है लेकिन हर बार जब यह प्राइम हो जाता है तो यह तेज हो जाता है;)

— स्प्लिटडिव डे

Answer 1

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

ÆR1;;\UFV

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

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

ÆR1;;\UFV  Main link. Argument: n

ÆR         Prime range; yield all primes up to n.
  1;       Prepend the "prime" 1.
    ;\     Cumulative concatenation; yield all prefixes of the prime range.
      U    Upend; reverse each prefix.
       F   Flatten the resulting 2D array.
        V  Eval. This casts the integer array to string first, thus concatenating
           the integers.

Comments

मुझे पता है कि मैं गोल्फ के बारे में सीखने में बहुत गहरी हूँ जब मैंने जेली को दूसरे तरीके के बजाय प्रश्न को समझने के लिए पढ़ा। (यह वास्तव में एक बहुत पठनीय जेली कार्यक्रम है, क्योंकि वे जाते हैं; मेरे लिए केवल भ्रमित करने वाला बिंदु Vएक सूची पर अजीब विशेष मामला था ।)

Answer 2

प्रसंस्करण, 161 बाइट्स

int p(int n){for(int k=1;++k<=sqrt(n);)if(n%k<1)return 0;return 1;}void t(int n){for(int i=1,j;i<=n;i++){if(p(i)<1)continue;for(j=i;j>0;j--)print(p(j)<1?"":j);}}

एक फंक्शन प्राइमलिटी चेकिंग करता है, दूसरा प्रिंटिंग करता है। इसके द्वारा कॉल करेंt(7)

Ungolfed

पहला कार्य प्रायोगिक जाँच करता है। इसके intबजाय यह booleanइस तरह से लौटता है क्योंकि इस तरह से अधिक बाइट्स बचाए जाते हैं। (के intबजाय boolean, के 0बजाय false, के 1बजाय true)

int Q103891p(int n){
  for(int k=1;++k<=sqrt(n);)
    if(n%k<1)return 0;
  return 1;
}

दूसरा फ़ंक्शन स्ट्रिंग को प्रिंट करता है। यह प्रत्येक संख्या के माध्यम से पुनरावृत्ति करता है, यदि यह एक प्रमुख नहीं है, तो अगले पुनरावृत्ति पर जाएं। यदि यह एक प्रमुख है, तो यह एक और for-लूप के अंदर मुद्रण तक जारी रहता है । फिर, यदि संख्या प्रमुख है, तो हम इसे प्रिंट करते हैं, अन्यथा नहीं।

void Q103891(int n){
  for(int i=1,j;i<=n;i++){
    if(p(i)<1)continue;
    for(j=i;j>0;j--)
      print(p(j)<1?"":j);
  }
}

Answer 3

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

ÆR;@1
ÇÇ€UVV

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

यदि यह बिल्कुल भी नहीं 1होता, तो मेरा कोड सिर्फ ÆRÆRUVV7 बाइट्स के लिए होता।

बढ़ी हुई व्याख्या:

ÇÇ€UVV Main link. Arguments: z.
Ç      Run link1 on z.
 ǀ    Run link1 on z's elements.
   U   Reverse z's elements.
    V  Flatten z.
     V Concatenate z's elements.

ÆR;@1 Link 1. Arguments: z.
ÆR    Range of primes [2..z].
    1 Integer: 1.
  ;@  Concatenate x to y.

आयरिश आदमी (डेनिस कहा जाता है?) किसी तरह मुझे lol outgolfed ।

Answer 4

05AB1E , 19 बाइट्स

LDpÏX¸ì€Lí˜ÐXQsp+ÏJ

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

व्याख्या

L                     # range [1 ... input]
 DpÏ                  # keep only primes
    X¸ì               # prepend a 1
       €L             # map: range [1 ... n]
         í            # reverse each sublist
          ˜           # flatten list to 1D
           Ð          # triplicate
            XQ        # check elements in one copy for equality with 1
              sp      # check elements in one copy for primality
                +     # add the above lists giving a list with true values at indices
                      # comtaining 1 or a prime
                 Ï    # keep only those elements of the unmodified copy of the list
                  J   # join

Comments

DpÏकथन से चकित । अच्छा काम!

— देवचर

Answer 5

ब्रेकीलॉग , 17 बाइट्स

y:{e1|e#p}f@[rcw\

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

लगता है कि इससे छोटा नहीं हो सकता ...

व्याख्या

y                      The list [0, ..., Input]
 :{      }f            Find all...
   e1                     ...elements that are 1 (there is 1)...
     |                    ...or...
      e#p                 ...elements that are prime...
           @[          Take a prefix of the result
             rc        Reverse it and concatenate it into a number
               w       Write to STDOUT
                  \    Backtrack: try another prefix

Answer 6

गेममेकर भाषा, 169 बाइट्स

मुख्य समारोह (68 बाइट्स)

b=""for(i=1;i<=argument0;i++){c=i while(j)b+=string(p(c--))}return b

समारोह पी (46 बाइट्स)

for(a=0;a<argument0;a++)while q(++b){}return b

समारोह q (55 बाइट्स)

n=argument0 for(i=2;i<n;i++)if!(n mod i)p=1return p|n=1

Comments

अच्छा, कोई है जो

— FireCubez

@FireCubez धन्यवाद :) मैंने इसका बहुत उपयोग किया। यह वास्तव में पहली प्रोग्रामिंग भाषा थी जिसे मैंने सीखा था।

— टाइमटेक

Answer 7

MATL , 15 बाइट्स

Zq"1@ZqP]1v!VXz

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

Zq      % Implicit input. Push array of primes up to that value
"       % For each prime in that array
  1     %   Push 1
  @     %   Push current prime
  Zq    %   Push array of primes up to that
  P     %   Reverse
]       % End
1       % Push 1
&h      % Concatenate all stack horizontally
V       % Convert to string
Xz      % Remove spaces. Implicit display

Answer 8

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

{[~] flat [\R,] 1,|grep *.is-prime,2..$_}

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

स्पष्टीकरण:

• 1, |grep(*.is-prime, 2..$_): अनुक्रम 1 और primes ... (1 2 3 5)
• [,] ...: अल्पविराम ऑपरेटर पर कम ("गुना") ... (1 2 3 5)
• [\,] ...: मध्यवर्ती परिणाम ( त्रिकोणीय कम ) के साथ ...((1) (1 2) (1 2 3) (1 2 3 5))
• [\R,] ...: उलटा मेटा-ऑपरेटर को अल्पविराम पर लागू करें ...((1) (2 1) (3 2 1) (5 3 2 1))
• [~] flat ...: सूची घोंसले के शिकार को निकालें, और स्ट्रिंग कॉनैट ऑपरेटर पर गुना करें ... 1213215321

(यह पिछली चुनौती के लिए मेरे जवाब पर आधारित है ।)

Answer 9

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

ToString/@(1<>Prime@Range[Range@PrimePi@#,0,-1]/.Prime@0->1)&

एक पूर्णांक तर्क लेने और एक स्ट्रिंग लौटने का कार्य करें। (यदि इनपुट एक अभाज्य नहीं है, तो यह निकटतम प्राइम में "इसे राउंड डाउन करता है"; यदि इनपुट नॉनपोजिटिव है, तो यह 1. दिखावा करता है)

यह कार्यान्वयन मार्टिन एंडर के उत्तर से समान पिछली चुनौती के लिए बुरा चाल का उपयोग करता है (जो कहता है कि यह पुराना कुत्ता नई चाल नहीं सीख सकता है?): <>पूर्णांक की एक नेस्टेड सूची को समतल करने के लिए दुरुपयोग करना।

प्रश्न में नेस्टेड सूची एक समान नेस्टेड सूची को उस उत्तर के रूप में उत्पन्न करने से शुरू होती है, जिसमें उपयुक्त लंबाई (इसके द्वारा PrimePi@#, इनपुट तक और इसके सहित primes की संख्या) होती है; फिर Primeहर तत्व पर लागू किया जाता है। उदाहरण के लिए, इनपुट के लिए 5जो कि 3 जी प्राइम है, कोड Range[Range@PrimePi@#,0,-1]पैदावार देता है {{1,0},{2,1,0},{3,2,1,0}}, और Primeप्रत्येक तत्व पैदावार के {{2,Prime[0]},{3,2,Prime[0]},{5,3,2,Prime[0]}}लिए 1, 2 और 3 के बाद से लागू होता है , क्रमशः 3, 2, और 5 हैं। मुझे गर्व महसूस होता है कि मैंने मार्टिन एंडर के दृष्टिकोण के लिए और भी अधिक त्रुटियों को जोड़ने में कामयाबी की - मैथेमेटिका हर बार लिखती है Prime[0]।

Prime[0]कोई बात नहीं है, लेकिन यह ठीक है: /.Prime@0->1उन सभी को बदल देता है 1। और हम 1मोर्चे पर भी चाहते हैं , इसलिए हम ""मार्टिन एंडर के उत्तर को बस से बदल देते हैं 1, जो वास्तव में एक बाइट बचाता है।

Answer 10

PHP, 72 बाइट्स

for(;$n<$argv[1];print$s=$n.$s)for($i=2;$i>1;)for($i=++$n;--$i&&$n%$i;);

बुद्धि दौड़ाओ -r

टूट - फूट

for(;$n<$argv[1];               // loop $n up to argument:
    print$s=$n.$s)                  // 2. prepend $n to $s, print $s
    for($i=2;$i>1;)                 // 1. find next prime: break if $i<2
        for($i=++$n;--$i&&$n%$i;);      // if $n is prime, $i is 1 after loop (0 for $n=1)

Answer 11

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

jkf!tPTs}R1S

टेस्ट सूट ।