Schreiben Sie ein Programm, das den Benutzer auffordert, eine gerade Ganzzahl größer als 2 einzugeben.

Ausgehend von Goldbachs Vermutung, dass jede gerade Zahl größer als 2 als Summe zweier Primzahlen ausgedrückt werden kann, werden zwei Primzahlen ausgedruckt, die zusammen die angeforderte gerade Zahl ergeben. Bearbeiten: Das Programm muss nur ein Paar Primzahlen drucken, nicht alle. Beispielsweise:

4: 2 + 2

6: 3 + 3

8: 3 + 5

10: 5 + 5 oder 3 + 7

APL, 34 oder 44 Bytes

Die erste Version hat eine Länge von 34 Symbolen und ist auf Zeichen aus den ursprünglichen Einzelbyte-APL-Zeichensätzen beschränkt, wie sie in Dyalog APL noch unterstützt werden:

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

Erläuterung:

                               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

Die zweite Version ist nur 22 Zeichen lang, da sie die πFunktion zur Prüfung auf Primzahlen ausnutzt. Diese Funktion ist jedoch nur in NARS2000 verfügbar , das Unicode verwendet. Daher beträgt die Bytezahl in UCS-2 44 :

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

Erläuterung:

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

Beispiele

(⎕: ist die Eingabeaufforderung, die nach einer Nummer fragt)

      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 Bytes

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

Teste es auf Ideone .

Wie es funktioniert

Wir verwenden eine Folgerung aus dem Satz von Wilson :

Zu jeder Zeit ist die Variable m gleich dem Quadrat der Fakultät von k - 1 ; k beginnt bei Wert 1 und m bei Wert 0! ² = 1 . Die Menge p besteht aus 0 und allen Primzahlen bis zum aktuellen Wert von k .

In jeder Iteration prüfen wir zuerst, ob sowohl n - k als auch k zu p gehören. Dies gilt nur dann, wenn die eingestellte Differenz von {nk, k} und p leer ist. Ist dies der Fall, ist die Bedingung falsch und die Schleife wird fortgesetzt.

Beachten Sie, dass k> 0 und {n - k, k} die Bedingung für einen positiven Wert von n - k erfüllen (unter der Annahme, dass Goldbachs Vermutung wahr ist), sodass die 0 in p nicht zu falsch positiven Ergebnissen führt.

In der Schleife aktualisieren wir k und m . Der neue Wert von m ist m × k² = (k - 1)! ² × k² = k! ² , und der neue Wert von k ist k + 1 , so dass m = (k - 1)! ² immer noch vorher und nachher gilt das Update.

Dann führen wir eine Mengenvereinigung durch, um den Wert von m% k × k zu p zu addieren . In der Folge von Wilsons Theorem addiert sich 1 × k = k, wenn k prim ist, und 0 × k = 0, wenn nicht.

Wenn die Schleife endet, drucken wir die letzten Werte von n - k und k , die Primzahlen mit der Summe n sind .

Ruby 2.0 (65)

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

PHP - 73 Bytes

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

Die Eingabe wird als Befehlszeilenargument verwendet.

Beispielnutzung:

$ php goldbach.php 7098
19+7079

GolfScript 41 33 32

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

Akzeptiert Befehlszeilenargumente, z

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

Findet alle relevanten Partitionen der Eingabenummer mit:

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

und findet dann die erste Partition, in der keine Zahlen NICHT mit Primzahlen versehen sind:

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

wo der zusammengesetzte Prüfblock npist:

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

Dieser Block filtert nach allen Zahlen, die eine bestimmte Zahl gleichmäßig teilen. Wenn es keine solchen Zahlen gibt (die Zahl ist also eine Primzahl), lautet das Ergebnis [], was in GolfScript falsch ist.

Perl 6: 69

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

R, 170 112 83 Zeichen

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

Eingerückt:

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)

Verwendung:

> 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 

Alte Lösung mit 112 Zeichen für die Nachwelt

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

Eingerückt:

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

Grundsätzlich eine Verbesserung gegenüber dem zweiten Teil der Antwort von Nutria (ich habe dies auf 2.7 ausgeführt, aber ich denke, es sollte auch für 3.x funktionieren)

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)

Jetzt haben Sie einen regulären Ausdruck, der die Goldbach-Vermutung testet, bei der nur geringe Anforderungen an spezielle Funktionen (grundlegende Rückverweisunterstützung, positive und negative Vorausschau) gestellt werden.

Dies verwendet String.prototype.repeat(), was Teil des EcmaScript 6th Edition-Vorschlags ist. Derzeit funktioniert dieser Code nur in Firefox.

Ich brauche wirklich eine bessere Sprache, die bei der Arbeit mit Regex ein knappes Kommando hat ...

Scala, 286 192 172 148 Zeichen

Nicht das schnellste aber es funktioniert. Rufen Sie g (10) auf, um die Liste der Goldbach-Paare für 10 zu erhalten.

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 ")}

Die Konvertierung nach C ++ ist unkompliziert.

C - 139 129 Zeichen

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 Zeichen

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

Enthält den Code zum Ausführen. Die Ergebnisse sind zu großzügig ...

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

Salbei, 60

In Punktzahl und Spielgefühl ähnlich wie bei res , aber ich denke, es ist anders genug, um etwas zu posten.

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

Salbei , 65 62

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

goldbach.sageFühren Sie die obige Datei aus , während Sage in einem Terminal ausgeführt wird:

sage: %runfile goldbach.sage 

Vielen Dank an @boothby für die p=is_primeIdee.

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]

Erläuterung:

• gist die "Goldbach" -Funktion. Wenn g nSie anrufen, erhalten Sie die beiden Primzahlen, die sich summieren n.
• pist eine Funktion, die eine Liste von Primzahlen erzeugt, die kleiner sind als n.
• cist die zur Definition verwendete Prim-Checker-Funktion p.

Beispiel läuft:

*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

Dies gibt alle Lösungen für die Eingabe-Ganzzahl zurück.

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

Zum Beispiel, wenn 1298 eingegeben wird ...

{{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}}

Wie geschrieben, wird jede Lösung zweimal zurückgegeben.

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}}

Julia, 62 Zeichen (85 mit Prompt)

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

Für Ihren TI-84 Rechner

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

Keine erstklassigen Einbauten.

Beispiel läuft

?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 Zeichen

Alte Version (150 Zeichen):

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

Neue Version (dank 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))]

Es wird jede Kombination gedruckt, zum Beispiel:
4 2 + 2
10 7 + 3 5 + 5 3 + 7

q [116 Zeichen]

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

Keine eingebaute Funktion zum Finden der Primzahl.

Eingang

72

Ausgabe

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

Ein bisschen zu spät zur Party, aber ich übe meine Golffähigkeiten.

Ich habe das tatsächlich codiert, bevor ich diese Frage gefunden habe! Meine enthält also nicht das schöne Lambda, das die anderen Python-Lösungen verwenden.

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

"Prompt the user" ist der Fluch eines jeden J-Golfers. Da gehen alle meine hart verdienten Charaktere!

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

Erklärt:

• ".1!:1]1- Lesen Sie einen String ( 1!:1) aus der Eingabe (Dateizugriff 1) ein und konvertieren Sie ihn in eine Zahl ( ".).
• p:i.n=:- Weisen Sie der Variablen diese Nummer zu nund nehmen Sie dann die ersten nPrimzahlen.
• +/~- Stellen Sie einen nbreiten und nhohen Beistelltisch auf.
• i.&n,- Verwandeln Sie die Tabelle in eine einzelne Liste und suchen Sie dann den Index des ersten Auftretens von n, der existiert, wenn Goldbachs Vermutung wahr ist.
• p:(n,n)#: - Rufen Sie die Zeile und die Spalte aus dem Index ab und nehmen Sie die entsprechenden Primzahlen.

Verwendung:

   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

Wäre die Eingabeaufforderung nicht erforderlich gewesen, ist hier ein 25-stelliges Verb:

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

Gelee , 8 Bytes (nicht konkurrierend)

_ÆRfÆR.ị

Probieren Sie es online! oder überprüfen Sie alle Testfälle .

Wie es funktioniert

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

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

Probieren Sie es online!

Wenn eine Funktion akzeptabel wäre, könnte der Code auf 32 Byte verkürzt werden :

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

Wie es funktioniert

~=primesErstellt einen Alias ​​für die integrierte Primzahlenfunktion , die eine Liste aller Primzahlen bis zu ihrem Argument zurückgibt. n=ARGS[]|>intAnalysiert das erste Befehlszeilenargument, während es in n gespeichert wird .

Um ein geeignetes Primpaar zu finden, berechnen wir zunächst den oben genannten Primbereich mit ~n. Dann n-~nergeben sich alle Differenzen dieser Primzahlen und n .

Indem ∩wir ( ) das Ergebnis mit dem Primbereich selbst schneiden , stellen wir sicher, dass die verbleibenden Primzahlen p so sind, dass n - p auch eine Primzahl ist.

Nimmt schließlich extremadie niedrigste und höchste Primzahl im Schnittpunkt, so muss ihre Summe n sein .

SQL, 295 284

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

Sollte aber in der Lage sein, es in der Hälfte des Raums zu tun, wenn es keine Dinge wie "no left outer join in recursion", "no subquery in recursion" gäbe ...

Hier ist die Ausgabe:

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)

Charge - 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!

Ordentlich aufbrechen -

@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 Bytes

57 plus 1 für -nE

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

Eingabe und Ausgabe sind unär. Beispiel:

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

Hutspitze.

Oracle SQL 11.2, 202 Bytes

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;   

Nicht golfen

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 Bytes

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) ist ein Primalitätstest für x, und g (x) rekursiert durch Zahlen, um zwei passende Primzahlen zu finden.