Viết chương trình nhắc người dùng cho số nguyên chẵn lớn hơn 2.

Theo phỏng đoán của Goldbach rằng mọi số nguyên chẵn lớn hơn 2 có thể được biểu diễn dưới dạng tổng của hai số nguyên tố, in ra hai số nguyên tố, khi được cộng lại với nhau, cung cấp số chẵn được yêu cầu. Chỉnh sửa: chương trình chỉ phải in A PAIR của các số nguyên tố, không phải tất cả. Ví dụ:

4: 2 + 2

6: 3 + 3

8: 3 + 5

10: 5 + 5 hoặc 3 + 7

APL, 34 hoặc 44 byte

Phiên bản đầu tiên dài 34 ký hiệu và được giới hạn ở các ký tự từ bộ ký tự APL byte đơn gốc, chẳng hạn như ký tự vẫn được hỗ trợ trong Dyalog APL:

↑c/⍨n=+/¨c←,∘.,⍨v/⍨~v∊v∘.×v←1↓⍳n←⎕

Giải trình:

                               n←⎕   ⍝ ask for a number, store as n
                          v←1↓⍳n     ⍝ generate all integers from 2 to n
                      v∘.×v          ⍝ compute the product table of any two such integers
                v/⍨~v∊               ⍝ select those that don't appear in the product table 
         c←,∘.,⍨                     ⍝ generate all possible pairs of these primes
    n=+/¨c                           ⍝ check which pairs have a sum equal to n
↑c/⍨                                 ⍝ take the first that does

Phiên bản thứ hai chỉ dài 22 ký hiệu, vì nó khai thác πchức năng để kiểm tra các số nguyên tố, nhưng chỉ có trong NARS2000 sử dụng Unicode, vì vậy số byte là 44 trong UCS-2:

2⍴(⌿⍨{∧/0π⍵})(⍪,⌽)⍳⎕-1

Giải trình:

                   ⎕    ⍝ ask for a number N
                  ⍳ -1  ⍝ generate all naturals from 1 to N-1
             (⍪,⌽)      ⍝ arrange it into a table of all pairs of naturals with sum N
     {∧/0π⍵}            ⍝ check which pairs are made of all primes
2⍴(⌿⍨       )           ⍝ return the first pair that does

Ví dụ

(: Là lời nhắc xin số)

      2⍴(⌿⍨{∧/0π⍵})(⍪,⌽)⍳⎕-1
⎕:
      4
2 2
      2⍴(⌿⍨{∧/0π⍵})(⍪,⌽)⍳⎕-1
⎕:
      6
3 3
      2⍴(⌿⍨{∧/0π⍵})(⍪,⌽)⍳⎕-1
⎕:
      8
3 5
      2⍴(⌿⍨{∧/0π⍵})(⍪,⌽)⍳⎕-1
⎕:
      124
11 113

Python 2, 75 71 byte

n=input();k=m=1;p={0}
while{n-k,k}-p:m*=k*k;k+=1;p|={m%k*k}
print n-k,k

Kiểm tra nó trên Ideone .

Làm thế nào nó hoạt động

Chúng tôi sử dụng một hệ quả của định lý Wilson :

Tại mọi thời điểm, biến m đều bằng bình phương của giai thừa của k - 1 ; k bắt đầu ở giá trị 1 và m ở giá trị 0! ² = 1 . Tập p sẽ bao gồm 0 và tất cả các số nguyên tố lên đến giá trị hiện tại của k .

Trong mỗi lần lặp, trước tiên chúng ta kiểm tra xem cả n - k và k có thuộc p hay không , điều này đúng khi và chỉ khi chênh lệch đã đặt của {nk, k} và p là trống. Nếu có, điều kiện là giả và vòng lặp tiếp tục.

Lưu ý rằng k> 0 và {n - k, k} sẽ thỏa mãn điều kiện cho một số giá trị dương của n - k (giả sử rằng phỏng đoán của Goldbach là đúng), do đó, 0 trong p sẽ không dẫn đến dương tính giả.

Trong vòng lặp, chúng tôi cập nhật k và m . Giá trị mới của m là m × k² = (k - 1)! ² × k² = k! ² và giá trị mới của k là k + 1 , vì vậy m = (k - 1)! ² vẫn giữ trước và sau bản cập nhật.

Sau đó, chúng tôi thực hiện thiết lập liên minh để thêm giá trị của m% k × k vào p . Theo hệ quả của định lý Wilson, điều này sẽ thêm 1 × k = k nếu k là số nguyên tố và 0 × k = 0 nếu không.

Khi vòng lặp kết thúc, chúng tôi in các giá trị cuối cùng của n - k và k , đó sẽ là các số nguyên tố với tổng n .

Ruby 2.0 (65)

require'prime'
n=gets.to_i
Prime.find{|i|p [i,n-i]if(n-i).prime?}

PHP - 73 byte

<?for(;@($n%--$$n?:$o=&$argv[1]>$$n=++$n)||${++$b}^${--$o};);echo"$b+$o";

Đầu vào được lấy làm đối số dòng lệnh.

Sử dụng mẫu:

$ php goldbach.php 7098
19+7079

GolfScript 41 33 32

~(,2>.-1%]zip{{.,2>\{\%!}+,},!}?

Chấp nhận đối số dòng lệnh, vd

echo "14" | ruby golfscript.rb goldbach.gs
-> [2 12]

Tìm tất cả các phân vùng có liên quan của số đầu vào với:

(,2>.-1%]zip  #If only zip were a one-character command!  It is so often useful.

và sau đó tìm phân vùng đầu tiên trong đó không có số nào KHÔNG phải là số nguyên tố:

{np,!}? #For each partition, filter down to elements that are not prime, and only accept if there are no such results (since [] is falsey).

trong đó khối kiểm tra tổng hợp nplà:

{.,2>\{\%!}+,}

khối này lọc xuống tất cả các số chia đều cho một số đã cho. Nếu không có số nào như vậy (vì vậy số đó là số nguyên tố), kết quả là [], đó là falsey trong GolfScript.

perl 6: 69

$/=get;for grep &is-prime,^$/ {exit say $_,$_-$/ if ($/-$_).is-prime}

R, 170 112 83 ký tự

a=scan();b=2:a;p=b[rowSums(!outer(b,b,`%%`))<2];q=p[(a-p)%in%p][1];cat(a,":",q,a-q)

Thụt lề:

a=scan() #Take user input as a numeric
b=2:a
p=b[rowSums(!outer(b,b,`%%`))<2] #Find all primes from 2 to user input
q=p[(a-p)%in%p][1] #Check which a-p also belong to p and takes the first one
cat(a,":",q,a-q)

Sử dụng:

> a=scan();b=2:a;p=b[rowSums(!outer(b,b,`%%`))<2];q=p[(a-p)%in%p][1];cat(a,":",q,a-q)
1: 72
2: 
Read 1 item
72 : 5 67 

Giải pháp cũ với 112 ký tự, cho hậu thế

a=scan();b=2:a;p=b[rowSums(!outer(b,b,`%%`))<2];w=which(outer(p,p,`+`)==a,T);cat(a,":",p[w[1,1]],p[w[1,2]])

Thụt lề:

a=scan()
b=2:a
p=b[rowSums(!outer(b,b,`%%`))<2]
w=which(outer(p,p,`+`)==a,T) #Find the index of valid combinations
cat(a,":",p[w[1,1]],p[w[1,2]]) #Prints the first valid combination

Con trăn - 107

Về cơ bản là một sự cải thiện về phần thứ hai của câu trả lời của nutria (Tôi đã chạy nó trên 2.7 nhưng tôi nghĩ nó cũng sẽ hoạt động cho 3.x)

p=lambda x:all(x%i!=0 for i in range(2,x))
n=input()
for i in range(2,n-1):
    if p(i)&p(n-i): print i,n-i

JavaScript (ES6) (Regex), 105

a=/^(xx+?)(?!(xx+)\2+$)x*(?=\1$)(?!(xx+)\3+$)/.exec("x".repeat(prompt()));alert(a[1].length+"+"+a[0].length)

Bây giờ bạn có một regex kiểm tra phỏng đoán Goldbach, yêu cầu thấp về các tính năng đặc biệt (hỗ trợ tham chiếu ngược cơ bản, nhìn về phía trước tích cực và tiêu cực).

Điều này sử dụng String.prototype.repeat(), là một phần của đề xuất phiên bản thứ 6 của EcmaScript. Hiện tại, mã này chỉ hoạt động trên Firefox.

Tôi thực sự cần một ngôn ngữ tốt hơn có lệnh ngắn gọn khi làm việc với regex ...

Scala, 286 192 172 148 ký tự

Không phải là nhanh nhất nhưng nó hoạt động. Gọi g (10) để lấy danh sách các cặp goldbach cho 10.

def g(n:Int)={def p(n:Int,f:Int=2):Boolean=f>n/2||n%f!=0&&p(n,f+1)
s"$n : "+(for(i<-2 to n/2;j=n-i if p(i)&&p(j))yield s"$i + $j").mkString(" or ")}

Chuyển đổi sang C ++ rất đơn giản.

C - 139 129 ký tự

a,b;i(x,y){return x>y?x%y?i(x,y+1):0:x>1;}main(){scanf("%i",&a);for(b=a/2;b-->1;)i(b,2)&&i(a-
b,2)&&printf("%i:%i+%i\n",a,b,a-b);}

newLISP - 169 148 ký tự

(define(p n)(=(length(factor n))1))
(define(g n)(when(even? n)(for(i 3 n 2)
(and(p i)(p(- n i))(println n {: } i { }(- n i))))))
(g(int(read-line)))

bao gồm mã để chạy nó. Kết quả quá hào phóng ...

72: 5 67
72: 11 61
72: 13 59
72: 19 53
72: 29 43
72: 31 41
72: 41 31
72: 43 29
72: 53 19
72: 59 13
72: 61 11
72: 67 5

Hiền nhân, 60

Tương tự về điểm số và cảm nhận về giải pháp của res , nhưng tôi nghĩ nó đủ khác để đăng.

i=n=input()
while not{i,n-i}<set(primes(n)):i-=1
print i,n-i

Hiền nhân , 65 62

n=input()
i=0
p=is_prime
while p(i)*p(n-i)==0:i+=1
print i,n-i

Với phần trên trong tệp goldbach.sage, thực thi nó với Sage đang chạy trong một thiết bị đầu cuối:

sage: %runfile goldbach.sage 

Cảm ơn @boothby cho p=is_primeý tưởng.

Haskell, 97C

g n=head[(a,b)|let q=p n,a<-q,b<-q,a+b==n]
p n=filter c[2..n]
c p=null[x|x<-[2..p-1],p`mod`x==0]

Giải trình:

• glà chức năng "goldbach". Gọi g ncho bạn các cặp số nguyên tố cộng lại n.
• plà một hàm tạo ra một danh sách các số nguyên tố nhỏ hơn n.
• clà hàm kiểm tra chính được sử dụng để xác định p.

Ví dụ chạy:

*Main> g 4
(2,2)
*Main> g 6
(3,3)
*Main> g 8
(3,5)
*Main> g 10
(3,7)
*Main> g 12
(5,7)
*Main> map g [4,6..100]
[(2,2),(3,3),(3,5),(3,7),(5,7),(3,11),(3,13),(5,13),(3,17),(3,19),(5,19),(3,23),(5,23),(7,23),(3,29),(3,31),(5,31),(7,31),(3,37),(5,37),(3,41),(3,43),(5,43),(3,47),(5,47),(7,47),(3,53),(5,53),(7,53),(3,59),(3,61),(5,61),(7,61),(3,67),(5,67),(3,71),(3,73),(5,73),(7,73),(3,79),(5,79),(3,83),(5,83),(7,83),(3,89),(5,89),(7,89),(19,79),(3,97)]

Toán học 56

Điều này trả về tất cả các giải pháp cho số nguyên đầu vào.

Select[Tuples[Prime@Range@PrimePi[n = Input[]], 2], Tr@# == n &]

Ví dụ: khi 1298 là đầu vào thì

{{7, 1291}, {19, 1279}, {61, 1237}, {67, 1231}, {97, 1201}, {127, 1171}, {181, 1117}, {211, 1087}, { 229, 1069}, | 757}, {547, 751}, {571, 727}, {607, 691}, {691, 607}, {727, 571}, {751, 547}, {757, 51 , {859, 439}, {877, 421}, {919, 379}, {967, 331}, {991, 307}, {1021, 277}, {1069, 229}, {1087, 211}, { 1117, 181}, {1171, 127}, {1201, 97}, {1231, 67}, {1237, 61}, {1279, 19}, {1291, 7}}

Như đã viết, nó trả về mỗi giải pháp hai lần.

Union[Sort/@ %]

{{7, 1291}, {19, 1279}, {61, 1237}, {67, 1231}, {97, 1201}, {127, 1171}, {181, 1117}, {211, 1087}, { 229, 1069}, | 757}, {547, 751}, {571, 727}, {607, 691}}

Julia, 62 Chars (85 với dấu nhắc)

julia> g(n)=collect(filter((x)->sum(x)==n,combinations(primes(n),2)))
g (generic function with 1 method)

julia> g(88)
4-element Array{Array{Int64,1},1}:
 [5,83] 
 [17,71]
 [29,59]
 [41,47]

GTB , 31

Dành cho Máy tính TI-84 của bạn

`A:.5A→B@%;A,4)4$~B+1,B-1#~B,B&

Không có số nguyên tố tích hợp.

Ví dụ chạy

?4
               2
               2
?6
               3
               3
?8
               3
               5
?10
               5
               5

JavaScript, 139 137 136

a=prompt();function b(n){for(i=2;i<n;i++)if(n%i<1)return;return 1}for(c=2,r=1;c<a&&r;c++)if(b(c)&&b(a-c))alert(a+": "+c+" + "+(a-c)),r=0

Con trăn 3 - 150 143 ký tự

Phiên bản cũ (150 ký tự):

p=lambda n:0 in[n % i for i in range(2,n)]
n=int(input())
[print('%d+%d'%(a, b))for b in range(2,n)for a in range(2,n)if not(a+b!=n or p(a) or p(b))]

Phiên bản mới (nhờ Chương trìnhFOX):

p=lambda n:0 in[n%i for i in range(2,n)]
n=int(input())
[print('%d+%d'%(a,b))for b in range(2,n)for a in range(2,n)if not((a+b!=n)|p(a)|p(b))]

Nó in mọi kết hợp, ví dụ:
4 2 + 2
10 7 + 3 5 + 5 3 + 7

q [116 ký tự]

y where all each{{2=count where 0=(x mod)each til x+1}each x}each y:{a where x=sum each a:a cross a:til x}"I"$read0 0

Không có chức năng inbuilt để tìm số nguyên tố.

Đầu vào

72

Đầu ra

5  67
11 61
13 59
19 53
29 43
31 41
41 31
43 29
53 19
59 13
61 11
67 5

Con trăn - 206

Đến bữa tiệc muộn một chút nhưng tôi đang luyện tập kỹ năng chơi gôn của mình.

Tôi thực sự đã mã hóa điều này trước khi tôi tìm thấy câu hỏi này! Vì vậy, của tôi không bao gồm lambda đẹp mà các giải pháp Python khác sử dụng.

import math
def p(n):
    if n%2==0&n>2:return False
    for i in range(3,n):
        if n%i==0:return False
    return True 
X=int(input())
for i in range(2,X):
    if p(i)&p(X-i):print i,X-i;break

J - 35 32 char

"Nhắc người dùng" là nguyên nhân của mọi golfer J. Có tất cả các nhân vật khó kiếm của tôi!

p:(n,n)#:i.&n,+/~p:i.n=:".1!:1]1

Giải thích:

• ".1!:1]1- Đọc trong một chuỗi ( 1!:1) từ đầu vào (xử lý tệp 1) và chuyển đổi nó thành một số ( ".).
• p:i.n=:- Gán số này cho biến n, rồi lấy nsố nguyên tố đầu tiên .
• +/~- Làm một bảng bổ sung, nrộng và ncao.
• i.&n, - Biến bảng thành một danh sách, sau đó tìm chỉ mục của lần xuất hiện đầu tiên của n , tồn tại nếu phỏng đoán của Goldbach là đúng.
• p:(n,n)#: - Lấy hàng và cột từ chỉ mục và lấy các số nguyên tố tương ứng.

Sử dụng:

   p:(n,n)#:i.&n,+/~p:i.n=:".1!:1]1
666
5 661
   p:(n,n)#:i.&n,+/~p:i.n=:".1!:1]1
1024
3 1021

Nếu dấu nhắc không phải là một yêu cầu, đây là một động từ 25 ký tự:

(,~p:@#:]i.~&,+/~@:p:@i.)

Jelly , 8 byte (không cạnh tranh)

_ÆRfÆR.ị

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

Làm thế nào nó hoạt động

_ÆRfÆR.ị  Main link. Argument: n (integer)

 ÆR       Prime range; yield all primes in [1, ..., n].
_         Subtract all primes from n.
   fÆR    Filter; intersect the list of differences with the prime range.
      .ị  At-index 0.5; yield the last and first element.

Julia, 50 49 byte

~=primes;n=ARGS[]|>int
(n-~n)∩~n|>extrema|>show

Hãy thử trực tuyến!

Nếu một hàm được chấp nhận, mã có thể được rút ngắn xuống còn 32 byte :

~=primes
!n=(n-~n)∩~n|>extrema

Làm thế nào nó hoạt động

~=primestạo một bí danh cho hàm số nguyên tố dựng sẵn để trả về một danh sách tất cả các số nguyên tố theo đối số của nó. n=ARGS[]|>intphân tích cú pháp đối số dòng lệnh đầu tiên khi lưu nó trong n .

Để tìm một cặp số nguyên tố phù hợp, trước tiên chúng ta tính toán phạm vi nguyên tố đã nói ở trên ~n. Sau đó, n-~nmang lại tất cả sự khác biệt của các số nguyên tố và n .

Bằng cách giao ( ∩) kết quả với phạm vi chính, chúng tôi đảm bảo rằng các số nguyên tố p còn lại sao cho n - p cũng là một số nguyên tố.

Cuối cùng, extremalấy số nguyên tố thấp nhất và cao nhất trong giao điểm, nên tổng của chúng phải là n .

SQL, 295 284

Trong postgresql:

create function c(c int) returns table (n int, m int) as $$ 
with recursive i(n) as
(select 2 union all select n+1 from i where n<c), 
p as (select * from i a where not exists 
(select * from i b where a.n!=b.n and mod(a.n,b.n)=0))
select * from p a, p b where a.n+b.n=c 
$$ language sql;

Tuy nhiên, có thể thực hiện nó trong một nửa không gian, nếu nó không dành cho những việc như "không có bên ngoài tham gia đệ quy", "không truy vấn phụ trong đệ quy" ...

Đây là đầu ra:

postgres=# select c(10);
   c   
-------
 (3,7)
 (5,5)
 (7,3)
(3 rows)

postgres=# select c(88);
   c    
---------
 (5,83)
 (17,71)
 (29,59)
 (41,47)
 (47,41)
 (59,29)
 (71,17)
 (83,5)
(8 rows)

Mẻ - 266

@echo off&setLocal enableDelayedExpansion&for /L %%a in (2,1,%1)do (set/aa=%%a-1&set c=&for /L %%b in (2,1,!a!)do set/ab=%%a%%%%b&if !b!==0 set c=1
if !c! NEQ 1 set l=!l!%%a,)&for %%c in (!l!)do for %%d in (!l!)do set/ad=%%c+%%d&if !d!==%1 set o=%%c + %%d
echo !o!

Đặt ra gọn gàng -

@echo off
setLocal enableDelayedExpansion
for /L %%a in (2,1,%1) do (
    set /a a=%%a-1
    set c=
    for /L %%b in (2,1,!a!) do (
        set /a b=%%a%%%%b
        if !b!==0 set c=1
    )
    if !c! NEQ 1 set l=!l!%%a,
)
for %%c in (!l!) do for %%d in (!l!) do (
    set /a d=%%c+%%d
    if !d!==%1 set o=%%c + %%d
)
echo !o!

Perl 5, 58 byte

57, cộng 1 cho -nE

/^(11+?)(?!(11+)\2+$)1*(?=\1$)(?!(11+)\3+$)/;say for$1,$&

Đầu vào và đầu ra là đơn nhất. Thí dụ:

$ perl -nE'/^(11+?)(?!(11+)\2+$)1*(?=\1$)(?!(11+)\3+$)/;say for$1,$&'
1111111111
111
1111111

Đầu mũ.

Oracle SQL 11.2, 202 byte

WITH v(x,y,s)AS(SELECT LEVEL,LEVEL,0 FROM DUAL CONNECT BY LEVEL<=:1 UNION ALL SELECT x,y-1,s+SIGN(MOD(x,y))FROM v WHERE y>1),p AS(SELECT x FROM v WHERE x-s=2)SELECT a.x,b.x FROM p a,p b WHERE:1=a.x+b.x;   

Không chơi gôn

WITH v(x,y,s) AS
(
  SELECT LEVEL,LEVEL,0 FROM DUAL CONNECT BY LEVEL<=:1 
  UNION ALL 
  SELECT x,y-1,s+SIGN(MOD(x,y))FROM v WHERE y>1
)
,p AS (SELECT x FROM v WHERE x-s=2)
SELECT a.x,b.x 
FROM p a,p b 
WHERE :1=a.x+b.x;   

Python 3, 107 byte

b=lambda x:all(x%y for y in range(2,x))
g=lambda x,i=2:((i,x-i)if b(i)&b(x-i)else g(x,i+1))if(i<x)else 0

b (x) là một phép thử nguyên thủy cho x và g (x) đệ quy thông qua các số để tìm hai số nguyên tố phù hợp.