A083569: सबसे छोटा मीटर पहले नहीं होता है जैसे कि m + n अभाज्य है

26

1-अनुक्रमित अनुक्रम को निम्नानुसार परिभाषित करें:

  • A083569(1) = 1
  • A083569(n)जहां nएक पूर्णांक से अधिक होता है 1, वहां सबसे छोटा पूर्णांक m होता है जो पहले नहीं होता है जो कि m+nएक प्रमुख संख्या है।

आपका काम अंदर लेना nऔर वापस आना है A083569(n)।

 n  A083569(n)
 1  1
 2  3
 3  2
 4  7
 5  6
 6  5
 7  4
 8  9
 9  8
10 13
11 12
12 11
13 10
14 15
15 14
16 21
17 20
18 19
19 18
20 17

और अधिक वृषण यहां पाए जा सकते हैं । OEIS पर मूल अनुक्रम यहां पाया जा सकता है ।

यह कोड-गोल्फ है । बाइट्स जीत में सबसे छोटा जवाब। मानक खामियां लागू होती हैं।

code-golf  sequence  primes 
— लीक नन
स्रोत
@ Mr.Xcoder "निम्न अनुक्रमित अनुक्रम को परिभाषित करें"
— लीक नून

जवाबों:

14

हास्केल , 87 86 83 80 74 69 बाइट्स

3 बाइट्स को सहेजने वाले कुछ परिवर्तनों के सुझाव के लिए xnor का धन्यवाद!

f n=[m|m<-[1..],all((>0).mod(n+m))[2..n+m-1],all((/=m).f)[1..n-1]]!!0

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

मैं हास्केल के लिए नया हूं, और हास्केल गोल्फिंग, प्रतिक्रिया की सराहना की गई है!

व्याख्या

हम एक फ़ंक्शन को परिभाषित करते हैं f n। हम सूची का f nपहला तत्व हैं !!0:

[m|m<-[1..],all((>0).mod(n+m))[2..n+m-1],all((/=m).f)[1..n-1]]

टूट गया है कि:

[m|          # Numbers m
m<-[1..],    # From the integers greater than 0
all          # Forall x
(>0).mod(n+m)# n+m mod x is not zero
[2..n+m-1]   # from the integers from 2 to n+m-1
all          # Forall
((/=m).f)    # when f is applied the result is not m
[1..n-1]     # from the integers from 1 to n-1
— गेहूं का जादूगर
स्रोत
3
हास्केल गोल्फ में आपका स्वागत है! [2,3..]बस हो सकता है [2..], 1 से तक की गिनती डिफ़ॉल्ट है। एक अंतर्निहित है notElem।
— xnor
@xnor धन्यवाद! मैंने उपयोग करने के आसपास एक बेहतर तरीका ढूंढना समाप्त कर दिया, notElemलेकिन पहला टिप मददगार था और मैं अपनी पीठ की जेब में उस दूसरे को रखना सुनिश्चित करूंगा।
— गेहूं जादूगर
ऐसा लगता है कि आपका नया संशोधन f 1गलत हो गया है, 1. होना चाहिए
— xnor
@xnor फिक्स्ड, दुर्भाग्य से 3 बाइट्स की कीमत पर।
— गेहूं जादूगर
6

जेली , 16 15 बाइट्स

Rɓ²R+⁸ÆPTḟḢṭµ/Ṫ

यह मान लेता है A083569 (n) 8 n the ( अनुक्रम रैखिक रूप से बढ़ता हुआ प्रतीत होता है)।

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

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

Rɓ²R+⁸ÆPTḟḢṭµ/Ṫ  Main link. Argument: n

R                Range; yield [1, ..., n].
 ɓ               Begin a dyadic chain with swapped arguments.
            µ/   Reduce the range by that chain.
                 If we call the chain f, this computes f(2,1), then f(3,f(2,1)),
                 then f(4,f(3,f(2,1)), etc.
                 The left argument is an integer k, the right one an array A.
  ²                Square; yield k².
   R               Range; yield [1, ..., k²].
    +⁸             Add k, yielding [1+k, ..., k²+k].
      ÆP           Test each sum for primality.
        T          Truth; get all indices of 1‘s. This finds all m in [1, ..., k²]
                   such that m+k is prime.
         ḟ         Filterfalse; remove all resulting elements that appear in A.
          Ḣ        Head; extract the first remaining result.
           ṭ       Tack; append the extracted integer to A.
                 This computes the first n elements of the sequence.
              Ṫ  Tail; extract the last, n-th element.
— डेनिस
स्रोत
4
वास्तव में, अपनी परिभाषा से A083569(n)अधिकांश nवें अभाज्य से बड़ा है n, जो कि अधिकांश 2nवें अभाज्य है, जो (के लिए n≥3) 4n*log(n)रोसेर-स्कोनफेल्ड के परिणामों से कम है ।
— ग्रेग मार्टिन
जबकि @GregMartin ने इसे सत्यापित किया, यह अभी भी एक बहुत ही जंगली धारणा है ...
— फलों को
4
@ चैलेंजर 5 मुझे "शिक्षित अनुमान" पसंद है।
— डेनिस
6

पायथ - 18 17 15 बाइट्स

मुझे दो बाइट्स बचाने के लिए @isaacg का शुक्रिया!

इस साइट पर वापस, थोड़ी देर के लिए व्यस्त होने के बाद, उम्मीद है कि यह एक और गोल्फ कर देगा।

esmaYf&-TYP_+Th

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

— Maltysen
स्रोत
4
PPCG में आपका स्वागत है!
— लीक नून
@LeakyNun धन्यवाद :)
— माल्टीसेन
1
-TYएक बाइट से छोटा है !/YT, और एक ही मामलों में सत्य है।
— इसाॅग
आप को बदलने के द्वारा एक और बाइट बचा सकते हैं +hdTकरने के लिए +Th।
— इसाॅग
@ लिसाक, ओह क्या यह सूची में पहला तत्व रखता है? यह वास्तव में अच्छा है।
— माल्टेन
3

सी # (.NET कोर) , 169 बाइट्स

n=>{if(n<2)return 1;var p=new int[n-1];int i=0,j,s;for(;i<n-1;)p[i]=f(++i);for(i=1;;i++){for(j=2,s=i+n;j<s&&s%j++>0;);if(j==s&!System.Array.Exists(p,e=>e==i))return i;}}

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

परिणामों की गणना करने के लिए अब तक का सबसे अक्षम वैसे, इतना की गणना करने से बचें f(n)के लिए n>=30इस कोड के साथ। पहला चरण यह है कि मानों की पुनरावृत्ति की गणना की f(1)जाए f(n-1)और फिर f(n)पहले की खोज करके गणना की जाए iजो कि n+iप्रधान है और iपिछले मान सूची में नहीं है।

— चार्ली
स्रोत
3

x86-64 विधानसभा, 57 55 बाइट्स

मैं गोल्फ के लिए नया हूं, इसलिए टिप्पणियों / प्रतिक्रिया की सराहना की जाती है।

नोट: यह मशीन कोड लंबाई के लिए अनुकूलित है, स्रोत लंबाई के लिए नहीं।

0: 89 f8 ff cf 74 32 97 89 fe 89 f1 ff c6 89 f0 99
1: f7 f1 85 d2 e0 f7 85 c9 75 ed 89 f9 ff c9 56 29
2: fe 56 57 51 89 fc e8 d3 ff ff ff 59 5f 5e 39 c6
3: e0 ef 96 5e 74 d1 c3

एक फ़ंक्शन को परिभाषित करता है, मानक कन्वेंशन (यानी ईएक्स में रिटर्न वैल्यू, ईडीआई में पहला तर्क, ईबेक्स को छोड़कर सभी रजिस्टरों को सहेजा गया) का उपयोग करके, जो एक अहस्ताक्षरित 32-बिट पूर्णांक लेता है और सबसे छोटा एम आदि लौटाता है।

स्रोत:

    .globl a083569
    // edi = original, probably don't touch
    // esi = candidate prime, if it's not a repeat we return edi-this
a083569:
    mov %edi, %eax
    dec %edi
    jz end
    xchg %eax, %edi
    mov %edi, %esi
primecheck:
    mov %esi, %ecx
    inc %esi
primeloop:
    mov %esi, %eax
    cdq
    div %ecx
    test %edx, %edx
    loopnz primeloop
/* end */
    // if esi isn't prime, then ecx is now one or greater.
    test %ecx, %ecx
    jnz primecheck
    // esi is now our target prime: check if it's not already one
    mov %edi, %ecx
    dec %ecx
    push %rsi   /* we need a flag-safe way to restore this later */
    sub %edi, %esi
chkdup:
    push %rsi
    push %rdi
    push %rcx
    mov %ecx, %edi
    call a083569
    pop %rcx
    pop %rdi
    pop %rsi
    cmp %eax, %esi
    loopne chkdup
/* end loop - chkdup */
    xchg %esi, %eax
    pop %rsi
    je primecheck
/* end outer loop - primecheck */
end:
    ret

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

— ObsequiousNewt
स्रोत
1

क्लोजर, 158 155 बाइट्स

#(loop[r[0 1]i 1](if(= i %)(last r)(recur(conj r(nth(for[j(range):when(=((set r)j)(seq(for[k(range 2(+ 1 i j)):when(=(mod(+ 1 i j)k)0)]j)))]j)0))(inc i))))

यह अभी भी कुछ मोटा हो सकता है, मैं इससे बहुत खुश नहीं हूं (+ 1 i j)लेकिन बेस केस n = 1और बाकी चीजों को संभालने का यह सबसे आसान तरीका था । ((set r)j)रिटर्न nilअगर jसेट में नहीं है, और (seq ())एक खाली सूची के रूप में अच्छी तरह से रिटर्न देता है। n = 100048 सेकंड में गणना करता है।

अपडेट: कोड nilसे =जांच को हटा दिया गया क्योंकि कोड इसके बिना भी सही ढंग से काम करता है।

— NikoNyrh
स्रोत
1

पायथन, 194 170 110 बाइट्स

लीकी नन द्वारा बचाए गए 84 बाइट्स

मैथमैनंदन द्वारा 2 बाइट्स बचाए गए

def s(n):
 a=[s(j)for j in range(1,n)];i=1
 while(i in a)|any((i+n)%j<1for j in range(2,i+n)):i+=1
 return i

एक फ़ंक्शन s (n) को परिभाषित करता है जो इनपुट के रूप में एक संख्या लेता है और A083569 (n) देता है।

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

— मैडिसन सिल्वर
स्रोत
1
आप इस TIO लिंक सहित विचार कर सकते हैं ।
— लीक से हटकर
1
आप p=lambda n:any(n%i<1for i in range(2,n))primality check के लिए उपयोग कर सकते हैं ।
— लीक नून
1
— लीकी नून
1
आप बिटवाइस का उपयोग कर सकते हैं या युगल बाइट्स को बचाने के लिए कर सकते हैं:while(i in a)|any(...
— मैथमैटैंडन
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.