एक त्रिकोणीय संख्या एक संख्या है जो n1 से प्राकृतिक संख्याओं का योग है n। उदाहरण के लिए 1 + 2 + 3 + 4 = 10तो 10एक त्रिकोणीय संख्या है।

0 < n <= 10000इनपुट के रूप में एक सकारात्मक पूर्णांक ( ) को देखते हुए (एक पूर्णांक के रूप में, या एक स्ट्रिंग के रूप में लिया जा सकता है), सबसे छोटा संभव त्रिकोणीय संख्या लौटाएं जो इनपुट में एक और त्रिकोणीय संख्या बनाने के लिए जोड़ा जा सकता है।

उदाहरण के लिए दिए गए इनपुट में 26, 10परिणाम जोड़ना 36, जो एक त्रिकोणीय संख्या भी है। इससे छोटी कोई त्रिकोणीय संख्या नहीं है 10जिसे 26एक और त्रिकोणीय संख्या बनाने के लिए जोड़ा जा सकता है , इसलिए 10इस मामले में सही परिणाम है।

0 एक त्रिकोणीय संख्या है, इसलिए यदि इनपुट स्वयं एक त्रिकोणीय संख्या है, तो आउटपुट होना चाहिए 0

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

प्रारूप में मामले दिए गए हैं input -> output (resulting triangular number)

0     -> 0   (0)
4     -> 6   (10)
5     -> 1   (6)
7     -> 3   (10)
8     -> 28  (36)
10    -> 0   (10)
24    -> 21  (45)
25    -> 3   (28)
26    -> 10  (36)
34    -> 21  (55)
10000 -> 153 (10153)

स्कोरिंग

यह प्रत्येक भाषा की जीत में कोड-गोल्फ इतनी कम बाइट्स है !

code-golf number integer

— Skidsdev
स्रोत

है ना 26 -> 2?

— ओकेक्स

@ ओएक्स मैंने वही गलती की, आपको खोजने की आवश्यकता है त्रिकोणीय संख्या बनाने के लिए वर्तमान को जोड़ने के लिए त्रिकोणीय संख्या ।

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

2

सम्बंधित।(बॉर्डरलाइन डुप्लिकेट)

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

21

जावा 8, 58 57 बाइट्स

n->{int i=0,m=0;while(n!=0)n+=n<0?++i:--m;return-~i*i/2;}

ऑनलाइन टेस्ट सूट

1-बाइट बचाने के लिए डेनिस के लिए धन्यवाद ।

— पीटर टेलर
स्रोत

6

अब यह जावा, गोल्फ है! :)

— ओलिवियर ग्रेजायर

4

@Computronium, जावा भाषा विनिर्देश द्वारा संचालन के आदेश की गारंटी है । जावा जानबूझकर सी। की कुछ कमजोरियों से बचता है

— पीटर टेलर

2

@Computronium docs.oracle.com/javase/tutorial/java/nutsandbolts/…

— जॉली जोकर

2

return-~i*i/2;एक बाइट बचाता है।

— डेनिस

1

@ ओक्स जावा आदिम प्रकारों के लिए पास-बाय-वैल्यू है और ऑब्जेक्ट्स (एरे सहित) के लिए पास-बाय-रेफरेंस है। यदि आप वास्तव में उसी चर में आउटपुट करना चाहते हैं, तो आपको पास-पास-संदर्भ संदर्भ में होना चाहिए (स्पष्ट रूप से आपके लिंक में कहा गया है)। जिस तरह से मैं पास-बाय-रेफरेंस देखता हूं, जो काम कर सकता था वह int[]एक intतर्क के बजाय पास करना है। लेकिन इसका मतलब है कि बाद में सरणियों से निपटना। यह काम कर सकता है: x->{int i=0,m=0,n=x[0];while(n!=0)n+=n<0?++i:--m;x[0]=-~i*i/2;}लेकिन यह 63 बाइट्स है।

— ओलिवियर ग्रेजायर

7

Matl , 13 12 बाइट्स

एमिगा के 05AB1E उत्तर से एक विचार (सेट चौराहे) का उपयोग करके 1 बाइट को हटा दिया गया

Q:qYstG-X&X<

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

व्याख्या

आज्ञा देना t(n) = 1 + 2 + ··· + nनिरूपितn वें त्रिकोणीय संख्या।

कोड इस तथ्य का फायदा उठाता है कि, दिया nगया समाधान ऊपरी सीमा से घिरा हुआ है t(n-1)। इसे देखने के लिए, t(n-1) + nबराबर है कि निरीक्षण करते हैं t(n)और इसलिए यह एक त्रिकोणीय संख्या है।

8उदाहरण के रूप में इनपुट पर विचार करें ।

Q:q   % Input n implicitly. Push [0 1 2 ... n]
      % STACK: [0 1 2 3 4 5 6 7 8]
Ys    % Cumulative sum
      % STACK: [0 1 3 6 10 15 21 28 36]
t     % Duplicate
      % STACK: [0 1 3 6 10 15 21 28 36], [0 1 3 6 10 15 21 28 36]
G-    % Subtract input, element-wise
      % STACK: [0 1 3 6 10 15 21 28 36], [-8 -7 -5 -2  2  7 13 20 28]
X&    % Set intersection
      % STACK: 28
X<    % Minimum of array (in case there are several solutions). Implicit display
      % STACK: 28

— लुइस मेंडो
स्रोत

क्या आप Qसीमा के बारे में अपने तर्क से अग्रणी को हटा सकते हैं ?

— ग्यूसेप

@Giuseppe नहीं, जो इनपुट के लिए विफल है 8। जब आउटपुट बाउंड के बराबर होता है t(n-1), तो कोड इसे प्राप्त करता है t(n)-n। इसलिए t(n)जरूरी है। वैसे भी विचार के लिए धन्यवाद!

— लुइस मेंडो

7

जावा (ओपनजेडके 8) , 83 बाइट्स

n->{int m=0,a=n,b;for(;a-->0;)for(b=0;b<=n;)m=2*n+b*~b++==a*~a?a*a+a:m;return m/2;}

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

क्रेडिट

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

— ओलिवियर ग्रेजायर
स्रोत

1

अच्छा जवाब (हमेशा की तरह ..)। जब मैंने पोस्ट किया था तो पहले से ही जावा का जवाब नहीं था। मेरा शुरू में छोटा था, लेकिन अब ऐसा नहीं लगता। :)

— केविन क्रूज़सेन

धन्यवाद! हाँ, मेरा पहला जवाब वास्तव में बेमानी था। मैंने इसे ठीक कर दिया और इसे और अधिक मैथी बना दिया, हालांकि अधिक प्रोसेसर-लालची भी। मैं तुम्हारा एक सेकंड में जाँच करेंगे!

— ओलिवियर ग्रेगोइरे

मुझे अभी भी समझ नहीं आया कि यहाँ क्या हो रहा है। क्यों काम कर रहा है? आप हर बार एम की जगह ले रहे हैं, तो बात क्या है?

— वी। कोर्टोइस

2

@ V.Courtois सबसे छोटा सवाल पूछता है m। इसलिए मैं aनीचे से जाता हूं 0। "लेकिन आप -loop में शायद 100 गुना समान मूल्य a*a+aदे mरहे हैं b", हां, मुझे इसे 100 बार करने की आवश्यकता नहीं है, लेकिन मैं b-loop को पहले नहीं तोड़कर बाइट्स प्राप्त कर रहा हूं ।

— ओलिवियर ग्रेजायर

मैं @ ओलिवियरग्रेयर देखता हूं। तो यह उद्देश्य पर विरोधी कुशल है: डी

— वी। कोर्टोइस

5

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

Min[Select[(d=Divisors[2#])-2#/d,OddQ]^2-1]/8&

— alephalpha
स्रोत

4

नीम , १२ 9 बाइट्स

tS𝕊Λt𝕚)0𝕔

यह गणना करने में बहुत लंबा समय लेता है (लेकिन अनंत समय और स्मृति को देखते हुए काम करता है), इसलिए लिंक में मैं केवल पहले 143 त्रिकोणीय संख्याओं का उपयोग करता हूं - £𝕖जो कि 10,000 के इनपुट को संभालने के लिए पर्याप्त है, लेकिन समय के लिए पर्याप्त नहीं है।

^{चेतावनी: यह भविष्य के संस्करणों में काम नहीं कर सकता है। यदि हां, तो 143 के लिए £ स्थानापन्न करें}

स्पष्टीकरण:

t                 Infinite list of triangular numbers
 [ 𝕖]             Select the first  v  numbers
 [£ ]                              143
     S𝕊           Subtract the input from each element
       Λ  )       Only keep elements that are
        t𝕚          triangular
           0𝕔     Get the value closest to 0 - prioritising the higher number if tie

कोशिश करो!

— Okx
स्रोत

0 और 10000 के बीच किसी भी इनपुट के लिए पहले 143 त्रिकोण नंबर पर्याप्त कैसे हैं? इनपुट के साथ 9998, अपेक्षित परिणाम है 3118753, जो 143 वें त्रिकोण संख्या (जो `10296) के ऊपर है।

— ओलिवियर ग्रेजायर

@ ओलिवियरग्रैगोयर क्योंकिThis takes too long to compute (but works given infinite time and memory)

— स्टीफन

शुक्रिया @StepHen लेकिन ऐसा मैंने नहीं कहा। मैंने जो अनुमान लगाया है वह वाक्य "पहले 143 त्रिकोणीय संख्या [हैं] 10,000 के इनपुट को संभालने के लिए पर्याप्त है" गलत है। मैंने गणित नहीं किया है, लेकिन मेरा मानना है कि 10000 तक के मामलों को संभालने के लिए आपको लगभग 10000 (देने या लेने) त्रिकोण संख्याओं की आवश्यकता होनी चाहिए।

— ओलिवियर ग्रेजायर

@ ओलिवियरग्रेयर मैंने कहा कि यह 10,000 के इनपुट को संभालने के लिए पर्याप्त है, लेकिन इससे कम संख्या में नहीं। £उच्च संख्या में बदलने के लिए स्वतंत्र महसूस करें , जैसे कि 200.

— ओकेक्स

@ ओकेएक्स ठीक है, मुझे यह समझ में नहीं आया कि जब मैंने पहली बार पढ़ा था, तो समझाने के लिए समय निकालने के लिए धन्यवाद :)

— ओलिवियर ग्रेजायर

4

PHP , 45 बाइट्स

for(;!$$t;$t+=++$i)${$argn+$t}=~+$t;echo~$$t;

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

का छोटा संस्करण है for(;!$r[$t];$t+=++$i)$r[$argn+$t]=~+$t;echo~$r[$t];

विस्तारित

for(;!$$t;  # stop if a triangular number exists where input plus triangular number is a triangular number
$t+=++$i) # make the next triangular number
  ${$argn+$t}=~+$t; # build variable $4,$5,$7,$10,... for input 4 
echo~$$t; # Output result

PHP , 53 बाइट्स

for(;$d=$t<=>$n+$argn;)~$d?$n+=++$k:$t+=++$i;echo+$n;

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

PHP 7 में नए स्पेसशिप ऑपरेटर का उपयोग करें

विस्तारित

for(;$d=$t<=>$n+$argn;) # stop if triangular number is equal to input plus triangular number 
  ~$d
    ?$n+=++$k  # raise additional triangular number
    :$t+=++$i; # raise triangular number sum
echo+$n; # Output and cast variable to integer in case of zero

PHP , 55 बाइट्स

for(;fmod(sqrt(8*($t+$argn)+1),2)!=1;)$t+=++$i;echo+$t;

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

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

4

जावा 8, 110 102 100 93 92 बाइट्स

n->{int r=0;for(;t(r)<-t(n+r);r++);return r;}int t(int n){for(int j=0;n>0;n-=++j);return n;}

-2 बाइट्स @PeterTaylor की बदौलत ।
-7 बाइट्स @JollyJoker को धन्यवाद ।
-1 बाइट @ceilingcat की बदौलत ।

स्पष्टीकरण:

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

n->{                  // Method with integer as parameter and return-type
  int r=0;            //  Result-integer (starting at 0)
  for(;t(r)<-t(n+r);  //  Loop as long as neither `r` nor `n+r` is a triangular number
    r++);             //   And increase `r` by 1 after every iteration
  return r;}          //  Return the result of the loop

int t(int n){         // Separate method with integer as parameter and return-type
                      // This method will return 0 if the input is a triangular number
  for(int i=0;n>0;)   //  Loop as long as the input `n` is larger than 0
    n-=++j;           //   Decrease `n` by `j` every iteration, after we've raised `j` by 1
  return n;}          //  Return `n`, which is now either 0 or below 0

— केविन क्रूज़सेन
स्रोत

1

जावा समाधान पढ़ने के लिए सबसे आसान :)

— जॉली जोकर

@ जॉली जोकर शायद इसीलिए सबसे लंबा है। ;) या यह मेरे अतिरिक्त स्पष्टीकरण के कारण है?

— केविन क्रूज़सेन

नहीं, मैं कोड के बारे में सोच रहा था। मैंने संभवत: 15 मिनट बिताए हैं कि पीटर टेलर का समाधान कैसे काम करता है। आपकी टिप्पणी के बिना भी स्पष्ट है।

— जॉली जोकर

3

ब्रजलॉग , १ 17 15 बाइट्स

⟦{a₀+}ᶠ⊇Ċ-ṅ?∧Ċh

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

व्याख्या

⟦                  [0, …, Input]
 {   }ᶠ            Find all…
  a₀+                …Sums of prefixes (i.e. triangular numbers)
       ⊇Ċ          Take an ordered subset of two elements
         -ṅ?       Subtracting those elements results in -(Input)
            ∧Ċh    Output is the first element of that subset

— Fatalize
स्रोत

3

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

lambda n:min((r-2*n/r)**2/8for r in range(1,2*n,2)if n%r<1)

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

यह त्रिकोणीय संख्याओं के निम्नलिखित लक्षण वर्णन की tतुलना में त्रिकोणीय संख्या nप्राप्त करने के लिए जोड़ा जा सकता है :

8*t+1 = (r-2*s)^2और विषम के (r,s)साथ भाजक जोड़े के लिए ।r*s==nr

कोड ऐसे सभी त्रिकोणीय संख्याओं को न्यूनतम लेता है।

— XNOR
स्रोत

3

जेली , 8 बाइट्स

0r+\ðf_Ḣ

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

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

0r+\ðf_Ḣ  Main link. Argument: n

0r        Build [0, ..., n].
  +\      Take the cumulative sum, generating A := [T(0), ..., T(n)].
    ð     Begin a dyadic chain with left argument A and right argument n.
      _   Compute A - n, i.e., subtract n from each number in A.
     f    Filter; keep only numbers of A that appear in A - n.
       Ḣ  Head; take the first result.

— डेनिस
स्रोत

3

जाप , २४ २३ १६ १५ बाइट्स

ò å+
m!nNg)æ!øU

झसे आज़माओ

1 बाइट ने ETH को धन्यवाद दिया

व्याख्या

    :Implicit input of integer U.
ò   :Create an array of integers from 0 to U, inclusive.
å+  :Cumulatively reduce by summing. Result is implicitly assigned to variable V.
m   :Map over U.
!n  :From the current element subtract...
Ng  :  The first element in the array of inputs (the original value of U).
æ   :Get the first element that returns true when...
!øU :  Checking if U contains it.
    :Implicit output of resulting integer.

— झबरा
स्रोत

I think you can save a byte with æ!øV. Other than that, looks great :-)

— ETHproductions

3

Octave, 38 36 bytes

2 bytes off thanks to @Giuseppe!

@(n)(x=cumsum(0:n))(any(x+n==x'))(1)

Anonymous function that uses almost the same approach as my MATL answer.

Try it online!

— Luis Mendo
स्रोत

2

05AB1E, 12 bytes

ÝηOãD€Æ¹QÏ¬¤

Uses the 05AB1E encoding. Try it online!

— Adnan
स्रोत

2

Mathematica, 62 bytes

(s=Min@Abs[m/.Solve[2#==(n-m)(n+m+1),{n,m},Integers]])(s+1)/2&

— J42161217
स्रोत

I don't know Mathematica, but would Solve[2*#==m(m+1)-n(n+1) be shorter (if it works)?

— Kritixi Lithos

yes, I just posted my answer and trying to golf it right now

— J42161217

2

Python 2, 78 71 70 bytes

Seven bytes saved, thanx to ovs and theespinosa

One more byte saved due to the remark of neil, x+9 is suffisant and checked for all natural numbers 0 <= n <= 10000. It was also verified for x+1 instead of x+9, it works also.

x=input()
I={n*-~n/2for n in range(x+1)}
print min(I&{i-x for i in I})

Try it online!

— mdahmoune
स्रोत

2

You can use n*-~n/2 instead of n*(n+1)/2

— ovs

2

Would range(x+9) work?

— Neil

2

You can use {n*(n+1)/2for n in range(999)} instead of explicit set and also use {} instead of set in the third line

— TheEspinosa

2

JavaScript (ES6), 43 42 bytes

f=(n,a=s=0)=>n?f(n+=n>0?--s:++a,a):a*++a/2

<input type=number min=0 value=0 oninput=o.textContent=f(+this.value)><pre id=o>0

Expand snippet

Edit: Saved 1 byte thanks to @PeterTaylor.

— Neil
स्रोत

Setting a global variable is a hideous abuse of a default parameter. +1. But FWIW you can save a further byte by replacing -++s with --s, as I did in my independently derived but quite similar Java version. (Addendum: you also need to change the test to n>0).

— Peter Taylor

@PeterTaylor Huh, so the n>s check was a red herring all along!

— Neil

Works not for 8192

— Jörg Hülsermann

@JörgHülsermann If you're referring to the snippet, then your browser's stack size may not be large enough, or you may need a browser with experimental tail call optimisation. Alternatively, if you're using NodeJS for testing, use node --stack_size= to increase its stack size.

— Neil

2

Python 3, 60 44 bytes

f=lambda n,k=1:(8*n+1)**.5%1and f(n+k,k+1)+k

Thanks to @xnor for a suggestion that saved 16 bytes!

Try it online!

Background

Let n be a non-negative integer. If n is the k^th triangular number, we have

condition

which means there will be a natural solution if and only if 1 + 8n is an odd, perfect square. Clearly, checking the parity of 1 + 8n is not required.

How it works

The recursive function n accepts a single, non-negative integer as argument. When called with a single argument, k defaults to 1.

First, (8*n+1)**.5%1 tests if n is a triangular number: if (and only if) it is, (8*n+1)**.5 will yield an integer, so the residue from the division by 1 will yield 0.

If the modulus is 0, the and condition will fail, causing f to return 0. If this happens in the initial call to f, note that this is the correct output since n is already triangular.

If the modulus is positive, the and condition holds and f(n+k,k+1)+k gets executed. This calls f again, incrementing n by k and k by 1, then adds k to the result.

When f(n₀, k₀) finally returns 0, we back out of the recursion. The first argument in the first call was n, the second one n + 1, the third one n + 1 + 2, until finally n₀ = n + 1 + … k₀-1. Note that n₀ - n is a triangular number.

Likewise, all these integers will be added to the innermost return value (0), so the result of the intial call f(n) is n₀ - n, as desired.

— Dennis
स्रोत

If you increment n in recursing as well, you can write n rather than (n+k).

— xnor

Or better, search triangular numbers directly.

— xnor

Wow, that's a lot nicer than what I was trying.

— xnor

2

C# (.NET Core), 291 281 bytes

class p{static int Main(string[]I){string d="0",s=I[0];int c=1,j,k;for(;;){j=k=0;string[]D=d.Split(' '),S=s.Split(' ');for(;j<D.Length;j++)for(;k<S.Length;k++)if(D[j]==S[k])return int.Parse(D[k]);j=int.Parse(D[0])+c++;d=d.Insert(0,$"{j} ");s=s.Insert(0,$"{j+int.Parse(I[0])} ");}}}

Try it online! Program that takes a string as input and outputs through Exit Code.

Saved 10 Bytes thanks to Kevin Cruijssen

— Kamil Drakari
स्रोत

1

Hi, welcome to PPCG! You don't need a full program unless the challenge states otherwise. The default is program/function, so a lambda is allowed as well in C#. But if you want to use program, you can golf some things in your current code:

class p{static int Main(string[]I){string d="0",s=I[0];int c=1,j,k;for(;;){j=k=0;string[]D=d.Split(' '),S=s.Split(' ');for(;j<D.Length;j++)for(;k<S.Length;k++)if(D[j]==S[k])return int.Parse(D[k]);j=int.Parse(D[0])+c++;d=d.Insert(0,$"{j} ");s=s.Insert(0,$"{j+int.Parse(I[0])} ");}}}

(281 bytes)

— Kevin Cruijssen

@KevinCruijssen Thanks for the advice! using for(;;) to make an infinite loop is a nice bump, and I'll make sure to think more carefully about whether using var is actually more efficient than using an explicit type but combining the declarations, and I guess be more diligent in removing unnecessary brackets. As for the program vs. function, I started with a lambda but couldn't get it to run in TIO. I know a TIO link isn't actually necessary, but it's something I like to see in others' answers so I wanted at least something similar in my own.

— Kamil Drakari

I'm also not very good in C# lambdas tbh, I usually codegolf in Java. But I think this should be correct. (252 bytes). Also, in case you haven't seen it yet: Tips for code-golfing in C# and Tips for golfing in <all languages> might be interesting to read through. Again welcome, and +1 from me. Nice first answer. Enjoy your stay. :)

— Kevin Cruijssen

2

JavaScript (ES7), 46 44 bytes

f=(n,x=r=0)=>(8*(n+x)+1)**.5%1?f(n,x+=++r):x

Try it

o.innerText=(
f=(n,x=r=0)=>(8*(n+x)+1)**.5%1?f(n,x+=++r):x
)(i.value=8);oninput=_=>o.innerText=f(+i.value)

<input id=i type=number><pre id=o>

Expand snippet

— Shaggy
स्रोत

1

Would r=x=0 work?

— Kritixi Lithos

Sadly not, @KritixiLithos.

— Shaggy

1

05AB1E, 8 bytes

ÝηODI-Ãн

Try it online! or as a Test suite

Explanation

Ý          # range [0 ... input]
 η         # prefixes
  O        # sum each
   D       # duplicate
    I-     # subtract input from each
      Ã    # keep only the elements in the first list that also exist in the second list
       н   # get the first (smallest)

— Emigna
स्रोत

1

Dyalog APL, 19 bytes

6 bytes saved thanks to @KritixiLithos

{⊃o/⍨o∊⍨⍵+o←0,+\⍳⍵}

Try it online!

How?

o←0,+\⍳⍵ - assign o the first ⍵ triangular numbers

o/⍨ - filter o by

o∊⍨⍵+o - triangular numbers that summed with ⍵ produce triangulars

⊃ - and take the first

— Uriel
स्रोत

+\⍳⍵ should work instead of what you are using to generate the triangular numbers.

— Kritixi Lithos

I think ⊃ works instead of ⌊/

— Kritixi Lithos

1

Pari/GP, 54 bytes

n->vecmin([y^2-1|y<-[2*n/d-d|d<-divisors(2*n)],y%2])/8

Try it online!

— alephalpha
स्रोत

1

Haskell, 56 bytes

f x|e<-(`elem`scanl1(+)[0..x])=[n|n<-[0..],e n,e$x+n]!!0

Try it online!

— ბიმო
स्रोत

1

Add++, 68 bytes

L,RBFEREsECAAx$pBcB_B]VARBFEREsB]GEi$pGBcB*A8*1+.5^1%!!@A!@*b]EZBF#@

Try it online!, or see the test suite!

Even Java is beating me. I really need to add some set commands to Add++

How it works

L,    - Create a lambda function
      - Example argument:  8
  R   - Range;     STACK = [[1 2 3 4 5 6 7 8]]
  BF  - Flatten;   STACK = [1 2 3 4 5 6 7 8]
  ER  - Range;     STACK = [[1] [1 2] ... [1 2 3 4 5 6 7 8]
  Es  - Sum;       STACK = [1 3 6 10 15 21 28 36]
  EC  - Collect;   STACK = [[1 3 6 10 15 21 28 36]]
  A   - Argument;  STACK = [[1 3 6 10 15 21 28 36] 8]
  A   - Argument;  STACK = [[1 3 6 10 15 21 28 36] 8 8]
  x   - Repeat;    STACK = [[1 3 6 10 15 21 28 36] 8 [8 8 8 8 8 8 8 8]]
  $p  - Remove;    STACK = [[1 3 6 10 15 21 28 36] [8 8 8 8 8 8 8 8]]
  Bc  - Zip;       STACK = [[1 8] [3 8] [6 8] [10 8] [15 8] [21 8] [28 8] [36 8]]
  B_  - Deltas;    STACK = [-7 -5 -2 2 7 13 20 28]
  B]  - Wrap;      STACK = [[-7 -5 -2 2 7 13 20 28]]
  V   - Save;      STACK = []
  A   - Argument;  STACK = [8]
  R   - Range;     STACK = [[1 2 3 4 5 6 7 8]]
  BF  - Flatten;   STACK = [1 2 3 4 5 6 7 8]
  ER  - Range;     STACK = [[1] [1 2] ... [1 2 3 4 5 6 7 8]]
  Es  - Sum;       STACK = [1 3 6 10 15 21 28 36]
  B]  - Wrap;      STACK = [[1 3 6 10 15 21 28 36]]
  G   - Retrieve;  STACK = [[1 3 6 10 15 21 28 36] [-7 -5 -2 2 7 13 20 28]]
  Ei  - Contains;  STACK = [[1 3 6 10 15 21 28 36] [0 0 0 0 0 0 0 1]]
  $p  - Remove;    STACK = [[0 0 0 0 0 0 0 1]]
  G   - Retrieve;  STACK = [[0 0 0 0 0 0 0 1] [-7 -5 -2 2 7 13 20 28]]
  Bc  - Zip;       STACK = [[0 -7] [0 -5] [0 -2] [0 2] [0 7] [0 13] [0 20] [1 28]]
  B*  - Products;  STACK = [0 0 0 0 0 0 0 28]
  A   - Argument;  STACK = [0 0 0 0 0 0 0 28 8]
  8*  - Times 8;   STACK = [0 0 0 0 0 0 0 28 64]
  1+  - Increment; STACK = [0 0 0 0 0 0 0 28 65]
  .5^ - Root;      STACK = [0 0 0 0 0 0 0 28 8.1]
  1%  - Frac part; STACK = [0 0 0 0 0 0 0 28 0.1]
  !!  - To bool;   STACK = [0 0 0 0 0 0 0 28 1]
  @   - Reverse;   STACK = [1 28 0 0 0 0 0 0 0]
  A   - Argument;  STACK = [1 28 0 0 0 0 0 0 0 8] 
  !   - Not;       STACK = [1 28 0 0 0 0 0 0 0 0]
  @   - Reverse;   STACK = [0 0 0 0 0 0 0 0 28 1]
  *   - Multiply;  STACK = [0 0 0 0 0 0 0 0 28]
  b]  - Wrap;      STACK = [0 0 0 0 0 0 0 0 [28]]
  EZ  - Unzero;    STACK = [[28]]
  BF  - Flatten;   STACK = [28]
  #   - Sort;      STACK = [28]
  @   - Reverse;   STACK = [28]

— caird coinheringaahing
स्रोत

1

R, 46 44 43 41 bytes

function(x,y=cumsum(0:x))y[(x+y)%in%y][1]

Try it online!

An anonymous function with one mandatory argument, x; computes first x+1 triangular numbers as an optional argument to golf out a few curly braces. I used choose before I saw Luis Mendo's Octave answer.

I shaved off a few bytes of Luis Mendo's answer but forgot to use the same idea in my answer.

— Giuseppe
स्रोत

0

Jelly, 18 bytes

0rRS$€ċ
0ð,+Ç€Ạð1#

Try it online!

— Erik the Outgolfer
स्रोत

0

Python 2, 83 81 bytes

@Felipe Nardi Batista saved 2 bytes.

lambda n:min(x for x in i(n)if n+x in i(n))
i=lambda n:[i*-~i/2for i in range(n)]

Try it online!

— officialaimm
स्रोत

0

APL (Dyalog Classic), 16 14 bytes

(⊃0∘,∩⊢-≢)+\∘⍳

Try it online!

— TwiNight
स्रोत

0

Clojure, 74 bytes

#(nth(for[t[(reductions +(range))]i t :when((set(take 1e5 t))(+ i %))]i)0)
#(nth(for[R[reductions]i(R + %(range)):when((set(R - i(range 1e5)))0)]i)0)

Pick your favourite :) Loops might be shorter...

— NikoNyrh
स्रोत

0

Python 2, 82 bytes

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

Try it online

This was created by modifying this answer from the related question.

— mbomb007
स्रोत

works not for 8192

— Jörg Hülsermann

It doesn't work for that on the related question either, because of the recursion depth. I'm not sure what the consensus is on that.

— mbomb007

Some other answers have the same problem. I give only the info

— Jörg Hülsermann

त्रिकोणीय निर्भरताएँ

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

स्कोरिंग

जावा 8, 58 57 बाइट्स

Matl , 13 12 बाइट्स

व्याख्या

जावा (ओपनजेडके 8) , 83 बाइट्स

क्रेडिट

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

नीम , १२ 9 बाइट्स

PHP , 45 बाइट्स

PHP , 53 बाइट्स

PHP , 55 बाइट्स

जावा 8, 110 102 100 93 92 बाइट्स

ब्रजलॉग , १ 17 15 बाइट्स

व्याख्या

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

जेली , 8 बाइट्स

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

जाप , २४ २३ १६ १५ बाइट्स

व्याख्या

Octave, 38 36 bytes

05AB1E, 12 bytes

Mathematica, 62 bytes

Python 2, 78 71 70 bytes

JavaScript (ES6), 43 42 bytes

Python 3, 60 44 bytes

Background

How it works

C# (.NET Core), 291 281 bytes

JavaScript (ES7), 46 44 bytes

Try it

05AB1E, 8 bytes

Dyalog APL, 19 bytes

Pari/GP, 54 bytes

Haskell, 56 bytes

Add++, 68 bytes

How it works

R, 46 44 43 41 bytes

Jelly, 18 bytes

Python 2, 83 81 bytes

APL (Dyalog Classic), 16 14 bytes

Clojure, 74 bytes

Python 2, 82 bytes