Un número triangular es un número que es la suma de nnúmeros naturales del 1 al n. Por ejemplo, 1 + 2 + 3 + 4 = 10así 10es un número triangular.

Dado un entero positivo ( 0 < n <= 10000) como entrada (puede tomarse como un entero o como una cadena), devuelve el número triangular más pequeño posible que se puede agregar a la entrada para crear otro número triangular.

Por ejemplo 26, entrada dada , agregando 10resultados en 36, que también es un número triangular. No hay números triangulares más pequeños 10que se puedan agregar para 26crear otro número triangular, por lo que 10es el resultado correcto en este caso.

0 es un número triangular, por lo tanto, si la entrada es en sí misma un número triangular, la salida debería ser 0

Casos de prueba

Los casos se dan en el formato 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)

Tanteo

Este es el código de golf, por lo que gana menos bytes en cada idioma .

Java 8, 58 57 bytes

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

Conjunto de pruebas en línea

Gracias a Dennis por un ahorro de 1 byte.

MATL , 13 12 bytes

1 byte eliminado usando una idea (establecer intersección) de la respuesta 05AB1E de Emigna

Q:qYstG-X&X<

Pruébalo en línea!

Explicación

Deje t(n) = 1 + 2 + ··· + ndenotar el nenésimo número triangular.

El código explota el hecho de que, dada n, la solución está limitada por t(n-1). Para ver esto, observe que t(n-1) + nes igual t(n)y entonces es un número triangular.

Considere la entrada 8como un ejemplo.

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 bytes

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

Pruébalo en línea!

Créditos

• -3 bytes gracias a ceilingcat

Mathematica, 46 bytes

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

Neim , 12 9 bytes

tS𝕊Λt𝕚)0𝕔

Esto toma demasiado tiempo para computar (pero funciona dado un tiempo y memoria infinitos), por lo que en el enlace solo genero los primeros 143 números triangulares, usando £𝕖, que es suficiente para manejar una entrada de 10,000, pero no lo suficiente como para agotar el tiempo de espera.

^{Advertencia: esto puede no funcionar en futuras versiones. Si es así, sustituya £ por 143}

Explicación:

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

¡Intentalo!

PHP , 45 bytes

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

Pruébalo en línea!

Es la variante más corta de for(;!$r[$t];$t+=++$i)$r[$argn+$t]=~+$t;echo~$r[$t];

Expandido

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;

Pruébalo en línea!

Use el nuevo operador de nave espacial en PHP 7

Expandido

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;

Pruébalo en línea!

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 gracias a @PeterTaylor .
-7 bytes gracias a @JollyJoker .
-1 byte gracias a @ceilingcat .

Explicación:

Pruébalo en línea.

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

Pruébalo en línea!

Explicación

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

Pruébalo en línea!

Utiliza la siguiente caracterización de los números triangulares tque se pueden agregar npara obtener un número triangular:

8*t+1 = (r-2*s)^2para pares divisores (r,s)con r*s==ny rimpar.

El código toma el mínimo de todos esos números triangulares.

Jalea , 8 bytes

0r+\ðf_Ḣ

Pruébalo en línea!

Cómo funciona

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

Pruébalo

1 byte guardado gracias a ETH

Explicación

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

Octava , 38 36 bytes

2 bytes de descuento gracias a @Giuseppe!

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

Función anónima que usa casi el mismo enfoque que mi respuesta MATL .

Pruébalo en línea!

05AB1E , 12 bytes

ÝηOãD€Æ¹QϬ¤

Utiliza la codificación 05AB1E . Pruébalo en línea!

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

Siete bytes guardados, gracias a los ovs y theespinosa

Un byte más salvado debido a la observación de Neil , x+9es suffisant y comprobado para todos los números naturales 0 <= n <= 10000. También se verificó para en x+1lugar de x+9, funciona también.

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

Pruébalo en línea!

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

Editar: guardado 1 byte gracias a @PeterTaylor.

Python 3 , 60 44 bytes

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

¡Gracias a @xnor por una sugerencia que ahorró 16 bytes!

Pruébalo en línea!

Fondo

Sea n un número entero no negativo. Si n es el k ^número triangular, tenemos

lo que significa que habrá una solución natural si y solo si 1 + 8n es un cuadrado extraño y perfecto. Claramente, no se requiere verificar la paridad de 1 + 8n .

Cómo funciona

La función recursiva n acepta un único entero no negativo como argumento. Cuando se llama con un solo argumento, k se establece de manera predeterminada en 1 .

Primero, (8*n+1)**.5%1comprueba si n es un número triangular: si (y solo si) lo es, (8*n+1)**.5producirá un número entero, por lo que el residuo de la división por 1 producirá 0 .

Si el módulo es 0 , la andcondición fallará, haciendo que f regrese 0 . Si esto sucede en la llamada inicial a f , tenga en cuenta que esta es la salida correcta ya que n ya es triangular.

Si el módulo es positivo, la andcondición se mantiene y f(n+k,k+1)+kse ejecuta. Esto llama a f nuevamente, incrementando n por k y k por 1 , luego agrega k al resultado.

Cuando f (n ₀ , k ₀ ) finalmente devuelve 0 , retrocedemos de la recursión. El primer argumento en la primera llamada fue n , el segundo n + 1 , el tercero n + 1 + 2 , hasta que finalmente n ₀ = n + 1 + ... k ₀ -1 . Tenga en cuenta que n ₀ - n es un número triangular.

Del mismo modo, todos estos enteros se agregarán al valor de retorno más interno ( 0 ), por lo que el resultado de la llamada inicial f (n) es n ₀ - n , como se desee.

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

Pruébalo en línea! Programa que toma una cadena como entrada y salida a través del código de salida.

Guardado 10 Bytes gracias a Kevin Cruijssen

JavaScript (ES7), 46 44 bytes

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

Intentalo

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

Pruébalo en línea! o como un conjunto de pruebas

Explicación

Ý          # 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 guardados gracias a @KritixiLithos

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

Pruébalo en línea!

¿Cómo?

o←0,+\⍳⍵- asigna olos primeros ⍵números triangulares

o/⍨- filtrar opor

o∊⍨⍵+o- números triangulares que se suman con ⍵producir triangulares

⊃ - y toma el primero

Pari / GP , 54 bytes

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

Pruébalo en línea!

Haskell , 56 bytes

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

Pruébalo en línea!

Agregar ++ , 68 bytes

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

Pruébalo en línea! , o ver el conjunto de pruebas !

Incluso Java me está ganando. Realmente necesito agregar algunos comandos establecidos para Agregar ++

Cómo funciona

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]

Pruébalo en línea!

Una función anónima con un argumento obligatorio x; calcula los primeros x+1números triangulares como argumento opcional para jugar golf con unas llaves. Solía chooseantes de ver la respuesta de Octava de Luis Mendo .

Afeité algunos bytes de la respuesta de Luis Mendo, pero olvidé usar la misma idea en mi respuesta.

Jalea , 18 bytes

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

Pruébalo en línea!

Python 2 , 83 81 bytes

• @Felipe Nardi Batista guardó 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)]

Pruébalo en línea!

APL (Dyalog Classic) , 16 14 bytes

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

Pruébalo en línea!

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)

Elige tu favorito :) Los bucles pueden ser más cortos ...

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

Pruébalo en línea

Esto fue creado modificando esta respuesta de la pregunta relacionada.