Dépendances triangulaires

25

Un nombre triangulaire est un nombre qui est la somme des nnombres naturels de 1 à n. Par exemple, 1 + 2 + 3 + 4 = 10il en 10va de même pour un nombre triangulaire.

Étant donné un entier positif ( 0 < n <= 10000) en entrée (peut être pris comme un entier ou comme une chaîne), retournez le plus petit nombre triangulaire possible qui peut être ajouté à l'entrée pour créer un autre nombre triangulaire.

Par exemple, pour une entrée donnée 26, l'ajout de 10résultats dans 36, qui est également un nombre triangulaire. Il n'y a pas de nombres triangulaires plus petits que ceux 10qui peuvent être ajoutés pour 26créer un autre nombre triangulaire, 10le résultat est donc correct dans ce cas.

0 est un nombre triangulaire, donc si l'entrée est elle-même un nombre triangulaire, la sortie doit être 0

Cas de test

Les cas sont donnés dans le 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)

Notation

C'est donc le moins d'octets dans chaque langue gagne!

Skidsdev
la source
N'est-ce pas 26 -> 2?
Okx
@Okx J'ai fait la même erreur, vous devez trouver un nombre triangulaire à ajouter à celui en cours pour faire un autre nombre triangulaire.
Martin Ender
2
En relation. (borderline duplicate)
Martin Ender

Réponses:

21

Java 8, 58 57 octets

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

Suite de tests en ligne

Merci à Dennis pour une économie d'un octet.

Peter Taylor
la source
6
Maintenant , c'est Java, golfed! :)
Olivier Grégoire
4
@Computronium, l'ordre des opérations est garanti par la spécification du langage Java . Java évite délibérément certaines des faiblesses de C.
Peter Taylor
2
return-~i*i/2;enregistre un octet.
Dennis
1
@Okx Java est une valeur de passage pour les types primitifs et une référence de passage pour les objets (y compris les tableaux). Si vous voulez réellement sortir dans la même variable, vous devez être dans un contexte passe-par-référence (dit explicitement dans votre lien). La seule façon que je vois de passer par référence qui pourrait fonctionner est de passer un int[]au lieu d'un intargument as. Mais cela signifie traiter des tableaux plus tard. Cela pourrait fonctionner:, x->{int i=0,m=0,n=x[0];while(n!=0)n+=n<0?++i:--m;x[0]=-~i*i/2;}mais c'est 63 octets.
Olivier Grégoire
7

MATL , 13 12 octets

1 octet supprimé à l'aide d'une idée (intersection définie) de la réponse 05AB1E d'Emigna

Q:qYstG-X&X<

Essayez-le en ligne!

Explication

Soit t(n) = 1 + 2 + ··· + nle n-ième nombre triangulaire.

Le code exploite le fait que, étant donné n, la solution est limitée par t(n-1). Pour voir cela, observez cela t(n-1) + négal t(n)et c'est donc un nombre triangulaire.

Considérez la saisie 8comme exemple.

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
Luis Mendo
la source
Pouvez-vous supprimer le Qdébut de votre argument sur la délimitation?
Giuseppe
@Giuseppe Non, cela échoue pour la saisie 8. Lorsque la sortie est égale à la limite t(n-1), le code l'obtient comme t(n)-n. C'est donc t(n)nécessaire. Merci pour l'idée quand même!
Luis Mendo
7

Java (OpenJDK 8) , 83 octets

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

Essayez-le en ligne!

Crédits

Olivier Grégoire
la source
1
Belle réponse (comme toujours ..). Je n'avais pas remarqué qu'il y avait déjà une réponse Java lorsque j'ai posté la mienne . La mienne était initialement plus courte, mais il ne semble plus. :)
Kevin Cruijssen
Merci! Ouais, ma première réponse était vraiment redondante. Je l'ai corrigé et rendu plus mathématique, bien que plus gourmand en processeur. Je vérifierai le vôtre dans une seconde!
Olivier Grégoire
Je ne comprends toujours pas ce qui se passe ici. Pourquoi ça marche? Vous remplacez m à chaque fois, alors à quoi ça sert?
V. Courtois
2
@ V.Courtois La question demande le plus petit m. Je vais donc de abas en haut 0. « mais vous attribuer la même valeur peut - être 100 fois a*a+aà mla b-loop », eh oui, je ne ai pas besoin de le faire 100 fois, mais je gagne octets en ne brisant le b-loop plus tôt.
Olivier Grégoire
Je vois @ OlivierGrégoire. Donc c'est
V. Courtois
5

Mathematica, 46 octets

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

Neim , 12 9 octets

tS𝕊Λt𝕚)0𝕔

Cela prend trop de temps à calculer (mais fonctionne avec un temps et une mémoire infinis), donc dans le lien, je ne génère que les 143 premiers nombres triangulaires - en utilisant £𝕖, ce qui est suffisant pour gérer une entrée de 10000, mais pas assez pour expirer.

Attention: cela pourrait ne pas fonctionner dans les futures versions. Si oui, remplacez £ par 143

Explication:

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

Essayez!

Okx
la source
Comment les 143 premiers nombres triangulaires suffisent-ils pour toute entrée entre 0 et 10000? Avec l'entrée 9998, le résultat attendu est 3118753, ce qui est bien au-dessus du 143ème numéro de triangle (qui est `10296).
Olivier Grégoire
@ OlivierGrégoire carThis takes too long to compute (but works given infinite time and memory)
Stephen
Merci @StepHen mais ce n'est pas ce que j'ai dit. Ce que j'ai sous-entendu, c'est que la phrase «les 143 premiers nombres triangulaires [sont] suffisants pour gérer une entrée de 10 000» est erronée. Je n'ai pas fait le calcul, mais je pense que vous devriez avoir besoin d'environ 10000 (donner ou prendre) nombres triangulaires pour gérer les cas jusqu'à 10000.
Olivier Grégoire
@ OlivierGrégoire J'ai déclaré qu'il suffit de gérer une entrée de 10 000, mais pas moins que cela. N'hésitez pas à passer £à un nombre plus élevé, tel que 200.
Okx
@Okx D'accord, je ne l'ai pas compris comme ça quand j'ai lu pour la première fois, merci d'avoir pris le temps de m'expliquer :)
Olivier Grégoire
4

PHP , 45 octets

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

Essayez-le en ligne!

Est la variante la plus courte de for(;!$r[$t];$t+=++$i)$r[$argn+$t]=~+$t;echo~$r[$t];

Étendu

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 octets

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

Essayez-le en ligne!

Utilisez le nouvel opérateur de vaisseau spatial en PHP 7

Étendu

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 octets

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

Essayez-le en ligne!

Jörg Hülsermann
la source
4

Java 8, 110 102 100 93 92 octets

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 octets grâce à @PeterTaylor .
-7 octets grâce à @JollyJoker .
-1 octet grâce à @ceilingcat .

Explication:

Essayez-le en ligne.

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
Kevin Cruijssen
la source
1
Le plus facile à lire des solutions Java :)
JollyJoker
@JollyJoker C'est peut-être pourquoi c'est le plus long. ;) Ou est-ce à cause de mon explication supplémentaire?
Kevin Cruijssen
Non, je pensais au code. J'ai probablement passé 15 minutes à comprendre comment fonctionne la solution de Peter Taylor. Le vôtre est clair même sans les commentaires.
JollyJoker
3

Brachylog , 17 15 octets

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

Essayez-le en ligne!

Explication

⟦                  [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
Fatalize
la source
3

Python 2 , 59 octets

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

Essayez-le en ligne!

Cela utilise la caractérisation suivante des nombres triangulaires qui tpeuvent être ajoutés npour obtenir un nombre triangulaire:

8*t+1 = (r-2*s)^2pour les paires de diviseurs (r,s)avec r*s==net rimpair.

Le code prend le minimum de tous ces nombres triangulaires.

xnor
la source
3

Gelée , 8 octets

0r+\ðf_Ḣ

Essayez-le en ligne!

Comment ça marche

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.
Dennis
la source
3

Japt , 24 23 16 15 octets

ò å+
m!nNg)æ!øU

Essaye-le

1 octet économisé grâce à ETH


Explication

    :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.
Hirsute
la source
Je pense que vous pouvez enregistrer un octet avec æ!øV. A part ça, ça a l'air super :-)
ETHproductions
2

Mathematica, 62 octets

(s=Min@Abs[m/.Solve[2#==(n-m)(n+m+1),{n,m},Integers]])(s+1)/2&
J42161217
la source
Je ne connais pas Mathematica, mais serait Solve[2*#==m(m+1)-n(n+1)plus court (si ça marche)?
Kritixi Lithos
oui, je viens de poster ma réponse et d'essayer de la
jouer
2

Python 2 , 78 71 70 octets

Sept octets enregistrés, merci aux ovules et à l' épinosa

Un octet de plus économisé grâce à la remarque de neil , x+9est suffisant et vérifié pour tous les nombres naturels 0 <= n <= 10000. Il a également été vérifié au x+1lieu de x+9, cela fonctionne également.

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

Essayez-le en ligne!

mdahmoune
la source
2
Vous pouvez utiliser n*-~n/2au lieu den*(n+1)/2
ovs
2
La plage (x + 9) fonctionnerait-elle?
Neil
2
Vous pouvez utiliser {n*(n+1)/2for n in range(999)}au lieu d'explicite setet également utiliser {}au lieu de setdans la troisième ligne
TheEspinosa
2

JavaScript (ES6), 43 42 octets

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

Edit: 1 octet enregistré grâce à @PeterTaylor.

Neil
la source
La définition d'une variable globale est un abus hideux d'un paramètre par défaut. +1. Mais FWIW, vous pouvez enregistrer un octet supplémentaire en le remplaçant -++spar --s, comme je l'ai fait dans ma version Java dérivée indépendamment mais assez similaire. (Addendum: vous devez également remplacer le test par n>0).
Peter Taylor
@PeterTaylor Huh, donc le n>schèque était un hareng rouge tout le temps!
Neil
Ne fonctionne pas pour 8192
Jörg Hülsermann
@ JörgHülsermann Si vous faites référence à l'extrait de code, la taille de la pile de votre navigateur peut ne pas être suffisamment grande ou vous pouvez avoir besoin d'un navigateur avec une optimisation expérimentale des appels de queue. Alternativement, si vous utilisez NodeJS pour les tests, utilisez node --stack_size=pour augmenter sa taille de pile.
Neil
2

Python 3 , 60 44 octets

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

Merci à @xnor pour une suggestion qui a sauvé 16 octets!

Essayez-le en ligne!

Contexte

Soit n un entier non négatif. Si n est le k ème nombre triangulaire, on a

état

ce qui signifie qu'il y aura une solution naturelle si et seulement si 1 + 8n est un carré parfait et impair. En clair, vérifier la parité de 1 + 8n n'est pas requise.

Comment ça marche

La fonction récursive n accepte comme argument un entier non négatif. Lorsqu'il est appelé avec un seul argument, k par défaut est 1 .

Premièrement, (8*n+1)**.5%1teste si n est un nombre triangulaire: si (et seulement si), (8*n+1)**.5il donnera un entier, donc le résidu de la division par 1 donnera 0 .

Si le module est égal à 0 , la andcondition échoue, ce qui fait que f renvoie 0 . Si cela se produit lors de l'appel initial à f , notez qu'il s'agit de la sortie correcte car n est déjà triangulaire.

Si le module est positif, la andcondition est vérifiée et f(n+k,k+1)+kexécutée. Cela appelle à nouveau f , incrémentant n de k et k de 1 , puis ajoute k au résultat.

Lorsque f (n 0 , k 0 ) renvoie finalement 0 , nous sortons de la récursivité. Le premier argument du premier appel était n , le deuxième n + 1 , le troisième n + 1 + 2 , jusqu'à ce que finalement n 0 = n + 1 +… k 0 -1 . Notez que n 0 - n est un nombre triangulaire.

De même, tous ces entiers seront ajoutés à la valeur de retour la plus intérieure ( 0 ), donc le résultat de l'appel initial f (n) est n 0 - n , comme souhaité.

Dennis
la source
Si vous augmentez également la nrécurrence, vous pouvez écrire nplutôt que (n+k).
xnor
Wow, c'est beaucoup mieux que ce que j'essayais.
xnor
2

C # (.NET Core) , 291 281 octets

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

Essayez-le en ligne! Programme qui prend une chaîne en entrée et sort via le code de sortie.

10 octets enregistrés grâce à Kevin Cruijssen

Kamil Drakari
la source
1
Salut, bienvenue chez PPCG! Vous n'avez pas besoin d'un programme complet, sauf indication contraire du défi. La valeur par défaut est programme / fonction, donc un lambda est également autorisé en C #. Mais si vous voulez utiliser le programme, vous pouvez 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])} ");}}}
jouer au
@KevinCruijssen Merci pour les conseils! utiliser for(;;)pour faire une boucle infinie est une belle bosse, et je m'assurerai de réfléchir plus attentivement à l'utilisation de var en fait plus efficace que d'utiliser un type explicite mais en combinant les déclarations, et je suppose que vous devez être plus diligent pour supprimer les crochets inutiles. Quant au programme vs fonction, j'ai commencé avec un lambda mais je n'ai pas pu le faire fonctionner dans TIO. Je sais qu'un lien TIO n'est pas vraiment nécessaire, mais c'est quelque chose que j'aime voir dans les réponses des autres, donc je voulais au moins quelque chose de similaire dans la mienne.
Kamil Drakari
Je ne suis pas non plus très bon en C # lambdas tbh, je codegolf habituellement en Java. Mais je pense que cela devrait être correct . ( 252 octets ). De plus, au cas où vous ne l'auriez pas encore vu: des conseils pour jouer au code en C # et des conseils pour jouer au golf dans <toutes les langues> pourraient être intéressants à lire. Encore une fois bienvenue et +1 de ma part. Belle première réponse. Profitez de votre séjour. :)
Kevin Cruijssen
2

JavaScript (ES7), 46 44 octets

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

Essayez-le

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>

Hirsute
la source
1
Ça r=x=0marcherait?
Kritixi Lithos
Malheureusement non, @KritixiLithos.
Shaggy
1

05AB1E , 8 octets

ÝηODI-Ãн

Essayez-le en ligne! ou comme suite de tests

Explication

Ý          # 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)
Emigna
la source
1

Dyalog APL, 19 octets

6 octets enregistrés grâce à @KritixiLithos

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

Essayez-le en ligne!

Comment?

o←0,+\⍳⍵- attribuer oles premiers nombres triangulaires

o/⍨- filtrer opar

o∊⍨⍵+o- nombres triangulaires qui se sont additionnés avec produisent des triangulaires

- et prenez le premier

Uriel
la source
+\⍳⍵devrait fonctionner à la place de ce que vous utilisez pour générer les nombres triangulaires.
Kritixi Lithos
Je pense que ça marche au lieu de⌊/
Kritixi Lithos
1

Ajouter ++ , 68 octets

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

Essayez-le en ligne! ou consultez la suite de tests !

Même Java me bat. J'ai vraiment besoin d'ajouter des commandes set à Add ++

Comment ça marche

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]
caird coinheringaahing
la source
1

R , 46 44 43 41 octets

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

Essayez-le en ligne!

Une fonction anonyme avec un argument obligatoire x; calcule les premiers x+1nombres triangulaires comme argument facultatif pour jouer quelques accolades. J'ai utilisé chooseavant de voir la réponse Octave de Luis Mendo .

J'ai rasé quelques octets de la réponse de Luis Mendo mais j'ai oublié d'utiliser la même idée dans ma réponse.

Giuseppe
la source
0

Python 2 , 83 81 octets

  • @Felipe Nardi Batista a enregistré 2 octets.
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)]

Essayez-le en ligne!

officialaimm
la source
0

Clojure, 74 octets

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

Choisissez votre préféré :) Les boucles peuvent être plus courtes ...

NikoNyrh
la source
0

Python 2 , 82 octets

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

Essayez-le en ligne

Cela a été créé en modifiant cette réponse de la question connexe.

mbomb007
la source
fonctionne pas pour 8192
Jörg Hülsermann
Cela ne fonctionne pas non plus pour la question connexe, en raison de la profondeur de récursivité. Je ne sais pas quel est le consensus à ce sujet.
mbomb007
Certaines autres réponses ont le même problème. Je ne donne que l'info
Jörg Hülsermann