编写一个程序，提示用户输入大于2的偶数整数。

考虑到哥德巴赫的猜想，每个大于2的偶数均可以表示为两个素数之和，请打印出两个素数，将它们相加即可提供所需的偶数。编辑：该程序仅需要打印素数对，而不是全部。例如：

4：2 + 2

6：3 + 3

8：3 + 5

10：5 + 5或3 + 7

APL，34或44个字节

第一个版本的长度为34个符号，并且仅限于原始单字节APL字符集的字符，例如Dyalog APL仍支持的字符集：

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

说明：

                               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

第二个版本只有22个符号长，因为它利用该π函数来检查素数，但这仅在使用Unicode的NARS2000中可用，因此UCS-2中的字节数为44：

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

说明：

                   ⎕    ⍝ 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

例子

（⎕：提示输入数字）

      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字节

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

在Ideone上进行测试。

怎么运行的

我们使用威尔逊定理的推论：

在任何时候，变量m等于k-1的阶乘的平方；ķ开始于值1和米在值0！2 = 1。集合p将由0和所有素数组成，直到k的当前值。

在每次迭代中，我们首先检查n-k和k是否都属于p，当且仅当{nk，k}与p的集合差为空时，才为true 。如果是，则条件为假，并且循环继续。

注意，K> 0，和{N - K，K}将满足一些正值的条件Ñ - K（假设哥德巴赫猜想是真实的），所以0在p不会导致误报。

在循环中，我们更新k和m。的新值米是米×K²=（K - 1）！²×K²= K²！和的新值ķ是K + 1，所以M =（K - 1）！²仍然之前和之后保持更新。

然后，我们执行集合并集以将m％k×k的值添加到p。根据威尔逊定理的推论，如果k为素数，则将相加1×k = k，否则为0×k = 0。

循环结束时，我们输出n-k和k的最后一个值，它们将是和n的素数。

Ruby 2.0（65）

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

PHP-73个字节

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

输入被当作命令行参数。

用法示例：

$ php goldbach.php 7098
19+7079

高尔夫脚本 41 33 32

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

接受命令行参数，例如

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

使用以下命令查找输入数字的所有相关分区：

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

然后找到第一个没有数字不是素数的分区：

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

其中，复合检查块np为：

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

该块过滤掉所有均分给定数字的数字。如果没有这样的数字（因此数字为质数），则结果为[]，这在GolfScript中是错误的。

Perl 6：69

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

R，170 112 83个字符

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

缩进：

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)

用法：

> 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 

后代有112个字符的旧解决方案

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]])

缩进：

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

的Python-107

基本上是对nutria答案的第二部分的改进（我在2.7上运行，但我认为它也应适用于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)

现在，您有一个正则表达式可以测试Goldbach猜想，该猜想对特殊功能（基本的后向引用支持，正向和负向提前查找）的要求较低。

这使用String.prototype.repeat()，这是EcmaScript第6版建议的一部分。目前，此代码仅适用于Firefox。

使用regex时，我真的需要一种具有简洁命令的更好的语言。

斯卡拉286 192 172 148个字符

不是最快的，但可以。调用g（10）获得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 ")}

转换为C ++很简单。

C- 139129个字符

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个字符

(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)))

包括运行它的代码。结果过于宽泛...

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

贤者，60

在评分和感觉上都与res的解决方案相似，但我认为它的区别足以发布。

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

贤者，65 62

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

有了以上文件goldbach.sage，在终端中运行Sage来执行它：

sage: %runfile goldbach.sage 

感谢@boothby的p=is_prime想法。

Haskell，97℃

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]

说明：

• g是“哥德巴赫”功能。调用g n会给您一对加在一起的素数n。
• p是产生小于的素数列表的函数n。
• c是用于定义的素数检查器功能p。

示例运行：

*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)]

Mathematica 56

这将返回输入整数的所有解决方案。

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

例如，当输入1298时…

{{7，1291}，{19，1279}，{61，1237}，{67,1231}，{97，1201}，{127，1171}，{181，1117}，{211，1087}，{ 229，1069}，{277，1021}，{307，991}，{331，967}，{379，919}，{421，877}，{439，859}，{487，811}，{541， 757}，{547、751}，{571、727}，{607、691}，{691、607}，{727、571}，{751、547}，{757、541}，{811、487} ，{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}}

如所写，它将每个解决方案返回两次。

Union[Sort/@ %]

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

朱莉娅62个字符（85个提示）

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

对于您的TI-84计算器

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

没有主要的内置。

运行示例

?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

Python 3- 150 143个字符

旧版本（150个字符）：

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))]

新版本（由于ProgramFOX）：

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))]

它打印每个组合，例如：
4 2 + 2
10 7 + 3 5 + 5 3 + 7

q [116个字符]

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

没有内置函数来查找素数。

输入值

72

输出量

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

Python-206

派对晚了一点，但是我正在练习高尔夫技能。

在发现此问题之前，我实际上已对此进行了编码！因此，我的不包括其他Python解决方案使用的漂亮的lambda。

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个字符

“提示用户”是每位J高尔夫球手的祸根。我所有来之不易的角色都走了！

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

解释：

• ".1!:1]1- 1!:1从输入（文件句柄1）中读取字符串（），并将其转换为数字（".）。
• p:i.n=:-将此数字分配给变量n，然后取第一个n素数。
• +/~-做一个加法表，n宽和n高。
• i.&n,-将表转为一个列表，然后查找第一次出现的索引，n如果Goldbach的猜想为真，则该索引存在。
• p:(n,n)#: -从索引中检索行和列，并采用相应的素数。

用法：

   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

如果不需要提示，这里有一个25个字符的动词：

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

果冻，8 字节（无竞争）

_ÆRfÆR.ị

在线尝试！或验证所有测试用例。

怎么运行的

_Æ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.

朱莉娅，50 49字节

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

在线尝试！

如果可以接受某个功能，则代码可以缩短为32个字节：

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

怎么运行的

~=primes为内置素数函数创建一个别名，该别名返回一个由其素数决定的所有素数的列表。n=ARGS[]|>int将第一个命令行参数解析为n并将其保存。

为了找到合适的素数对，我们首先使用来计算上述素数范围~n。然后，n-~n得出这些素数和n的所有差。

通过∩将结果与质数范围本身相交（），我们确保剩余质数p使得n-p也是质数。

最后，extrema求交点的最低和最高素数，因此它们的和必须为n。

SQL， 295 284

在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;

如果不是因为“在递归中没有左外连接”，“在递归中没有子查询”之类的东西，那么应该能够在一半的空间中做到这一点。

这是输出：

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)

批次-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!

整齐地摆放-

@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个字节

57，另加1 -nE

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

输入和输出均为一元。例：

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

帽子尖。

Oracle SQL 11.2，202字节

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;   

未打高尔夫球

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个字节

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）是对x的素数检验，g（x）通过数字递归找到两个适合的素数。