27

इससे पहले कि कोई कुछ भी कहे, समान और समान । लेकिन यह कोई धोखा नहीं है।

कुछ सकारात्मक पूर्णांकों को कम से कम दो लगातार सकारात्मक पूर्णांकों के योग के रूप में लिखा जा सकता है। उदाहरण के लिए, 9=2+3+4=4+5। एक फ़ंक्शन लिखें जो अपने इनपुट के रूप में एक सकारात्मक पूर्णांक लेता है और अपने आउटपुट के रूप में प्रिंट करता है जो लगातार सकारात्मक पूर्णांक बढ़ने का सबसे लंबा अनुक्रम है जो इसके लिए योग है (कोई भी प्रारूप स्वीकार्य है, हालांकि -5 बाइट्स यदि आउटपुट +ऊपर दिखाए गए अनुसार अलग-अलग अनुक्रम है। । यदि ऐसा कोई अनुक्रम मौजूद नहीं है, तो संख्या को स्वयं मुद्रित किया जाना चाहिए।

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

नमूने (ध्यान दें कि स्वरूपण भिन्न होता है)

Input:   9
Output:  2,3,4

Input:   8
Output:  8

Input:   25
Output:  [3,4,5,6,7]

— आर्कटुरस
स्रोत

2

क्या आउटपुट किए गए नंबरों को एक विशिष्ट क्रम में होना चाहिए (जैसे बढ़ते हुए)?

— xnor

2

क्या संख्याएँ> 0: 6 = 0 + 1 + 2 + 3 या 6 = 1 + 2 + 3 है

— डेमियन

5

एक साइड नोट के रूप में, यदि निकट संबंधी चुनौतियां हैं, तो यह कहना कि "यह एक डुबकी नहीं है", लोगों को यह समझाने के लिए बहुत कम करेगा कि अगर वे सोचते हैं कि यह एक डुपी है। यह अधिक उपयोगी होगा यदि आपने बताया कि आपको क्यों लगता है कि यह नहीं है।

— मार्टिन एंडर

1

@ डैमियन "पॉजिटिव" का सामान्य अर्थ है> 0। यदि 0 को शामिल किया गया था, तो इसे "गैर-नकारात्मक" कहा जाएगा।

— मार्टिन एंडर

3

सीसी @Vixen ^ (भी अगर ऋणात्मक संख्याओं की अनुमति दी गई, इष्टतम समाधान हमेशा से लेकर होगा -n+1करने के लिए n)

— मार्टिन Ender

11

अजगर, 67 बाइट्स

f=lambda n,R=[1]:n-sum(R)and f(n,[R+[R[-1]+1],R[1:]][sum(R)>n])or R

एक विषम सीधी रणनीति: अंतराल आर के लिए सही योग की खोज करें।

यदि योग बहुत छोटा है, तो अगले उच्चतम संख्या को जोड़कर अंतराल के सही समापन बिंदु को ऊपर की ओर स्थानांतरित करें।
यदि योग बहुत बड़ा है, तो सबसे छोटे तत्व को हटाकर बाएं समापन बिंदु को स्थानांतरित करें
यदि योग सही है, तो आउटपुट आर।

चूंकि अंतराल का निचला सिरा केवल बढ़ता है, इसलिए छोटे अंतराल से पहले लंबे अंतराल पाए जाते हैं।

— XNOR
स्रोत

अजीब तरह से कुशल भी। पुनरावृत्ति स्टैक अंततः अतिप्रवाह करता है, जैसे n = 8192।

— प्रिमो

7

पायथ, 12 10 बाइट्स

j\+hfqsTQ}M^SQ2

कोड 15 बाइट्स लंबा है और -5 बाइट्स बोनस के लिए योग्य है । इसे Pyth Compiler में ऑनलाइन आज़माएँ ।

2 बाइट बंद करने के लिए @Jakube का धन्यवाद!

यह काम किस प्रकार करता है

j\+hfqsTQ}M^SQ2    (implicit) Store evaluated input in Q.

            S      Compute [1, ..., Q].
           ^  2    Get all pairs of elements of [1, ..., Q].
         }M        Reduce each pair by inclusive range. Maps [a, b] to [a, ..., b].
    f              Filter; for each pair T:
      sT             Add the integers in T.
     q  Q            Check if the sum equals Q.
                   Keep the pair if it does.
   h               Retrieve the first match.
                   Since the ranges [a, ..., b] are sorted by the value of a,
                   the first will be the longest, in ascending order.
j\+                Join, using '+' as separator.

— डेनिस
स्रोत

1

हम में से जो पायथ के क्षेत्र में प्रबुद्ध नहीं हैं, क्या आप कृपया स्पष्टीकरण जोड़ सकते हैं? :)

— ETHproductions

मैंने अपना उत्तर संपादित कर दिया है।

— डेनिस

बहुत अच्छे धन्यवाद! मुझे आपकी तकनीक पसंद है।

— ETHproductions

1

इनपुट 1000: 30 मिनट और गिनती ...

— प्राइमो

3

मैथमेटिका, 73 68 65 56 43 बाइट्स

Cases[Range~Array~{#,#},i_/;Tr@i==#,{2},1]&

— alephalpha
स्रोत

1

+1 मैंने कल रात इसी तरह के समाधान के साथ समाप्त किया, लेकिन मेरा इंटरनेट नीचे चला गया। इसके अलावा, आप Tuplesएक infix अभिव्यक्ति कर सकते हैं ।

— लीजनमोनमाल 978

3

हास्केल, 49 48 बाइट्स

f n=[[a..b]|a<-[1..n],b<-[a..n],sum[a..b]==n]!!0

— डेमियन
स्रोत

1

बचाने के लिए 1 बाइट: के [...]!!0बजाय का उपयोग करें head[...]।

— nimi

2

MATLAB, 87 79 बाइट्स

मुझे पता है कि पहले से ही MATLAB उत्तर है, लेकिन यह एक दृष्टिकोण में काफी अलग है।

x=input('');m=1:x;n=.5-m/2+x./m;l=max(find(~mod(n(n>0),1)));disp(m(1:l)+n(l)-1)

यह ऑक्टेव पर भी काम करता है । आप यहाँ ऑनलाइन कोशिश कर सकते हैं । मैंने consecutiveSum.mलिंक को पहले ही लिंक किए गए कार्यक्षेत्र में जोड़ दिया है, इसलिए बस consecutiveSumकमांड प्रॉम्प्ट पर दर्ज करें, फिर मान दर्ज करें (जैसे 25)।

मैं अभी भी इसे कम करने पर काम कर रहा हूं (शायद समीकरण का उपयोग थोड़ा समायोजित किया गया है), लेकिन मूल रूप से यह सबसे बड़ा मूल्य पाता है nजिसके mलिए एक पूर्णांक है, फिर mशुरू होने वाले पहले नंबरों को प्रदर्शित करता है n।

तो यह काम क्यों करता है? वैसे मूल रूप से उन सभी संख्याओं को नियंत्रित करने वाला एक गणितीय समीकरण है। यदि आप समझते हैं कि वे सभी लगातार हैं, और कुछ बिंदु से शुरू करते हैं, तो आप मूल रूप से कह सकते हैं:

n+(n+1)+(n+2)+(n+3)+...+(n+p)=x

अब, इससे यह स्पष्ट हो जाता है कि अनुक्रम मूल रूप से केवल पहला pत्रिभुज संख्या है (0'th सहित), p+1बहुत से जोड़े गए n। अब अगर हम दें m=p+1, हम कह सकते हैं:

m*(n+(m-1)/2)==x

यह वास्तव में काफी सॉल्व है। मैं अभी भी इसे करने का सबसे छोटा कोड तरीका ढूंढ रहा हूं, ऊपर दिए गए कोड को आजमाने और कम करने के लिए मेरे पास कुछ विचार हैं।

25 के इनपुट के लिए, आउटपुट होगा:

3     4     5     6     7

— टॉम बढ़ई
स्रोत

2

त्रिकोण संख्याओं के बारे में अपनी बात के संबंध में, यह चुनौती अनिवार्य रूप से इनपुट के सकारात्मक अंतर के साथ त्रिकोणीय संख्याओं को खोजने की कोशिश कर रही है, ताकि अनुक्रम में त्रिकोणीय संख्याओं के सूचकांक 1,3,6,10,...को अधिकतम किया जा सके।

— आर्कटिकस

1

पायथन 2, 94 बाइट्स

n=input()
r=int((2*n)**.5)
while r:
 if~r%2*r/2==n%r:print range(n/r-~-r/2,n/r-~r/2);r=1
 r-=1

इनपुट स्टड से लिया गया है। यह समाधान बहुत बड़े इनपुट के लिए उपयुक्त है।

यह संभव समाधान लंबाई, आर , आर √ 2 (2n) होने पर पुनरावृत्त करता है, और स्पष्ट रूप से समाधान के लिए जाँच करता है। किसी समाधान के अस्तित्व के लिए, यदि r विषम है, तो n mod r शून्य होना चाहिए, और यदि r सम है, n mod r को r / 2 होना चाहिए ।

नमूना उपयोग

$ echo 8192 | python sum-con-int.py
[8192]

$ echo 1000002 | python sum-con-int.py
[83328, 83329, 83330, 83331, 83332, 83333, 83334, 83335, 83336, 83337, 83338, 83339]

$ echo 1000000006 | python sum-con-int.py
[250000000, 250000001, 250000002, 250000003]

मैंने अपेक्षाकृत छोटे आउटपुट के साथ जानबूझकर उदाहरण चुना है।

— Primo
स्रोत

1

ऑक्टेव, 89 बाइट्स

यह सबसे अच्छा मैं ऑक्टेव में कर सकता है। एल्गोरिथ्म xnor की तरह ही है।

x=input('');k=i=1;while x;s=sum(k:i);if s<x;i++;elseif s>x;k++;else;x=0;end;end;disp(k:1)

MATLAB में यह 95 बाइट्स होगा:

x=input('');k=1;i=1;while x;s=sum(k:i);if s<x;i=i+1;elseif s>x;k=k+1;else x=0;end;end;disp(k:i)

MATLAB में यह इनपुट के लिए लगभग 0.1 सेकंड 2000000और इनपुट के लिए 1 सेकंड में चलता है 1000002।

— स्टीवी ग्रिफिन
स्रोत

1

awk, 51 बाइट्स

{while($0!=s+=s<$0?++j:-++i);while(++i-j)r=r i"+"}$0=r j

आउटपुट फॉर्मेट के लिए कोड 56 बाइट्स, माइनस 5 बाइट्स है। मुझे उस प्रारूप का निर्माण करने के लिए 4 अतिरिक्त बाइट्स का उपयोग करना पड़ा, इसलिए मैंने वास्तव में 1 बाइट बचाई। हुर्रे! ;)

यह वास्तव में 1 से शुरू होने वाले योग की कड़ी मेहनत कर रहा है जब तक कि इनपुट से बड़ा नहीं है। तब यह 1 से शुरू होने वाली संख्याओं को घटाना शुरू कर देता है जब तक कि संख्या इनपुट से छोटी न हो। यह प्रारंभ और अंतिम संख्या को इस तरह बदलता रहता है जब तक कि इसका परिणाम नहीं मिल जाता है, जो तब प्रिंट करता है।

उदाहरण का उपयोग करें

echo 303 | awk '{while($0!=s+=s<$0?++j:-++i);while(++i-j)r=r i"+"}$0=r j'

उदाहरण का आउटपुट

48 + 49 + 50 + 51 + 52 + 53

मैंने इसके इनपुट के लिए कोशिश की है 1e12और इसने 464562+...+1488562लगभग तुरंत ही सही परिणाम ( ) दिया है। हालांकि इसे प्रिंट करने में थोड़ा समय लगा ...

— Cabbie407
स्रोत

अवाक दृष्टिकोण से प्रेम करो। मुझे बाइंडिंग में वरीयता के क्रम पर काम करने में परेशानी हो रही है। क्या आप इसे और अधिक स्पष्ट करने के लिए जोड़े गए अधिक कोष्ठक के साथ एक संस्करण को शामिल करने की कृपा करेंगे? :)

— वाइल्डकार्ड

1

आशा है कि यह मदद करता है: {while($0!=s)s+=(s<$0) ? (++j) : -(++i); while(++i<j)r=r i"+"}$0=r j मैं हमेशा अंतिम पूर्णांक है जो श्रृंखला की शुरुआत से घटाया गया है, j हमेशा श्रृंखला के अंत में जोड़ा गया अंतिम पूर्णांक है

— Cabbie407

0

जाप , 33 बाइट्स

यह डेनिस की पाइथ तकनीक का उपयोग करता है , हालांकि यह काफी लंबा है ...

1oU à2 £W=Xg o1+Xg1¹x ¥U©W} rª ªU

इसे ऑनलाइन आज़माएं! चेतावनी: बड़े इनपुट के लिए (<= 20), इसे समाप्त होने में कुछ समय लगता है, और आपके ब्राउज़र को तब तक फ्रीज करता है जब तक कि यह नहीं हो जाता।

अपुष्ट और व्याख्या

1oU à2 £    W=Xg o1+Xg1¹ x ¥ U© W} rª  ª U
1oU à2 mXYZ{W=Xg o1+Xg1) x ==U&&W} r|| ||U

          // Implicit: U = input integer
1oU à2    // Generate a range from 1 to U, and take all combinations of length 2.
mXYZ{     // Map each item X in this range to:
W=Xg o    //  Set variable W to the range of integers starting at the first item in X,
1+Xg1)    //  and ending at 1 + the second item in X.
x ==U&&W  //  If the sum of this range equals U, return W; otherwise, return false.
r||       // Reduce the result with the || operator, returning the first non-false value.
||U       // If this is still false, there are no consecutive ranges that sum to U,
          // so resort to U itself.
          // Implicit: output last expression

बोनस कमाने वाला संस्करण: (38 बाइट्स - 5 = 33)

1oU à2 £W=Xg o1+Xg1¹x ¥U©W} rª ªU² q'+

— ETHproductions
स्रोत

0

जूलिया, 92 बाइट्स

x->(t=filter(i->all(j->j==1,diff(sort(i))),partitions(x));collect(t)[indmax(map(length,t))])

यह एक अनाम फ़ंक्शन है जो पूर्णांक को स्वीकार करता है और एक सरणी देता है। इसे कॉल करने के लिए, इसे एक नाम दें, उदा f=x->...।

Ungolfed:

function f(x::Integer)
    # Get all arrays of integers that sum to x
    p = partitions(x)

    # Filter these down to only consecutive runs by checking whether
    # all differences are 1
    t = filter(i -> all(j -> j == 1, diff(sort(i))), p)

    # Find the index of the longest element of t
    i = indmax(map(length, t))

    return collect(t)[i]
end

— एलेक्स ए।
स्रोत

0

रूबी, 94 बाइट्स

->n{([*1..n].permutation(2).map{|i,j|[*i..j]if(i..j).reduce(:+)==n}-[p]).max_by{|k|k.size}||n}

Ungolfed:

-> n {
  ([*1..n].permutation(2).map { |i,j|   # Finds all the possible sets of size 2
     [*i..j] if(i..j).reduce(:+) == n   # Adds a set to an array if sum of the set is n.
   }-[p]                                # Removes nil from the array
  ).max_by { |k|                        # Finds the longest sequence
    k.size
  } || n                                # Returns n if no sequence found.
}

उपयोग:

->n{([*1..n].permutation(2).map{|i,j|[*i..j]if(i..j).reduce(:+)==n}-[p]).max_by{|k|k.size}||n}[25]
=> [3, 4, 5, 6, 7]

— वासु अडारी
स्रोत

0

गंभीरता से, 53 - 5 = 48 बाइट्स

,;;;╝`;u@n╟(D;)`n(XXk`iu@u@x;Σ╛=[])Ii`╗`ñ╜M`M;░p@X'+j

हेक्स डंप

2c3b3b3bbc603b75406ec728443b29606e2858586b60697540754
0783be4be3d5b5d29496960bb60a4bd4d604d3bb0704058272b6a

यह ऑनलाइन की कोशिश करो!

यह डेनिस के पाइथ के समान ही ब्रूट फोर्स अप्रोच है।

करने के लिए सब कुछ kसिर्फ पढ़ता इनपुट nरजिस्टर 1 में और उसके बाद सूची बनाता है [[1],[2,2],[3,3,3],[4,4,4,4],...]अप करने के लिए n nके।

अगला बिट अप ╗रजिस्टर 0 में संग्रहित एक फ़ंक्शन है जो एक जोड़ी लेता है, दोनों तत्वों को बढ़ाता है, उन्हें एक सीमा में परिवर्तित करता है, सीमा का योग पाता है, और जाँचता है कि क्या यह योग रजिस्टर में मूल्य 1 है। यदि यह है, तो यह संबंधित सीमा देता है, और यदि यह नहीं है, तो यह एक खाली सूची देता है।

Mऊपर वर्णित सूचियों की अंतिम घटना तक का हिस्सा , ऊपर वर्णित सूचियों की फैंसी सूची enumerateपर प्रत्येक सूची में कर रहा है , फिर उस पर संग्रहीत कार्य को मैप कर रहा है। जब यह किया जाता है, तो हमारे पास उन सूचियों की एक सूची होती है, जिनमें से प्रत्येक खाली होती है या एक सीमा होती है, जो रकम होती है n।

;░खाली सूचियों को निकालता है। p@Xपहली सूची लेता है जो बनी हुई है ( 0@Eयह भी काम करेगी)। प्रत्येक संख्या के बीच '+jरखता है +क्योंकि यह सूची को बोनस के लिए स्ट्रिंग में परिवर्तित करता है।

— quintopia
स्रोत

0

ईएस 6, 72 बाइट्स

n=>{for(l=u=1;n;)n>0?n-=u++:n+=l++;return[...Array(u).keys()].slice(l);}

@ Cabbie407 के awk सॉल्यूशन का सीधा पोर्ट, लेकिन फॉर्मेटिंग बोनस के बिना, क्योंकि यहां पेनल्टी है।

— नील
स्रोत

0

पायथन 3, 239 236 215 203 बाइट्स

यह थोड़ा बोझिल है। मुझे इसे बाद में नीचे करना होगा।

def x(n):
 r=[n]
 for i in range(2,n):
  t=[]
  if i%2*(n%i<1):t=[j+n//i-i//2for j in range(i)]
  elif i%2<1and n%i==i//2:t=[j+n//i-i//2+1for j in range(i)]
  if t[:1]>[0]*(sum(t)==n):r+=t,
 return r[-1]

ऐसा kइसलिए है क्योंकि यदि आप t[0]एक खाली पर जाँच करते हैं t, तो पायथन आप पर असभ्य शोर करता है। फिर, यह गोल्फ की जरूरत है। के लिए धन्यवाद t[:1], और कोई अशिष्ट शोर! आपको बस एक और सरणी के खिलाफ जांच करने की आवश्यकता है।

— Sherlock9
स्रोत

0

जेली , 8 बाइट्स (गैर-प्रतिस्पर्धात्मक)

ẆS⁼¥Ðf⁸Ṫ

इसे ऑनलाइन आज़माएं!

अगर मैं सही ढंग से समझूं, तो यह एक (11-5 = 6) -बीट संस्करण हो सकता है:

ẆS⁼¥Ðf⁸Ṫj”+

— आउटग्रॉफर को एरिक करें
स्रोत

ब्याज की खातिर, समान आयामों के लिए गैर-वेक्टराइज़िंग समानों की अदला-बदली करके, 12-समान समाधान (एक सहित) हैं, बाएं-तर्क को पहले-तर्क में बदलना या पहचान के लिए, और बराबर-बराबर और फ़िल्टर-के साथ बराबर स्वैप करना वेक्टरिंग और गैर-वेक्टराइजिंग दोनों के लिए फ़िल्टर-आउट। : ओ

— हाइपरनेत्रिनो

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

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

0

05AB1E , 11 - 5 = 6 बाइट्स (गैर-प्रतिस्पर्धात्मक)

पाठ्यक्रम का वह बोनस लेना :)

LŒʒOQ}é¤'+ý