सूची सोफी जर्मेन प्रिम्स

Question

प्रश्न

एक सोफी जर्मेन प्राइम एक प्रमुख पी है जैसे कि 2 पी + 1 प्रमुख है। उदाहरण के लिए, 11 एक सोफी जर्मेन प्राइम है क्योंकि 23 प्राइम भी है। आरोही क्रम में सोफी जर्मेन अपराधों की गणना के लिए सबसे छोटा कार्यक्रम लिखें

नियम

• सोफी जर्मेन प्रिम्स को आपके प्रोग्राम द्वारा उत्पन्न किया जाना चाहिए , न कि किसी बाहरी स्रोत से।
• आपके कार्यक्रम को 2 1-1 के तहत सभी सोफी जर्मेन की गणना करनी चाहिए
• आपको प्रत्येक विशिष्ट सोफी जर्मेन प्राइम को प्रिंट करना चाहिए जिसे आपका प्रोग्राम ढूंढता है।
• सबसे कम स्कोर वाला व्यक्ति जीतता है

स्कोरिंग

• अपने कोड के प्रति बाइट के 2 अंक
• -10 यदि आप अपने प्रोग्राम को 2 1-1 से बड़ा प्राइम दिखा सकते हैं

Comments

टिप्पणियाँ विस्तारित चर्चा के लिए नहीं हैं; इस वार्तालाप को बातचीत में स्थानांतरित कर दिया गया है ।

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

Answer 1

CJam

17 वर्णों के लिए हमें 2 ^ 32 तक पूर्ण गणना प्राप्त होती है:

G8#,{_mp*2*)mp},`

4 चार्ट से अधिक के लिए, हमें एक सीमा मिलती है, जिसमें एक एसजी प्राइम को 2 ^ 32 से अधिक शामिल करने के लिए पर्याप्त है:

G8#K_*+,{_mp*2*)mp},`

4294967681 = 2 ^ 32 + 385 <2 ^ 32 + 400 के बाद से।

बेशक, हम समान रूप से मुफ्त में सीमा का विस्तार कर सकते हैं

C9#,{_mp*2*)mp},`

Comments

इसका मतलब है कि आप इसे 17 पात्रों के लिए बोनस के बिना या 21 पात्रों के लिए बोनस के साथ जमा कर सकते हैं

— मेव मिक्स

@ user3502615, या 17 वर्णों के बोनस के साथ। हालांकि यह बहस का विषय है कि क्या एसजी प्राइम I सूची वास्तव में "मेरे कार्यक्रम द्वारा" उत्पन्न हुई थी, क्योंकि मेरे पास इसे चलाने के लिए एक शक्तिशाली कंप्यूटर नहीं है।

— पीटर टेलर

I,Iएक हस्ताक्षरित 32-बिट पूर्णांक के रूप में व्यवहार करता है , इसलिए अधिकतम मूल्य Iहै 2 ** 31 - 1।

— डेनिस

@ डेनिस, यह है कि भाषा की एक प्रलेखित संपत्ति या जावा कार्यान्वयन का कार्यान्वयन क्विक है?

— पीटर टेलर

यह प्रलेखित नहीं है, लेकिन व्यवहार जावा और ऑनलाइन दुभाषिया दोनों के लिए संगत है।

— डेनिस

Answer 2

पायथ, 19 बाइट्स * 2 - 10 = 28

ध्यान दें कि ऑनलाइन संकलक / निष्पादक आउटपुट नहीं दिखाता है क्योंकि यह एक अनंत लूप है।

K1#~K1I&!tPK!tPhyKK

व्याख्या की:

K1                      K=1
  #                     While true:
   ~K1                  K+=1
      I                 If
       &                logical AND
        !tPK            K is prime
            !tPhyK      2*K+1 is prime (y is double, h is +1)
                  K     Print K

Comments

PZएक सत्य या मिथ्या मूल्य वापस नहीं करता है। यह का मुख्य कारक है Z। प्राइम के लिए परीक्षण है !tPZ, जो यह जांचता है कि क्या प्राइम फ़ैक्टर में केवल एक कारक होता है।

— जेक्यूब

हाँ। अब यह काम कर रहा है। !tPगलतियों 0और 1प्रमुख होने के बावजूद, क्योंकि उनके प्रमुख कारक में केवल 1 कारक होता है। आराम से ठीक सभी को बदलने के लिए है Zद्वारा Kऔर आवंटित K2शुरुआत में।

— जकुबे

कुछ अन्य गोल्फ: K1इसके बजाय असाइन करें K2, और अगर और इंक्रीमेंट स्वैप करें। इस तरह से आप हटा सकते हैं )। और +1*K2जैसा है वैसा ही है hyK।

— जकुबे

आह, मैंने ट्यूटोरियल पेज पर उन लोगों के बारे में पढ़ा था। क्या यह आपके लिए pyth.herokuapp.com/?code=K2%23I%26 -tPK -tPhyKK

— ~K1&debug

ऑनलाइन कंपाइलर एक परिणाम नहीं दिखाता है, क्योंकि कार्यक्रम एक अनंत लूप में फंस गया है। और वेबसाइट कार्यक्रम समाप्त होने के बाद केवल आउटपुट दिखाती है। मैंने ऑफ़लाइन कंपाइलर का उपयोग करके कोड का परीक्षण किया है। यह काम करता हैं।

— जकुबे

Answer 3

पायथ - 2 * 16 बाइट्स - 10 = 22

पाइथ में प्राइम चेकिंग की प्रथागत पद्धति का उपयोग करता है !tPऔर इसे संख्या और इसके सुरक्षित-प्राइम दोनों के लिए लागू करता है, एक बार में दोनों की जाँच करने के लिए एक छोटी सी चाल के साथ। तक जाता है 10^10, इसलिए मैं बोनस के लिए जा रहा हूं।

f!+tPTtPhyTr2^TT

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

f          r2^TT     Filter from 2 till 10^10
 !                   Logical not to detect empty lists
  +                  List concatenation
   tP                All but the firs element of the prime factorization
    T                The filter element
   tP                All but the firs element of the prime factorization
    hyT              2n+1

1000 के तहत ऑनलाइन प्रयास करें ।

Comments

यह लगभग 40 जीबी रैम मेमोरी के साथ एक मशीन लेता है। काफी कुशल ;-)

— जैकब

मुझे नहीं लगता कि आप - 10 का दावा कर सकते हैं जब तक आप वास्तव में सफलतापूर्वक कोड नहीं चलाते हैं?

— orlp

@orlp नहीं, मैंने ओपी से पूछा और उन्होंने कहा कि सीमा को छोटा बनाना और पूरे कार्यक्रम का अनुकरण करना पर्याप्त होगा: chat.stackexchange.com/transcript/message/21585393#21585393

— माल्टीज़

Answer 4

#include<stdio.h>
#include<math.h>

int isprime(int);
int main(){
    int check,n,secondcheck;
    printf("enter how long you want to print\n");
    scanf("%d",&n);
    for(int i=2;i<n;i++){
        check = isprime(i);
        if(check==0){
        secondcheck = isprime(2*i+1);
        if(secondcheck==0){
        printf("%d\t",i);
        }
        else
        continue;
        }
    }
}
int isprime(int num){   
    int check = num,flag=0;
     num = sqrt(num);
    for(int i=2;i<=num;i++){
        if(check%i==0){
            flag=1;
            return 1;
        }
    }
    if(flag==0){
        return 0;
    }
}

Comments

कृपया अपने कार्यक्रम (स्थान को हटाकर ..etc) पर विचार करें और देखें कि आप कितनी दूर जा सकते हैं।

— मुहम्मद

Answer 5

सीजाम, 34 (2 * 22 - 10)

C9#{ImpI2*)mp&{Ip}&}fI

सभी सोफी जर्मेन के तहत प्रिंट करता है 12 ** 9, जिसमें शामिल हैं 4294967681 > 2 ** 32।

मुझे लगता है कि मेरी मशीन पर लगभग 8 घंटे लगेंगे। मैं इसे आज रात चलाऊंगा।

Answer 6

हास्केल, 2 * 54-10 = 98 132

i a=all((>0).rem a)[2..a-1]
p=[n|n<-[2..],i n,i$2*n+1]

iएक प्रमुख जाँच है। pसभी नंबरों को लेता है nजहां दोनों प्रमुख हैं nऔर 2*x+1प्राइम हैं। pएक अनंत सूची है।

संपादित करें: अगर 2*n+1प्रधान है जाँच के लिए बेहतर तरीका है।

Answer 7

जूलिया, 2 * 49 - 10 = 88

p=primes(2^33)
print(p[map(n->isprime(2n+1),p)])

, सूची प्रारूप में उन्हें प्रिंट करता है [2,3,5,11,...]। यदि वह प्रारूप, primesफ़ंक्शन का उपयोग कर रहा है, या तब तक प्रतीक्षा करता है जब तक कि प्रिंट करने के लिए सभी संगणना स्वीकार्य नहीं हो जाती है, यह उन्हें प्रति पंक्ति एक रन के रूप में प्रिंट करता है।

isprime=f
for i=1:2^33;f(i)&&f(2i+1)&&println(i)end

यह थोड़ा लंबा है, 52 वर्ण है। दोनों सभी सोफी जर्मेन की गणना करते हैं 2^33, इसलिए उन्हें 10 अंक की छूट मिलनी चाहिए।

Answer 8

पायथन 3, 124 123 बाइट्स

i=3
q=[2]
while 1:
 p=1
 for x in range(2,round(i**.5)+1):p=min(p,i%x)
 if p:
  q+=[i];s=(i-1)/2
  if s in q:print(s)
 i+=2

यह कैसे काम करता है?

i=3                                 # Start at 3
q=[2]                               # Create list with first prime (2), to be list of primes.
while 1:                            # Loop forever
 p=1                                # Set p to 1 (true)
 for x in range(2,round(i**0.5)+1): # Loop from 2 to the number's square root. x is the loop value
     p=min(p,i%x)                   # Set p to the min of itself and the modulo of
                                    # the number being tested and loop value (x).
                                    # If p is 0 at the end, a modulo was 0, so it isn't prime.
 if p:                              # Check if p is 0
  q+=[i]                            # Add the current number (we know is prime) to list of primes (q)
  s=(i-1)/2                         # Generate s, the number that you would double and add 1 to make a prime.

  if s in q:print(s)                # If (i-1)/2 is a prime (in the list), then that prime satifies
                                    # the condition 2p+1 is prime because i is 2p+1, and i is prime
 i+=2                               # Increment by 2 (no even numbers are prime, except 2)

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

---

मेरे कंप्यूटर का कहना है कि यह 2 ^ 32 से नीचे के सभी सोफी जर्मेन के 0.023283% उत्पन्न कर चुका है।

जब यह समाप्त हो जाता है, तो मैं इसे पास्टबिन पर पोस्ट करूँगा यदि पर्याप्त लाइनें हैं। आप यह जांचने के लिए उपयोग कर सकते हैं कि आप उन्हें सब कुछ मिल गया है।

Comments

.5से कम है0.5

— mbomb007

Answer 9

पर्ल, 2 * 57-10 = 104

use ntheory":all";forprimes{say if is_prime(2*$_+1)}2**33

2
3
5
11
...
8589934091
8589934271

42 सेकंड से 2 ^ 32, 1m26s से 2 ^ 33। 50% तेजी से चलेगा अगर 2*$_+1लिखा जाए 1+$_<<1लेकिन यह एक और बाइट है।

मॉड्यूल भी स्थापित करता है primes.plजिसमें सोफी-जर्मेन के लिए एक सहित कई फिल्टर हैं। तो: primes.pl --so 2**33(20 बाइट्स)

Answer 10

रूबी, 61 * 2 - 10 = 112

require'prime';Prime.each(1.0/0)do|n|p Prime.prime?(n*2+1)end

यह हमेशा के लिए 2 ** 32 तक के सभी मूल्यों का प्रिंट आउट लेगा

संपादित करें

फ्लोट को प्रतिस्थापित करने वाले कुछ बाइट्स का मुंडन :: 1.0 / 0 के लिए जानकारी

Answer 11

PARI / GP, 46 * 2 - 10 = 82

forprime(p=2,2^33,if(isprime(2*p+1),print(p)))