एक धनात्मक पूर्णांक को देखते हुए इनपुट निर्धारित करता है कि क्या यह एक परिमाण संख्या है।

एक परिमाणी संख्या एक ऐसी संख्या है +जो किसी भी दो अंकों के बीच आधार 10 में किसी भी पूर्णांक की अभिव्यक्ति में किसी भी अंक के सम्मिलन का संकेत देती है।

उदाहरण के लिए ४०४२ is विशाल है क्योंकि

4+0427  = 431  is prime
40+427  = 467  is prime
404+27  = 431  is prime
4042+7  = 4049 is prime

उत्पादन

आपको दो अलग-अलग मानों को आउटपुट करना चाहिए, एक जब इनपुट शानदार है और एक जब इनपुट नहीं है।

स्कोरिंग

इस प्रतियोगिता का लक्ष्य बाइट्स में दिए गए इस कार्य को हल करने के लिए लिखे गए स्रोत कोड का आकार बनाना होगा, जितना संभव हो उतना छोटा।

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

1       -> True
2       -> True
4       -> True
10      -> False
98      -> True
101     -> True
109     -> False
819     -> False
4063    -> True
40427   -> True
2000221 -> True

OEIS 253996

— गेहूं का जादूगर
स्रोत

मैं सिर्फ चुनौती की परिभाषा से भ्रमित हूं कि 1 और 2 कैसे मान्य इनपुट हैं। अकेले इस तथ्य को बताएं कि 1किसी भी दो वर्णों (कोई सम्मिलित नहीं) के बीच डाला गया एक प्लस चिन्ह केवल उसी परिणाम में हो सकता है 1, जो स्वयं अभाज्य नहीं है।

— मैजिक ऑक्टोपस Urn

4

@MagicOctopusUrn प्लस को दो अंकों के बीच डाला जाना चाहिए, इस प्रकार से 1और 2दो अंक नहीं होने के कारण अभिव्यक्तियों का सेट खाली है। खाली सेट के सभी सदस्य प्राइम हैं। इसके अलावा, उनमें से कोई भी नहीं है, लेकिन बिंदु के अलावा thats। यह थोड़ा भ्रामक है, मैं आपको वह देता हूँ लेकिन मुझे लगता है कि यह विकल्पों की तुलना में अधिक समझ में आता है।

— गेहूं जादूगर

8

05AB1E , 10 बाइट्स

कोड

η¨¹.s¨R+pP

05AB1E एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें!

व्याख्या

η¨             # Take the prefixes of the input and remove the last element
  ¹.s¨         # Take the suffixes of the input and remove the last element
      R        # Reverse the array of suffixes
       +       # Vectorized addition
        p      # Check if each element is prime
         P     # Product of the array

— अदनान
स्रोत

कैसे इसके लिए काम करता है 1 - 9। एक खाली सेट का उत्पाद 1 है? क्यूं कर?

— मैजिक ऑक्टोपस Urn

@MagicOctopusUrn खाली उत्पाद हमेशा 1. बराबर होता है

— अदनान

@MagicOctopusUrn उत्पाद लेना मूल रूप 1से सेट में प्रत्येक आइटम द्वारा इसे शुरू करना और गुणा करना है, इसलिए ...

— ETHproductions

1

आह, गणितीय रूप से समझ में आता है। जैसे कैसे लगता sumपर []के बराबर है 0, लागू करते समय बहुत होशियार था प्रेरण संपत्ति का उपयोग कर।

— मैजिक ऑक्टोपस Urn

@jontro हां, UTF-8 में , यह 14 बाइट्स है। हालांकि, 05AB1E 05AB1E कोड पेज का उपयोग करता है , जहां यह 10 बाइट्स है।

— अदनान

7

सी (जीसीसी) , 8384 85 83 84 86 75 111 बाइट्स

सभी अनुकूलन बंद हो गए और केवल जीसीसी 32-बिट पर।

-1 बाइट थैंक्यू @ceilingcat

+ 1मामले के लिए कुछ बाइट्स ।

+ पुन: प्रयोज्य कार्यों के लिए कुछ बाइट्स।

i,j,r,s;f(a){for(i=10,r=1;a/i;i*=10)for(s=a%i+a/i,r*=s-1,j=2;j<s;)r*=s%j++>0;a=!r;}

एक पूर्णांक के रूप में इनपुट लेता है। झूठे मामलों के लिए 1, सच्चे मामलों के लिए 0 लौटाएं।

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

गणितज्ञ कोड (55 बाइट्स) के लिए मेरा एक और जवाब देखें।

— कीउ गण
स्रोत

यह दो अलग-अलग उत्तर होना चाहिए। इसके अलावा, मेथेमेटिका समाधान के लिए गलत परिणाम देता है 1, 98और 4063।

— २१:११ पर २१

6

रेटिना , 38 बाइट्स

\B
$`$*_$'$*_
S`\d
G`^_$|^(__+)\1+$
^$

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

शानदार 1संख्या के लिए प्रिंट और 0अन्यथा।

व्याख्या

\B
$`$*_$'$*_

हम दो अंकों (स्थिति जो शब्द सीमाएं नहीं हैं) के बीच प्रत्येक स्थिति से मेल खाते से शुरू होते हैं और एकतरफा के _रूप में उपयोग करते हुए, उस मैच के उपसर्ग और प्रत्यय दोनों को जोड़ते हैं। इसलिए +s डालने के बजाय , हम सीधे वहाँ के योग के असमान परिणाम को सम्मिलित करते हैं।

S`\d

अब हम स्ट्रिंग को अंकों के चारों ओर विभाजित करते हैं, ताकि प्रत्येक राशि अपनी रेखा पर चले और हम उन अंकों से छुटकारा पाएं (साथ ही एक खाली अग्रणी और अनुगामी रेखा भी होगी, लेकिन यह महत्वपूर्ण नहीं है)।

G`^_$|^(__+)\1+$

यह गैर-अभाज्य संख्याओं को एकात्मक में मिलान करने के लिए मानक रीजेक्स है। Gयहां एक प्रतिनिधि चरण का उपयोग करने का मतलब है कि हम बस उन सभी लाइनों को रखते हैं जिनमें सकारात्मक गैर-प्राइम्स हैं (खाली लाइनों को छोड़ना)।

^$

अंत में हम जांचते हैं कि क्या स्ट्रिंग खाली है। यदि इनपुट शानदार था, तो पिछले चरण ने सभी लाइनों को समाप्त कर दिया होगा (क्योंकि वे सभी primes थे), और यह हमें देता है 1। अन्यथा, यदि कोई रेखा प्रधान नहीं थी, तो यह स्ट्रिंग में रहेगी और रेगेक्स विफल रहता है 0।

— मार्टिन एंडर
स्रोत

4

पायथन 2 , 82 79 78 बाइट्स

f=lambda n,d=10:n<d or d/n<all((n/d+n%d)%k*f(n,10*d)for k in range(2,n/d+n%d))

यह धीमा है और केवल संस्मरण के साथ परीक्षण के मामलों का सामना कर सकता है।

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

वैकल्पिक संस्करण, 79 बाइट्स

f=lambda n,d=10:n<d or f(n,10*d)>d/n<all((n/d+n%d)%k for k in range(2,n/d+n%d))

एक बाइट की कीमत पर खर्च किया गया।

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

— डेनिस
स्रोत

3

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

DJ⁵*⁸dṖS€ÆPẠ

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

सभी परीक्षण मामलों की जाँच करें।

— लीक नन
स्रोत

चतुर का उपयोग d!

— आउटगोल्फर

@EriktheOutgolfer यह तीसरा विकल्प है, जिसकी मैंने कोशिश की, "सभी विभाजन के बाद -> लंबाई 2 के लिए फ़िल्टर" और "J, असत्य, विभाजन प्रत्येक"

— लीक नून

3

जावा 8, 175 171 94 88 बाइट्स

n->{long d=10,r=0,i,t;for(;d<=n;d*=10,r|=t-i)for(t=n/d+n%d,i=1;t%++i%t>0;);return r==0;}

-77 एक अंकगणित (साथ स्ट्रिंग के बजाय ) का उपयोग करके और पूर्णांक एक प्रमुख है अगर जाँच करने के लिए अलग विधि से छुटकारा पाकर @PeterTaylor के लिए धन्यवाद .substring।
-6 बाइट्स @SaraJ की प्राइम-चेकिंग विधि का उपयोग करते हुए , इसलिए उसे अपवोट करना सुनिश्चित करें!

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

स्पष्टीकरण:

n->{                  // Method with long as both parameter and return-type
  long d=10,r=0,i,t;  //  Some temp longs
  for(;d<=n           //  Loop as long as `d` is below or equal to input `n`
                      //  (inclusive instead of exclusive due to special case 10)
      ;               //    After every iteration:
       d*=10,         //     Multiple `d` by 10
       r|=t-i)        //     and Bitwise-OR `r` with `t-i`
    for(t=n/d+n%d,    //   Set `t` to `n` integer-divided by `d` plus `n` modulo-`d`
        i=1;          //   Set `i` to 1
        t%++i%t>0;);  //   Inner oop as long as `t` modulo `i+1` modulo `t` is not 0 yet
                      //   (after we've first increased `i` by 1 with `++i`)
                      //   (if `t` equals `i` afterwards, it means `t` is a prime)
  return r==0;}       //  Return if `r` is still 0

— केविन क्रूज़सेन
स्रोत

1

मुझे लगता है कि इसे छोटा करने के लिए कम से कम दो तरीके हैं: सबसे पहले, लूप pको पुनरावृत्ति के साथ बदलें ; दूसरे, परिणाम को ऐसे संचित करें कि मुख्य फ़ंक्शन को केवल एक returnस्टेटमेंट की आवश्यकता हो जिससे सेंटिनल वैल्यू pहो -1और &जो सभी लौटाए गए मानों की जांच कर रहे हों -1।

— पीटर टेलर

1

असल में, एक बड़ा है: तार का उपयोग न करें।

— पीटर टेलर

n->{for(long d=10,m=1;d<n;d*=10)m|=p(n/d+n%d,2)-2;return m>0;}long p(long n,int i){return i<n?p(n%i<1?1:n,i+1):n;}

— पीटर टेलर

@PeterTaylor सुझाव के लिए धन्यवाद! अंत में अपने सुझाए गए कार्य के लिए, क्या आप सुनिश्चित हैं कि यह सही है? मैं वर्तमान में गलत परिणाम देता हूं , जब तक कि मैं कुछ गलत नहीं कर रहा हूं।

— केविन क्रूज़सेन

1

ठीक है, d<=nसंभाल करने के लिए 10। स्टैक ओवरफ्लो एक समस्या नहीं है (कल्पना इनपुट की एक सीमा नहीं देती है जिसे संभाला जाना चाहिए), लेकिन तय किया जा सकता है और अधिक बचत एक लूप और इनलाइनिंग द्वारा प्राप्त की जा सकती है ।

— पीटर टेलर

2

अजगर , 14 बाइट्स

.AmP_ssMcQ]dtU

इसे ऑनलाइन आज़माएं! यह प्रदर्शित करेगा Trueकि संख्या कितनी है या Falseनहीं। एक स्ट्रिंग के रूप में संख्या लेता है।

स्पष्टीकरण

.AmP_ssMcQ]dtU

              Q    # Implicit input Q
            tU     # Generate the range [1, 2, ..., len(Q)-1]
  m                # For each index d in the above range...
        cQ]d       # Split Q at index d
      sM           # Convert the two parts to integers
     s             # Sum
   P_              # Check it is a prime
.A                 # ...end for. Check all elements are True

— जिम
स्रोत

2

पायथन 2 , 104 102 98 96 103 बाइट्स

2 बाइट्स के लिए @Wheat विज़ार्ड के लिए धन्यवाद: iपूरी तरह से अनाम बनाया गया क्योंकि यह केवल एक बार कहा जाता है।
4 बाइट्स के लिए @Hyperneutrino को धन्यवाद: स्लाइसिंग के बजाय मुख्य संख्या से संख्या प्राप्त करने का स्मार्ट तरीका
@Hyperneutrino ने एक और 2 बाइट्स बचाए: x-1सिर्फ xप्राइम चेकिंग रार्ज के लिए।
मामले के लिए निश्चित विफलता x=10, इस प्रकार 7 बाइट्स जोड़ने के लिए, @Dennis और @Wheat विज़ार्ड को इसे स्पॉट करने के लिए धन्यवाद: मेरे पहले संस्करण को एक प्रमुख माना गया था

lambda x:all((lambda x:x>1and all(x%j for j in range(2,x)))(x/10**j+x%10**j)for j in range(1,len(`x`)))

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

— officialaimm
स्रोत

1

98 बाइट्स

— हाइपरनेत्रिनो

कूल, थैंक्स @HyperNeutrino

— आधिकारिक

1

96 बाइट्स : आपको x-1सीमा के अंत में ज़रूरत नहीं है ; रेंज दाईं ओर अनन्य है।

— हाइपरनेत्रिनो

1

यह 10 (नए परीक्षण मामले) के लिए विफल रहता है ।

— डेनिस

1

यह 10 के लिए विफल रहता है। मेरा यह भी मानना है कि 10 एकमात्र संख्या है जिसके लिए यह विफल रहता है।

— गेहूं जादूगर

2

जाप , 24 16 बाइट्स

यह @Shaggy, @ETHproduction और खुद के बीच बहुत सहयोग था।

¬£[YîU UtY]xÃÅej

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

एक स्ट्रिंग के रूप में इनपुट लेता है।

— ओलिवर
स्रोत

गाह! वैकल्पिक समाधान के समान लगभग मैं जिस पर काम कर रहा था! यहां 22 बाइट्स हैं जो मैंने अब तक नीचे कर दी थीं। संपादित करें: दोनों से सामान मिलाकर इसे 20 बाइट्स तक नीचे लाएं ।

— झबरा

@ शगुन काफी मज़ेदार है, मैं अभी अपने एडिट पर काम कर रहा हूँ ... यह चौंकाने वाला आपके जैसा है: ethproductions.github.io/japt/…

— ओलिवर

संकेत: xस्वचालित रूप से संख्याओं में आइटमों को धर्मान्तरित करता है ;-)

— ETHproductions

हाँ, यह वह जगह है जहाँ मैं भी जाना होगा, @ मूल्य: 16 बाइट्स ।

— शैगी

इसके अलावा, XîUप्रतिभाशाली है। मुझे लगता U¯Xहै कि एक ही लंबाई के लिए काम करता है, लेकिन अभी भी

— ETHproductions

2

पिप , 25 24 बाइट्स

$&0N_%,_=1M$+(a^@_)M1,#a

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

व्याख्या

aपहला कमांड-लाइन तर्क है। 1,#aके 1माध्यम से संख्या युक्त रेंज उत्पन्न करता है len(a)-1। इसके लिए, हम एक लंबो फ़ंक्शन को मैप करते हैं:

$+(a^@_)
   a^@_   Split a at this index
$+(    )  Fold the resulting 2-element list on +

अगला, हम एक और लंबो फंक्शन को मैप करते हैं 0N_%,_=1, जो कि प्राइमलिटी के लिए टेस्ट करता है। मैंने इसे इस उत्तर से लिया ; आप वहां स्पष्टीकरण पढ़ सकते हैं। अंत में, हम सूची को तार्किक और ( $&) पर मोड़ते हैं । नतीजा यह है कि 1यदि सभी योग मुख्य थे, 0यदि उनमें से कोई भी नहीं था।

उदाहरण, इनपुट के साथ 4063:

                    1,#a   [1; 2; 3]
           $+(a^@_)M       [67; 103; 409]
  0N_%,_=1M                [1; 1; 1]
$&                         1

— DLosc
स्रोत

2

सीजेएम , 22 बाइट्स

r:L,({)_L<i\L>i+mp!},!

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

सत्य के लिए सकारात्मक पूर्णांक प्रिंट करता है, मिथ्या के लिए शून्य।

-1 पीटर टेलर द्वारा एक चतुर चाल के लिए धन्यवाद ।
-3 पीटर टेलर द्वारा एक और टिप के लिए धन्यवाद।

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

0&!से छोटा है1+:*

— पीटर टेलर

@PeterTaylor ऊह है कि चालाक है ... आप इस तथ्य का दुरुपयोग किया है कि !नकली मूल्य के साथ एक बूलियन और इस्तेमाल किया सेट-चौराहे0 ताकि आप 0&!3 के बजाय कर सकें 1&!!...

— आउटगॉल्फ

आप एक चर को इनपुट असाइन करके एक और 3 बाइट्स बचा सकते हैं, जो स्टैक जोड़तोड़ को सरल करता है, और ,इसके बजाय फ़िल्टर ऑपरेटर का उपयोग कर रहा है f।

— पीटर टेलर

PS मुझे !बूलियन में कनवर्ट करने के लिए कोई दुरुपयोग नहीं दिखता है : जो कि गोल्फस्क्रिप्ट में मानक था और सीजाम में मानक है। और 1&!!गलत होगा: 0&!स्पष्ट परीक्षण है क्योंकि आवश्यकता का उल्लेख है, मौजूद नहीं है।

— पीटर टेलर

@PeterTaylor यह मेरा मतलब नहीं है ...: पी

— आउटगॉल्फ

2

जाप , 23 बाइट्स

एक स्ट्रिंग के रूप में इनपुट लेता है।

धत तेरे की; एक बहुत छोटे विकल्प पर पंच करने के लिए पीटा गया, जिस पर मैं काम कर रहा था।

¬£i+YÃÅe@OxXr"%+0+"'+)j

झसे आज़माओ

— झबरा
स्रोत

@ETHproductions, नहीं, आप सही थे; मूल संस्करण गलत था; केवल उदार के लिए जाँच का अभाज्य ।¬£i+YÄÃe@OxX j

— झबरा

मुझे पता था कि मैंने अपना दिमाग नहीं खोया है; पी

— ETHproductions

1

पर विफल 4063(सच होना चाहिए, गलत है)। यहाँ चाल यह है कि जेएस सोचता है कि 0आप एक प्रमुख साधन चाहते हैं जिसे आप चाहते हैं ...

— ETHproductions

हम्म ... ठीक है, मुझे लगता है कि मेरे पास एक विकल्प है - इसे परीक्षण करने और इसे गोल्फ करने में कुछ मिनट लगेंगे।

— झबरा

मुझे लगता है कि यह अब किसी ऐसे मामले पर विफल हो जाएगा जिसमें दो 0 होते हैं, जिसके बाद दो अन्य अंक होते हैं ... ( 40043उदाहरण के लिए) बस इसे ठीक करने +के 0लिए बाद में जोड़ें ।

— ETHproductions

2

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

And@@Table[PrimeQ@ToExpression@StringInsert[#,"+",n],{n,2,StringLength@#}]&

Functionजो उम्मीद करता है String।PrimeQ@ToExpression@StringInsert[#,"+",n]वें अंक के +बाद डालने पर रिटर्न nएक प्रमुख संख्या देता है। Table[...,{n,2,StringLength@#}]के रूप में इन मानों की सूची देता है nसे लेकर 2स्ट्रिंग की लंबाई करने के लिए। हम फिर Andउस सूची के प्रत्येक तत्व को लेते हैं। आसानी से, यदि StringLength@#<2, तो Table[...]खाली सूची है, जिसके लिएAnd@@{}==True

— ngenisis
स्रोत

2

गणितज्ञ, ५५ 50 45 49 50 54 62 बाइट्स

ऐसा लगता है कि मुझे इसे अलग से पोस्ट करना चाहिए।

+6 बाइट्स कोड लंबाई के लिए फिर से बनाया गया।

+5 बाइट्स ngenisis के लिए धन्यवाद।

And@@(qPrimeQ[#~Mod~q+⌊#/q⌋])@Rest@PowerRange@#&

एक पूर्णांक के रूप में इनपुट लेता है और नियमित रूप से लौटता है Trueऔर False। के बीच 0xF4A1 यूनिकोड, के लिए कम है Function[,]। कोड की लंबाई फ़ाइल के आकार (यूटीएफ -8 बिना बीओएम) पर मापा जाता है, टिप्पणी करें कि क्या यह सही नहीं है।

PowerRange[x]1, 10, 100 रिटर्न ... इससे अधिक नहीं x, जो कि गणितज्ञ 10 में पेश किया गया है।

— कीउ गण
स्रोत

2

सादा अंग्रेजी 4,204 341 315 251 241 240 बाइट्स

(पुनः-) ने प्लेन इंग्लिश के पुस्तकालय में 3,863 बाइट को स्थानांतरित करके, प्लेन इंग्लिश के पुस्तकालय में परीक्षण को शामिल किया। सफेद स्थान के 26 बाइट हटाए गए। स्थानीय चर को संक्षिप्त करके 64 बाइट्स सहेजे गए। इंटरफ़ेस को संक्षिप्त करके 10 बाइट्स सहेजे गए। प्रति RosLuP के सुझाव, बदल रहा है कैसे मीटर प्रारंभ और वृद्धि की जाती है द्वारा 1 बाइट बचा लिया।

To decide if a n number is g:
Put 1 in a m number.
Loop.
Multiply the m by 10.
If the m is greater than the n, say yes.
Divide the n by the m giving a q quotient and a r remainder.
Add the q to the r.
If the r is not prime, say no.
Repeat.

अंतिम कोड का अधूरा संस्करण:

To decide if a number is magnanimous:
  Put 1 in another number.
  Loop.
    Multiply the other number by 10.
    If the other number is greater than the number, say yes.
    Divide the number by the other number giving a quotient and a remainder.
    Add the quotient to the remainder.
    If the remainder is not prime, say no.
  Repeat.

नोट: सादा अंग्रेजी IDE github.com/Folds/english पर उपलब्ध है । IDE विंडोज पर चलता है। यह 32-बिट x86 कोड को संकलित करता है।

Osmosian आदेश सादा अंग्रेजी के की गतिशील कांटा पहले से ही संस्करण 4700 में परीक्षण primality था, लेकिन यह एक बहुत अक्षम एल्गोरिथ्म (जून 2017 के माध्यम से जनवरी के रूप में) का इस्तेमाल किया। GitHub साइट के डायनामिक फोर्क के 4001-4011 वर्जन के कारण प्राइमलिटी टेस्टिंग छोड़ी गई। GitHub साइट के डायनामिक फोर्क के संस्करण 4013 में प्राइमलिटी टेस्टिंग शामिल है। इस उत्तर के पिछले संशोधनों के हिस्से के रूप में मौलिकता परीक्षण करने के लिए कोड विकसित किया गया था।

— जैस्पर
स्रोत

1

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

{?(10,10* *...^*>$_).map({$_ div$^a+$_%$^a}).all.is-prime}

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

10, 10 * * ...^ * > $_इनपुट पैरामीटर से अधिक होने वाले तत्व से पहले एक तक दस के गुणक का ज्यामितीय अनुक्रम है $_। तब हम सिर्फ यह जाँचते हैं कि प्रत्येक दस की शक्ति के लिए, इनपुट पैरामीटर का योग div और mod है कि शक्ति अभाज्य है।

— शॉन
स्रोत

1

हास्केल, 114 110 बाइट्स

p x=[x]==[i|i<-[2..x],x`mod`i<1]
i!x|i<1=0<1|0<1=p(uncurry(+)$divMod x$10^i)&&(i-1)!x
f x=(length(show x)-1)!x

स्पष्टीकरण के साथ अपुष्ट:

-- Check if x is a prime number
p x = [x] == [i | i<-[2..x], x`mod`i < 1]
-- Checks all pairs of numbers a '+' can be put in between
i ! x | i<1 = 0<1                                -- Single-digit numbers are always truthy
      | 0<1 = p (uncurry (+) $ divMod x $ 10^i)  -- Does x split at i digits from right sum up to a prime?
           && (i-1) ! x                          -- If so, check next pair
-- Start (!) with the number of digits in x minus one
f x = (length (show x)-1) ! x

— सिराकुसा
स्रोत

यदि आप p x=[x]==[i|i<-[2..x],x`mod`i<1]अपने मुख्य चेक के रूप में उपयोग करते हैं तो आप 2 बाइट बचा सकते हैं।

— गेहूं जादूगर

आप divMod x$10^iइसके बजायx`divMod`(10^i)

— व्हीट विजार्ड

@WheatWizard: मुझे पता था कि प्राइम टेस्ट में अभी भी किसी तरह सुधार किया जा सकता है। ;) धन्यवाद!

— सिरकासु जु

1

Axiom, 88 बाइट्स

f(n:PI):Boolean==(i:=10;repeat(q:=n quo i;q=0 or ~prime?(q+n rem i)=>break;i:=i*10);q=0)

परीक्षण और परिणाम

(10) -> [[i,f(i)]  for i in [1,2,4,10,98,101,109,819,4063,40427,2000221,999999999999999999999999999999999999999999999]]
   (10)
   [[1,true], [2,true], [4,true], [10,false], [98,true], [101,true],
    [109,false], [819,false], [4063,true], [40427,true], [2000221,true],
    [999999999999999999999999999999999999999999999 ,false]]

— RosLuP
स्रोत

1

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

{~cĊℕᵐ+}ᶠṗᵐ

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

{      }ᶠ      Find every
      +        sum of
   Ċ           two
    ℕᵐ         whole numbers
 ~c            which concatenate to the input,
          ᵐ    and assert that all of them
         ṗ     are prime.

— असंबंधित स्ट्रिंग
स्रोत

1

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

{m:ex/^(.+)(.+)$/.all.sum.is-prime}

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

स्पष्टीकरण:

{                                 }     # Anonymous code block that
 m:ex/^        $/                         # Match all
       (.+)(.+)                           # Splits of the input number
                 .all                     # Are all of them
                     .sum                   # When summed
                         .is-prime          # Prime?

— मजाक कर रहा है
स्रोत

0

स्टैक किया गया , 51 बाइट्स

[tostr:#'1-~>splitat tr['+',' '#`#~prime]map 1,all]

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

यह एक फंक्शन है। यह अपने तर्क को एक स्ट्रिंग ( tostr) में परिवर्तित करके , इसे डुप्लिकेट करके और इसकी लंबाई प्राप्त करने के द्वारा काम करता है :#', 1 को घटाता है ( 1-), 1 से उस संख्या तक एक सीमा बनाता है ( ~>)। इनपुट के लिए स्टैक कुछ इस तरह दिखता है 40427:

('40427' (1 2 3 4))

हम वेक्टराइज्ड प्रदर्शन करते हैं splitat, जिसके परिणामस्वरूप स्टैक के शीर्ष पर निम्न सरणी होती है:

(('4' '40' '404' '4042') ('0427' '427' '27' '7'))

इसके साथ ट्रांज़ोज़ करना tr, हमें मिलता है:

(('4' '0427') ('40' '427') ('404' '27') ('4042' '7'))

फिर, हम फंक्शन को मैप करते हैं ['+',' '## ~ (withPrime ] map`)। यह कार्य करता है:

['+',' '#`#~prime]
 '+',                concatenate a plus sign (string)    `('4' '0427' '+')
     ' '#`           join by spaces                      `'4 0427 +'`
          #~         evaluate                            `431`
            prime    check primality                     `1`

फिर, नक्शे के बाद, हम संक्षिप्त करते हैं 1। यह खाली सूची के लिए allरिटर्न है undef।

— कोनोर ओ ब्रायन
स्रोत

0

जावास्क्रिप्ट (ईएस 6), 70 बाइट्स

P=(n,x=2)=>n%x?P(n,x+1):n==x
f=(n,i=10)=>i>n||P((n/i|0)+n%i)&f(n,i*10)

गणना करते समय "बहुत अधिक पुनरावृत्ति" त्रुटि के कारण मेरे ब्राउज़र में अंतिम मामले में विफल रहता है P(200023)। उम्मीद है कि यह इसे अमान्य नहीं करता।

— ETHproductions
स्रोत

0

क्यूबिक , 38 बाइट्स

_L;|[a-1|q=q*µ!_sA,b|!+!_sA,b+1,a|!}?q

व्याख्या

_L |     Create a variable a and set it to the length of
  ;      the input string (A$)
[a-1|    FOR b = 1 to a-1
q=q*     multiply q by
 µ       -1 if prime, 0 if not, of
  !        a cast of 
   _s       a substring of
     A,       A$
     b        from index 1 to index b (only one index is given, so that is assumed to be the req. length from 1)
      |!   to number
 +         plus
 !         a cast of
  _s         a substring of
    A,         A$
    b+1        from index b+1
    ,a         for the length of a (does not error if it exceeds the end of the string)
      |!   to number
 }       NEXT 
 ?q      PRINT q, which is eitrher -1 or 1 for all-prime sums, or 0 otherwise

— steenbergh
स्रोत

0

CJam (21 बाइट्स)

r:R,({RiA@)#md+mp!},!

ऑनलाइन डेमो , ऑनलाइन टेस्ट सूट

विच्छेदन

r:R       e# Take a token of input and assign it to R
,(        e# Take the length of R minus one
{         e# Filter i = 0 to (length of R minus two)
  Ri      e#   Push R as an integer value
  A@)#    e#   Push 10 to the power of (i + 1)
  md      e#   divmod
  +mp!    e#   Add, primality test, negate result
},        e# The result of the filter is a list of splits which give a non-prime
!         e# Negate result, giving 0 for false and 1 for true

— पीटर टेलर
स्रोत

0

अजगर, 15 14 बाइट्स

.AmP_svcz]dtUz

परीक्षण सूट

पायथ के नवीनतम परिवर्तन का उपयोग करके एक बाइट को बचाया।

— isaacg
स्रोत

0

एपीएल (एनएआरएस), चार्ट्स 35, बाइट्स 70

{0≥k←¯1+≢⍕⍵:1⋄∧/0π(m∣⍵)+⌊⍵÷m←10*⍳k}

परीक्षा:

  f←{0≥k←¯1+≢⍕⍵:1⋄∧/0π(m∣⍵)+⌊⍵÷m←10*⍳k}
  f¨1 2 4 10 98 101 109 819 4063 40427 2000221
1 1 1 0 1 1 0 0 1 1 1

यह एआईएलओएम पोस्ट एलगो से एपीएल में अनुवाद होगा ...

{0≥k←¯1+≢⍕⍵:1⋄∧/0π(m∣⍵)+⌊⍵÷m←10*⍳k}
 0≥k←¯1+≢⍕⍵:1⋄  assign to k the length as array of argument return 1 if that is <=0
 ∧/0π(m∣⍵)+⌊⍵÷m←10*⍳k
              m←10*⍳k  m is the array pow(10,1..k)
           ⌊⍵÷m       the array of quotient of argumet with m
          +           sum 
     (m∣⍵)            with array of remander
   0π                 build the binary array of "are prime each"
 ∧/                   and that array

— RosLuP
स्रोत

0

PHP, 100 बाइट्स

for(;++$k<strlen($a=$argn);$x+=$i==1)for($i=$n=substr($a,$k)+$b.=$a[$k-1];--$i&&$n%$i;);echo$x+2>$k;

1यदि इनपुट विशाल है, तो रिक्त आउटपुट यदि नहीं है तो प्रिंट करता है। ऑनलाइन के साथ पाइप के रूप में चलाएं -nRया इसे आज़माएं ।

— टाइटस
स्रोत

0

पर्ल 5 `-p` , 42 बाइट्स

$\=1;s//map$\&&=($`+$')%$_,2..$`+$'-1/ge}{

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

— Xcali
स्रोत

अघोर संख्या

उत्पादन

स्कोरिंग

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

05AB1E , 10 बाइट्स

कोड

व्याख्या

सी (जीसीसी) , 8384 85 83 84 86 75 111 बाइट्स

रेटिना , 38 बाइट्स

व्याख्या

पायथन 2 , 82 79 78 बाइट्स

वैकल्पिक संस्करण, 79 बाइट्स

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

जावा 8, 175 171 94 88 बाइट्स

अजगर , 14 बाइट्स

पायथन 2 , 104 102 98 96 103 बाइट्स

जाप , 24 16 बाइट्स

पिप , 25 24 बाइट्स

व्याख्या

सीजेएम , 22 बाइट्स

जाप , 23 बाइट्स

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

गणितज्ञ, ५५ 50 45 49 50 54 62 बाइट्स

सादा अंग्रेजी 4,204 341 315 251 241 240 बाइट्स

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

हास्केल, 114 110 बाइट्स

Axiom, 88 बाइट्स

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

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

स्पष्टीकरण:

स्टैक किया गया , 51 बाइट्स

जावास्क्रिप्ट (ईएस 6), 70 बाइट्स

क्यूबिक , 38 बाइट्स

व्याख्या

CJam (21 बाइट्स)

विच्छेदन

अजगर, 15 14 बाइट्स

एपीएल (एनएआरएस), चार्ट्स 35, बाइट्स 70

PHP, 100 बाइट्स

पर्ल 5 -p , 42 बाइट्स

पर्ल 5 `-p` , 42 बाइट्स