Sebuah angka segitiga adalah angka yang merupakan penjumlahan dari nbilangan dari 1 sampai n. Misalnya 1 + 2 + 3 + 4 = 10demikian 10adalah angka segitiga.

Diberikan bilangan bulat positif ( 0 < n <= 10000) sebagai input (dapat diambil sebagai bilangan bulat, atau sebagai string), kembalikan angka segitiga sekecil mungkin yang dapat ditambahkan ke input untuk membuat nomor segitiga lain.

Misalnya input yang diberikan 26, menambahkan 10hasil 36, yang juga merupakan angka segitiga. Tidak ada angka segitiga yang lebih kecil dari 10yang dapat ditambahkan 26untuk membuat angka segitiga lain, jadi 10adalah hasil yang benar dalam kasus ini.

0 adalah bilangan triangular, oleh karena itu jika input itu sendiri bilangan triangular, output seharusnya 0

Testcases

Kasing diberikan dalam format 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)

Mencetak gol

Ini adalah kode-golf sehingga byte paling sedikit di setiap bahasa menang!

Java 8, 58 57 byte

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

Test suite online

Terima kasih kepada Dennis untuk penghematan 1 byte.

MATL , 13 12 byte

1 byte dihapus menggunakan ide (set persimpangan) dari jawaban 05AB1E Emigna

Q:qYstG-X&X<

Cobalah online!

Penjelasan

Biarkan t(n) = 1 + 2 + ··· + nmenunjukkan angka nsegitiga -th.

Kode mengeksploitasi fakta bahwa, mengingat n, solusinya dibatasi oleh t(n-1). Untuk melihat ini, amati bahwa itu t(n-1) + nsama t(n)dan jadi itu adalah bilangan segitiga.

Pertimbangkan input 8sebagai contoh.

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 byte

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

Cobalah online!

Kredit

• -3 bytes berkat ceilingcat

Mathematica, 46 byte

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

Neim , 12 9 byte

tS𝕊Λt𝕚)0𝕔

Ini membutuhkan waktu terlalu lama untuk dihitung (tetapi bekerja dengan waktu dan memori yang tak terbatas), jadi di tautan saya hanya menghasilkan 143 angka segitiga pertama - menggunakan £𝕖, yang cukup untuk menangani input 10.000, tetapi tidak cukup untuk waktu habis.

^{Peringatan: ini mungkin tidak berfungsi di versi mendatang. Jika demikian, gantikan £ untuk 143}

Penjelasan:

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

Cobalah!

PHP , 45 byte

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

Cobalah online!

Apakah varian lebih pendek dari for(;!$r[$t];$t+=++$i)$r[$argn+$t]=~+$t;echo~$r[$t];

Diperluas

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 byte

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

Cobalah online!

Gunakan operator pesawat ruang angkasa baru di PHP 7

Diperluas

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 byte

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

Cobalah online!

Java 8, 110 102 100 93 92 byte

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 byte terima kasih kepada @PeterTaylor .
-7 byte terima kasih kepada @JollyJoker .
-1 byte terima kasih kepada @ceilingcat .

Penjelasan:

Cobalah online.

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 byte

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

Cobalah online!

Penjelasan

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

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

Cobalah online!

Ini menggunakan karakterisasi angka segitiga berikut yang tdapat ditambahkann untuk mendapatkan angka segitiga:

8*t+1 = (r-2*s)^2untuk pasangan pembagi (r,s)dengan r*s==ndan rganjil.

Kode mengambil minimum dari semua angka segitiga tersebut.

Jelly , 8 byte

0r+\ðf_Ḣ

Cobalah online!

Bagaimana itu bekerja

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 bytes

ò å+
m!nNg)æ!øU

Menguji

1 byte disimpan berkat ETH

Penjelasan

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

Oktaf , 38 36 byte

2 byte off berkat @Giuseppe!

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

Fungsi anonim yang menggunakan pendekatan yang hampir sama dengan jawaban MATL saya .

Cobalah online!

05AB1E , 12 byte

ÝηOãD€Æ¹QϬ¤

Menggunakan penyandian 05AB1E . Cobalah online!

Mathematica, 62 byte

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

Python 2 , 78 71 70 byte

Tujuh byte disimpan, thanx ke ovs dan theespinosa

Satu byte lagi yang disimpan karena pernyataan neil , x+9suffisant dan diperiksa untuk semua bilangan asli 0 <= n <= 10000. Hal itu juga diverifikasi untuk x+1bukan x+9, ia bekerja juga.

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

Cobalah online!

JavaScript (ES6), 43 42 byte

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

Sunting: Disimpan 1 byte berkat @PeterTaylor.

Python 3 , 60 44 byte

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

Terima kasih kepada @xnor untuk saran yang menghemat 16 byte!

Cobalah online!

Latar Belakang

Biarkan n menjadi bilangan bulat non-negatif. Jika n adalah ^bilangan segitiga k , kita miliki

yang berarti akan ada solusi alami jika dan hanya jika 1 + 8n adalah kuadrat yang aneh dan sempurna. Jelas, memeriksa paritas 1 + 8n tidak diperlukan.

Bagaimana itu bekerja

Fungsi rekursif n menerima integer tunggal, non-negatif sebagai argumen. Saat dipanggil dengan argumen tunggal, k default ke 1 .

Pertama, (8*n+1)**.5%1 menguji apakah n adalah bilangan segitiga: jika (dan hanya jika) itu, (8*n+1)**.5akan menghasilkan bilangan bulat, sehingga residu dari divisi dengan 1 akan menghasilkan 0 .

Jika modulus 0 , andkondisinya akan gagal, menyebabkan f untuk mengembalikan 0 . Jika ini terjadi pada panggilan awal ke f , perhatikan bahwa ini adalah output yang benar sejak n sudah segitiga.

Jika modulus positif, andkondisinya menahan dan f(n+k,k+1)+kdieksekusi. Ini memanggil f lagi, bertambah n oleh k dan k dengan 1 , lalu menambahkan k ke hasilnya.

Ketika f (n ₀ , k ₀ ) akhirnya mengembalikan 0 , kami kembali dari rekursi. Argumen pertama dalam panggilan pertama adalah n , yang kedua n + 1 , yang ketiga n + 1 + 2 , sampai akhirnya n ₀ = n + 1 + ... k ₀ -1 . Perhatikan bahwa n ₀ - n adalah angka segitiga.

Demikian juga, semua bilangan bulat ini akan ditambahkan ke nilai balik terdalam ( 0 ), sehingga hasil dari panggilan awal f (n) adalah n ₀ - n , seperti yang diinginkan.

C # (.NET Core) , 291 281 byte

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])} ");}}}

Cobalah online! Program yang mengambil string sebagai input dan output melalui Kode Keluar.

Disimpan 10 Bytes berkat Kevin Cruijssen

JavaScript (ES7), 46 44 byte

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

Cobalah

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 byte

ÝηODI-Ãн

Cobalah online! atau sebagai Test suite

Penjelasan

Ý          # 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 byte

6 byte disimpan berkat @KritixiLithos

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

Cobalah online!

Bagaimana?

o←0,+\⍳⍵- tetapkan oyang pertama⍵ angka segitiga

o/⍨ - filter o menurut

o∊⍨⍵+o - angka segitiga yang dijumlahkan dengan ⍵ menghasilkan segitiga

⊃ - dan ambil yang pertama

Pari / GP , 54 byte

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

Cobalah online!

Haskell , 56 byte

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

Cobalah online!

Tambahkan ++ , 68 byte

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

Cobalah online! , atau lihat test suite !

Bahkan Jawa mengalahkan saya. Saya benar-benar perlu menambahkan beberapa set perintah ke Tambah ++

Bagaimana itu bekerja

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 byte

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

Cobalah online!

Fungsi anonim dengan satu argumen wajib, x; menghitung x+1angka segitiga pertama sebagai argumen opsional untuk menghilangkan beberapa kurung kurawal. Saya menggunakan choosesebelum saya melihat jawaban Oktaf Luis Mendo .

Saya memotong beberapa byte jawaban Luis Mendo tetapi lupa untuk menggunakan ide yang sama dalam jawaban saya.

Jelly , 18 byte

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

Cobalah online!

Python 2 , 83 81 byte

• @Felipe Nardi Batista menyimpan 2 byte.

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)]

Cobalah online!

APL (Dyalog Classic) , 16 14 byte

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

Cobalah online!

Clojure, 74 byte

#(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)

Pilih favorit Anda :) Loop mungkin lebih pendek ...

Python 2 , 82 byte

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]))

Cobalah online

Ini dibuat dengan mengubah jawaban ini dari pertanyaan terkait.