Liczba trójkątna to liczba będąca sumą nliczb naturalnych od 1 do n. Przykładowo 1 + 2 + 3 + 4 = 10więc 10jest liczbą trójkątną.

Biorąc pod uwagę dodatnią liczbę całkowitą ( 0 < n <= 10000) jako dane wejściowe (można ją traktować jako liczbę całkowitą lub ciąg), zwraca najmniejszą możliwą liczbę trójkątną, którą można dodać do wejścia, aby utworzyć kolejną liczbę trójkątną.

Na przykład dane wejściowe 26, dodawanie 10wyników 36, który jest również liczbą trójkątną. Nie ma żadnych trójkątnych liczb mniejszych niż te, 10które można dodać, aby 26utworzyć kolejną liczbę trójkątną, więc 10w tym przypadku jest prawidłowy wynik.

0 jest liczbą trójkątną, dlatego jeśli sam sygnał wejściowy jest liczbą trójkątną, wynik powinien wynosić 0

Przypadki testowe

Sprawy są podawane w formacie 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)

Punktacja

To jest golf golfowy, więc wygrywa najmniej bajtów w każdym języku !

Java 8, 58 57 bajtów

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

Zestaw testów online

Dzięki Dennis za 1-bajtową oszczędność.

MATL , 13 12 bajtów

1 bajt usunięty przy użyciu pomysłu (ustaw przecięcie) z odpowiedzi Emigna 05AB1E

Q:qYstG-X&X<

Wypróbuj online!

Wyjaśnienie

Niech t(n) = 1 + 2 + ··· + noznacza n-ty numer trójkątny.

Kod wykorzystuje fakt, że dane nrozwiązanie jest ograniczone t(n-1). Aby to zobaczyć, zauważ, że t(n-1) + njest równy, t(n)a więc jest to liczba trójkątna.

Rozważ dane wejściowe 8jako przykład.

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 bajty

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

Wypróbuj online!

Kredyty

• -3 bajty dzięki pułapce cat

Mathematica, 46 bajtów

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

Neim , 12 9 bajtów

tS𝕊Λt𝕚)0𝕔

Obliczenie zajmuje zbyt dużo czasu (ale działa z nieskończonym czasem i pamięcią), więc w łączu generuję tylko pierwsze 143 trójkątne liczby - używając £𝕖, co wystarcza do obsługi wejścia 10 000, ale nie wystarcza do przekroczenia limitu czasu.

^{Ostrzeżenie: może to nie działać w przyszłych wersjach. Jeśli tak, zamień 143 na £}

Wyjaśnienie:

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

Spróbuj!

PHP , 45 bajtów

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

Wypróbuj online!

Jest krótszym wariantem for(;!$r[$t];$t+=++$i)$r[$argn+$t]=~+$t;echo~$r[$t];

Rozszerzony

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 bajty

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

Wypróbuj online!

Użyj nowego operatora statku kosmicznego w PHP 7

Rozszerzony

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 bajtów

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

Wypróbuj online!

Java 8, 110 102 100 93 92 bajty

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 bajty dzięki @PeterTaylor .
-7 bajtów dzięki @JollyJoker .
-1 bajt dzięki @ceilingcat .

Wyjaśnienie:

Wypróbuj 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 bajtów

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

Wypróbuj online!

Wyjaśnienie

⟦                  [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 bajtów

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

Wypróbuj online!

Wykorzystuje się następującą charakterystykę liczb trójkątnych, którą tmożna dodać, naby uzyskać liczbę trójkątną:

8*t+1 = (r-2*s)^2dzielnik dla par (r,s)z r*s==ni rnieparzystych.

Kod bierze minimum wszystkich takich liczb trójkątnych.

Galaretka , 8 bajtów

0r+\ðf_Ḣ

Wypróbuj online!

Jak to działa

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 bajtów

ò å+
m!nNg)æ!øU

Sprawdź to

1 bajt zapisany dzięki ETH

Wyjaśnienie

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

Oktawa , 38 36 bajtów

2 bajty wyłączone dzięki @Giuseppe!

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

Anonimowa funkcja, która wykorzystuje prawie takie samo podejście jak moja odpowiedź MATL .

Wypróbuj online!

05AB1E , 12 bajtów

ÝηOãD€Æ¹QϬ¤

Wykorzystuje kodowanie 05AB1E . Wypróbuj online!

Mathematica, 62 bajty

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

Python 2 , 78 71 70 bajtów

Zapisano siedem bajtów, dziękuję ovs i thespinosa

Jeden bajt zapisany powodu zaznaczeniem Neil , x+9jest suffisant i sprawdzone dla wszystkich liczb naturalnych 0 <= n <= 10000. Zostało również zweryfikowane pod kątem x+1zamiast x+9, działa również.

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

Wypróbuj online!

JavaScript (ES6), 43 42 bajty

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

Edycja: Zapisano 1 bajt dzięki @PeterTaylor.

Python 3 , 60 44 bajtów

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

Dzięki @xnor za sugestię, która pozwoliła zaoszczędzić 16 bajtów!

Wypróbuj online!

tło

Niech n będzie liczbą całkowitą nieujemną. Jeśli n jest k- ^tą trójkątną liczbą, to mamy

co oznacza, że ​​będzie naturalne rozwiązanie wtedy i tylko wtedy, gdy 1 + 8n jest nieparzystym, idealnym kwadratem. Oczywiście sprawdzanie parzystości 1 + 8n nie jest wymagane.

Jak to działa

Funkcja rekurencyjna n przyjmuje jako argument jedną pojedynczą, nieujemną liczbę całkowitą. W przypadku wywołania z jednym argumentem, k domyślnie wynosi 1 .

Najpierw (8*n+1)**.5%1sprawdza, czy n jest liczbą trójkątną: jeśli (i tylko jeśli) jest, (8*n+1)**.5da liczbę całkowitą, więc reszta z dzielenia przez 1 da 0 .

Jeśli moduł wynosi 0 , andwarunek zakończy się niepowodzeniem, co spowoduje, że f zwróci 0 . Jeśli tak się stanie w pierwszym wywołaniu f , zauważ, że jest to poprawny wynik, ponieważ n jest już trójkątny.

Jeśli moduł jest dodatni, andwarunek f(n+k,k+1)+kzostaje zachowany i zostaje wykonany. To wywołuje ponownie f , zwiększając n o k i k o 1 , a następnie dodaje k do wyniku.

Kiedy f (n ₀ , k ₀ ) ostatecznie zwraca 0 , wycofujemy się z rekurencji. Pierwszym argumentem w pierwszym wywołaniu było n , drugim n + 1 , trzecim n + 1 + 2 , aż w końcu n ₀ = n + 1 +… k ₀ -1 . Zauważ, że n ₀ - n jest liczbą trójkątną.

Podobnie, wszystkie te liczby całkowite zostaną dodane do najbardziej wewnętrznej wartości zwracanej ( 0 ), więc wynik początkowego wywołania f (n) wynosi n ₀ - n , zgodnie z potrzebą.

C # (.NET Core) , 291 281 bajtów

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

Wypróbuj online! Program, który pobiera ciąg znaków jako dane wejściowe i wyjściowe za pośrednictwem kodu wyjścia.

Uratował 10 bajtów dzięki Kevinowi Cruijssenowi

JavaScript (ES7), 46 44 bajtów

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

Spróbuj

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 bajtów

ÝηODI-Ãн

Wypróbuj online! lub jako pakiet testowy

Wyjaśnienie

Ý          # 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 bajtów

6 bajtów zapisanych dzięki @KritixiLithos

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

Wypróbuj online!

W jaki sposób?

o←0,+\⍳⍵- przypisz opierwsze ⍵trójkątne liczby

o/⍨- filtruj owedług

o∊⍨⍵+o- liczby trójkątne, które zsumowane z ⍵produkują trójkąty

⊃ - i weź pierwszy

Pari / GP , 54 bajty

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

Wypróbuj online!

Haskell , 56 bajtów

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

Wypróbuj online!

Dodaj ++ , 68 bajtów

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

Wypróbuj online! lub zobacz pakiet testowy !

Nawet Java mnie bije. Naprawdę muszę dodać kilka zestawów poleceń do Add ++

Jak to działa

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 bajtów

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

Wypróbuj online!

Anonimowa funkcja z jednym obowiązkowym argumentem x; oblicza pierwsze x+1liczby trójkątne jako opcjonalny argument do gry w golfa w kilku nawiasach klamrowych. Użyłem, choosezanim zobaczyłem odpowiedź Octave Luisa Mendo .

Wygoliłem kilka bajtów odpowiedzi Luisa Mendo, ale zapomniałem użyć tego samego pomysłu w mojej odpowiedzi.

Galaretka , 18 bajtów

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

Wypróbuj online!

Python 2 , 83 81 bajtów

• @Felipe Nardi Batista zapisał 2 bajty.

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

Wypróbuj online!

APL (Dyalog Classic) , 16 14 bajtów

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

Wypróbuj online!

Clojure, 74 bajty

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

Wybierz swój ulubiony :) Pętle mogą być krótsze ...

Python 2 , 82 bajty

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

Wypróbuj online

Zostało to utworzone przez zmianę tej odpowiedzi na powiązane pytanie.