(अधिकतम) 5 योग

Question

टेरेंस ताओ ने हाल ही में गोल्डबैक के अनुमान का एक कमजोर रूप साबित किया ! चलो शोषण करते हैं!

एक अजीब पूर्णांक को देखते हुए n > 1, n5 तक की राशि के रूप में लिखें । हालाँकि आपको जो इनपुट पसंद है वह लें, और आउटपुट दें जो आपको पसंद है। उदाहरण के लिए,

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

सेज कोड है जो एक पूर्णांक को इनपुट के रूप में लेता है, और पूर्णांकों की सूची को आउटपुट के रूप में देता है जिसका योग है n। ताओ के प्रमेय द्वारा, यह हमेशा समाप्त होगा!

इनपुट

एक अजीब पूर्णांक n। आप तय करते हैं कि इनपुट कैसे लेना है, लेकिन अगर यह अजीब है, तो इसे समझाएं।

उत्पादन

बल्कि खुल्लम-खुल्ला हुआ। एक सूची लौटाओ। एक स्ट्रिंग प्रिंट करें। एक, कुछ, या सभी को गिम्मे। स्टैक (जीएस, पिएट, इत्यादि) या एक निरंतर (पहुंच में) मेमोरी ब्लॉक (बीएफ, आदि) के आसपास झूठ बोलने वाली बकवास छोड़ दें। इन बाद के मामलों के लिए, आउटपुट की व्याख्या करें। सभी मामलों में, आप जो वापस लौटते हैं / प्रिंट करते हैं / व्हाटएवौ को n6 भागों में कम से कम भागों में विभाजन का एक सीधा प्रतिनिधित्व होना चाहिए ।

स्कोरिंग

यह कोड गोल्फ, सबसे छोटी बाइट गिनती जीत है।

बक्शीश! यदि शब्द 'गोल्डबैक' आपके प्रोग्राम के बाद के क्रम के रूप में प्रकट होता है (जरूरी नहीं कि लगातार; बस क्रम में कोई फर्क नहीं पड़ता) 8 अंक घटाते हैं। ऊपर दिया गया कोड इसका एक उदाहरण है।

Comments

जाँच करने के लिए पहली संख्या, विषम पूर्णांक> 1 है, 3. कौन सा योग 3 का उत्पादन करता है? क्या मुझे स्पष्ट नहीं दिख रहा है?

— उपयोगकर्ता अज्ञात

The स्पष्ट ’भाषाई है। चूंकि 3 अभाज्य है, यह 1 अभाज्य का योग है। स्मार्टास प्रतिक्रिया: कॉनवे कहेंगे कि 3 का योग 7 + (-1) + (-1) + (-1) + (-1) है।

— boothby

एक एकल मान एक योग नहीं है। मैं केवल नकारात्मक मूल्यों को पेश करने के बजाय मूल्यों> 3 से शुरू करने का सुझाव दूंगा।

— उपयोगकर्ता अज्ञात

एक एकल मान एक राशि है। नकारात्मक मूल्यों के बारे में टिप्पणी एक चतुर टिप्पणी थी, जैसा कि स्पष्ट रूप से नोट किया गया है।

— बूथबंदी

"प्रतिस्थापन (जरूरी नहीं कि लगातार; बस क्रम में ...)" इसे एक अनुवर्ती कहा जाता है ।

— जॉय एडम्स

Answer 1

जे , २ ९

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

मान लिया गया इनपुट में है y। अभिव्यक्ति का मूल्य 5 योगों या 0 की सूची के बक्से की सूची है जो कि योग है y।

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

किसी भी बोनस अंक अर्जित करने के लिए पर्याप्त पत्र नहीं।

Comments

अच्छी तरह से किया! मुझे लगता है कि कोई भी भाषा इस चुनौती पर जे को हरा नहीं सकती थी।

— क्रिस्टियन लुपस्क्यू

Answer 2

गणितज्ञ , ३ 38

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

Comments

एक रास्ता नहीं मिल सकता है के माध्यम से ...

— डॉ। Belisarius

मुझे Mathematica तक पहुँच मिली है, और इसने मेरे द्वारा दिए गए सभी इनपुट पर काम किया है।

— बूथबंदी

कल्पना कीजिए कि क्या IntegerPartitionsसमारोह का नाम Goldbach...?)

— क्रिस्टियन लुपस्कू

@ w0lf तो भी, यह J> _> से 1 अधिक होगा

— Rixius

@ रिक्सीस नो, यह उस मामले में 21 स्कोर करेगा , 8 जे से कम

— Mr.Wizard

Answer 3

सी, 192-8 = 184 चार्ट

"गोल्डबैक" को लगातार (विराम चिह्न को छोड़कर) और "ताओ" को भी शामिल करता है।
जब योग 5 से कम है (यानी हमेशा), तो शून्य शून्य (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अगले प्रधानमंत्री के लिए चर में से एक को आगे बढ़ाता है ।
सभी छोरों के लिए, हम जाँचते हैं कि क्या राशि मेल खाती है, और यदि ऐसा होता है तो प्रिंट करें और बाहर निकलें।

Comments

G,o,l,d,*b,a;c(h)एक अच्छा स्पर्श है!

— जोएल कॉर्नेट

यह n = 3 के लिए विफल रहता है

— बूथबाई

@ बॉबी, आप सही कह रहे हैं, यह केवल 5 में से कुछ प्राइमर पाता है, कम नहीं।

— बदसूरत

user_unknown के पास इसके लिए एक अच्छा समाधान है: योग के लिए शून्य प्राइम पर विचार करें

— बूथबाई

@ बॉथबी, बदल गया। मैं जितना चाहूंगा उससे अधिक खर्च करूंगा, क्योंकि मेरा तर्क स्वाभाविक रूप से 1 को प्रधान मानता है, और 0 से शुरू करने पर मुझे इसे छोड़ना होगा।

— बदसूरत

Answer 4

ब्रेकीलॉग , 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.)

Comments

आप आदेश को बदलकर एक बाइट बचा सकते हैं । यह भी ध्यान दें कि प्रश्न बताता है कि इनपुट विषम है

— H.PWiz

@ H.PWiz और इस तरह एक और एक ।

— एग्रीकल्चर से एरिक

Answer 5

रूबी 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

Comments

बस डाल #dbलाइन 3 पर बोनस के लिए पर्याप्त होगा: आप मिल जाएगा achसे .each।

— इल्मरी करोनें

आपका क्या मतलब है 'निश्चित आउटपुट स्वरूप'? यह पूरी तरह से खुला है - यदि आप चाहें तो आप रिक्त स्थान को निक्स कर सकते हैं।

— बूथ 35

@ इल्मारिकारोनन महान टिप! मैंने अपनी पोस्ट संपादित की है। धन्यवाद!

— क्रिस्टियन लुपस्क्यू

@boothby यह ध्यान देने के लिए धन्यवाद। मैंने नमूना आउटपुट देखा और सोचा कि यह एक आवश्यकता थी। मैं देख रहा हूं कि आउटपुट फॉर्मेट खुला है। अपडेट किया गया।

— क्रिस्टियन लुपस्क्यू

Answer 6

PHP 143 122 - 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
";}

unrolled:

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

Comments

हम्म ... आपका सबमिट किया गया कोड काम नहीं कर रहा है। आपको ~õ;}अंत में कुछ मज़ेदार चीजें मिली हैं ...

— बूथ '20 '23

~ ~ (chr (245)) "\ n" के लिए आशुलिपि है। इस उदाहरण में, यह वास्तव में आवश्यक नहीं है। मैं इसे समाधान से हटा दूंगा।

— प्रिमो

n = 3 के लिए कोड विफल रहता है।

— बूथबंदी

@ मुझे विश्वास नहीं होता कि यह करता है। N = 3 के लिए, यह संख्या 3 को आउटपुट करता है, और फिर समाप्त हो जाता है (क्योंकि primes की कोई अन्य राशि नहीं है जो 3 हैं)। आप इसे बनाने के लिए क्या उम्मीद कर रहे थे?

— Primo

मुझे कोई आउटपुट नहीं दिख रहा है। 5, 7, 9, 11. ideone.com/cMNR8 के लिए ठीक काम करता है। इसके अलावा, ध्यान दें कि आप फ़ंक्शन को परिभाषित करने के लिए स्वतंत्र हैं और इसे कॉल नहीं करते हैं।

— बूथ

Answer 7

रूबी 2 -Rrathn, 66 बाइट्स - 8 = 58

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

भारी रूप से गोल्फवॉल्फ के जवाब पर आधारित है, लेकिन जब से यह 6 साल का है, मैं नाइटपैकिंग के बजाय अपनी खुद की पोस्ट करने जा रहा हूं। प्रौद्योगिकी में उन्नति में स्थिर लैम्ब्डा शामिल है, जिसका उपयोग मुफ्त के reduceबजाय , 5 के विभाजन पर रुकने का एक सुव्यवस्थित तरीका है, और , जो सभी primes से कम या इसके बराबर (और भट्टी ) के बराबर है । शायद एक और 6 वर्षों में वहाँ का उपयोग करने का एक बेहतर तरीका होगा ।injectdPrime.each(o)oachb

Answer 8

स्काला 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)}}

बूथबी के संकेत के बाद: एक फ़ंक्शन कॉल को समाप्त कर दिया, 3 को 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) ; ए <-एल; सी <-एल; एच <-एल; ई <-एल; अगर (बी + ए + एच + ई == ओ)) उपज {( ए, सी, एच , ई) }}

मंगलाचरण और परिणाम:

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

आउटपुट प्रत्येक सूची के लिए x को योग करने के लिए दोहराता है, और फिर 5 सारांश दिखाता है। 0 लापता समन के लिए, अर्थात 2 + 2 + 13।

Ungolfed:

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

Comments

मैं स्काला से परिचित नहीं हूं। यह कैसे कहा जाता है? क्या आप ideone.com पर काम करने का उदाहरण दे सकते हैं ?

— बूथबीज

आप इस पर बेहतर अमल करते हैं केवल स्कैला क्योंकि इसे IDEone की तुलना में कम बॉयलरप्लेट की आवश्यकता होती है। उदाहरण के लिए, आह्वान println (l(17))के लिए। आउटपुट आम तौर पर जैसा दिखता है Vector((17,0,0,2,2,13), (17,0,0,2,13,2), (17,0,0,3,3,11)और इसका मतलब है: 17 को समन किया जाना है, और समन 0, 0 (शून्य का अर्थ समन की अनुपस्थिति) 2 + 2 + 13 है। बस स्कैला का

— उपयोगकर्ता अज्ञात

धन्यवाद! ऐसा लगता है कि आप कुछ वर्ण सहेज सकते हैं: yield{(d,a,...-> yield{(a,...और की परिभाषा को पैक gकरके filterNot(...)। तथापि। यह n = 3 के लिए विफल रहता है।

— बूथबंदी

(2 to d)इसके बजाय करो (2 to d-1), लेकिन मैं इस बात से सहमत नहीं हूं कि 3 का योग है। 3. यदि आप सेट करते हैं, तो, यह एक खाली सेट या एक नंबर से मिलकर सेट हो सकता है। लेकिन एक राशि का निर्माण जो n की ओर जाता है - मैं केवल विरोध के तहत अपना कोड बदलता हूं।

— उपयोगकर्ता अज्ञात

जैसा कि आपके जवाब को छोटा करने से आपके अयोग्य इनकार के रूप में महान है, आपके कारण आपके बहुत ही जवाब से कम आंका गया है। आप वे सूचियाँ लौटा रहे हैं जिनका योग है 3। ऐसा एक होना चाहिए (0,0,0,0,3)।

— 12:12

Answer 9

मुपाड 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। किसे पड़ी है? :-)

Ungolfed संस्करण:

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

Comments

मेरे पास मुराद तक नहीं है - क्या कोई जांच कर सकता है कि यह काम करता है?

— बूथबाई

Answer 10

जेली , 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!

यदि आपके पास इसे तेज और कम करने के लिए कोई विचार है, तो कृपया मुझे बताएं!

Comments

12 बाइट्स । ṗЀ5पाँच के माध्यम से लंबाई के साथ primes के सभी संयोजनों का उत्पादन करता है। S=¥जाँचता है कि तत्वों में से किसी एक का योग श्रृंखला के तर्क के बराबर है और Ðfकेवल उन तत्वों को रखता है। Ẏवहाँ केवल सूची में सभी स्तरों की एक ही स्तर पर डाल करने के लिए है

— dylnan

अब 10 बाइट्स के बाद से Ɱऔर Ƈके लिए उपनाम के रूप में जोड़ दिया गया है ЀऔरÐf

— dylnan