Bir üçgen sayısı toplamı olan bir sayıdır n, 1 ila doğal sayılar n. Örneğin 1 + 2 + 3 + 4 = 10böylece 10üçgen bir sayıdır.

0 < n <= 10000Giriş olarak pozitif bir tamsayı ( ) verildiğinde ( bir tamsayı veya bir dize olarak alınabilir), başka bir üçgen sayı oluşturmak için girişe eklenebilecek en küçük üçgen sayısını döndürün.

Örneğin verilen girdi 26, 10sonuçların 36üçgen şeklinde olduğu bir sonuç eklemek . Başka bir üçgen sayı oluşturmak 10için eklenebilecek sayıdan daha küçük üçgen sayıları yoktur , bu durumda bu doğru sonuçtur.2610

0 üçgen bir sayıdır, bu nedenle girişin kendisi de üçgen bir sayıysa 0

testcases

Vakalar formatta verilmiştir. 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)

puanlama

Bu kod golf, yani her dilde en az bayt kazanıyor!

Java 8, 58 57 bayt

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

Çevrimiçi test paketi

1-byte tasarruf için Dennis'e teşekkürler .

Matl , 13 12 bayt

1 bayt, Emigna'nın 05AB1E yanıtından bir fikir (kesişme kümesi) kullanarak kaldırıldı

Q:qYstG-X&X<

Çevrimiçi deneyin!

açıklama

- Üçgen sayıyı t(n) = 1 + 2 + ··· + ngösterelim n.

Kod, verilen gerçeği kullanır n çözümün üst sınırlarat(n-1) . Bunu görmek için, t(n-1) + neşittir t(n)ve bu yüzden üçgen bir sayı olduğunu gözlemleyin .

8Bir örnek olarak girişi düşünün .

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

Java (OpenJDK 8) , 83 bayt

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;}

Çevrimiçi deneyin!

Kredi

• Ceilingcat sayesinde -3 bayt

Mathematica, 46 bayt

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

Neim , 12 9 bayt

tS𝕊Λt𝕚)0𝕔

Bu, hesaplanması çok uzun sürüyor (ancak sonsuz zaman ve bellek verilen eserler), bu yüzden bağlantıda sadece ilk 143 üçgen sayıyı oluşturuyorum - kullanarak £𝕖, 10.000 girişini işlemek için yeterli ancak zaman aşımına uğramak için yeterli değil.

^{Uyarı: bu gelecek sürümlerde çalışmayabilir. Öyleyse, 143 yerine £ kullanın}

Açıklama:

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

Dene!

PHP , 45 bayt

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

Çevrimiçi deneyin!

Kısa çeşididir for(;!$r[$t];$t+=++$i)$r[$argn+$t]=~+$t;echo~$r[$t];

Expanded

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 bayt

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

Çevrimiçi deneyin!

PHP 7'de yeni uzay gemisi operatörünü kullanın.

Expanded

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 bayt

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

Çevrimiçi deneyin!

Java 8, 110 102 100 93 92 bayt

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;}

@PeterTaylor sayesinde -2 bayt . -JollyJoker
sayesinde -7 bayt . @Ceilingcat sayesinde -1 bayt .

Açıklama:

Çevrimiçi deneyin.

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

Brachylog , 17 15 bayt

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

Çevrimiçi deneyin!

açıklama

⟦                  [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

Python 2 , 59 bayt

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

Çevrimiçi deneyin!

Bu, üçgen bir sayı elde tetmek niçin eklenebilecek üçgen sayıların aşağıdaki karakterizasyonunu kullanır :

8*t+1 = (r-2*s)^2bölen çiftleri için (r,s)olan r*s==nve rtek.

Kod, tüm bu üçgen sayıların minimumunu alır.

Jöle , 8 bayt

0r+\ðf_Ḣ

Çevrimiçi deneyin!

Nasıl çalışır

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.

Japt , 24 23 16 15 bayt

ò å+
m!nNg)æ!øU

Dene

ETH sayesinde 1 bayt kurtarıldı

açıklama

    :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.

Octave , 38 36 bayt

@Giuseppe sayesinde 2 bayt kapalı !

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

MATL cevabımla neredeyse aynı yaklaşımı kullanan isimsiz fonksiyon .

Çevrimiçi deneyin!

05AB1E , 12 bayt

ÝηOãD€Æ¹QϬ¤

05AB1E kodlamasını kullanır . Çevrimiçi deneyin!

Mathematica, 62 bayt

(s=Min@Abs[m/.Solve[2#==(n-m)(n+m+1),{n,m},Integers]])(s+1)/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!

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

Edit: Saved 1 byte thanks to @PeterTaylor.

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

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.

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

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>

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)

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

Pari/GP, 54 bytes

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

Try it online!

Haskell, 56 bytes

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

Try it online!

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]

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.

Jelly, 18 bytes

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

Try it online!

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!

APL (Dyalog Classic), 16 14 bytes

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

Try it online!

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

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.