Eine Dreieckszahl ist eine Zahl, die die Summe der nnatürlichen Zahlen von 1 bis ist n. Zum Beispiel , 1 + 2 + 3 + 4 = 10so 10ist eine Dreieckszahl.

Bei einer positiven Ganzzahl ( 0 < n <= 10000) als Eingabe (kann als Ganzzahl oder als Zeichenfolge verwendet werden) wird die kleinstmögliche Dreieckszahl zurückgegeben, die zur Eingabe hinzugefügt werden kann, um eine weitere Dreieckszahl zu erstellen.

Wenn Sie beispielsweise eine Eingabe machen 26, 10ergibt 36das Addieren eine Dreieckszahl. Es gibt keine kleineren Dreieckszahlen 10, die hinzugefügt werden können, 26um eine andere Dreieckszahl zu erstellen. 10In diesem Fall ist das richtige Ergebnis.

0 ist eine Dreieckszahl. Wenn die Eingabe selbst eine Dreieckszahl ist, sollte die Ausgabe eine Dreieckszahl sein 0

Testfälle

Fälle werden im Format angegeben 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)

Wertung

Dies ist Codegolf, so dass die wenigsten Bytes in jeder Sprache gewinnen!

Java 8, 58 57 Bytes

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

Online-Testsuite

Vielen Dank an Dennis für die 1-Byte-Speicherung.

MATL , 13 - 12 Bytes

1 Byte entfernt mit einer Idee (Schnittmenge setzen) aus Emignas 05AB1E-Antwort

Q:qYstG-X&X<

Probieren Sie es online!

Erläuterung

Lassen Sie t(n) = 1 + 2 + ··· + ndie bezeichnen n-te Dreieckszahl.

Der Code macht sich die Tatsache zunutze, dass ndie Lösung nach oben begrenzt ist t(n-1). Um dies zu sehen, beobachten Sie, dass t(n-1) + ngleich ist t(n)und es sich somit um eine dreieckige Zahl handelt.

Betrachten Sie die Eingabe 8als Beispiel.

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

Probieren Sie es online!

Credits

• -3 Bytes dank ceilingcat

Mathematica, 46 Bytes

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

Neim , 12 9 Bytes

tS𝕊Λt𝕚)0𝕔

Die Berechnung dauert zu lange (funktioniert aber bei unendlicher Zeit und unendlichem Speicher), sodass ich im Link nur die ersten 143 Dreieckszahlen generiere - mit £𝕖, was für eine Eingabe von 10.000 ausreicht, für eine Zeitüberschreitung jedoch nicht ausreicht.

^{Warnung: Dies funktioniert möglicherweise in zukünftigen Versionen nicht mehr. Wenn ja, ersetzen Sie 143 durch £}

Erläuterung:

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

Versuch es!

PHP , 45 Bytes

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

Probieren Sie es online!

Ist die kürzere Variante von for(;!$r[$t];$t+=++$i)$r[$argn+$t]=~+$t;echo~$r[$t];

Erweitert

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 Bytes

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

Probieren Sie es online!

Verwenden Sie den neuen Raumschiff-Operator in PHP 7

Erweitert

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 Bytes

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

Probieren Sie es online!

Java 8, 110 102 100 93 92 Bytes

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 Bytes dank @PeterTaylor .
-7 Bytes dank @JollyJoker .
-1 Byte dank @ceilingcat .

Erläuterung:

Probieren Sie es online aus.

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 Bytes

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

Probieren Sie es online!

Erläuterung

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

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

Probieren Sie es online!

Hierbei wird die folgende Charakterisierung der Dreieckszahlen tverwendet, die hinzugefügt werden kann n, um eine Dreieckszahl zu erhalten:

8*t+1 = (r-2*s)^2für Divisorenpaare (r,s)mit r*s==nund rungerade.

Der Code nimmt das Minimum aller solcher Dreieckszahlen.

Gelee , 8 Bytes

0r+\ðf_Ḣ

Probieren Sie es online!

Wie es funktioniert

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

Probier es aus

Dank ETH 1 Byte gespart

Erläuterung

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

Oktave , 38 36 Bytes

2 Bytes weniger dank @Giuseppe!

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

Anonyme Funktion, die fast den gleichen Ansatz wie meine MATL-Antwort verwendet .

Probieren Sie es online!

05AB1E , 12 Bytes

ÝηOãD€Æ¹QϬ¤

Verwendet die 05AB1E- Codierung. Probieren Sie es online!

Mathematica, 62 Bytes

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

Python 2 , 78 71 70 Bytes

Sieben Bytes gespart, Danke an Ovs und Theespinosa

Ein weiteres Byte, das aufgrund der Bemerkung von neil gespeichert wurde , x+9ist ausreichend und wird auf alle natürlichen Zahlen überprüft0 <= n <= 10000 . Es wurde auch überprüft für x+1statt x+9, funktioniert es auch.

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

Probieren Sie es 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

Bearbeiten: 1 Byte dank @PeterTaylor gespeichert.

Python 3 , 60 44 Bytes

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

Vielen Dank an @xnor für einen Vorschlag, mit dem 16 Bytes eingespart wurden!

Probieren Sie es online!

Hintergrund

Sei n eine nicht negative ganze Zahl. Wenn n die k- ^te Dreieckszahl ist, haben wir

Das heißt, es wird eine natürliche Lösung geben, wenn 1 + 8n ein ungerades, perfektes Quadrat ist. Es ist offensichtlich nicht erforderlich , die Parität von 1 + 8n zu überprüfen .

Wie es funktioniert

Die rekursive Funktion n akzeptiert eine einzelne, nicht negative Ganzzahl als Argument. Wenn k mit einem einzelnen Argument aufgerufen wird, ist es standardmäßig 1 .

Zunächst wird (8*n+1)**.5%1geprüft, ob n eine Dreieckszahl ist: Wenn (und nur wenn), (8*n+1)**.5wird eine ganze Zahl erhalten, sodass der Rest der Division durch 1 0 ergibt .

Wenn die Modul ist 0 , der andwird Zustand versagen, was f auf Rückkehr 0 . Wenn dies beim ersten Aufruf von f der Fall ist, beachten Sie, dass dies die richtige Ausgabe ist, da n bereits dreieckig ist.

Wenn der Modul positiv ist, gilt die andBedingung und f(n+k,k+1)+kwird ausgeführt. Dies ruft f erneut auf, inkrementiert n um k und k um 1 und addiert dann k zum Ergebnis.

Wenn f (n ₀ , k ₀ ) schließlich 0 ergibt, verlassen wir die Rekursion. Das erste Argument im ersten Aufruf war n , das zweite n + 1 , das dritte n + 1 + 2 , bis schließlich n ₀ = n + 1 +… k ₀ -1 . Beachten Sie, dass n ₀ - n eine dreieckige Zahl ist.

Ebenso werden alle diese Zahlen auf den innerste Rückgabewert (hinzugefügt 0 ), so ist das Ergebnis der anfänglichen Aufruf f (n) ist , n ₀ - n , wie gewünscht.

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

Probieren Sie es online! Programm, das einen String als Eingabe und Ausgabe über den Exit-Code akzeptiert.

Dank Kevin Cruijssen 10 Bytes gespart

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.