सकारात्मक पूर्णांक N को देखते हुए , आपका कार्य N तक पहुंचने के लिए निम्न एल्गोरिथम द्वारा आवश्यक चरणों की संख्या को वापस करना है :

सबसे छोटा त्रिभुजाकार संख्या T _i ज्ञात करें कि T _i । N। संबंधित सूची L = [1, 2, ..., i] बनाएँ ।
जबकि L की शर्तों का योग N से अधिक है , सूची से पहला शब्द हटा दें।
यदि L की शर्तों का योग अब N से कम है , तो वेतन वृद्धि i और इसे सूची में जोड़ें। # 2 कदम के साथ जाओ।

N के पहुँचते ही हम रुक जाते हैं । केवल पहले चरण को व्यवस्थित रूप से निष्पादित किया जाता है। चरण # 2 और # 3 को संसाधित नहीं किया जा सकता है।

उदाहरण

नीचे N = 11 के लिए एक उदाहरण दिया गया है :

तो के लिए उम्मीद उत्पादन एन = 11 है 4 ।

अन्य उदाहरण:

एन = 5 - हम टी ₃ = 1 + 2 + 3 = 6 से शुरू करते हैं , इसके बाद 2 + 3 = 5 । अपेक्षित आउटपुट: २ ।
एन = 10 - केवल पहले चरण की आवश्यकता है क्योंकि 10 एक त्रिकोणीय संख्या है: टी ₄ = 1 + 2 + 3 + 4 = 10 । अपेक्षित आउटपुट: १ ।

पहले 100 मान

नीचे 1 ≤ N the 100 के परिणाम हैं :

  1,  2,  1,  4,  2,  1,  2, 10,  2,  1,  4,  2,  6,  2,  1, 22,  8,  2, 10,  2,
  1,  2, 12,  6,  2,  4,  2,  1, 16,  2, 18, 50,  2,  6,  2,  1, 22,  6,  2,  4,
 26,  2, 28,  2,  1,  8, 30, 16,  2,  6,  4,  2, 36,  2,  1,  2,  4, 12, 40,  2,
 42, 14,  2,108,  2,  1, 46,  2,  6,  4, 50,  2, 52, 18,  2,  4,  2,  1, 56, 12,
  2, 20, 60,  4,  2, 22, 10,  2, 66,  2,  1,  4, 10, 24,  2, 40, 72,  8,  2,  6

नियम

आप या तो एक पूर्ण कार्यक्रम या एक फ़ंक्शन लिख सकते हैं, जो या तो प्रिंट करता है या परिणाम देता है।
आपको किसी भी N 55 65536 को मिड-रेंज हार्डवेयर पर एक मिनट से कम समय में संसाधित करना होगा ।
पर्याप्त समय दिया, आपका कार्यक्रम / समारोह को सैद्धांतिक रूप से N के किसी भी मूल्य के लिए काम करना चाहिए जो मूल रूप से आपकी भाषा द्वारा समर्थित है। यदि ऐसा नहीं है, तो कृपया अपने उत्तर में स्पष्ट करें।
यह कोड गोल्फ है, इसलिए बाइट्स जीत में सबसे छोटा जवाब है!

code-golf math integer-partitions

— Arnauld
स्रोत

सम्बंधित। (मुझे संदेह है कि आप पहले से ही इस बारे में जानते हैं, लेकिन सिर्फ इसे पोस्ट करने के लिए पोस्ट कर रहे हैं)

— ETHproductions

हमें संभालने के लिए N की अधिकतम कीमत क्या है?

— ल्यूक

@ ल्यूक कृपया अद्यतन नियम देखें।

— अरनौलद

4

जेली , 29 31 बाइट्स

ÆDµ’H+Ṛ%1$ÐḟṂ
>TḢ_@Ç}‘Ḥ
R+\ðċȯç

परिणाम को वापस करने वाला एक मोनडिक लिंक (N = 65536 दो सेकंड से कम समय लेता है)।

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

कैसे?

एल्गोरिथ्म की गहन व्याख्या के लिए मार्टिन एंडर द्वारा शानदार पोस्ट देखें ।

ÆDµ’H+Ṛ%1$ÐḟṂ - Link 1, smallest natural number, M, that satisfies the below*, N
              - * N = T(M) - T(i) for some non-negative integer i <= M
ÆD            - divisors of N
  µ           - monadic chain separation, call that d
   ’          - increment d (vectorises)
    H         - halve (vectorises
      Ṛ       - reverse d
     +        - add (vectorises)
          Ðḟ  - filter discard if:
       %1$    -   modulo one is truthy (those which are the result of even divisors)
            Ṃ - minimum

>TḢ_@Ç}‘Ḥ - Link 2, evaluate result for non-triangular: list of T(1) to T(N), N
>         - T(i) > N
 T        - truthy indexes
  Ḣ       - head (yields the first i for which T(i) > N)
     Ç}   - call last link (1) as a monad converted to a dyad using the right argument
   _@     - subtract with reverse @rguments
       ‘  - increment
        Ḥ - double 

R+\ðċȯç - Main link: N
R       - range -> [1,2,...,N]
 +\     - reduce with addition -> [1,3,6,10,...T(N)]
   ð    - dyadic chain separation, call that t
    ċ   - count occurrences of N in t (1 if N is triangular else 0)
      ç - call last link (2) as a dyad(t, N)
     ȯ  - or

29 बाइट पूर्ण-प्रोग्राम कार्यान्वयन मैं वर्णित एल्गोरिथ्म से बना मेरे लैपटॉप पर एन = 65536 के लिए 4 मिनट 30 लेता है, इसलिए मुझे लगता है कि इसकी गिनती नहीं है।

Ṁ‘ṭµS<³µ¿
ḊµS>³µ¿
0®Ḃ‘©¤ĿÐĿL’

हर चरण 3 के लिए थोड़ी देर के लूप का उपयोग करना और चरण 1 के रूप में इसका पुन: उपयोग करना लंबाई के बराबर है जो मैं सूची को शुरू करने के साथ प्रबंधित कर सकता हूं क्योंकि चरण 3 पर कोई भी जांच का मतलब सूची बनाना नहीं है जब तक कि कुछ भी नहीं रहता है और फिर मूल्य का पहला सूचकांक ढूंढता है:

ḊµS>³µ¿
Ṁ‘ṭ
Ḥ½_.ĊR®Ḃ‘©¤ĿÐĿS€i

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

25

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

Min[2#/(d=Divisors@#~Cases~_?OddQ)+d]-2⌊(2#)^.5+.5⌋+⌈Sqrt[8#+1]~Mod~1⌉&

व्याख्या

मुझे चुनौती में एल्गोरिथ्म को लागू करने के लिए परेशान नहीं किया जा सकता है, इसलिए मैं समाधान के लिए एक शॉर्टकट देखना चाहता था। जब मैंने एक पाया, दुर्भाग्य से यह गणितज्ञ उत्तर को हरा नहीं करता है जो एल्गोरिथ्म को लागू करता है। उस ने कहा, मुझे यकीन है कि यह अभी तक गोल्फ नहीं है, और ऐसी अन्य भाषाएं हो सकती हैं जो इस दृष्टिकोण या प्रक्रिया में प्राप्त कुछ अंतर्दृष्टि से लाभ उठा सकती हैं।

इसलिए मेरा दावा है कि हम जिस अनुक्रम की गणना करने वाले हैं वह है:

f (n) = 2 * ( A212652 (n) - A002024 (n)) + 1 + A023532 (n-1)

वैकल्पिक रूप से, यह f (n) = 1 है यदि n त्रिकोणीय संख्या है और f (n) = 2 * ( A212652 (n) - A002024 (n) + 1) अन्यथा।

पहली अभिव्यक्ति में, A023532 केवल इन दो अलग-अलग मामलों को एन्कोड करता है। अन्य दो क्रम (प्लस 1) सबसे बड़े पूर्णांक k के बीच का अंतर है जो कि पूर्णांक में n के सबसे लंबे विघटन में होता है (k-i + 1) + (k-i + 2) + ... + k = n और सबसे बड़ा पूर्णांक j तो 1 + 2 + ... + j <n ।

कुछ सरल शब्दों में, यहां बताया गया है कि हम गैर-त्रिकोणीय संख्याओं के लिए कैसे उत्तर पाते हैं: सबसे पहले, सबसे बड़ा त्रिकोणीय संख्या T _{j खोजें,} जो n से कम है । फिर j वह पेनलाइन इंटीजर है जो चरण 1 के दौरान जुड़ जाता है (क्योंकि j + 1 को जोड़ने के बाद हमने n को पार कर लिया होगा )। फिर संभव के रूप में कई (या छोटे) लगातार पूर्णांकों में n को विघटित करें और इन नंबरों के बीच अधिकतम कॉल करें k । परिणाम केवल 2 * (kj) है । इसका सहज कारण यह है कि अपघटन में अधिकतम हर दूसरे चरण में 1 बढ़ता है और हम पहुंचते ही रुक जाते हैंके ।

हमें यह साबित करने के लिए चार चीजें दिखाने की जरूरत है कि यह काम करता है:

f (n) = 1 त्रिकोणीय संख्याओं के लिए। यह तुच्छ रूप से मामला है, क्योंकि पहला कदम बस सभी त्रिकोणीय संख्याओं के माध्यम से पुनरावृत्त होता है। यदि हम इस प्रक्रिया के दौरान n n से टकराते हैं तो हम कर रहे हैं और गणना करने के लिए केवल एक कदम था।
अन्य सभी नंबरों के लिए, हम हमेशा एक विलोपन चरण के बाद समाप्त होते हैं, एक सम्मिलन चरण के बाद कभी नहीं। इसका मतलब है कि अन्य सभी f (n) सम हैं।
पहले के बाद प्रत्येक प्रविष्टि चरण में, हम केवल एक ही संख्या जोड़ते हैं। यह गारंटी देता है कि हम चरणों के kj जोड़े के बाद कश्मीर सहित एक अपघटन तक पहुंचेंगे ।
N का अंतिम अपघटन जो हमें प्राप्त होता है वह हमेशा n का लगातार पूर्णांक में सबसे लंबे समय तक संभव अपघटन होता है, या दूसरे शब्दों में, सदैव संख्याओं के बीच सबसे कम n के साथ n का अपघटन होता है । दूसरे शब्दों में, हम जिस अंतिम संख्या को जोड़ते हैं वह हमेशा A212652 (n) है ।

हमने पहले ही दिखाया है कि (1) सत्य क्यों है। अगला, हम साबित करते हैं कि हम प्रारंभिक एक को छोड़कर एक प्रविष्टि चरण पर समाप्त नहीं हो सकते हैं (जो गैर-त्रिकोणीय संख्याओं के लिए नहीं होता है)।

मान लीजिए कि हमें एक प्रविष्टि कदम को समाप्त हो गया, तक पहुँचने n एक मूल्य जोड़ने के बाद पी योग करने के लिए। इसका मतलब है कि इस प्रविष्टि कदम से पहले, मूल्य np था ( या कम है अगर हमने एक साथ कई मान जोड़े हैं)। लेकिन यह प्रविष्टि चरण एक विलोपन चरण से पहले था (क्योंकि हम चरण 1 के दौरान n को हिट नहीं कर सकते थे )। एल्गोरिथ्म के काम करने के तरीके के कारण इस विलोपन चरण के दौरान हटाए गए अंतिम मान क्यू आवश्यक रूप से p से कम था । लेकिन इसका मतलब यह है कि इससे पहले कि हम q हटा दें, हमारे पास n-p + q ( या कम ) है जो n से कम है। लेकिन यह एक विरोधाभास है, क्योंकि जब हमने n-p + q मारा, तो एक और q हटाने के बजाय पूर्णांक हटाना बंद करना होगा । यह ऊपर बिंदु (2) साबित होता है। तो अब हम जानते हैं कि हम हमेशा एक विलोपन कदम पर समाप्त होते हैं और इसलिए सभी गैर-त्रिकोणीय संख्याओं में भी आउटपुट होते हैं।

अगला हम साबित करते हैं (3), कि प्रत्येक प्रविष्टि कदम केवल एक मूल्य सम्मिलित कर सकता है। यह अनिवार्य रूप से (2) का एक कोरोलरी है। हमने दिखाया है कि एक मान जोड़ने के बाद हम n को बिल्कुल नहीं मार सकते हैं और चूंकि यह साबित कर रहा है कि असमानता का उपयोग किया जा रहा है, इसलिए हम n को भी समाप्त नहीं कर सकते (तब से n-p + q अभी भी n से कम होगा और हमें हटाया नहीं जाना चाहिए था पहली बार में कई मूल्य)। इसलिए जब भी हम एक मान जोड़ते हैं, तो हम n से अधिक होने की गारंटी देते हैं क्योंकि हम एक छोटे मान को हटाकर n से नीचे चले गए हैं । इसलिए, हम जानते हैं कि राशि का ऊपरी सिरा 1 हर दूसरे चरण से बढ़ता है । हम इस ऊपरी छोर का प्रारंभिक मूल्य जानते हैं (यह सबसे छोटा मीटर ऐसा है)टी _एम > एन )। जब हम अंतिम राशि पर पहुँच जाते हैं तो हमें केवल इस ऊपरी सिरे का पता लगाने की आवश्यकता होती है। फिर चरणों की संख्या बस अंतर से दोगुनी है (प्लस 1)।

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

कहें कि एन का जल्द से जल्द / सबसे लंबा संभव अपघटन कुछ a + (a + 1) + ... (b-1) + b , long b है , और एल्गोरिथ्म इसे छोड़ देता है। समय है कि कम से इसका मतलब है कि ख जुड़ जाता है, एक जरूरी नहीं रह गया है योग का हिस्सा हो। तो एक योग का हिस्सा था रों है, तो हम चाहते हैं n ≤ है उस पल में। तो या तो योग केवल से मान हैं एक करने के लिए ख है, जो बराबर होती है n और हम रोक (इसलिए हम इस विघटन को छोड़ नहीं किया था), या वहाँ कम से कम एक मूल्य से कम है एक राशि में, जीतने के जो मामले n <रोंऔर उस मूल्य को हटा दिया जाएगा जब तक कि हम सटीक राशि (फिर से, अपघटन को छोड़ नहीं दिया गया था) को मारा। तो हम से छुटकारा पाने के होगा एक जोड़ने से पहले ख । लेकिन उस साधन हम होगा एक स्थिति है जिसमें तक पहुंचने के लिए एक राशि में सबसे छोटी घटक है, और सबसे बड़ा नहीं है ख अभी तक। हालाँकि, उस बिंदु पर हम ए नहीं हटा सकते हैं , क्योंकि योग स्पष्ट रूप से n से कम है (क्योंकि बी गायब है), इसलिए हमें मूल्यों को जोड़ने की आवश्यकता है जब तक कि हम बी नहीं जोड़ते हैं और वास्तव में एन को हिट करते हैं। यह साबित करता है (4)।

इसलिए इन चीजों को एक साथ लेना: हम जानते हैं कि चरणों की पहली जोड़ी हमें A002024 (n) का अधिकतम मूल्य देती है । हम जानते हैं कि अंतिम अपघटन का अधिकतम मूल्य A212652 (n) है । और हम जानते हैं कि प्रत्येक जोड़ी में एक बार यह अधिकतम वृद्धि होती है। इसलिए, अंतिम अभिव्यक्ति 2 * ( A212652 (n) - A002024 (n) + 1) है । यह सूत्र लगभग त्रिकोणीय संख्याओं के लिए काम करता है, सिवाय इसके कि हमें केवल 2 के बजाय 1 चरण की आवश्यकता होती है, यही कारण है कि हम त्रिकोणीय संख्याओं (या इसके विपरीत, जो भी अधिक सुविधाजनक है) के सूचक फ़ंक्शन के साथ परिणाम को सही करते हैं।

अंत में, कार्यान्वयन के लिए के रूप में। पूर्व अनुक्रम के लिए, मैं OEIS से सूत्र MIN (विषम d। N; n / d + (d-1) / 2) का उपयोग कर रहा हूं । यह कुछ बाइट्स को बचाने के लिए निकलता है यदि हम MIN (विषम d। = 2n / d + d-1) प्राप्त करने के लिए इस अभिव्यक्ति में 2 का कारक लेते हैं , क्योंकि -1 मेरे पहले संस्करण में +1 के साथ रद्द करता है के च (एन) जो सीधे त्रिकोणीय और गैर त्रिकोणीय संख्या के लिए दो मामलों encodes। कोड में, यह है:

Min[2#/(d=Divisors@#~Cases~_?OddQ)+d]

बाद के अनुक्रम के लिए ( 1, 2, 2, 3, 3, 3, ...), हम एक सरल बंद फॉर्म का उपयोग कर सकते हैं:

⌊(2#)^.5+.5⌋

और अंत में, त्रिकोणीय संख्याओं का व्युत्क्रम सूचक फ़ंक्शन 0 है जब भी 8n + 1 एक पूर्ण वर्ग होता है। इसे गणितज्ञ के रूप में व्यक्त किया जा सकता है

⌈Sqrt[8#+1]~Mod~1⌉

इन अंतिम दो अनुक्रमों को व्यक्त करने और उनके बीच कुछ निरंतर ऑफसेट को स्थानांतरित करने के बहुत सारे तरीके हैं, इसलिए मुझे यकीन है कि यह अभी तक एक इष्टतम कार्यान्वयन नहीं है, लेकिन मुझे आशा है कि इससे दूसरों को नए दृष्टिकोणों को देखने के लिए एक प्रारंभिक बिंदु मिल सकता है। उनकी अपनी भाषाएं।

जब से मैं इस सारी परेशानी में गया, यहाँ n = 1000 तक के अनुक्रम की एक साजिश है (मैं कुछ सेकंड में 100k की गणना भी कर सकता हूं, लेकिन यह वास्तव में कोई अतिरिक्त अंतर्दृष्टि नहीं दिखाता है):

यह उन बहुत सीधी रेखाओं के बारे में विविधताओं को देखना दिलचस्प हो सकता है, लेकिन मैं इसे किसी और को छोड़ दूँगा ...

— मार्टिन एंडर
स्रोत

मैंने आखिरकार आपके उत्तर को अच्छी तरह से पढ़ने के लिए समय लिया। ये जबरदस्त है। ध्यान दें कि (3) पहले से ही एल्गोरिथ्म में मान लिया गया था (चरण # 3 एक है , थोड़ी देर नहीं ), लेकिन प्रमाण है - बेशक - बहुत स्वागत किया।

— अरनौलड़

@ अर्नुलद धन्यवाद। :) मैं अनदेखा किया जाना चाहिए / गलत समझा अगर / जबकि भाग। अच्छी बात यह है कि तब फर्क नहीं पड़ता।

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

7

गणितज्ञ, 72 बाइट्स

(For[l=u=c=k=0,k!=#,c++,If[#>k,While[#>k,k+=++u],While[#<k,k-=l++]]];c)&

शुद्ध कार्य पूर्णांक तर्क ले रहा है।

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

For[ ... ]

एक Forपाश।

l=u=c=k=0

प्रारंभ; सेट l(कम), u(ऊपरी), c(काउंटर), और k(राशि) ०।

k!=#

शर्त; kइनपुट के बराबर होने पर दोहराएं ।

c++

बढ़ते क्रम में; काउंटर बढ़ाना c।

If[#>k,For[,#>k,,k+=++u],For[,#<k,,k-=l++]]

तन

If[#>k, ... ]

यदि इनपुट इससे अधिक है k:

While[#>k,k+=++u]

जबकि इनपुट से अधिक है k, वेतन वृद्धि uऔर वेतन वृद्धि kसे u।

यदि इनपुट इससे अधिक नहीं है k:

While[#<k,k-=l++]

जबकि इनपुट से भी कम है k, घटती kद्वारा lऔर वेतन वृद्धि l।

( ... ;c)

cपाश के बाद लौटें ।

— जंगहवान मिन
स्रोत

1

For[,...]धड़कता है While[...]।

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

5

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

N=input();i=s=0;l=()
while N!=sum(l):exec'while sum(l)'+['<N:i+=1;l+=i,','>N:l=l[1:]'][s%2];s+=1
print s

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

सूची के अंत में शब्द जोड़ने और शुरुआत से शब्द हटाने के बीच विकल्प।

— mathmandan
स्रोत

5

हास्केल , 70 63 68 64 बाइट्स

संपादित करें:

-7 बाइट्स: एक अंतरिक्ष से छुटकारा पा लिया, दो संकेत और कुछ कोष्ठक की भावना को नकारने से a। स्पष्टीकरण में निश्चित ऑफ-बाय-वन त्रुटियां।
+5 बाइट्स: अर्घ, पूरी तरह से याद किया कि 65536 की आवश्यकता है, और यह निकलता है (1) 2 की शक्तियां विशेष रूप से महंगी हैं, क्योंकि वे केवल तब हिट हो जाते हैं जब आप खुद नंबर पर पहुंच जाते हैं (2) इसलिए लंबी दूरी की सीमा होती है (वह लपेटें) चारों ओर शून्य) हर समय। एक गणितीय सूत्र के साथ योग को प्रतिस्थापित किया।
-4 बाइट्स: समायोजन सूत्र में शर्तों को प्राप्त करने के लिए समायोजित aऔर bरैखिक रूप से रद्द करने के लिए।

1#1 एक अनाम फ़ंक्शन लेना और पूर्णांक वापस करना है।

के रूप में उपयोग करें (1#1) 100।

1#1
(a#b)n|s<-a*a-b*b=sum$[a#(b+2)$n|s>8*n]++[(b#a)(-n)+1|s<8*n]

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

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

(a#b)nगणना के वर्तमान चरण का प्रतिनिधित्व करता है। जबकि a, bमें नंबर हैं1, 3, 5, ..n कदम के आधार पर सकारात्मक या नकारात्मक हो सकता है।
- जब चरण 1 या 3 में, यह सूची [(a+1)/2,(a+3)/2..(b-1)/2]और लक्ष्य संख्या का प्रतिनिधित्व करता है-n ।
- जब चरण 2 में, यह सूची [(b+1)/2,(b+3)/2..(a-1)/2]और लक्ष्य संख्या का प्रतिनिधित्व करता है n।
के बीच a, bऔर अजीब पत्राचार छोटी अभिव्यक्ति के साथ योग करने में सक्षम होने के लिए है s=a*a-b*b।
- चरण 1 और 3 में, यह समान है s= -8*sum[(a+1)/2..(b-1)/2]।
- चरण 2 में, यह जैसा है वैसा ही है s=8*sum[(b+1)/2..(a-1)/2]।
शाखाओं में बँटवारे के लिए सूची बोध होता है जो केवल एक ही मामले में तत्वों का उत्पादन करते हैं, और परिणामों को जोड़ते हैं।
- यदि s>8*n, तो b2 से पहले वेतन वृद्धि होती है।
  - चरण 1 और 3 में, यह सूची को बढ़ाता है, जबकि चरण 2 में, यह इसे सिकोड़ता है।
- यदि s<8*n, तो पुनरावृत्ति अदला a- बदली करके कदम बदल देती है b, और नकारा जाता है n, और परिणाम में 1 जोड़ा जाता है।
- यदि s==8*n, तो दोनों में से कोई भी सूची बोध किसी भी तत्व को नहीं देता है, इसलिए योग है 0।
(1#1) nशुरू करने से पहले एक डमी "स्टेज 2" का प्रतिनिधित्व करता है, जो तुरंत चरण 1 में बदल जाता है, जिससे सूची का निर्माण होता है [1..0]=[]।

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

4

PHP> = 7.0, 74 बाइट्स

while($i=$r<=>$argn)for($s++;($r<=>$argn)==$i;)$r+=$i+1?-++$y:++$x;echo$s;

स्पेसशिप ऑपरेटर का उपयोग करें

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

विस्तारित

while($i=$r<=>$argn) # if input is not equal sum of array
  for($s++;  # raise count steps
  ($r<=>$argn)==$i;)
  # so long as value compare to input has not change to lower/higher to higher/lower or equal  
    $r+=$i+1
      ?-++$y # if $i was higher remove the first integer
      :++$x;} # if $i was lower add the next highest integer     
echo$s; # Output steps

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

क्या है $argn?

— चक्स

@chx एक चर जो उपलब्ध है जब आप कमांड लाइन से PHP को -R विकल्प php.net/manual/en/features.commandline.options.php

— Jörg Hülsermann

वाह। मैंने -Rबहुत कम argvया कभी नहीं सुना argi। मुझे बेशक argc और argv का पता था। बहुत दिलचस्प, धन्यवाद।

— शाम

4

सी, 94 91 बाइट्स

ऑनलाइन प्रयास करें

c;s;m;M;f(n){while(s-n){while(s<n)s+=++M;c++;if(s==n)break;while(s>n)s-=++m;c++;}return c;}

— Khaled.K
स्रोत

— एकतरफा

CY में @YSC, वैश्विक स्तर पर घोषित पूर्णांक के अनैतिक रूप से संकलन समय पर शून्य पर सेट हैं। और पढ़ें

— खालिद। के

इस बारे में भूल गए। इस अनुस्मारक के लिए धन्यवाद।

— YSC

FYI करें, मैंने एक और C उत्तर पोस्ट किया । मेरे द्वारा उपयोग किए गए कम से कम एक ट्रिक अन्य संकलक (लापता return) के साथ काम नहीं करेगा , लेकिन जो लोग ऐसा करते हैं, उन्हें अपने उत्तर में शामिल करने के लिए स्वतंत्र महसूस करें।

— hvd

3

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

D=(o,a=0,b=1,d=1,c=0)=>a<o?D(o,a+=b,b+1,d,c+(a>=o)):a>o?D(o,a-=d,b,d+1,c+(a<=o)):c

टेस्ट स्निपेट

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

D=(o,a=0,b=1,d=1,c=0)=>a<o?D(o,a+=b,b+1,d,c+(a>=o)):a>o?D(o,a-=d,b,d+1,c+(a<=o)):c

<input type="number" oninput="o.textContent=D(this.value)"></input>
<pre id='o'></pre>

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

— आर। कप
स्रोत

यह कहने के लिए क्षमा करें, लेकिन प्रत्येक tes 3 बाइट्स के रूप में गिना जाता है। मुझे लगता है कि यह महत्वपूर्ण नहीं है क्योंकि यह तुच्छ नाम बदलने योग्य है।

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

@ MerjanJohansen मुझे याद दिलाने के लिए धन्यवाद। मुझे वास्तव में लंबाई के बजाय बाइट द्वारा अपना कोड याद रखना चाहिए। मुझे नहीं लगता कि "तुच्छ परिवर्तनशील [चर]" पर एक सामुदायिक सहमति है, इसलिए मैंने पोस्ट को संपादित किया। ओह अच्छा।

— आर। कप

3

स्निपेट 6553 पर "बहुत अधिक पुनरावृत्ति" के साथ विफल रहता है। 6553 स्थानीय रूप से नोड (6.9.1) में काम करता है, लेकिन 65536 ("अधिकतम कॉल स्टैक आकार को पार कर गया") नहीं है।

— eush77

3

डीसी , 61 बाइट्स

dsN[ddd9k4*d2*1+dv-0k2/-d1+*2/-d[q]s.0=.-lN-0lN-sNlFx]dsFxz2-

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

व्याख्या

मुख्य पुनरावर्ती मैक्रो:

ddd9k4*d2*1+dv-0k2/-d1+*2/-d[q]s.0=.-lN-0lN-sNlFx
   9k4*d2*1+dv-0k2/-                              # Compute triangular root
                    d1+*2/                        # Compute triangular number
  d                       -d[q]s.0=.              # Check if sum is exact
 d                                  -lN-          # Compute S-N or S+N
                                        0lN-sN    # Update N := -N
d                                             lFx # Leave the trail and recurse

यह मैक्रो:

न्यूनतम त्रिकोणीय संख्या पाता है जो स्टैक पर वर्तमान संख्या से अधिक है (संशोधित त्रिकोणीय मूल सूत्र का उपयोग करके )।
जाँच करता है कि त्रिकोणीय योग Sवर्तमान संख्या का सटीक रूप से प्रतिनिधित्व करता है। बाहर करता है अगर यह करता है।
या तो S+N(अति-सन्निकटन) या S-N(अंडर-अंदाजन) के साथ चरण 1 में आगे बढ़ता है , विकल्प पुनरावृत्तियों के बीच वैकल्पिक होता है।

जब यह बाहर निकलता है, तो स्टैक पर छोड़ा गया निशान मुख्य कार्यक्रम को बताता है कि कितने पुनरावृत्तियों ने इसे लिया।

— eush77
स्रोत

3

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

n=int(input())
S=sum
l=[1]
i=s=1
while S(l)<n:i+=1;l+=[i]
while S(l)!=n:
 while S(l)>n:l.pop(0)
 s+=1
 if S(l)<n:i+=1;l+=[i];s+=1
print(s)

बदलाव का:

बदला गया +, = हटा दिया गया (धन्यवाद Musicman523, Loovjo; -12 बाइट्स)

— L3viathan
स्रोत

1

चरण # 2 सूची से एक बार में एक या कई शब्द निकाल सकते हैं (जैसे कि N = 11 के लिए उदाहरण में 1, 2 और 3) लेकिन इसे एक कदम के रूप में गिना जाता है।

— अरनौलद

@Arnauld ने अनदेखी की; तय की।

— L3viathan

1

क्या आप बता सकते हैं कि क्यों elseजरूरी है? मेरा मानना है कि elseहर बार रन, क्योंकि लूप हमेशा सामान्य रूप से (बिना break) समाप्त होता है , और यह इसके बिना ठीक काम करता है ।

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

आप इसके बजाय A=l.appendभाग को छोड़ सकते हैं और उपयोग कर सकते l+=[x]हैं।

— लोवोजो

3

बैच, 126 बाइट्स

@echo off
set/an=s=l=u=0
:l
if %s% lss %1 set/as+=u+=1,n+=!!l&goto l
if %s% gtr %1 set/as-=l+=1&goto l
cmd/cset/an+n+2-!l

स्पष्टीकरण: lशून्य है यदि चरण 2 को कभी निष्पादित नहीं किया गया है। यह nचरण 3 के पुनरावृत्तियों की संख्या को ट्रैक करने की अनुमति देता है। चूँकि एल्गोरिथ्म चरण 3 पर कभी नहीं रुकता है, इसलिए इसे एक बार चरण 1 और चरण 2 में n+1कुल n+n+2चरणों के लिए चलना चाहिए । हालाँकि अगर पैरामीटर एक त्रिकोणीय संख्या है तो चरण 2 कभी भी निष्पादित नहीं होता है इसलिए हमें एक चरण को घटाना होगा।

— नील
स्रोत

3

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

n=input()
l=u=i=s=0
while n:k=n>0;i+=k^s;s=k;l+=k;n-=l*k;u+=k^1;n+=u*-~-k
print i

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

टीआईओ पर 65536 परीक्षण मामले की गणना करता है 0.183s।

84 बाइट्स पर यह पुनरावर्ती संस्करण 65536 तक के सभी मूल्यों की गणना करने में सक्षम नहीं है:

def f(n,l=[0],m=1):k=n>sum(l);return n==sum(l)or f(n,[l[1:],l+[l[-1]+1]][k],k)+(m^k)

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

— OVS
स्रोत

2

गणितज्ञ, 92 बाइट्स

(For[q=a=b=0;t={},t~AppendTo~q;q!=#,If[q<#,q+=++b,q-=++a]];Length@Split@Sign@Differences@t)&

शुद्ध कार्य पूर्णांक तर्क ले रहा है और पूर्णांक वापस कर रहा है।

चर aऔर bके लिए खड़े (लगातार बदल रहा है) शुरुआत और विचाराधीन राशि में अंत नंबर, जबकि qचल रहा है कुल (संख्या के से के लिए खड़ा a+1करने के लिए b); अब तक सामना किए गए tसभी मूल्यों पर नज़र रखता है q। इन चरों को आरंभ करने के बाद, Forलूप निष्पादित होता रहता है If[q<#,q+=++b,q-=++a], जो या तो अंत में एक नया नंबर जोड़ता है या सामने की ओर संख्या को घटाता है, जब तक कि कल्पना द्वारा निर्धारित नहीं किया जाता है, तब तकq कि इनपुट बराबर ।

अब हमें बस चरणों की संख्या निकालना है t, qरास्ते में आने वाले मूल्यों की सूची । उदाहरण के लिए, जब इनपुट होता है 11, तो Forलूप tबराबर होने के साथ बाहर निकलता है {0,1,3,6,10,15,14,12,9,15,11}। इस से चरणों की संख्या की गणना करने का सबसे अच्छा तरीका मुझे यह गणना करना है कि मतभेदों को ऊपर जाने से कितनी बार स्विच करना है; यह वही है जो क्रिया कमांड Length@Split@Sign@Differences@tकरता है, लेकिन मुझे संदेह है कि इसमें सुधार किया जा सकता है।

— ग्रेग मार्टिन
स्रोत

2

C (tcc), 71 बाइट्स (61 + 10)

कमांड-लाइन तर्क (एक स्थान सहित):

-Dw=while

स्रोत:

c,m,M,s;f(n){w(++c,s-n){w(c&s<n)s+=++M;w(~c&s>n)s-=m++;}--c;}

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

cचरणों की संख्या गिना जाता है। mऔर Mन्यूनतम और अधिकतम सीमा को स्टोर करें,s योग को । प्रारंभ में, वे सभी शून्य हैं।

लगातार, cबढ़ाया जाता है, और sतुलना की जाती है n। जब तक वे असमान हैं:

यदि cविषम है, तो जब तक s<n, सीमा के अंत में एक पूर्णांक जोड़ें: एक से बढ़ें M, और sद्वारा M।
तो cजब तक भी है, तो है s>n, रेंज की शुरुआत से एक पूर्णांक निकालें: कमी sसे m, और बढ़ाने के mएक एक करके।

जब लूप बाहर निकलता है, तो cकई बार एक बढ़ाया गया है। इसे घटाकर सही परिणाम का उत्पादन होता है, और यह वापसी मूल्य के रूप में कार्य करने के लिए सही रजिस्टर में गणना की जाती है।

आम तौर पर ऐसा ही होता है कि खालेद.के सी उत्तर के समान चर नामों का उपयोग किया जाए । वे नकल नहीं कर रहे हैं।

— HVD
स्रोत

1

पर्ल 6 , 114 बाइट्स

{((0,0,1),->(\a,\b,\c){b,(a..*).first(->\d{(d,b).minmax.sum*c>=$_*c}),-c}...->(\a,\b,\c){(a,b).minmax.sum==$_})-1}

(पूर्ववर्ती हास्केल कार्यान्वयन से प्रेरित )

इसे आज़माएं यह
मेरे कंप्यूटर पर 45 सेकंड से कम समय में 65536 इनपुट के साथ चलता है, लेकिन मैं इसे 60 सेकंड से कम समय में TIO.run के साथ चलाने में असमर्थ रहा हूं।
मेरे पास Rakudo v2017.04 + है, जहाँ यह v2017.01 है ।
राकोडो / एनक्यूपी / एमओआरवीएम को लगभग दैनिक रूप से अनुकूलन मिलते हैं, इसलिए अंतरिम से उनमें से कोई भी संख्या हो सकती है जो इसे समय के साथ प्राप्त करने के लिए आवश्यक है।

विस्तारित

{
  (

    # generate a sequence

    (0,0,1),           # initial value 

    -> (\a,\b,\c) {
      b,               # swap the first two values

      (a..*)
      .first(          # find the first number that brings us to or past the input

        -> \d {
          (d,b).minmax # get a Range object regardless of which is larger
          .sum * c     # sum it, and negate it every other time

          >=           # is it equal to or greater than

          $_ * c       # negate the original input every other time
        }

      ),

      -c               # invert for next round
    }

    ...                # keep doing that until

    -> (\a,\b,\c) {
     (a,b).minmax.sum == $_ # it finally reaches the input
    }

  ) - 1 # count the number of elements in the sequence
        # and subtract one for the initializer
}

ध्यान दें कि Rakudo के लिए एक अनुकूलन है Range.sumताकि इसे सभी मूल्यों के माध्यम से पुनरावृति न करना पड़े।

— ब्रैड गिल्बर्ट b2gills
स्रोत

11 = (1 + 2 + 3 + 4 + 5) - (1 + 2 + 3) + (6) - (4)

उदाहरण

पहले 100 मान

नियम

जेली , 29 31 बाइट्स

कैसे?

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

व्याख्या

गणितज्ञ, 72 बाइट्स

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

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

हास्केल , 70 63 68 64 बाइट्स

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

PHP> = 7.0, 74 बाइट्स

सी, 94 91 बाइट्स

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

टेस्ट स्निपेट

डीसी , 61 बाइट्स

व्याख्या

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

बैच, 126 बाइट्स

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

गणितज्ञ, 92 बाइट्स

C (tcc), 71 बाइट्स (61 + 10)

पर्ल 6 , 114 बाइट्स

विस्तारित