গোল্ডব্যাচ পার্টিশন

18

গোল্ডবাচের অনুমানে বলা হয়েছে যে দু'জনেরও বেশি সংখ্যক দুটি সংখ্যাকে দুটি প্রধানের যোগফল হিসাবে প্রকাশ করা যেতে পারে। উদাহরণ স্বরূপ,

4 = 2 + 2
6 = 3 + 3
8 = 5 + 3

তবে, একবার আমরা 10 এ পৌঁছে গেলে আকর্ষণীয় কিছু ঘটে happens 10 হিসাবেই লেখা যায় না

5 + 5

তবে এটি হিসাবে লেখা যেতে পারে

7 + 3

যেহেতু 10 দুই মৌলিক সংখ্যার যোগফল হিসেবে প্রকাশ করা যেতে পারে দুটি উপায়ে , আমরা বলতে 10 এর "Goldbach পার্টিশন" হয় 2। বা আরও সাধারণভাবে,

একটি সংখ্যা Goldbach পার্টিশন লেখার স্বতন্ত্র উপায়ে মোট সংখ্যা n = p + qযেখানে pএবং qমৌলিক এবংp >= q

আপনার চ্যালেঞ্জটি এমন একটি প্রোগ্রাম বা ফাংশন লিখুন যা কোনও সংখ্যার গোল্ডব্যাক বিভাজন খুঁজে পায় finds এখন, প্রযুক্তিগতভাবে "গোল্ডব্যাক পার্টিশন" শব্দটি কেবলমাত্র সংখ্যার উল্লেখ করতে ব্যবহৃত হয়। যাইহোক, বিজোড় পূর্ণসংখ্যায় পি +2 করতে আরো যদি দুটি মৌলিক সংখ্যার যোগফল হিসেবে প্রকাশ করা যেতে পি> 2 মৌলিক, আমরা এই সব ধনাত্মক পূর্ণসংখ্যা (প্রসারিত হবে A061358 )।

আপনি নিরাপদে ধরে নিতে পারেন যে আপনার ইনপুটটি সর্বদা একটি ইতিবাচক পূর্ণসংখ্যার হবে এবং আপনি আমাদের কোনও ডিফল্ট অনুমোদিত পদ্ধতিতে ইনপুট এবং আউটপুট নিতে পারেন , উদাহরণস্বরূপ ফাংশন আর্গুমেন্ট এবং রিটার্ন মান, STDIN এবং STDOUT, কোনও ফাইলে পড়া এবং লেখা ইত্যাদি etc.

ধনাত্মক পূর্ণসংখ্যার 100 টি পর্যন্ত গোল্ডবাচের পার্টিশনগুলি হ'ল:

0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 0, 1, 1, 2, 1, 2, 0, 2, 1, 2, 1, 3, 0, 3, 1,
3, 0, 2, 0, 3, 1, 2, 1, 4, 0, 4, 0, 2, 1, 3, 0, 4, 1, 3, 1, 4, 0, 5, 1, 4,
0, 3, 0, 5, 1, 3, 0, 4, 0, 6, 1, 3, 1, 5, 0, 6, 0, 2, 1, 5, 0, 6, 1, 5, 1,
5, 0, 7, 0, 4, 1, 5, 0, 8, 1, 5, 0, 4, 0, 9, 1, 4, 0, 5, 0, 7, 0, 3, 1, 6

যথারীতি, স্ট্যান্ডার্ড লুফোলগুলি প্রয়োগ হয় এবং বাইটের মধ্যে সংক্ষিপ্ত উত্তর!

code-golf  math  sequence  number-theory  primes 
— ডিজেএমসিএমহেম
সূত্র
1
আপনি সর্বদা এই জাতীয় চমৎকার চ্যালেঞ্জ নিয়ে আসবেন :-)
— লুইস মেন্ডো

উত্তর:

6

জেলি , 8 বাইট

_ÆRÆPSHĊ

এটি অনলাইন চেষ্টা করুন! বা সমস্ত পরীক্ষার কেস যাচাই করুন ।

কিভাবে এটা কাজ করে

_ÆRÆPSHĊ  Main link. Argument: n (positive integer)

 ÆR       Prime range; yield [2, 3, 5, ..., n].
_         Subtract all primes in this range from n.
   ÆP     Compute the primality of the resulting differences.
          This returns 1 for each prime p such that n - p is also prime.
     S    Compute the sum of the resulting Booleans.
      H   Divide it by 2, since [p, n - p] and [n - p, p] have both been counted.
       Ċ  Ceil; round the resulting quotient up (needed if n = 2p).
— ডেনিস
সূত্র
ওহ আরও ভাল: ডি
— জোনাথন অ্যালান
5

পাইথন 2, 76 বাইট

g=lambda n,k=2:n/k/2and all(x%i for x in[k,n-k]for i in range(2,x))+g(n,k+1)

Recursively থেকে হামাগুড়ি দেয় k=2করার n/2, মান যেখানে উভয় আপ যোগ kএবং n-kমৌলিক আছে। nপরিবর্তে একই সময়ে গণনা করা ভাল হবে, তবে এটির একটি সমস্যা রয়েছে k=0এবং k=1এটি মিথ্যাভাবে প্রধান বলা হয়:

g=lambda n,k=0:n/k and all(x%i for x in[k,n]for i in range(2,x))+g(n-1,k+1)

প্রাথমিকতা পরীক্ষাটি ট্রায়াল-বিভাগ, উভয় kএবং n-kএকসাথে চেক করে সংক্ষিপ্ত করে দেওয়া । আমি এটি উইলসনের উপপাদ্য জেনারেটর (by৯ বাইট) ব্যবহারের চেয়ে কম বলে মনে করেছি:

f=lambda n,k=1,P=1,l=[]:n/k and P%k*(n-k in l+P%k*[k])+f(n,k+1,P*k*k,l+P%k*[k])

এইটির জন্য ধারণাটি হ'ল নীচের অর্ধের সমস্ত প্রাইমগুলির একটি তালিকা রাখা উচিত যখন আমরা উপরের অর্ধে পৌঁছানোর সময়টি যাচাই করা উচিত তবে মিডপয়েন্টের জন্য আমাদের কাছে পৌঁছানোর k=n/2সময় n-kতালিকার বাইরে যোগ করার সময় হয়নি when k। একটি পুনরাবৃত্ত সংস্করণ এটি প্রায় পাওয়া যায়, তবে এটি 82 বাইট:

n=input()
s=P=k=1;l=[]
while k<n:l+=P%k*[k];s+=P%k*(n-k in l);P*=k*k;k+=1
print~-s
— xnor
সূত্র
5

এমএটিএল , 8 বাইট

tZq&+=Rz

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

8উদাহরণ হিসাবে ইনপুট বিবেচনা করুন

      % Take input implicitly
t     % Duplicate
      % STACK: 8, 8
Zq    % All primes up to that number
      % STACK: 8, [2 3 5 7]
&+    % Matrix with all pairwise additions
      % STACK: 8, [4  5  7  9
                   5  6  8 10
                   7  8 10 12
                   9 10 12 14]
=     % True for entries that equal the input
      % STACK: [0 0 0 0
                0 0 1 0
                0 1 0 0
                0 0 0 0]
R     % Extract upper triangular part (including diagonal). 
      % This removes pairs that are equal up to order
      % STACK: [0 0 0 0
                0 0 1 0
                0 0 0 0
                0 0 0 0]
z     % Number of nonzero entries
      % STACK: 1
      % Display implicitly

কোডটির কিছুটা পরিবর্তিত সংস্করণ ব্যবহার করে ক্রমটির গ্রাফটি পর্যবেক্ষণ করা আকর্ষণীয় :

:"@       % Input n implicitly. For each k from 1 to n, push k
tZq&+=Rz  % Same code as above. Pushes the result for each k
]v'.'&XG  % End. Concatenate all results into a vector. Plot as dots

ইনপুট 10000জন্য ফলাফল হয়

এখানে চিত্র বর্ণনা লিখুন

আপনি এটি এমএটিএল অনলাইনে চেষ্টা করতে পারেন ( চাপলে "রান" বোতামটি "কিল" তে না বদলে পৃষ্ঠাটি রিফ্রেশ করুন)। ইনপুটটির জন্য গ্রাফ তৈরি করতে প্রায় 25 সেকেন্ড সময় লাগে 3000; কয়েক হাজারের উপরে ইনপুটগুলি শেষ হয়ে যাবে।

— লুইস মেন্ডো
সূত্র
1
সেই Upper triangular partকৌশলটি সত্যিই দুর্দান্ত!
— ডিজেএমসিএমহেম
3

জাভাস্ক্রিপ্ট (ES6), 77 73 70 বাইট

@ আরনাউল্ডকে 3 টি বাইট সংরক্ষণ করা হয়েছে

f=(n,x=n)=>--x<2||n%x&&f(n,x)
g=(a,b=a>>1)=>b>1?f(b)*f(a-b)+g(a,b-1):0

fএকটি প্রাথমিকতা-পরীক্ষা ফাংশন; সম্পর্কিত ফাংশন হয় g।

fn-1 থেকে বারবার গণনা করে কাজ করে ; প্রতিটি পর্যায়ে নিয়ন্ত্রণ প্রবাহ এভাবে চলে:

  • x<2||যদি x <2 , সংখ্যাটি প্রধান; প্রত্যাবর্তন 1 ।
  • n%x&&অন্যথায় যদি n মোড x = 0 , সংখ্যাটি প্রধান নয়; ফিরে আসতে n%x।
  • f(n,x-1)অন্যথায়, সংখ্যাটি প্রধান হতে পারে বা নাও হতে পারে; হ্রাস x এবং আবার চেষ্টা করুন।

gএতটা নিয়ন্ত্রণ প্রবাহ না থাকলেও একই ধরণের ফ্যাশনে কাজ করে। এটা তোলে গুন করে কাজ করে চ (খ) দ্বারা চ (AB) প্রতিটি পূর্ণসংখ্যা জন্য খ সীমার মধ্যে [2, তল (ক / 2)] , তারপর ফলাফল summing। এটা আমাদের যুগলের সংখ্যা দেয় যে সমষ্টি একটি যেখানে যুগল উভয় সংখ্যার মৌলিক, যা আমরা ঠিক কি চাই।

— ETHproductions
সূত্র
যেহেতু aইতিবাচক, তাই b=a>>1আপনার একটি বাইট সংরক্ষণ করা উচিত।
— আর্নল্ড
@ আরনাউল্ড ধন্যবাদ! আমার >>অপারেটরটির কথা স্মরণ করা উচিত ছিল ...
— ETH প্রোডাকশনগুলি অক্টোব
প্রাথমিকতা-পরীক্ষা ফাংশন সম্পর্কিত, আপনি কি করতে পারেন f=(n,x=n)=>--x<2||n%x&&f(n,x)?
— আর্নল্ড
@ আরনাউল্ড এটি প্রতিভা, ধন্যবাদ :)
— ইটিএইচ প্রোডাকশনস
2

05 এ বি 1 ই , 10 8 বাইট

চূড়ান্তভাবে অদক্ষ।

D!f-pO;î

এটি অনলাইন চেষ্টা করুন! অথবা প্রাইমগুলি উত্পাদনের একটি কম দক্ষ পদ্ধতি চেষ্টা করুন

ব্যাখ্যা

n = 10 উদাহরণ হিসাবে ব্যবহৃত।

D          # duplicate
           # STACK: 10, 10 
 !         # factorial
           # STACK: 10, 3628800
  f        # unique prime factors
           # STACK: 10, [2,3,5,7]
   -       # subtract
           # STACK: [8,7,5,3]
    p      # is prime
           # STACK: [0,1,1,1]
     O     # sum
           # STACK: 3
      ;    # divide by 2
           # STACK: 1.5
       î   # round up
           # STACK: 2
           # implicit output
— Emigna
সূত্র
üপরিবর্তে আপনি ব্যবহার করতে পারবেন না? পছন্দ D!fü+r¢?
— ম্যাজিক অক্টোপাস উরন
1
@ কারাসোকম্পুটিং: আমি দেখছি না এটি কীভাবে কাজ করবে। উদাহরণ হিসাবে n=10যা গণনা করা হবে (10, [5,8,12]) যা 2 এর পরিবর্তে 0 হয় üকেবলমাত্র প্রতিটি জোড়া আইটেমের মধ্যে প্রয়োগ করা হয়। এটি আমাকে চেষ্টা করার ধারণাটি দিয়েছে ã, তবে দুর্ভাগ্যক্রমে এটি 1 বাইট হয়ে গেছে।
— এমিগানা
2

জিএপি , 57 বাইট

n->Number([2..QuoInt(n,2)],k->IsPrime(k)and IsPrime(n-k))

আমি মনে করি না জিএপির এই সুস্পষ্টর চেয়ে একটি ছোট পথ আছে। Numberতালিকার কতগুলি উপাদান একটি প্রাকটিকাকে সন্তুষ্ট করে তা গণনা করে।

প্রথম 100 টি মান গণনা করতে এটি ব্যবহার করে:

gap> List([1..100],n->Number([2..QuoInt(n,2)],k->IsPrime(k)and IsPrime(n-k)));
[ 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 0, 1, 1, 2, 1, 2, 0, 2, 1, 2, 1, 3, 0, 3, 1, 
  3, 0, 2, 0, 3, 1, 2, 1, 4, 0, 4, 0, 2, 1, 3, 0, 4, 1, 3, 1, 4, 0, 5, 1, 4, 
  0, 3, 0, 5, 1, 3, 0, 4, 0, 6, 1, 3, 1, 5, 0, 6, 0, 2, 1, 5, 0, 6, 1, 5, 1, 
  5, 0, 7, 0, 4, 1, 5, 0, 8, 1, 5, 0, 4, 0, 9, 1, 4, 0, 5, 0, 7, 0, 3, 1, 6 ]
— খ্রিস্টান সিভারস
সূত্র
2

ব্র্যাচল্যাগ , 22 বাইট

:{,A:B>=.:#pa+?,.=}fl

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

সমস্যার সরাসরি প্রতিলিপি।

:{                }f       Find all valid outputs of the predicate in brackets for the Input
                    l      Output is the number of valid outputs found

  ,A:B>=.                  Output = [A, B] with A >= B
         :#pa              Both A and B must be prime numbers
             +?,           The sum of A and B is the Input
                .=         Label A and B as integers that verify those constraints
— Fatalize
সূত্র
2

গণিত, 52 বাইট

Count[IntegerPartitions[#,{2}]//PrimeQ,{True,True}]&

ফলাফল একটি বেনামি ফাংশন হিসাবে সরবরাহ করা হয়। এটির উপরে একটি গ্রাফ প্লট করার চেষ্টা করুন:

DiscretePlot[
 Count[IntegerPartitions[#, {2}] // PrimeQ, {True, True}] &[i], {i, 1,
   1000}]

অনুক্রমের প্লট

যাইহোক, কোডটির ওইআইএসে ডেমো কোডের ফাংশন সংস্করণের সমান দৈর্ঘ্য রয়েছে।

— কিউ গান
সূত্র
2
49 বাইট:PrimeQ[#~IntegerPartitions~{2}]~Count~{a=True,a}&
— লিজিয়নম্যামাল 978
1

জেলি , 12 বাইট

HRð,_@ÆPð×/S

ট্রাইটাইনলাইন 1-100 00

কিভাবে?

HRð,_@ÆPð×/S - Main link: n    e.g. 22
H            - halve
 R           - range          [1,2,3,4,5,6,7,8,9,10,11] (note this will be 1 to n//2)
  ð          - dyadic chain separation
   ,         - pair with
    _@       - n -           [[1,2,3,4,5,6,7,8,9,10,11],[21,20,19,18,17,16,15,14,13,12,11]]
      ÆP     - is prime? (1 if prime 0 if not)
                            [[0,1,1,0,1,0,1,0,0,0,1],[0,0,1,0,1,0,0,0,1,0,1]]
        ð    - dyadic chain separation
         ×/  - reduce with multiplication
                             [0,0,1,0,1,0,0,0,0,0,1]
           S - sum           3
— জোনাথন অ্যালান
সূত্র
1

219 বাইট রেকেট

(let*((pl(for/list((i n) #:when(prime? i))i))(ll(combinations(append pl pl)2))(ol'()))(for/list((i ll))(define tl(sort i >))
(when(and(= n(apply + i))(not(ormap(λ(x)(equal? x tl))ol)))(set! ol(cons tl ol))))(length ol))

Ungolfed: 

(define(f n)
 (let* ((pl                                   ; create a list of primes till n
          (for/list ((i n) #:when (prime? i))
            i))
         (ll (combinations (append pl pl) 2)) ; get a list of combinations of 2 primes
         (ol '()))                            ; initialize output list
    (for/list ((i ll))                        ; test each combination
      (define tl (sort i >))
      (when (and (= n (apply + i))            ; sum is n
                 (not(ormap (lambda(x)(equal? x tl)) ol))) ; not already in list
        (set! ol (cons tl ol))))              ; if ok, add to list
    (println ol)                              ; print list
    (length ol)))                             ; print length of list

পরীক্ষামূলক: 

(f 10)
(f 100)

আউটপুট: 

'((5 5) (7 3))
2
'((97 3) (89 11) (83 17) (71 29) (59 41) (53 47))
6
— rnso
সূত্র
0

হাস্কেল, 73 বাইট

f n|r<-[a|a<-[2..n],all((<2).gcd a)[2..a-1]]=sum[1|p<-r,q<-r,q<=p,p+q==n]

ব্যবহারের উদাহরণ: map f [1..25]-> [0,0,0,1,1,1,1,1,1,2,0,1,1,2,1,2,0,2,1,2,1,3,0,3,1]।

সংজ্ঞাটির প্রত্যক্ষ বাস্তবায়ন: প্রথমে rইনপুট নম্বর পর্যন্ত সমস্ত প্রাইমকে বেঁধে রাখুন n, তারপরে 1সকলের জন্য একটি pএবং কোথা qথেকে rযান q<=pএবং p+q==nসেগুলি যোগ করুন।

— nimi
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.