Escreva um programa que solicite ao usuário um número inteiro maior que 2.

Dada a conjectura de Goldbach de que todo número inteiro maior que 2 pode ser expresso como a soma de dois números primos, imprima dois números primos que, quando somados, fornecem o número par solicitado. Editar: o programa só precisa imprimir UM PAR de números primos, não todos. Por exemplo:

4: 2 + 2

6: 3 + 3

8: 3 + 5

10: 5 + 5 ou 3 + 7

APL, 34 ou 44 bytes

A primeira versão possui 34 símbolos e é restrita a caracteres dos conjuntos de caracteres APL originais de byte único, como o ainda suportado no Dyalog APL:

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

Explicação:

                               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

A segunda versão possui apenas 22 símbolos, porque explora a πfunção para verificar números primos, mas está disponível apenas no NARS2000 que usa Unicode, portanto, a contagem de bytes é 44 no UCS-2:

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

Explicação:

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

Exemplos

(⎕: é o prompt solicitando um número)

      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 em Ideone .

Como funciona

Usamos um corolário do teorema de Wilson :

Em todo momento, a variável m é igual ao quadrado do fatorial de k - 1 ; k começa no valor 1 e m no valor 0! ² = 1 . O conjunto p será composto por 0 e todos os números primos até o valor atual de k .

Em cada iteração, primeiro verifique se ambos nk e k pertencem p , o que é verdade se e somente se a diferença conjunto de {nk, k} e p está vazio. Se for, a condição é falsa e o loop continua.

Observe que k> 0 e {n - k, k} satisfarão a condição para algum valor positivo de n - k (assumindo que a conjectura de Goldbach seja verdadeira), portanto, o 0 em p não levará a falsos positivos.

No loop, atualizamos k e m . O novo valor de m é m × k² = (k - 1)! ² × k² = k! ² , e o novo valor de k é k + 1 , então m = (k - 1)! ² ainda é válido antes e depois a atualização.

Em seguida, executamos a união de conjuntos para adicionar o valor de m% k × k a p . Pelo corolário do teorema de Wilson, isso adicionará 1 × k = k se k for primo e 0 × k = 0 se não.

Quando o loop termina, imprimimos os últimos valores de n - k e k , que serão primos com a soma n .

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

A entrada é tomada como um argumento de linha de comando.

Uso da amostra:

$ php goldbach.php 7098
19+7079

GolfScript 41. 33 32.

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

Aceita argumento de linha de comando, por exemplo

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

Localiza todas as partições relevantes do número de entrada com:

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

e encontra a primeira partição onde nenhum número NÃO é primo com:

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

onde o bloco de verificação composta npé:

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

esse bloco é filtrado para todos os números que dividem igualmente um determinado número. Se não houver tais números (portanto, o número é primo), o resultado é o []que é falso no GolfScript.

perl 6: 69

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

R, 170 112 83 caracteres

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

Recuado:

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)

Uso:

> 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 

Solução antiga de 112 caracteres, para posteridade

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

Recuado:

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

Basicamente, uma melhoria na segunda parte da resposta da nutria (executei isso em 2.7, mas acho que também deve funcionar para 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)

Agora você tem um regex que testa a conjectura de Goldbach, que tem baixo requisito em recursos especiais (suporte básico de referência posterior, previsão positiva e negativa).

Isso usa String.prototype.repeat()parte da proposta da 6ª edição do EcmaScript. Atualmente, esse código funciona apenas no Firefox.

Eu realmente preciso de uma linguagem melhor que tenha comando conciso ao trabalhar com regex ...

Scala, 286 192 172 148 caracteres

Não é o mais rápido, mas funciona. Chame g (10) para obter a lista de pares goldbach para 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 ")}

A conversão para C ++ é simples.

C - 139 129 caracteres

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

novoLISP - 169 148 caracteres

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

inclui o código para executá-lo. Os resultados são excessivamente generosos ...

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

Sálvia, 60

Semelhante na pontuação e na solução da res , mas acho que é diferente o suficiente para postar.

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

Sábio , 65 62

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

Com o arquivo acima goldbach.sage, execute-o com o Sage executando em um terminal:

sage: %runfile goldbach.sage 

Obrigado a @boothby pela p=is_primeideia.

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]

Explicação:

• gé a função "goldbach". A chamada g nfornece o par de números primos que somam n.
• p é uma função que gera uma lista de números primos menor que n .
• c é a função do verificador principal usada para definir p .

Exemplo é executado:

*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

Isso retorna todas as soluções para o número inteiro de entrada.

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

Por exemplo, quando 1298 é inserido…

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

Como está escrito, ele retorna cada solução duas vezes.

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 caracteres (85 com 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

Para a sua calculadora TI-84

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

Sem embutidos principais.

Execuções de exemplo

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

Versão antiga (150 caracteres):

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

Nova versão (graças ao 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))]

Imprime todas as combinações, por exemplo:
4 2 + 2
10 7 + 3 5 + 5 3 + 7

q [116 caracteres]

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

Nenhuma função embutida para encontrar o número primo.

Entrada

72

Resultado

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

Um pouco tarde para a festa, mas estou praticando minhas habilidades no golfe.

Na verdade, eu codifiquei isso antes de encontrar essa pergunta! Portanto, o meu não inclui a linda lambda usada pelas outras soluções Python.

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 car

"Avisar o usuário" é a desgraça de todo jogador de golfe. Lá vão todos os meus personagens suados!

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

Explicado:

• ".1!:1]1- Leia uma string ( 1!:1) da entrada (identificador de arquivo 1) e converta-a em um número ( ".).
• p:i.n=:- Atribua esse número à variável ne, em seguida, pegue os primeiros nnúmeros primos.
• +/~- Faça uma mesa de adição, nlarga e nalta.
• i.&n, - Transforme a tabela em uma única lista e encontre o índice da primeira ocorrência de n , que existe se a conjectura de Goldbach for verdadeira.
• p:(n,n)#: - Recupere a linha e a coluna do índice e pegue os números primos correspondentes.

Uso:

   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

Se o prompt não fosse um requisito, aqui está um verbo de 25 caracteres:

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

Geleia , 8 bytes (não concorrente)

_ÆRfÆR.ị

Experimente online! ou verifique todos os casos de teste .

Como funciona

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

Experimente online!

Se uma função fosse aceitável, o código poderia ser reduzido para 32 bytes :

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

Como funciona

~=primescria um alias para a função de números primos internos , que retorna uma lista de todos os números primos até o argumento. n=ARGS[]|>intanalisa o primeiro argumento da linha de comandos como o salva em n .

Para encontrar um par adequado de números primos, primeiro calculamos o intervalo principal mencionado acima ~n. Então, n-~nproduz todas as diferenças desses números primos e n .

Ao cruzar ( ∩) o resultado com o próprio intervalo primo, garantimos que os primos restantes p sejam tais que n - p também seja um primo.

Finalmente, extremaobtém o primo mais baixo e o mais alto na interseção, portanto, sua soma deve ser n .

SQL, 295 284

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

No entanto, deve ser capaz de fazê-lo na metade do espaço, se não fosse por coisas como "nenhuma junção externa esquerda na recursão", "nenhuma subconsulta na recursão" ...

Aqui está a saída:

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)

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

Decididamente -

@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, mais 1 para -nE

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

Entrada e saída são unárias. Exemplo:

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

Gorro.

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;   

Sem golfe

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) é um teste de primalidade para x, eg (x) se repete através de números para encontrar dois números primos adequados.