Một số tam giác là một con số đó là tổng của ncác số tự nhiên từ 1 tới n. Ví dụ 1 + 2 + 3 + 4 = 10như vậy 10là một số tam giác.

Cho một số nguyên dương ( 0 < n <= 10000) làm đầu vào (có thể được lấy dưới dạng một số nguyên hoặc dưới dạng chuỗi), trả về số tam giác nhỏ nhất có thể có thể được thêm vào đầu vào để tạo một số tam giác khác.

Ví dụ đầu vào đã cho 26, thêm 10kết quả vào 36, đó cũng là một số tam giác. Không có số tam giác nào nhỏ hơn số 10đó có thể được thêm vào 26để tạo số tam giác khác, do đó, 10là kết quả chính xác trong trường hợp này.

0 là một số tam giác, do đó, nếu đầu vào chính nó là một số tam giác, thì đầu ra phải là 0

Tủ thử

Các trường hợp được đưa ra trong định dạng 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)

Chấm điểm

Đây là môn đánh gôn để có ít byte nhất trong mỗi ngôn ngữ !

Java 8, 58 57 byte

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

Bộ kiểm tra trực tuyến

Cảm ơn Dennis vì đã tiết kiệm 1 byte.

MATL , 13 12 byte

Xóa 1 byte bằng cách sử dụng một ý tưởng (đặt giao lộ) từ câu trả lời 05AB1E của Emigna

Q:qYstG-X&X<

Hãy thử trực tuyến!

Giải trình

Để cho t(n) = 1 + 2 + ··· + n biểu thị nsố tam giác -th.

Mã khai thác thực tế rằng, đưa ra n, giải pháp được giới hạn trên bởi t(n-1). Để thấy điều này, hãy quan sát rằngt(n-1) + n bằng t(n)và vì vậy nó là một số tam giác.

Hãy xem xét đầu vào 8là một ví dụ.

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

Hãy thử trực tuyến!

Tín dụng

• -3 byte nhờ trần

Toán học, 46 byte

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

Neim , 12 9 byte

tS𝕊Λt𝕚)0𝕔

Việc này mất quá nhiều thời gian để tính toán (nhưng hoạt động trong thời gian và bộ nhớ vô hạn), vì vậy trong liên kết tôi chỉ tạo ra 143 số tam giác đầu tiên - sử dụng £𝕖, đủ để xử lý đầu vào 10.000, nhưng không đủ thời gian.

^{Cảnh báo: điều này có thể không hoạt động trong các phiên bản trong tương lai. Nếu vậy, thay thế £ cho 143}

Giải trình:

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

Thử nó!

PHP , 45 byte

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

Hãy thử trực tuyến!

Là biến thể ngắn hơn của for(;!$r[$t];$t+=++$i)$r[$argn+$t]=~+$t;echo~$r[$t];

Mở rộng

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;

Hãy thử trực tuyến!

Sử dụng toán tử tàu vũ trụ mới trong PHP 7

Mở rộng

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;

Hãy thử trực tuyến!

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 nhờ @PeterTaylor .
-7 byte nhờ @JollyJoker .
-1 byte nhờ @ceilingcat .

Giải trình:

Hãy thử trực tuyến.

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

Hãy thử trực tuyến!

Giải trình

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

Hãy thử trực tuyến!

Điều này sử dụng đặc tính sau của các số tam giác thơn có thể được thêm vào nđể có được một số tam giác:

8*t+1 = (r-2*s)^2cho các cặp chia (r,s)với r*s==nvà rlẻ.

Mã này lấy tối thiểu của tất cả các số tam giác như vậy.

Thạch , 8 byte

0r+\ðf_Ḣ

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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 byte

ò å+
m!nNg)æ!øU

Kiểm tra nó

Lưu 1 byte nhờ ETH

Giải trình

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

Giảm 2 byte nhờ @Giuseppe!

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

Hàm ẩn danh sử dụng cách tiếp cận gần giống với câu trả lời MATL của tôi .

Hãy thử trực tuyến!

05AB1E , 12 byte

ÝηOãD€Æ¹QϬ¤

Sử dụng mã hóa 05AB1E . Hãy thử trực tuyến!

Toán học, 62 byte

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

Con trăn 2 , 78 71 70 byte

Bảy byte được lưu, thanx đến ovs và theespinosa

Thêm một byte được lưu do nhận xét của neil ,x+9 là đủ và kiểm tra tất cả các số tự nhiên 0 <= n <= 10000. Nó cũng đã được xác nhận cho x+1thay x+9, nó hoạt động cũng có.

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

Hãy thử trực tuyến!

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

Chỉnh sửa: Đã lưu 1 byte nhờ @PeterTaylor.

Python 3 , 60 44 byte

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

Cảm ơn @xnor về một đề xuất đã lưu 16 byte!

Hãy thử trực tuyến!

Lý lịch

Đặt n là số nguyên không âm. Nếu n là số tam giác ^thứ k , ta có

có nghĩa là sẽ có một giải pháp tự nhiên nếu và chỉ khi 1 + 8n là một hình vuông kỳ lạ, hoàn hảo. Rõ ràng, kiểm tra tính chẵn lẻ của 1 + 8n .

Làm thế nào nó hoạt động

Hàm đệ quy n chấp nhận một số nguyên duy nhất, không âm làm đối số. Khi được gọi với một đối số duy nhất, k mặc định là 1 .

Đầu tiên, (8*n+1)**.5%1kiểm tra nếu n là số tam giác: nếu (và chỉ nếu), (8*n+1)**.5sẽ mang lại một số nguyên, do đó phần dư từ phép chia cho 1 sẽ mang lại 0 .

Nếu mô đun là 0 , andđiều kiện sẽ thất bại, khiến f trả về 0 . Nếu điều này xảy ra trong cuộc gọi ban đầu đến f , lưu ý rằng đây là đầu ra chính xác vì n đã là hình tam giác.

Nếu mô đun là dương, andđiều kiện giữ và f(n+k,k+1)+kđược thực thi. Điều này gọi lại f , tăng n theo k và k thêm 1 , sau đó thêm k vào kết quả.

Khi f (n ₀ , k ₀ ) cuối cùng trả về 0 , chúng ta sẽ thoát khỏi đệ quy. Đối số đầu tiên trong cuộc gọi đầu tiên là n , cuộc gọi thứ hai n + 1 , cuộc gọi thứ ba n + 1 + 2 , cho đến cuối cùng n ₀ = n + 1 + bit k ₀ -1 . Lưu ý rằng n ₀ - n là số tam giác.

Tương tự, tất cả các số nguyên này sẽ được thêm vào giá trị trả về trong cùng ( 0 ), do đó, kết quả của cuộc gọi nội bộ f (n) là n ₀ - n , như mong muốn.

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

Hãy thử trực tuyến! Chương trình lấy một chuỗi làm đầu vào và đầu ra thông qua Mã thoát.

Đã tiết kiệm được 10 byte nhờ Kevin Cruijssen

JavaScript (ES7), 46 44 byte

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

Thử nó

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-Ãн

Hãy thử trực tuyến! hoặc như một bộ thử nghiệm

Giải trình

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

APL Dyalog, 19 byte

6 byte được lưu nhờ @KritixiLithos

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

Hãy thử trực tuyến!

Làm sao?

o←0,+\⍳⍵- gán ocác ⍵số tam giác đầu tiên

o/⍨- lọc otheo

o∊⍨⍵+o- số tam giác tổng hợp với ⍵sản xuất tam giác

⊃ - và lấy cái đầu tiên

Pari / GP , 54 byte

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

Hãy thử trực tuyến!

Haskell , 56 byte

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

Hãy thử trực tuyến!

Thêm ++ , 68 byte

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

Hãy thử trực tuyến! hoặc xem bộ thử nghiệm !

Cũng Java cũng đang đánh bại tôi. Tôi thực sự cần thêm một số lệnh thiết lập vào Add ++

Làm thế nào nó hoạt động

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]

Hãy thử trực tuyến!

Một hàm ẩn danh với một đối số bắt buộc , x; tính toán các x+1số tam giác đầu tiên như là một đối số tùy chọn để chơi một vài dấu ngoặc nhọn. Tôi đã sử dụngchoose trước khi tôi thấy câu trả lời Octave của Luis Mendo .

Tôi đã loại bỏ một vài byte câu trả lời của Luis Mendo nhưng quên sử dụng cùng một ý tưởng trong câu trả lời của tôi.

Thạch , 18 byte

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

Hãy thử trực tuyến!

Python 2 , 83 81 byte

• @Felipe Nardi Batista đã lưu 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)]

Hãy thử trực tuyến!

APL (Dyalog Classic) , 16 14 byte

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

Hãy thử trực tuyến!

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)

Chọn mục yêu thích của bạn :) Vòng lặp có thể ngắn hơn ...

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

Dùng thử trực tuyến

Điều này đã được tạo ra bằng cách sửa đổi câu trả lời này từ câu hỏi liên quan.