Terence Tao는 최근 약한 형태의 Goldbach의 추측을 증명했습니다! 그것을 활용하자!

홀수 정수가 주어지면 최대 5 개의 소수의 합계로 n > 1쓰십시오 n. 원하는대로 입력을 취하고 원하는대로 출력하십시오. 예를 들어

def g(o):
    for l in prime_range(o+1):
        if l == o:
            return l,
        for d in prime_range(l+1):
            for b in prime_range(d+1):
                if l+d+b == o:
                    return l,d,b
                for c in prime_range(b+1):
                    for h in prime_range(c+1):
                        if l+d+b+c+h == o:
                            return l,d,b,c,h

정수를 입력으로 사용하고 합계가 인 출력으로 정수 목록을 리턴하는 Sage 코드입니다 n. 도의 정리에 의해, 이것은 항상 종료됩니다!

입력

홀수 n. 입력 방법을 결정하지만 이상한 경우 설명하십시오.

산출

오히려 개방형입니다. 리스트를 돌려줍니다. 문자열을 인쇄하십시오. 하나 또는 몇 개 또는 전부 쓰레기를 스택 (GS, Piet 등) 또는 연속적인 (접근 가능한) 메모리 블록 (BF 등)에 예측 가능한 방식으로 배치하십시오. 이러한 경우에는 출력을 설명하십시오. 모든 경우에 반환 / 인쇄 / 무엇이 n6 개 미만의 소수로 구성된 소수 부분을 간단하게 표현해야합니다 .

채점

이것은 코드 골프이며, 가장 작은 바이트 수입니다.

보너스! 'goldbach'라는 단어가 프로그램의 하위 시퀀스 (반드시 연속적 일 필요는 없습니다. 순서대로 중요하지 않습니다)로 나타나는 경우 8 점을 뺍니다. 위의 코드는 이에 대한 예입니다.

J , 29

(#~y=+/@>),{5$<0,p:i._1 p:>:y

입력이에 있다고 가정합니다 y. expression의 값은 5 소수 또는 0을 합한 목록 상자의 목록입니다 y.

   y =. 16
   (# ~ y = + / @>), {5 $ <0, p : i._1 p :> : y
+ ---------- + ---------- + ---------- ++ ---------- + ----- ----- + --------- + ---------- + ---------- + ------------ +- --------- + ---------- + ---------- + ---------- + ------- -+ --------- + ---------- + ------------ + ---------- + ---- ------ + ---------- + ---------- + ---------- + --------- + ------...
| 0 0 3 13 | 0 0 5 11 | 0 0 11 5 | 0 0 13 3 | 0 2 3 11 | 0 2 7 7 | 0 2 11 3 | 0 0 3 13 13 | 0 0 3 2 11 | 0 3 11 2 | 0 3 13 0 | 0 5 11 11 5 5 11 0 | 0 7 2 7 | 0 7 7 2 | 0 11 0 5 | 0 11 11 2 3 | 00 11 3 2 | 0 11 5 0 | 0 0 13 0 3 | 0 13 3 0 | 0 2 0 3 11 | 0 2 0 7 7 | 0 2 0 ...
+ ---------- + ---------- + ---------- ++ ---------- + ----- ----- + --------- + ---------- + ---------- + ------------ +- --------- + ---------- + ---------- + ---------- + ------- -+ --------- + ---------- + ------------ + ---------- + ---- ------ + ---------- + ---------- + ---------- + --------- + ------...

보너스 포인트를 적립 할 편지가 충분하지 않습니다.

수학 , 38

IntegerPartitions[n,5,Prime~Array~n,1]

C, 192-8 = 184 자

연속으로 "Goldbach"(구두 제외) 및 "Tao"를 포함합니다.
합계가 5 소수보다 작 으면 (즉, 항상) 0을 인쇄합니다 (16 = 0+0+0+3+13)
표준 입력에서 숫자를 읽습니다 echo 30 | ./prog.

#define T(x)for(x=0;x<=s;b=&x,c(++x))
G,o,l,d,*b,a;c(h)
{(*b-1?h<3:++*b)||c(*b%--h?h:++*b);}
main(s){
    scanf("%d",&s);
    T(G)T(o)T(l)T(d)T(a)o+G+l+d+a-s?0:exit(printf("%d+%d+%d+%d+%d\n",G,o,l,d,a));
}

이전 버전 (179 자). 정확히 5 개의 소수만 찾을 수 있으므로 x <10에서는 실패합니다.

#define T(x)for(x=2;x<s;b=&x,c(++x))
G,o,l,d,*b,a;c(h)
{h<3||c(*b%--h?h:++*b);}
main(s){
    scanf("%d",&s);
    T(G)T(o)T(l)T(d)T(a)o+G+l+d+a-s?0:exit(printf("%d+%d+%d+%d+%d\n",G,o,l,d,a));
}

설명 : 다음 프라임으로
c설정 *b합니다 (프라임 인 *b경우 포함 ).
T변수 중 하나를 G,o,l,d,a다음 소수로 진행하는 for 루프를 빌드합니다 .
모든 for 루프 내에서 합이 일치하는지 확인하고 일치하면 인쇄 및 종료합니다.

Brachylog , 9 바이트

~+.ṗᵐl≤5∧

온라인으로 사용해보십시오!

~+.          Output (.) should sum to the input,
   ṗᵐ        consist of all primes,
     l≤5     and have length ≤ 5.
        ∧    (Don't unify that 5 with the implicit output variable.)

루비 138 124 117-8 = 109

require'mathn'
def g(o,l=[])
p l if l.inject(:+)==o#db
(l.last||1..o).each{|d|d.prime?and g(o,l+[d])if l.count<5}
end

와 전화 g(<number>) . 샘플 출력 :

[2, 2, 2, 2, 19]
[2, 2, 3, 3, 17]
[2, 2, 3, 7, 13]
...

테스트 : http://ideone.com/rua7A

PHP 143122-8 = 114

편집 : 출력에 몇 바이트를 저장하고 명시 적 함수 호출을 제거했습니다.

<?function g($o,$l,$d,$b){for(;$o>=$b=gmp_intval(gmp_nextprime(+$b));)echo$b^$o?$l<4&&g($o-$b,$l+1,"$d$b,",$b-1):"$d$b
";}

풀림 :

<?
function g($o,$l,$d,$b){
  for(;$o>=$b=gmp_intval(gmp_nextprime(+$b));)
    echo$b^$o?$l<4&&g($o-$b,$l+1,"$d$b,",$b-1):"$d$b
";}

다음에 @g(<number>);대한 샘플 출력을 호출하십시오 n=27.

2,2,2,2,19
2,2,3,3,17
2,2,3,7,13
2,2,5,5,13
2,2,5,7,11
2,2,23
2,3,3,19
2,3,5,17
2,3,11,11
2,5,7,13
2,7,7,11
3,3,3,5,13
3,3,3,7,11
3,3,5,5,11
3,3,7,7,7
3,5,5,7,7
3,5,19
3,7,17
3,11,13
5,5,5,5,7
5,5,17
5,11,11
7,7,13

루비 2 -rmathn, 66 바이트-8 = 58

g=->o,*l{o==l.reduce(:+)?p(l):l[5]||b=Prime.each(o){|x|g[o,*l,x]}}

GolfWolf의 답변에 크게 의존하지만 6 세 이후부터 nitpicking 대신 내 자신을 게시 할 것입니다. 기술의 발전에는 free reduce대신에 사용하는 stabby lambda, 5의 파티션에서 멈추는 간결한 방법 및 ) 이하의 모든 소수를 반복하고을 제공합니다 . 다른 6 년 후에는을 사용하는 더 좋은 방법이있을 것 입니다.injectdPrime.each(o)oachb

스칼라 137-8 = 129

def g(o:Int)={val l=0+:(2 to o).filterNot(d=>(2 to d-1).exists(d%_==0))
for(b<-l;a<-l;c<-l;h<-l;e<-l;if(b+a+c+h+e==o))yield{(b,a,c,h,e)}}

boothby의 힌트 후에 : 하나의 함수 호출을 제거하고 3을 3의 합으로 해석하고 아무것도 출력하지 않고 출력에서 ​​입력을 제거하십시오-다른 20 문자를 저장합니다.

보너스 강조 :

def g (o : Int) = {val l = 0 + :( 2 to o) .filterNot ( d => (2 to d-1) .exists (d % _ == 0)) for (b <-l ; a <-1; c <-1; h <-1; e <-1; if (b + a + c + h + e == o)) 수율 {( b, a, c, h , e) }}

호출 및 결과 :

println (l(17)) 
Vector((17,0,0,2,2,13), (17,0,0,2,13,2), (17,0,0,3,3,11), ...

출력은 모든 목록에 대해 x를 반복하여 x까지 합한 다음 5 개의 summand를 표시합니다. 누락 된 summand의 경우 0, 즉 2 + 2 + 13입니다.

언 골프 드 :

// see if there is some x, such that o%x is 0.
def dividable (o:Int) = (2 to o-1).exists (x=> o % x == 0)

// +: is a kind of cons-operator for Vectors
def primelist (d: Int) = {
  val s = 0 +: (2 to d).filterNot (b => dividable (b))
  for (a <- s;
    b <- s;
    c <- s;
    h <- s;
    e <- s;
    if (a+b+c+h+e == d)) yield {(a,b,c,h,e)}
}

MuPAD 113-8 = 105

g:=[0,ithprime(i)$i=1..n]:f:=_for_in:f(l,g,f(d,g,f(b,g,f(a,g,f(c,g,if l+d+b+a+c=n then print(l,d,b,a,c)end)))))

이 버전은 모든 솔루션의 모든 순열을 인쇄합니다.

0, 0, 0, 0, 7
0, 0, 0, 2, 5
0, 0, 0, 5, 2
0, 0, 0, 7, 0
0, 0, 2, 0, 5
...

그리고 예, 너무 긴 목록을 만듭니다 g. 무슨 상관이야? :-)

언 골프 버전 :

g:=[0].select([$1..n],isprime):
for l in g do
  for d in g do
    for b in g do
      for a in g do
        for c in g do
          if l+d+b+a+c=n then print(l,d,b,a,c); end;
        end
      end
    end
  end
end

젤리 , 19 바이트 (그러나 매우 느림-조언 필요)

ÆR;0x5Œ!ḣ€5¹©S€i³ị®

온라인으로 사용해보십시오!

ÆR;0x5Œ!ḣ€5¹©€i³ị®     main link, takes one argument N
ÆR                     get all the primes less than N
  ;0x5                 add zero, and then repeat the entire list 5 times
      Œ!               get all the permutations of this huge list (takes a long time!)
        ḣ€5            for each permutation, just take the first 5 numbers
                       (this gives us all possible length-5 combinations of the primes plus zero, with some repeats)
           ¹©          save that list to register
              S€       take the sum of every permutation in the list...
                i³     and find the index of our first argument N in that list of sums
                  ị®   then recall our list of permutations, and get the correct permutation at that index!

더 빠르고 더 짧은 아이디어가 있다면 알려주세요!