यद्यपि संबंधित चुनौतियों से पूछा गया है, यह अपने स्वयं के प्रश्न को वारंट करने के लिए अलग है।

चुनौती

एक सकारात्मक पूर्णांक को देखते हुए, लगातार सकारात्मक विषम पूर्णांक के सबसे लंबे अनुक्रम को लौटाएं जिसका योग पूर्णांक है। यदि ऐसा कोई अनुक्रम मौजूद नहीं है, तो आप अपनी भाषा के लिए किसी भी तरह से एक त्रुटि की रिपोर्ट कर सकते हैं, जिसमें एक गलत मूल्य वापस करना या एक अपवाद फेंकना शामिल है।

परीक्षण के मामलों

  1 -> [1]
  2 -> []
  3 -> [3]
  4 -> [1, 3]
  5 -> [5]
  6 -> []
  9 -> [1, 3, 5] (ध्यान दें कि [9] एक वैध उत्तर नहीं है)
 15 -> [3, 5, 7]
104 -> [23, 25, 27, 29] (ध्यान दें कि [51, 53] एक वैध उत्तर नहीं है)

स्कोरिंग

यह कोड-गोल्फ है , इसलिए प्रत्येक भाषा में सबसे कम उत्तर जीतता है।

code-golf number

— musicman523
स्रोत

2

अगर कोई समाधान नहीं है तो क्या मेरा कार्यक्रम हमेशा के लिए चल सकता है?

— डेनिस

बहुत संबंधित । तथ्य यह है कि कुछ भी संख्याओं का प्रतिनिधित्व इस में नहीं किया जा सकता है, हालांकि इसे एक डुबकी होने से बचा सकता है।

— ETHproductions

6

15 नहीं दे सकता [-1, 1, 3, 5, 7]? यदि केवल सकारात्मक मूल्यों की अनुमति है, तो आपको ऐसा कहना चाहिए।

— xnor

2

@ ЕвгенийНовиков आप 17 को छोड़ दिया

— kalsowerus

1

@kalsowerus हाँ। मैं "लगातार" शब्द को गलत

— समझता

11

हास्केल, 67 65 63 62 58 बाइट्स

जूलियन वुल्फ के लिए धन्यवाद 4 बाइट्स बचाता है

f x=[[2*n+1,2*n+3..2*m]|n<-[0..x],m<-[n..x],m^2-n^2==x]!!0

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

मैं जांचता हूं कि क्या संख्या को दो वर्गों के अंतर के रूप में व्यक्त किया जा सकता है m^2-n^2:। मैं तो लगातार विषम संख्याओं की सूची का निर्माण कर सकता हूं [2n+1,2n+3...2m-1]:। ध्यान दें कि क्योंकि न्यूनतम nचुना जाता है, सबसे लंबी सूची आउटपुट होगी

— H.PWiz
स्रोत

7

डाउन-वोटर: यह आपके मित्र को जोड़ने के लिए अधिक रचनात्मक और अधिक रचनात्मक होगा, खासकर जब एक नया उपयोगकर्ता डाउन-वोटिंग करता है।

— जोनाथन एलन

1

जब तक मैं कुछ याद कर रहा हूँ, आप 4 बाइट्स बचा सकते हैं केवल xदोनों के लिए जा रहे हैं nऔरm

— जूलियन वुल्फ

जैसा कि आप जानते हैं, डाउनवोट को सामुदायिक उपयोगकर्ता द्वारा स्वचालित रूप से डाला गया था जब आपने अपना उत्तर संपादित किया था। मैं इसे एक बग मानता हूं । (CC @JonathanAllan)

— डेनिस

आह, यह उन लोगों में से एक था।

— जोनाथन एलन

9

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

f=lambda n,k=0,*r:n-sum(r)and f(n,k+1,*range(k%n|1,k/n,2))or r

यदि कोई समाधान नहीं है, तो एक रनटाइम एटर (अधिकतम पुनरावर्तन गहराई से अधिक) के साथ बाहर निकलता है ।

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

— डेनिस
स्रोत

1

यदि इनपुट मान पर्याप्त हैं, लेकिन एक समाधान है, तो क्या इसका परिणाम RuntimeError होगा ?

— ओकेक्स

यदि पुनरावृत्ति सीमा पर्याप्त नहीं है और / या स्टैक पर्याप्त बड़ा नहीं है, तो हाँ। हालांकि, शारीरिक सीमाओं को अनदेखा करना आम है (उदाहरण के लिए, C उत्तर में केवल 32-बिट इनटस के लिए काम करना पड़ता है), और ओपी ने स्पष्ट रूप से कहा कि अगर कोई समाधान नहीं है तो हमेशा के लिए चलना स्वीकार्य है।

— डेनिस

9

जेली , 11 10 बाइट्स

डेनिस के लिए -1 बाइट धन्यवाद (अंतर्निहित सीमा निर्माण का उपयोग करें Ẇ- के Rm2Ẇसाथ बदलें ẆḤ’)

ẆḤ’S_¥Ðḟ⁸Ṫ

यदि संभव हो, या 0नहीं तो समन की एक सूची लौटाने वाला एक विचित्र लिंक ।

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

कैसे?

ẆḤ’S_¥Ðḟ⁸Ṫ - Link: number, n
Ẇ          - all sublists (implicit range of input) note: ordered by increasing length
           -                i.e. [[1], [2], [3], ..., [1,2], [2,3], ..., [1,2,3], ...]]
 Ḥ         - double              [[2], [4], [6], ..., [2,4], [4,6], ..., [2,4,6], ...]]
  ’        - decrement           [[1], [3], [5], ..., [1,3], [3,5], ..., [1,2,5], ...]]
        ⁸  - link's left argument, n
      Ðḟ   - filter out items for which the following yields a truthy value:
     ¥     -   last two links as a dyad:
   S       -     sum
    _      -     subtract the right from the left = sum - n
         Ṫ - tail (last and hence longest such run)

— जोनाथन एलन
स्रोत

1

ẆḤ’एक बाइट बचाता है।

— डेनिस

8

जावास्क्रिप्ट (ईएस 7), 87 86 85 81 बाइट्स

पूर्णांक की अल्पविराम-सीमांकित सूची देता है, या 0यदि कोई समाधान मौजूद नहीं है।

n=>(g=(s,k,x=n+s)=>(x**.5|0)**2-x?k>n?0:g(s+k,k+2):(n-=k)?k+','+g(-n,k+2):k)(0,1)

कैसे?

हम पहले सबसे छोटे पूर्ण वर्ग s की तलाश करते हैं जैसे कि x = n + s एक और पूर्ण वर्ग है।

यदि s मौजूद है, तो n अंतर x है - 2 पूर्ण वर्गों का, जिसे लगातार विषम संख्याओं के 2 क्रमों के अंतर के रूप में लिखा जा सकता है। हम फिर परिणामी सूची बनाते हैं।

उदाहरण:

के लिए एन = 104 :

हमें s = 11 find = 121 मिलता है जो x = n + s = 225 = 15² को संतुष्ट करता है

फिर:

15 = 1 + 3 + 5 + 7 + 9 + 11 + 13 + 15 + 17 + 19 + 21 + 23 + 25 + 27 + 29
11 27 = 1 + 3 + 5 + 7 + 9 + 11 + 13 + 15 + 15 + 17 + 19 + 21
104 = 15² - 11² = 23 + 25 + 27 + 29

कोड स्निपेट दिखाएं

let f =

n=>(g=(s,k,x=n+s)=>(x**.5|0)**2-x?k>n?0:g(s+k,k+2):(n-=k)?k+','+g(-n,k+2):k)(0,1)

console.log(f(1))   // -> 1
console.log(f(2))   // -> 0
console.log(f(3))   // -> 3
console.log(f(4))   // -> 1,3
console.log(f(5))   // -> 5
console.log(f(6))   // -> 0
console.log(f(9))   // -> 1,3,5
console.log(f(15))  // -> 3,5,7
console.log(f(104)) // -> 23,25,27,29

स्निपेट का विस्तार करें

— Arnauld
स्रोत

3

रुको आप मुझे बता रहे हैं कि n^2हमेशा पहली nविषम संख्याओं के योग के बराबर है ? हुह, दिलचस्प

— स्किड्सदेव

2

@ माय्यूब वास्तव में !

— अरनुलद

1

math.stackexchange.com/questions/639068/...

— PatrickT

7

05AB1E , 9 8 बाइट्स

-1 बाइट एमिग्ना के लिए धन्यवाद

ÅÉŒʒOQ}н

स्पष्टीकरण:

ÅÉ           Generate a list of odd numbers up to, and including, the input
  Œ          Substrings
   ʒ         Only keep values
    O          where the sum
     Q         equals the input
       }     End
             For 9, the result would look like this:
             [[1, 3, 5], [9]]
        н    Get the first value

अमान्य इनपुट पर, आउटपुट कुछ नहीं करता है।

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

— Okx
स्रोत

ʒOQ}इसके बजाय DO¹QÏएक बाइट बचाता है।

— एमिगा जूल

@JonathanAllan डॉक्स का कहना है कि "असमान" इसलिए कि भ्रमित हो सकता है ...

— एरिक आउटगोलर

1

@JonathanAllan छोटी सी गलती। फिक्स्ड।

— ओकेक्स

6

हास्केल , 61 60 बाइट्स

1 बाइट शेविंग करने के लिए @maple_shaft को धन्यवाद

f n=[k|r<-[1,3..],s<-[r,r+2..n],k<-[[r,r+2..s]],sum k==n]!!0

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

इस तथ्य का उपयोग करता है कि सबसे लंबा रन हमेशा वह रन होगा जो सबसे कम संख्या से शुरू होता है।

मैं ब्रूट-फोर्सिंग के स्थान पर अंकगणित के साथ कुछ करना चाहता था k, लेकिन fromIntegerलगता है कि इसे मार डाला जाए।

— जूलियन वुल्फ
स्रोत

आप अपने आप को एक बाइट में बदल [1,3..n]सकते हैं[1,3..]

— मेपल_शाफ्ट

1

आप एक सहायक कार्य के साथ 7 बाइट्स बचा सकते हैं r?n=[r,r+2..n]। इसे ऑनलाइन आज़माएं!

— अर्जन जोहान्सन

4

पायथन , 67 बाइट्स

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

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

मैं की नकल की पिछले लगातार योग चुनौती से मेरा उत्तर है और उसे बदला +1करने के लिए +2। कौन जानता था कि गोल्फ कोड इतना मॉड्यूलर हो सकता है?

एक विषम सीधी रणनीति: Rवांछित राशि के साथ अंतराल की खोज करें ।

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

चूंकि अंतराल का निचला सिरा केवल बढ़ता है, इसलिए छोटे अंतराल से पहले लंबे अंतराल पाए जाते हैं। यदि कोई संभावित अंतराल नहीं पाया जा सकता है, तो IndexError के साथ समाप्त होता है।

— XNOR
स्रोत

4

जावास्क्रिप्ट (ईएस 6), 65 64 बाइट्स

f=(a,i=1)=>a>i?(c=f(a-i,i+=2))[0]==i?[i-2,...c]:f(a,i):a<i?0:[i]

यदि कोई समाधान है, या 0 के लिए कोई समाधान नहीं है, तो एक सरणी देता है।

यह समस्या के लिए एक अत्यधिक अक्षम अभी तक गोल्फ समाधान है।

यह पहले समाधान का उपयोग करके खोज करता है a-iऔर i=1, भले ही यह पुनरावर्ती स्टैक का काम न करे। यदि वह समाधान शुरू नहीं होता है i+2, तो हम पुन: उपयोग करके पहले समाधान के लिए खोज करते हैं aऔर i+2।

Ungolfed

f=(a,i=1)=>
  a > i ? 
    (c = f(a - i, i += 2))[0] == i ? 
      [i-2, ...c] : 
      f(a, i) :
  a < i ? 
    0 :
    [i]

परीक्षण के मामलों:

कोड स्निपेट दिखाएं

f=(a,i=1)=>a>i?(c=f(a-i,i+=2))[0]==i?[i-2,...c]:f(a,i):a<i?0:[i]

console.log(JSON.stringify(f(1)));   //[1]
console.log(JSON.stringify(f(3)));   //[3]
console.log(JSON.stringify(f(4)));   //[1, 3]
console.log(JSON.stringify(f(5)));   //[5]
console.log(JSON.stringify(f(6)));   //[0]
console.log(JSON.stringify(f(9)));   //[1, 3, 5]
console.log(JSON.stringify(f(15)));  //[3, 5, 7]
console.log(JSON.stringify(f(104))); //[23, 25, 27, 29]

Expand snippet

यह कितना अक्षम है, इस विचार के लिए, f(104)69,535 पुनरावर्ती कॉल की आवश्यकता है। स्टैक कभी भी 51 से अधिक स्तर गहरा नहीं होता है, इसलिए स्टैक ओवरफ्लो के साथ कोई समस्या नहीं है।

समाधान के f(200)लिए 8.6 मिलियन पुनरावर्ती कॉल की आवश्यकता होती है , जिसमें एक स्टैक 99 का स्तर गहरा होता है। (इसका समाधान है [11,13,15,17,19,21,23,25,27,29]।)

यहां चल रहे कार्यक्रम का एक दृश्य प्रतिनिधित्व है:

कोड स्निपेट दिखाएं

r=0;
output=o=>setTimeout(_=>O.textContent += o + '\n', r++ * 20);

f=(a,i=1,s='',o = s + 'a=' + a + '; i=' + i + ';')=>
(
  output(o),
  a > i ? 
    (c = f(a - i, i += 2, s + '  '))[0] == i ? (
      output(o + ' a > i; [i-2, ...c] = [' + [i-2, ...c] + '];'),
      [i-2, ...c]
    ) : (
      output(o + ' a > i; c=[' + c + ']; ' + 'c[0]+2 != i ... dead end\n' + s + 'trying a, i+2:'),
      f(a, i, s)
    ) :
  a < i ? (
    output(o + ' a < i ... dead end'),
    0 
  ) : (
    output(o + ' a == i;'),
    [i]
  )
)

f(21);  //[5, 7, 9]

<pre id=O></pre>

Expand snippet

— रिक हिचकॉक
स्रोत

3

पायथन 2.7, 109 108 97 बाइट्स

11 बाइट्स डाउन, एरिक द आउटगॉल्फ को धन्यवाद।

यह मेरा पहला कोड गोल्फ है!

def f(N):
 for n in range(N):
    x=(n*n+N)**.5-n
    if x%1==0:return[2*(k+n)+1for k in range(int(x))]

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

मैं अच्छी तरह से ज्ञात पहचान का उपयोग करता था 1 + 3 + 5 + ... + (2n - 1) = n²

मामले को लें 15

15 = 3 + 5 + 7 = (1 + 2) + (3 + 2) + (5 + 2) = (1 + 3 + 5) + 3×2 = 3² + 3×2

सामान्य तौर पर, अगर वहाँ से शुरू होने वाले एक्स शब्द हैं 2n + 1, जैसे

(2n + 1) + (2n + 3) + (2n + 5) ... (2n + (2x-1))

के बराबर है 2nx + x²

यदि Nइनपुट पूर्णांक है, तो समस्या अधिकतम को खोजने के लिए कम हो जाती xहै

x² + 2nx - N = 0

यह समाधान के साथ एक द्विघात समीकरण है

x = sqrt(n² + N) - n

सबसे लंबा क्रम सबसे बड़ा है x। कार्यक्रम इससे पुनरावृत्त nहोता 0है Nऔर जब यह पता चलता xहै कि यह पूर्णांक है, तो यह सूची बनाता है (2n + 1) + (2n + 3) + (2n + 5) ... (2n + (2x-1))और इसे लौटाता है।

— dark32
स्रोत

1

आप तुच्छ रूप से गोल्फ को 11 बाइट्स कर सकते हैं।

— आउटगोल्फ जूल

@EriktheOutgolfer, धन्यवाद, मैं टैब का उपयोग करने के बारे में भूल गया (=

— dark32

3

पायथन 3, 190 81 बाइट्स

def c(q,l,i):
    if sum(l)0:
        l.append(i)
        return c(q,l,i+2)
    elif sum(l)>q:
        l.pop(0)
        return c(q,l,i)
    else:
        print(l)
c(q,[1],1)

c=lambda q,l=[1]:c(q,l+[l[-1]+2])if(sum(l)<q)*l else c(q,l[1:])if sum(l)>q else l

@Ovs और @ musicman523 के लिए धन्यवाद

— साइमन
स्रोत

4

आप केवल कुछ इंडेंटेशन को हटाकर इसे 122 बाइट्स तक प्राप्त कर सकते हैं । यदि आप अपने कोड को और छोटा करना चाहते हैं, तो पायथन में गोल्फ के लिए टिप्स देखें ।

— अंडा

3

यह पायथन 3 में नहीं चलता है, क्योंकि कॉल में printकोष्ठक गायब है

— संगीतज्ञ 523

2

आप l.append(i)केवल l+[i]पुनरावर्ती कॉल में उपयोग करके निकाल सकते हैं। आप पुनरावर्ती कॉल में l.pop(0)उपयोग करके निकाल सकते l[1:]हैं। आप cइसके बजाय कीवर्ड तर्कों का उपयोग करके कॉल को बहुत नीचे तक हटा सकते हैं । आप >0लाइन 2 पर हटा सकते हैं । अंत में, आप अपने ifऔर elseकथनों को अभिव्यक्तियों में बदल सकते हैं , टर्नरी फॉर्म का उपयोग करते हुए, जो आपको लंबोदर अभिव्यक्ति के रूप में 92 बाइट्स तक ले जाता है। इसे ऑनलाइन आज़माएं!

— संगीतकार ५२३

1

@ Musicman523 सुझावों के आधार पर हम अभी भी स्थितियों को छोटा कर सकते हैं और iकुल 81 बाइट्स प्राप्त कर सकते हैं ।

— 6

मुझे लगता है कि आप को बदल सकता है sum(l)>q elseके लिए q<sum(l)else1 बाइट को बचाने के लिए।

— Zacharý

2

QBIC , 47 बाइट्स

{_Cg=q┘q=q+2~g>:|_Xp\?g,[q,a,2|?b,┘g=g+b~g=a|_X

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

व्याख्या

{       Do infinitely
_C      Clear the screen (we basically print every run of odd numbers, but clear out everything that doesn't sum up to n)
g=q     Set g to the first num of this cycle (q starts as 1 in QBIC)    
┘       (Syntatcic linebreak)
q=q+2   Raise q to the next odd number, this sets up both the next outer loop as well as a coming FOR loop
~g>:|   If we start out with a number > n (read as 'a' from the cmd line)
_Xp     THEN quit, printing 0 (the value of the number var 'p')
\       ELSE
[q,a,2| FOR b = q, b <= n, b+=2
?b,┘    PRINT b followed by a tab
g=g+b   Add 'b' to running total 'g'
~g=a|   and if that lands us on 'n'
_X      QUIT (printing nothing: everything is already printed)

— steenbergh
स्रोत

1

आर , 90 बाइट्स

f=function(x,y=1)'if'(length(w<-which(cumsum(r<-y:x*2-1)==x)),r[1:w],'if'(y>x,0,f(x,y+1)))

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

एक पुनरावर्ती फ़ंक्शन का उपयोग करता है जो अनुक्रम अनुक्रम y का योग करता है: x एक विषम संख्या अनुक्रम में परिवर्तित हो जाता है। जब तक यह x से अधिक नहीं हो जाता, तब तक प्रत्येक पुनरावर्तन पर y को बढ़ाया जाता है। पहला अनुक्रम जो लक्ष्य के लिए बोता है, उसे वापस कर दिया जाएगा।

— MickyT
स्रोत

1

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

lambda n,r=range:[v for v in[r(1,n+1,2)[i:j]for i in r(n)for j in r(n+1)]if sum(v)==n][0]

एक अनाम फ़ंक्शन एक सकारात्मक पूर्णांक ले रहा है n, और यदि यह मौजूद है और एक IndexErrorअन्यथा बढ़ाकर परिणाम लौटाता है ।

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

उन सभी प्रासंगिक विषम संख्याओं की सूची बनाता है r(1,n+1,2)जिनके साथ है range(start=1, stop=n+1, step=2); कि से सभी प्रासंगिक उप स्लाइस (प्लस कुछ खाली वाले) टुकड़ा करने की क्रिया द्वारा पैदा iकरने के लिए समावेशी jके साथ विशेष [i:j]भर iमें [0, एन) का उपयोग करते हुए r(n)और jमें 0 [, एन] का उपयोग कर r(n+1)(खाली लोगों जब i>=jया iसीमा से बाहर है); सही राशि वाले लोगों के लिए फ़िल्टर if sum(v)==n; इस तरह के स्लाइस का उपयोग करके पहला (और इसलिए सबसे लंबा) रिटर्न देता है [0]।

— जोनाथन एलन
स्रोत

1

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

-1 बाइट @ @McAvoy को धन्यवाद

lambda n,r=range:[r(i,j+1,2)for i in r(1,n+1,2)for j in r(i,n+1,2)if(i+j)*(2+j-i)==4*n][0]

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

— अण्डों का
स्रोत

1

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

efqsTQ.:%2S

इसे यहाँ आज़माएँ।

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

1

PHP , 73 बाइट्स

कोई समाधान अनंत लूप नहीं है

for($e=-1;$s-$i=$argn;)$s+=$s<$i?$n[]=$e+=2:-array_shift($n);print_r($n);

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

पीएचपी , 83 बाइट्स

कोई समाधान नहीं के लिए प्रिंट

हर इनपुट mod 4 == 2 का कोई हल नहीं है

for($e=-1;($i=$argn)%4-2&&$s-$i;)$s+=$s<$i?$n[]=$e+=2:-array_shift($n);print_r($n);

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

— जार्ग हुल्सरमैन
स्रोत

अयोग्य इनपुट का पता लगाने में विफल रहता है

— टाइटस

@ टिट्स तय ...

— जॉर्ग हल्सरमन

0

पायथन 2 , 122 121 119 115 बाइट्स

-1 बाइट संगीतज्ञ 523 के लिए धन्यवाद। चरण बाइट के लिए -4 बाइट्स धन्यवाद। ^haha

def f(n,R=range):r=R(1,n,2);print[i for w in R(1,len(r)+1)for i in[r[j:j+w]for j in R(len(r)-w+1)]if sum(i)==n][-1]

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

— पूरी तरह से
स्रोत

1

यह एक बाइट एक फ़ंक्शन के रूप में छोटा है। इसे ऑनलाइन आज़माएं!

— संगीतज्ञ ५२३

यदि आप फिर से परिभाषित करते हैं range, तो बाइट्स सहेजें , इसे ऑनलाइन आज़माएं!

— स्टीफन

यह 1 के लिए विफल रहता है ।

— डेनिस

0

पायथन 3 , 93 बाइट्स

lambda n,r=range:[[*r(s,e+1,2)]for s in r(1,n+1,2)for e in r(s,n+1,2)if(s+e)*(2+e-s)==4*n][0]

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

केवल विशेष चीज जो मैंने किया था वह उस (s+e)*(2+e-s)==4*nके बराबर नहीं है sum(range(s,e+1,2))==n, और हालांकि वे एक ही आकार के हैं r=range, जब पूर्व को ifकथन के करीब रखा जा सकता है ।

— C मैकआवॉय
स्रोत

0

पायथन 3 , 185 बाइट्स

def f(s):
  d={k:v for k,v in{a:(1-a+((a-1)**2+4*s)**(.5))/2 for a in range(1,s,2)}.items()if int(v)==v};m=max(d.keys(), key=(lambda k: d[k]));return list(range(int(m),int(m+2*d[m]),2))

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

यह कैसे काम करता है, इसके लिए मैंने एक साधारण जानवर बल खोज की तुलना में थोड़ा अधिक सुरुचिपूर्ण समाधान की कोशिश की। मैंने अंकगणितीय अनुक्रम के योग के सूत्र को पुन: व्यवस्थित किया और अभिव्यक्ति प्राप्त करने के लिए द्विघात सूत्र लागू किया (1-a+((a-1)**2+4*s)**(.5))/2, जो कोड में दिखाई देता है। अभिव्यक्ति की गणना क्या है, एक वांछित राशि sऔर अंकगणितीय अनुक्रम के लिए पहला शब्द दिया गया है, अनुक्रम aकी लंबाई। ये लंबाई कुंजी के रूप में पहले शब्दों के मान के रूप में एक शब्दकोश में संग्रहीत की जाती हैं।

इसके बाद, सभी गैर-पूर्णांक मान शब्दकोश से हटा दिए जाते हैं, क्योंकि वे अमान्य अनुक्रमों का प्रतिनिधित्व करते हैं। वहां से, सबसे बड़े मूल्य की पहचान की जाती हैmax(d.keys(), key=(lambda k: d[k])) और उस स्थिति में विषम संख्या के अनुक्रम और उस लंबाई के साथ बनाया जाता है list(range(int(m),int(m+2*d[m]),2))।

अगर आप कुछ भी देख रहे हैं तो मैं इसे मदद के लिए खोज रहा हूं। मुझे यह देखने में अधिक दिलचस्पी थी कि मैं गैर-तुच्छ एल्गोरिथ्म के साथ कितना अच्छा कर सकता था; मेरा जवाब सबसे अच्छा पायथन समाधान के रूप में लगभग दो बार है।

— चेस वोगली
स्रोत

क्या यह काम करेगा? repl.it/JTt7 (177 बाइट्स)

— Zacharý

0

मैथेमेटिका, 56 बाइट्स

Last@Cases[Subsequences@Table[n,{n,1,#,2}],x_/;Tr@x==#]&

Functionपहले तर्क के साथ #। Table[n,{n,1,#,2}]से कम या इसके बराबर सकारात्मक विषम संख्याओं की सूची की गणना करता है #। Subsequencesउस सूची के सभी क्रमों को बढ़ाकर लंबाई बढ़ाने का आदेश दिया। हम फिर Casesकौन सा मैच लेते हैं x_/;Tr@x==#, वह है, सीक्वेंस xऐसे कि उनका योग Tr@xइनपुट के बराबर हो #। हम फिर Lastऐसा क्रम लेते हैं ।

— ngenisis
स्रोत

0

जावास्क्रिप्ट (ईएस 6), 72 बाइट्स

n=>(g=s=>s?s>0?g(s-(u+=2)):g(s+l,l+=2):u-l?l+' '+g(s,l+=2):u)(n-1,l=u=1)

अमान्य इनपुट पर एक अंतरिक्ष-पृथक स्ट्रिंग की संख्या लौटाता है या फेंकता है। 84 बाइट संस्करण जो एक रिटर्न (उपयुक्त होने पर खाली) सरणी:

n=>n%4-2?(g=s=>s?s>0?g(s-(u+=2)):g(s+l,l+=2):u-l?[l,...g(s,l+=2)]:[u])(n-1,l=u=1):[]

स्पष्टीकरण: मैं लगातार कुछ बाइट्स को बचाने के लिए पुनरावृत्ति का उपयोग करके सक्षम करने के लिए सक्षम होने के अलावा @ Cabbie407 के अजीब समाधान पर आधारित था।

— नील
स्रोत

0

PHP, 78 बाइट्स

for($b=-1;$s-$argn;)for($n=[$s=$x=$b+=2];$s<$argn;)$s+=$n[]=$x+=2;print_r($n);

कोई समाधान नहीं तो अनंत लूप। इसके बजाय खाली सरणी मुद्रित करने ?$b>$argn+2?$n=[]:1:0के $s-$argnलिए डालें ।

इसे ऑनलाइन चलाएं -nRया इसके लिए प्रयास करें ।

— टाइटस
स्रोत

0

C # (.NET Core) , 129 बाइट्स

(i)=>{int s,j,b=1,e=3;for(;;){var o="";s=0;for(j=b;j<e;j+=2){s+=j;o+=j+" ";}if(s==i)return o;s=s<i?e+=2:b+=2;if(b==e)return"";}};

एक स्ट्रिंग में आउटपुट संख्या, अंतरिक्ष सीमांकित (किसी अन्य वर्ण को बस बदलने की आवश्यकता होगी " ")। बिना किसी समाधान के इनपुट एक खाली स्ट्रिंग देता है (हालांकि यदि बिना त्रुटि के हमेशा के लिए चलने का कोई समाधान नहीं है, तो 17 बाइट्स को हटाने से बचाया जा सकता है।if(b==e)return""; )।

एल्गोरिथम है:

[1] से शुरू करें
यदि योग लक्ष्य के बराबर है, तो सूची वापस करें
यदि राशि लक्ष्य से कम है, तो अगली विषम संख्या जोड़ें
यदि राशि लक्ष्य से अधिक है, तो पहले आइटम को हटा दें
यदि सूची खाली है, तो उसे वापस कर दें
2 से दोहराएं

— कामिल दकरी
स्रोत

आप के (i)=>रूप में लिख सकते हैंi=>

— aloisdg का कहना है कि मोनिका

0

सी ++, 157 -> 147 बाइट्स

-10 बाइट्स DJMcMayhem के लिए धन्यवाद

यदि कोई उत्तर नहीं है, तो 0 वापस आ जाएगा, अन्यथा

अंतिम पंक्ति यह प्रिंट का उत्तर है

int f(int n){for(int i=1;;i+=2){int v=0;for(int k=i;;k+=2){v+=k;std::cout<<k<<" ";if(v==n)return 1;if(v>n)break;}if(i>n)return 0;std::cout<<"\n";}}

ungolfed:

int f(int n)
{
    for (int i = 1;; i += 2)
    {
        int v = 0;
        for (int k = i;; k += 2)
        {
            v += k;
            std::cout << k << " ";
            if (v == n)
                return 1;
            if (v > n)
                break;

        }
        if (i > n)
            return 0;
        std::cout << "\n";
    }
}

यह मेरा पहला कोड गोल्फ ^ ^ है

— SeeSoftware
स्रोत

आप कुछ बाइट्स बचा सकते हैं यदि आप इसे एक इंट फ़ंक्शन करते हैं और 0 या 1. लौटाते हैं, तो आप इसके int v=0;बजाय कर सकते हैं int v;....v=0;और यदि आपने अपना आउटपुट न्यूलाइन सीमांकित किया है, तो आप कर सकते हैं std::cout<<k<<"\n";और फिर दूसरी न्यूलाइन को पूरी तरह से हटा सकते हैं

— DJMcMayhem

अगर मैंने अंतिम पुनर्मूल्यांकन किया है, तो यह हर एक नंबर पर एक नई लाइन प्रिंट करेगा, लेकिन मैं संख्या समूहों को अलग करना चाहता हूं, लेकिन -10 बाइट्स के लिए धन्यवाद वैसे भी

— SeeSoftware

0

कोटलिन, 152 बाइट्स

fun f(a:Double){var n=Math.sqrt(a).toInt()+1;var x=0;while(n-->0){if(((a/n)-n)%2==0.0){x=((a/n)-n).toInt()+1;while(n-->0){println(x.toString());x+=2}}}}

इसे ऑनलाइन आज़माएं (4-5 सेकंड प्रतीक्षा करें, संकलक धीमा है)

Ungolfed

fun f(a: Double){
    var n=Math.sqrt(a).toInt()+1;
    var x=0;

    while(n-->0){
        if(((a/n)-n)%2==0.0){
            x=((a/n)-n).toInt()+1;

            while(n-->0){
                println(x.toString());
                x+=2;
            }

        }
    }
}

— Оввгений Новиков
स्रोत

0

एक्सेल VBA, 139 बाइट्स

Subरूटीन जो nअपेक्षित प्रकार के पूर्णांक का इनपुट लेता है और सेल में लगातार विषम संख्याओं के सबसे लंबे अनुक्रम की रिपोर्ट करता है[A1]

Sub a(n)
For i=1To n Step 2
s=0
For j=i To n Step 2
s=s+j
If s=n Then:For k=i To j-1 Step 2:r=r &k &"+":Next:[A1]=r &j:End
Next j,i
End Sub

— टेलर स्कॉट
स्रोत

लगातार विषम संख्याओं का योग

चुनौती

परीक्षण के मामलों

स्कोरिंग

हास्केल, 67 65 63 62 58 बाइट्स

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

जेली , 11 10 बाइट्स

कैसे?

जावास्क्रिप्ट (ईएस 7), 87 86 85 81 बाइट्स

कैसे?

05AB1E , 9 8 बाइट्स

हास्केल , 61 60 बाइट्स

पायथन , 67 बाइट्स

जावास्क्रिप्ट (ईएस 6), 65 64 बाइट्स

पायथन 2.7, 109 108 97 बाइट्स

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

पायथन 3, 190 81 बाइट्स

QBIC , 47 बाइट्स

व्याख्या

आर , 90 बाइट्स

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

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

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

PHP , 73 बाइट्स

पीएचपी , 83 बाइट्स

पायथन 2 , 122 121 119 115 बाइट्स

पायथन 3 , 93 बाइट्स

पायथन 3 , 185 बाइट्स

मैथेमेटिका, 56 बाइट्स

जावास्क्रिप्ट (ईएस 6), 72 बाइट्स

PHP, 78 बाइट्स

C # (.NET Core) , 129 बाइट्स

सी ++, 157 -> 147 बाइट्स

कोटलिन, 152 बाइट्स

एक्सेल VBA, 139 बाइट्स