11 के बिना पलिंड्रोमिक प्राइम

Question

अंकों की संख्या के साथ प्रत्येक पलिंड्रोम 11 से विभाज्य है, इसलिए 11 अंकों की समान संख्या के साथ एकमात्र [पैलिंड्रोमिक प्राइम] है। - डेविड वासरमैन, OEIS

जब मैंने अपना शोध किया था, तो मैंने इसे आज ही मैनुअल तरीके से सीखा था, जब मेरे कार्यक्रम ने पैलिंड्रोमिक अपराधों की गणना करते समय अंकों की संख्या (11 को छोड़कर) के साथ संख्या को छोड़ दिया था। आपका कार्य: एक प्रोग्राम या फ़ंक्शन बनाएं जो पूर्णांक इनपुट एन दिए जाने पर, स्टीफन के पलिंड्रोमिक अनुक्रम ™ में एनटी शब्द को आउटपुट करता है।

स्टीफन के पलिंड्रोमिक अनुक्रम ™

11 के साथ स्टीफन मुरजबंध संबंधी अनुक्रम ™ शुरू होता है, और के साथ जारी है मुरजबंध संबंधी semiprimes , मूल रूप से 11. से विभाज्य semiprimes कि अभाज्य संख्या हो सकता है अगर 11 नहीं था के सभी "गिनती।" उल्टा यह है कि इस सूची में अंकों की संख्या के साथ संख्याएँ हैं! वाह। और, विषम संख्या वाले अंकों की संख्या बहुत कम हो जाती है, क्योंकि वे पहले से ही प्रमुख थे।

अनुक्रम की शुरुआत:

1   : 11
2   : 22
3   : 33
4   : 55
5   : 77
6   : 121
7   : 737
8   : 979
9   : 1111
10  : 1441
11  : 1661
12  : 1991
13  : 3113
14  : 3223
15  : 3443
16  : 3883
17  : 7117
18  : 7447
19  : 7997
20  : 9119
21  : 9229
22  : 9449
23  : 10901

_{^{* हालांकि 1331 (11 ^ 3) और इसी क्रम की भावना के अनुरूप, वे नियमों में फिट नहीं होते हैं।}}

लंबे समय तक परीक्षण के मामले:

26  : 91619
31  : 103301
41  : 139931
51  : 173371
61  : 305503
71  : 355553
81  : 395593
91  : 725527
101 : 772277
127 : 997799
128 : 1099901
141 : 3190913
151 : 3739373
161 : 7589857
171 : 9460649
200 : 11744711
528 : 39988993

इनपुट

पूर्णांक एन,> = = 1. यदि आप अपने उत्तर में निर्दिष्ट करते हैं, तो आप 0-अनुक्रमित एन (परीक्षण मामलों को समायोजित करना सुनिश्चित करें) का उपयोग कर सकते हैं। अनुगामी newlines की अनुमति दी।

उत्पादन

स्टीफन के पलिंड्रोमिक अनुक्रम ™ में नौवां कार्यकाल। अनुगामी newlines की अनुमति दी।

नियम

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

Comments

संबंधित: अगला प्रधान तालमेल खोजने के लिए सबसे छोटा कोड

— स्टीफन

11 शामिल होना चाहिए? यह अर्धविराम नहीं है।

— xnor

@xnor 11 को अनुक्रम की शुरुआत के रूप में परिभाषित किया गया है। आप सही हैं कि यह एक अर्धवृत्ताकार नहीं है, लेकिन 1 परिभाषा के अनुसार फिबोनाची संख्या नहीं है :)

— स्टीफन

Answer 1

जेली , 18 13 बाइट्स

ṬÆẸש11ŒḂµ#ṛ®

किसी कारण से, यह मेरे शुरुआती संशोधन की तुलना में बहुत धीमा है, बिल्कुल वैसा ही करने के बावजूद।

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

एन = 127

dennis-home:~$ time jelly eun 'ṬÆẸש11ŒḂµ#ṛ®' <<< 127
997799

real    1m43.745s
user    1m43.676s
sys     0m0.113s

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

ṬÆẸש11ŒḂµ#ṛ®  Main link. No arguments.

         µ     Combine all links to the left into a chain.
          #    Read an integer n from STDIN and call the chain monadically, with
               argument k = 0, 1, 2, ... until n values of k result in a truthy
               output. Return the array of all matching values of k.
Ṭ                Untruth; yield [0, 0, 0, ..., 1] (k-1 zeroes followed by a 1) or
                 [] if k = 0.
 ÆẸ              Unexponents; consider the resulting array as exponents of the
                 sequence of primes and yield the corresponding integer. For k = 0,
                 this yields 1. For k > 0, it yields the k-th prime.
   ש11          Multiply the result by 11 and copy the product to the register.
       ŒḂ        Test if the product is a palindrome.
           ṛ®  Replace the resulting array with the integer in the register.

Answer 2

पायथन 2 , 76 73 72 70 69 68 बाइट्स

n=input();c=k=m=11
while n:m*=k/c;k+=c;n-=`k`==`k`[::~m%k-c]
print k

3 बाइट्स बंद करने के लिए @WheatWizard को धन्यवाद!

1 बाइट को बंद करने के लिए @ JrjanJohansen को धन्यवाद!

68 बाइट्स का मार्ग प्रशस्त करने के लिए @xnor और @ @rjanJohansen को धन्यवाद!

इनपुट 0-अनुक्रमित है। इसे ऑनलाइन आज़माएं! या पहले 31 परीक्षण मामलों को सत्यापित करें ।

पृष्ठभूमि

याद करें कि विल्सन के प्रमेय में कहा गया है कि सभी पूर्णांकों के लिए p> 1 ,

अर्थ है कि (पी - 1)! + 1 पी से समान रूप से विभाज्य है अगर और केवल यदि पी प्राइम है।

यदि p> 1 है नहीं प्रधानमंत्री, यह समग्र है, चलो q , p का सबसे छोटा प्रधान विभाजक है । स्पष्ट रूप से, क्यू ly पी / क्यू । दो मामले हैं:

• यदि q = p / q , हमारे पास वह p = q² है ।

  यदि q = 2 , (p - 1)! = ३! = 6 , तो (पी - 1)! 2 मोडुलो पी के अनुरूप है ।

  यदि p / q = q> 2 , तो 2q <p । इस तरह, q और 2q दोनों 1,…, p - 1 के बीच हैं , जिसका उत्पाद p - 1 का भाज्य है , इसलिए 2p = 2q² = q · 2q विभाजित (p - 1)! समान रूप से।

• यदि q <p / q , q और p / q दोनों 1,…, p - 1 में से हैं , तो p = q · p / q विभाजित (p - 1)! समान रूप से।

उपसंहार,

सभी पूर्णांकों के लिए p> 1 ।

अब, सभी पूर्णांक बधाई और सभी पूर्णांकों के लिए , बी , और सी , निम्नलिखित हैं।

जब a = -1 , b = 11 और c = -1 होता है , तो हम उसका अनुसरण करते हैं

और, के बाद से 21 और -23 हैं अनुकूल सापेक्ष 44 और -1 और 11p -1 हैं अनुकूल सापेक्ष 11p , हम निम्नलिखित निष्कर्ष पर पहुंचने।

पी के सभी संभावित मूल्यों के लिए , परिणाम ( 11 , 21 , या 11 पी - 1 ) 0,…, 11 पी - 1 की श्रेणी में आएगा , इसलिए ये मूल्य उन लोगों से मेल खाते हैं जिन्हें पायथन के %ऑपरेटर द्वारा वापस किया जाएगा ।

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

N में इनपुट सेव करने के बाद हम c , k , और m 11 को इनिशियलाइज़ करते हैं । c शेष कार्यक्रम के लिए स्थिर रहेगा। के बाद से वहाँ के तीन घटनाओं रहे हैं ग निम्नलिखित लाइन पर और बताए ग केवल दो बाइट्स लागत, यह एक बाइट बचाता है। k पिछले पैराग्राफ से p के अर्थ का उपयोग करते हुए 11p के बारे में सोचा जा सकता है ; शुरू में, के = ११ = ११ · १! । मी 11 की जगह लेता है · (पी - 1)! ; शुरू में, एम = ११ = ११ · ०! । के और एमरिश्ते को संतुष्ट करेगा m = 11 · (k / 11)! हर समय।

n "स्टीफन के पलिंडोमेस" की संख्या का प्रतिनिधित्व करता है जिसे हमें ढूंढना है। शुरू में k = 11 के बाद से , हम आगे की गणना के बिना k verbatim को आउटपुट कर सकते हैं । हालांकि, जब n सकारात्मक होता है, तो हम लूप में प्रवेश करते हैं। पाश गुणा करके शुरू होता है मीटर से कश्मीर / सी = पी , फिर जोड़ने 11 को कश्मीर , इस प्रकार बढ़ाने पी । यदि k अनुक्रम का सदस्य है, तो हम n से 1 घटाते हैं और शुरू करते हैं। एक बार जब n 0 पर पहुंच जाता है , तो हमने अनुक्रम सदस्य को वांछित सूचकांक पर पाया और लूप से बाहर निकल गया, फिर k के अंतिम मान को प्रिंट किया।

भाव

`k`==`k`[::~m%k-c]

वास्तविक परीक्षण करता है, और यह परिणाम है ( अनुक्रम सदस्यों के लिए सच / 1 , 0 / गलत अन्यथा) एन से घटाया जाता है । जैसा कि पहले देखा गया, ~ m% k = (-m - 1)% k = (-11 · (p - 1)! - 1)% 11p 10 % बराबर होता है यदि p अभाज्य, 21 यदि p = 4 , और 11p - 1 है > 43 यदि p> 4 संमिश्र है। इस प्रकार, c = 11 को घटाने के बाद , हम प्राइम पी के लिए -1 से बचे हैं और एक सकारात्मक पूर्णांक 9 से बड़ा है ।

प्राइम पी के लिए , ​`k`[::-1]हमें उल्टे अंकों के क्रम के साथ कश्मीर का स्ट्रिंग प्रतिनिधित्व देता है , इसलिए इसकी तुलना यह जांचने के लिए ​`k`​करता है कि क्या k एक पैलिंड्रोम है। यदि यह है, सभी शर्तों को पूरा कर रहे हैं और कश्मीर एक अनुक्रम सदस्य है। हालाँकि, यदि p अभाज्य नहीं है, तो बड़ी श्रेणी का चरण और तथ्य यह है कि k का हमेशा एक से अधिक अंकों का मतलब होगा कि ​`k`[::-1]इसमें उतने अंक नहीं हो सकते हैं, जितने ​`k`​कि इसके बराबर होते हैं।

Comments

मेरा कहना है, आपका प्राणशक्ति परीक्षण वास्तव में शानदार है। मैं इस जवाब का मुकाबला नहीं कर सकता।

— पोस्ट रॉक गार्फ हंटर

यह आशाजनक है लेकिन

— स्काइप

@xnor अतिरिक्त बाइट की कीमत पर 121 को शामिल करने का प्रबंधन करता है। धन्यवाद!

— डेनिस

Answer 3

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

:I{11|ṗ×₁₁≜.↔}ᶠ⁽t

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

यह 1-अनुक्रमित है।

व्याख्या

:I{          }ᶠ⁽t    Find the Input'th result of the following:
   11                  Output = 11
     |                 Or
          ≜.           Output is an integer…
      ṗ×₁₁             …which is the result of multiplying a prime by 11…
           .↔          …and Output reversed is still the Output

इस उत्तर के साथ दो अहसास:

• मुझे इस तथ्य को ठीक करने की आवश्यकता है कि ⁽यदि मेटाफ़्रेडिकेट्स (साथ ) से गुजरने वाली सुपरस्क्रिप्ट काम नहीं करती है यदि पास करने के लिए कोई इनपुट नहीं है (यही वजह है कि मुझे जोड़ना होगा :I)।
• मुझे Nएक विधेय के वें परिणाम को प्राप्त करने के लिए एक रूपक जोड़ना होगा (जो कि ᶠ⁽tउदाहरण के बजाय प्रयोग करने से बचना होगा ⁿ⁽)।

दोनों परिवर्तनों को लागू करने से वह उत्तर 14 बाइट्स हो जाएगा।

Answer 4

गणितज्ञ, ६५ ६० बाइट्स

n=NextPrime;11Nest[n@#//.x_/;!PalindromeQ[11x]:>n@x&,1,#-1]&

NextPrime11 बार प्राइम एक पलिंड्रोम का उपयोग करके जांच के माध्यम से सीधे Iterates । N = 528 तक काम करता है । परिणाम 528 और 529 2 ¹⁶ से अधिक प्राइम हैं, जिस बिंदु पर //.पर्याप्त संख्या में प्रतिस्थापन का प्रयास करने में विफल रहेंगे।

Answer 5

पायथन 2 , 111 107 103 102 101 100 91 90 89 बाइट्स

डेनिस ने मुझे यहां हराया है , इसलिए उसका उत्तर देखें।

यह उत्तर शून्य अनुक्रमित है

n=input()
r=1
while n:r+=1;c=`r*11`;n-=all(r%x for x in range(2,r))*c==c[::-1]
print r*11

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

एक बाइट ने गणित के दीवाने को धन्यवाद दिया

व्याख्या

पहले हम इनपुट लेते हैं और इसे सेट करते हैं, nहम एक नया वैरिएबल भी बनाते हैं r=1। हम rपालिंड्रोम्स की खोज करेंगे, जो कि प्राइम का उत्पाद है और 11. हर बार जब हम पाते हैं कि हम n0 तक पहुँचते हैं तब तक हम कम हो जाएंगे ।

तो हम लूप शुरू करते हैं:

while n:

पहली बात हम वेतन वृद्धि है r

r+=1

हम cस्ट्रिंग के प्रतिनिधित्व के रूप में एक चर को भी पूर्वनिर्धारित करते हैंr*11

c=`r*11`

अब हम nइस तरह के एक नंबर मिला है, तो हम कम करना चाहते हैं । यदि हम r*11पैटर्न से फिट होते हैं, तो हम केवल एक बूलियन को घटाते हैं r। यदि यह है Falseतो हम शून्य को घटाएंगे और यदि यह है Trueतो 1 को घटाएगा।

हम करते हैं बूलियन की गणना करने के लिए:

all(r%x for x in range(2,r))*c==c[::-1]

पहला भाग allनिर्धारित करेगा कि क्या rप्रधान है। यदि हम अभाज्य हैं cतो परिणाम को गुणा rकरेंगे यह सिर्फ होगा cलेकिन अगर rसमग्र होगा तो यह ""रिक्त स्ट्रिंग होगा। हम इसके बाद इसकी तुलना करते हैं, c[::-1]जिसका उल्टा है c। यदि rप्राइम है और cएक पैलिंड्रोम है तो यह होगा True, यदि या तो विफल हो जाता है तो पूरी चीज झूठी के रूप में मूल्यांकन करेगी।

जब nशून्य हम बस है print c।

83 बाइट्स

यहाँ एक पुनरावर्ती समाधान है जो छोटा है लेकिन दुर्भाग्य से ऐनक को पूरा नहीं करता है क्योंकि यह अजगर की पुनरावृत्ति टोपी को बहुत तेज़ मारता है।

f=lambda n,r=1:n and f(n-all(r%x*(`r*11`==`r*11`[::-1])for x in range(2,r)),r+1)+11

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

Answer 6

05AB1E , 15 बाइट्स

0 अनुक्रमित।

11Iµ11N*DÂQNp*½

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

व्याख्या

11               # initialize stack with 11
  Iµ             # loop over N in [1 ... inf] until counter equals input
    11N*         # multiply N by 11
        D        # duplicate
         ÂQ      # check if the copy equals its reverse
           Np    # check if N is prime
             *   # multiply the results of the checks together
              ½  # if 1, increase counter

Answer 7

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

h#n|n<2=0|mod n h<1=1+h#div n h|j<-h+1=j#n
([n|n<-[0,11..],(==)=<<reverse$show n,3>2#n]!!)

इसे ऑनलाइन आज़माएं! उदाहरण उपयोग: ([n|n<-[0,11..],(==)=<<reverse$show n,3>2#n]!!) 127।

[0,11..]अनंत सूची का निर्माण करता है [0,11,22,33, ...](अनुक्रम 1-अनुक्रमित बनाने के लिए शून्य की आवश्यकता होती है)। nइस सूची में से प्रत्येक के लिए हम जांचते हैं n==(read.reverse.show)n, कि क्या nकोई तालमेल है। 3>2#nजाँच करें कि nक्या दो मुख्य विभाजक हैं। क्योंकि nहमेशा 11 से विभाज्य होता है, हमें कोई वास्तविक अपराध नहीं मिलता, बल्कि केवल अर्धविराम मिलते हैं।

संपादित करें: 4 बाइट गोल्फिंग के लिए अर्जन जोहान्सन को धन्यवाद!

Comments

आपको चारों ओर कोष्ठक की आवश्यकता नहीं है div n h। इसके अलावा, यह केवल दक्षता को प्रभावित करता है, लेकिन पहला 2#शायद हो सकता है h#।

— अर्जन जोहान्सन

(==)=<<reverse$show nछोटा है।

— अर्जन जोहान्सन

Answer 8

PHP, 82 बाइट्स

for(;$d<$argn;$i>1||($p=11*$n)!=strrev($p)?:$d++)for($i=++$n;--$i&&$n%$i;);echo$p;

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

Comments

"इसे ऑनलाइन आज़माएं" मुझे इनपुट कहां लिखना है? अगर मैं बॉक्स "इनपुट" में 1 लिखता हूं तो यह 395593

— RosLuP

@RosLuP सामान्य रूप से -R विकल्प के साथ कमांड लाइन से चलता है। ऑनलाइन संस्करण में आपके पास सीमाएं हैं और $argn=81;इनपुट चर है जो एक कमांड लाइन संस्करण में उपलब्ध है

— Jörg Hülsermann

इसलिए किसी को "$ argn = 81" में इनपुट चर लिखना है, इसलिए उदाहरण के लिए यदि इनपुट 10 है तो इसे "$ argn = 10" ठीक

— लिखें

@RosLuP हाँ इनपुट के साथ संख्या 81 तुम चाहो की जगह

— Jörg Hülsermann

Answer 9

Axiom, 105 बाइट्स

g(n)==(i:=c:=1;repeat(c=n=>break;i:=i+1;if(prime? i)then(x:=(11*i)::String;x=reverse(x)=>(c:=c+1)));i*11)

ungolf, परीक्षण कोड और परिणाम

f(n)==
   i:=c:=1
   repeat
      c=n=>break
      i:=i+1
      if(prime? i)then(x:=(11*i)::String;x=reverse(x)=>(c:=c+1))
   i*11


(5) -> [[i,g(i)]  for i in 1..23]
   (5)
   [[1,11], [2,22], [3,33], [4,55], [5,77], [6,121], [7,737], [8,979],
    [9,1111], [10,1441], [11,1661], [12,1991], [13,3113], [14,3223], [15,3443],
    [16,3883], [17,7117], [18,7447], [19,7997], [20,9119], [21,9229],
    [22,9449], [23,10901]]
                                          Type: List List PositiveInteger
(6) -> [[i,g(i)]  for i in [26,31,41,101,151,200]]
   (6)
   [[26,91619], [31,103301], [41,139931], [101,772277], [151,3739373],
    [200,11744711]]

यहाँ g (700) = 92511529 इसलिए सीमा> 700 होगी; ww (१०००) = 999०३ ९९ ३० but