क्रेजी लाइब्रेरियन का दिलचस्प प्राइम परमुटेशन इंडेक्स नंबर जेनरेटर

13

आपने अपने प्राइम अनुक्रम कोड के साथ दिन बचाया , और गणित शिक्षक इसे पसंद करते थे। इतना कि लाइब्रेरियन (ए / के / ए, आपके बॉस) को एक नई चुनौती दी गई थी। बधाई हो, आपको समाधान कोड करने के लिए मिलता है ताकि लाइब्रेरियन एक बार फिर गणित शिक्षक को प्रभावित कर सके।

आधार -10, एन में प्राकृतिक संख्याओं के अनुक्रम से शुरू करें

0, 1, 2, 3, 4, 5, 6 ...

छोड़कर 0और 1, इस क्रम में प्रत्येक संख्या या तो प्रधान है, पी

2, 3, 5, 7, 11, 13 ...

या समग्र, सी

4, 6, 8, 9, 10, 12, 14, 15, 16, 18, 20 ...

कैसे से एक संख्या का दशमलव विस्तार में एक पूर्णांक अंकों डालने के लिए लाइब्रेरियन सोचा पर अपनी प्रतिक्रिया व्यक्त पी , गणित शिक्षक के बजाय एक समारोह बनाई जी (एक्स, वाई) कि एक नंबर लेता xसे एन के साथ 1 <= x <= 9और एक नंबर yसे सी और आवेषण xमें yहर स्थिति में दशमलव का विस्तार , बाएं से दाएं क्रम में, केवल अद्वितीय संख्या का चयन करते हुए।

उदाहरण के लिए, G (3,14) है 314, 134, 143। हालाँकि, G (1,14) केवल 114, 141यह है कि क्या आप प्रीपेंड करते हैं या इसमें सम्मिलित 1करते हैं 14, वही संख्या 114उत्पन्न होती है।

गणित के शिक्षक ने सोचा कि जब आप बढ़ते क्रम में पी में नंबर लेते हैं, तो आपको कितनी बार ये क्रमपरिवर्तन xकरने होंगे। गणित शिक्षक ने इसे एक संख्या का समग्र-प्रधान सूचकांक कहा , और इसे CPI (y) के रूप में लिखा ।

उदाहरण के लिए, 4केवल दो बार किए जाने की आवश्यकता है: 14, 41चूंकि 41प्रधान है, इसलिए CPI (4) है 2। हालांकि, प्राइम नंबर के रूप में पहुंचने से पहले 86 बार करने की जरूरत है , इसलिए CPI (8) है ।18, 81, 28, 82, 38, 83836

आपका काम एक ऐसा कोड लिखना है जो इनपुट नंबर को देखते हुए इस कंपोजिट-प्राइम इंडेक्स को आउटपुट करेगा ।

इनपुट

  • एक एकल पूर्णांक y, जैसे कि Cy में है , फ़ंक्शन तर्क के माध्यम से इनपुट, STDIN या समकक्ष।
  • गणना के प्रयोजनों के लिए, आप मान सकते हैं कि yसामान्य पूर्णांक पर्वतमाला में फिट होंगे (उदाहरण के लिए, ऊपरी सीमा के रूप में 2 31 -1 मान लें )।
  • Cy में नहीं के लिए व्यवहार अपरिभाषित है।

उत्पादन

परिणामी कम्पोजिट-प्राइम इंडेक्स , जो ऊपर वर्णित है, दो अपवादों के साथ STDOUT या समकक्ष के लिए आउटपुट:

  • अगर आखिरी क्रमचय (यानी, जोड़कर 9करने के लिए y) में से एक है कि एक प्रमुख में परिणाम, उत्पादन -1। एक उदाहरण, नीचे विस्तार किया गया है y=14।
  • यदि कोई क्रमपरिवर्तन नहीं है (अर्थात, G (x, y) सभी के लिए C का उपसमूह है 1 <= x <= 9), आउटपुट 0। एक उदाहरण, नीचे विस्तार किया गया है y=20।

उदाहरण

 y -> operations             : output
 4 -> 14, 41                 : 2
 6 -> 16, 61                 : 2
 8 -> 18, 81, 28, 82, 38, 83 : 6
 9 -> 19                     : 1
10 -> 110, 101               : 2
12 -> 112, 121, 212, 122, 312, 132, 123, 412, 142, 124, 512, 152, 125, 612, 162, 126, 712, 172, 127 : 19
14 -> 114, 141, 214, 124, 142, 314, 134, 143, 414, 144, 514, 154, 145, 614, 164, 146, 714, 174, 147, 814, 184, 148, 914, 194, 149 : -1
15 -> 115, 151               : 2
16 -> 116, 161, 216, 126, 162, 316, 136, 163 : 8
18 -> 118, 181               : 2
20 -> 120, 210, 201, 220, 202, 320, 230, 203, 420, 240, 204, 520, 250, 205, 620, 260, 206, 720, 270, 207, 820, 280, 208, 920, 290, 209 : 0

प्रतिबंध

  • यह कोड-गोल्फ है, चूंकि आपको इसे एक इंडेक्स कार्ड में स्थानांतरित करना होगा, ताकि लाइब्रेरियन गणित शिक्षक को दिखा सके, और आपके हाथ में आसानी से ऐंठन हो।
  • मानक ढील प्रतिबंध लागू होते हैं। लाइब्रेरियन चीटर्स को बर्दाश्त नहीं करता है।

लीडरबोर्ड

कोड स्निपेट दिखाएं

code-golf  math  sequence  primes  number-theory 
— AdmBorkBork
स्रोत
9 के लिए, 19प्राइम है, इसलिए आउटपुट 1 नहीं होना चाहिए?
— isaacg
वाह, शांत उत्तर चार्ट!
— कैस्केडिंग-शैली
1
@ कैस्केडिंग-शैली यदि आपका मतलब लीडरबोर्ड है, तो यह मुख्य रूप से मार्टिन की करतूत है ।
— AdmBorkBork

जवाबों:

2

हास्केल, 166 161 बाइट्स

p n=mod(product[1..n-1]^2)n>0
q=p.read
n#c=[h++c:t|i<-[0..length n],(h,t)<-[splitAt i n]]
[y]%i|q y= -1|1<2=0
(y:z)%i|q y=i|1<2=z%(i+1)
f n=((n#)=<<['1'..'9'])%1

उपयोग के उदाहरण: f "8"-> 6, f "14"-> -1, f "20"-> 0।

यह कैसे काम करता है: pप्रायोगिक परीक्षण ( एक अलग चुनौती में @ मौरिस के जवाब से चोरी )। प्रकार को तार से पूर्णांक में बदलने के qलिए एक आवरण p। में हर स्थिति में n # cसम्मिलित करता cहै n। %संख्या और सूचकांक की सूची लेता है i। जब सूची का पहला तत्व प्रधान होता है, तो वापस लौटें i, और सूची की पूंछ के साथ पुनरावृत्ति करें और i+1। तब रुकें जब एक भी तत्व बचा हो और वापस लौटें -1अगर यह प्रमुख है और 0अन्यथा।

— nimi
स्रोत
1

मिंकोलंग 0.11 , 85 बाइट्स

n1(l*$d`)d9[i3G(0c2c$%$r2c*l*2c3c1+*++2gl:d2G)2gx1c2G3gx]r3XS(2M4&I)N.ikI1-4&1~N.1+N.

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

स्पष्टीकरण (जल्द ही आ रहा है)

n            Take integer from input (say, n)
1(           Calculate smallest power of 10 greater than n (say, a)
  l*         Multiply by 10
    $d`      Duplicate stack and push n>a
       )     Close while loop (ends when n<=a)
        d    Duplicates a (let's call it b)

9[                                                 For loop that runs 9 times 
  i1+                                              Loop counter + 1 (say, i)
     3G                                            Puts the loop counter in position 3
       (                                           Opens while loop
        0c2c$%                                     Copies n and b and pushes n//b, n%b
              $r                                   Swaps top two elements of stack
                2c*l*                              Copies b and multiplies by 10
                     2c3c*                         Copies b and i and multiplies them
                          ++                       Adds it all together (inserts i)
                            2gl:                   Gets b and divides by 10
                                d2G                Duplicates and puts one copy back
                                   )               Closes while loop (breaks when b=0)
                                    2gx            Gets and dumps b
                                       1c2G        Copies a and puts it in b's place
                                           3gx     Get and dumps i
                                              ]    Close for loop

r       Reverses stack
 3X     Dumps the top three elements (namely, n, a, and b)
   S    Removes duplicates

(                           Opens while loop
 2M                         Pushes 1 if top of stack is prime, 0 otherwise
   4&                       Jump four spaces if prime
     I)N.                   If the loop actually finishes, then all were composite,
                             so output 0 and stop.
         ik                 Pushes loop counter and breaks
           I1-              Pushes length of stack minus 1 (0 if last one was prime)
              4&1~N.        If this is 0, pushes -1, outputs as integer, and stops.
                    1+N.    Adds 1, outputs as integer, and stops.
— एलेंडिया स्ट्राटन
स्रोत
1

जावास्क्रिप्ट, 324 बाइट्स

y=>(p=(n,c)=>n%c!=0?c>=n-1?1:p(n,++c):0,u=a=>a.filter((c,i)=>a.indexOf(c)==i),g=(x,y)=>u(((x,y,z)=>z.map((c,i)=>z.slice(0,i).join("")+x+z.slice(i).join("")).concat(y+x))(x,y,y.split(''))),h=(x,y)=>g(x,y).concat(x==9?[]:h(++x,y)),i=h(1,y).reduce((r,c,i)=>r?r:p(c,2)?i+1:0,0),console.log(p(y,2)||y<2?'':i==h(1,y).length?-1:i))

यदि C में y नहीं है, तो STDOUT आउटपुट खाली है।

व्याख्या

y=>(
    //Prime Test function
    p=(n,c)=>n%c!=0?c>=n-1?1:p(n,++c):0,

    //Unique function
    u=a=>a.filter((c,i)=>a.indexOf(c)==i),

    //Generates numbers from a couple x and y
    g=(x,y)=>u(((x,y,z)=>z.map((c,i)=>z.slice(0,i).join("")+x+z.slice(i).join("")).concat(y+x))(x,y,y.split(''))),

    //Generates all possible numbers from y using recusion
    h=(x,y)=>g(x,y).concat(x==9?[]:h(++x,y)),

    //Check if any prime in the generated numbers
    i=h(1,y).reduce((r,c,i)=>r?r:p(c,2)?i+1:0,0),

    console.log(
        //Is Y in C ?
        p(y,2)||y<2?
            ''
            :
            // Check if the answer is not the last one
            i==h(1,y).length?-1:i)
    )
— Naouak
स्रोत
इस टिप्पणी पर बहुत देर हो सकता है, लेकिन आप को बदल कर कुछ बाइट्स नहीं बचा सका n%c!=0साथ n%c; c>=n-1साथ c>n-2; और x==9साथ x-9?
— ज़ाचारी
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.