Dipendenze triangolari


25

Un numero triangolare è un numero che è la somma dei nnumeri naturali da 1 a n. Ad esempio, 1 + 2 + 3 + 4 = 10così 10è un numero triangolare.

Dato un numero intero positivo ( 0 < n <= 10000) come input (può essere preso come numero intero o come stringa), restituisce il numero triangolare più piccolo possibile che può essere aggiunto all'input per creare un altro numero triangolare.

Ad esempio, dato l'input 26, aggiungendo 10risultati in 36, che è anche un numero triangolare. Non ci sono numeri triangolari più piccoli di quelli 10che possono essere aggiunti 26per creare un altro numero triangolare, quindi 10in questo caso è il risultato corretto.

0 è un numero triangolare, quindi se l'input è esso stesso un numero triangolare, l'output dovrebbe essere 0

Casi test

I casi sono indicati nel 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)

punteggio

Si tratta di quindi vince il minor numero di byte in ogni lingua !


No 26 -> 2?
Okx,

@Okx Ho fatto lo stesso errore, devi trovare un numero triangolare da aggiungere a quello attuale per creare un altro numero triangolare.
Martin Ender,

2
Relazionato. (duplicato limite)
Martin Ender,

Risposte:


21

Java 8, 58 57 byte

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

Suite di test online

Grazie a Dennis per un risparmio di 1 byte.


6
Ora questo è Java, golf! :)
Olivier Grégoire,

4
@Computronium, l'ordine delle operazioni è garantito dalla specifica del linguaggio Java . Java evita deliberatamente alcune delle debolezze di C.
Peter Taylor,


2
return-~i*i/2;salva un byte.
Dennis,

1
@Okx Java è pass-by-value per i tipi primitivi e pass-by-reference per gli oggetti (compresi gli array). Se si desidera effettivamente eseguire l'output nella stessa variabile, è necessario trovarsi in un contesto pass-by-reference (esplicitamente indicato nel collegamento). L'unico modo in cui vedo il pass-by-reference che potrebbe funzionare è passare un argomento int[]anziché un intargomento. Ma questo significa occuparsi di array più tardi. Potrebbe funzionare:, x->{int i=0,m=0,n=x[0];while(n!=0)n+=n<0?++i:--m;x[0]=-~i*i/2;}ma è 63 byte.
Olivier Grégoire,

7

MATL , 13 12 byte

1 byte rimosso usando un'idea (imposta intersezione) dalla risposta 05AB1E di Emigna

Q:qYstG-X&X<

Provalo online!

Spiegazione

Lasciare che t(n) = 1 + 2 + ··· + nindicano il nnumero triangolare -esimo.

Il codice sfrutta il fatto che, data n, la soluzione è limitata da t(n-1). Per vedere questo, osserva che è t(n-1) + nuguale t(n)e quindi è un numero triangolare.

Considera l'input 8come esempio.

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

Riesci a rimuovere il Qcomando dalla tua argomentazione sul limite?
Giuseppe,

@Giuseppe No, questo non riesce per l'input 8. Quando l'output è uguale al limite t(n-1), il codice lo ottiene come t(n)-n. Quindi t(n)è necessario. Grazie comunque per l'idea!
Luis Mendo,

7

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

Provalo online!

Crediti


1
Bella risposta (come sempre ..). Non avevo notato che c'era già una risposta Java quando ho pubblicato la mia .. La mia inizialmente era più corta, ma non sembra più. :)
Kevin Cruijssen,

Grazie! Sì, la mia prima risposta è stata davvero ridondante. L'ho risolto e reso più mathy, anche se più avido di processore. Controllerò il tuo tra un secondo!
Olivier Grégoire,

Ancora non capisco cosa sta succedendo qui. Perché funziona Stai sostituendo m ogni volta, quindi qual è il punto?
V. Courtois,

2
@ V.Courtois La domanda richiede il più piccolo m. Quindi vado dal abasso al 0. "ma stai assegnando forse 100 volte lo stesso valore a*a+aa mnel b-loop", sì, non ho bisogno di farlo 100 volte, ma sto guadagnando byte non rompendo il b-loop prima.
Olivier Grégoire,

Vedo @ OlivierGrégoire. Quindi è di proposito anti-efficiente: D
V. Courtois,

5

Mathematica, 46 byte

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

4

Neim , 12 9 byte

tS𝕊Λt𝕚)0𝕔

Questo richiede troppo tempo per il calcolo (ma funziona con un tempo e una memoria infiniti), quindi nel collegamento generi solo i primi 143 numeri triangolari - usando £𝕖, che è sufficiente per gestire un input di 10.000, ma non abbastanza per il timeout.

Attenzione: questo potrebbe non funzionare nelle versioni future. In tal caso, sostituire £ per 143

Spiegazione:

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

Provalo!


In che modo i primi 143 numeri dei triangoli sono sufficienti per qualsiasi input compreso tra 0 e 10000? Con l'input 9998, il risultato atteso è 3118753, che è molto al di sopra del 143 ° numero del triangolo (che è `10296).
Olivier Grégoire,

@ OlivierGrégoire perchéThis takes too long to compute (but works given infinite time and memory)
Stephen,

Grazie @StepHen ma non è quello che ho detto. Ciò che ho insinuato è che la frase "i primi 143 numeri triangolari [sono] sufficienti per gestire un input di 10.000" è errata. Non ho fatto la matematica, ma credo che dovresti aver bisogno di circa 10000 (dare o prendere) numeri triangolari per gestire i casi fino a 10000.
Olivier Grégoire,

@ OlivierGrégoire Ho affermato che è sufficiente gestire un input di 10.000, ma non un numero inferiore. Sentiti libero di passare £a un numero più alto, come 200.
Okx,

@Okx Okay, non l'ho capito così quando ho letto per la prima volta, grazie per aver dedicato del tempo a spiegare :)
Olivier Grégoire,

4

PHP , 45 byte

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

Provalo online!

È la variante più breve di for(;!$r[$t];$t+=++$i)$r[$argn+$t]=~+$t;echo~$r[$t];

allargato

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;

Provalo online!

Usa il nuovo operatore astronave in PHP 7

allargato

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;

Provalo online!


4

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

Spiegazione:

Provalo 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

1
Più

@JollyJoker Forse è per questo che è il più lungo. ;) O è a causa della mia spiegazione aggiunta?
Kevin Cruijssen,

No, stavo pensando al codice. Probabilmente ho impiegato 15 minuti per capire come funziona la soluzione di Peter Taylor. Il tuo è chiaro anche senza i commenti.
JollyJoker il

3

Brachylog , 17 15 byte

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

Provalo online!

Spiegazione

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

3

Python 2 , 59 byte

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

Provalo online!

Questo utilizza la seguente caratterizzazione dei numeri triangolari tche possono essere aggiunti nper ottenere un numero triangolare:

8*t+1 = (r-2*s)^2per coppie divisori (r,s)con r*s==ne rdispari.

Il codice prende il minimo di tutti questi numeri triangolari.


3

Gelatina , 8 byte

0r+\ðf_Ḣ

Provalo online!

Come funziona

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.

3

Japt , 24 23 16 15 byte

ò å+
m!nNg)æ!øU

Provalo

1 byte salvato grazie a ETH


Spiegazione

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

Penso che puoi salvare un byte con æ!øV. A parte questo, sembra fantastico :-)
ETHproductions



2

Mathematica, 62 byte

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

Non conosco Mathematica, ma sarebbe Solve[2*#==m(m+1)-n(n+1)più breve (se funziona)?
Kritixi Lithos,

sì, ho appena pubblicato la mia risposta e sto provando a
giocarla

2

Python 2 , 78 71 70 byte

Sette byte salvati, grazie a ovs e theespinosa

Un altro byte salvato a causa dell'osservazione di Neil , x+9è sufficiente e controllato per tutti i numeri naturali 0 <= n <= 10000. È stato anche verificato per x+1invece di x+9, funziona anche.

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

Provalo online!


2
Puoi usare al n*-~n/2posto din*(n+1)/2
ovs il

2
Range (x + 9) funzionerebbe?
Neil,

2
Puoi usare {n*(n+1)/2for n in range(999)}invece di esplicito sete anche usare {}invece che setnella terza riga
TheEspinosa,

2

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

Modifica: salvato 1 byte grazie a @PeterTaylor.


L'impostazione di una variabile globale è un abuso orribile di un parametro predefinito. +1. Ma FWIW puoi salvare un ulteriore byte sostituendolo -++scon --s, come ho fatto nella mia versione Java derivata in modo indipendente ma abbastanza simile. (Addendum: è inoltre necessario modificare il test in n>0).
Peter Taylor,

@PayTaylor Huh, quindi l' n>sassegno è sempre stato un'aringa rossa!
Neil,

Funziona non per 8192
Jörg Hülsermann,

@ JörgHülsermann Se ti riferisci allo snippet, le dimensioni dello stack del tuo browser potrebbero non essere abbastanza grandi o potresti aver bisogno di un browser con ottimizzazione sperimentale delle chiamate in coda. In alternativa, se si utilizza NodeJS per i test, utilizzare node --stack_size=per aumentare le dimensioni dello stack.
Neil,

2

Python 3 , 60 44 byte

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

Grazie a @xnor per un suggerimento che ha salvato 16 byte!

Provalo online!

sfondo

Sia n un numero intero non negativo. Se n è il k esimo numero triangolare, abbiamo

condizione

il che significa che ci sarà una soluzione naturale se e solo se 1 + 8n è un quadrato strano e perfetto. Chiaramente, controllando la parità di 1 + 8n non è necessario .

Come funziona

La funzione ricorsiva n accetta come argomento un singolo intero non negativo. Quando viene chiamato con un singolo argomento, k per impostazione predefinita è 1 .

Innanzitutto, (8*n+1)**.5%1verifica se n è un numero triangolare: if (e solo se) lo è, (8*n+1)**.5produrrà un numero intero, quindi il residuo della divisione per 1 produrrà 0 .

Se il modulo è 0 , la andcondizione fallirà, facendo sì che f restituisca 0 . Se ciò accade nella chiamata iniziale a f , si noti che questo è l'output corretto poiché n è già triangolare.

Se il modulo è positivo, la andcondizione è valida e f(n+k,k+1)+kviene eseguita. Ciò richiede f nuovamente, incrementando n da k e k da 1 , poi aggiunge k al risultato.

Quando f (n 0 , k 0 ) restituisce finalmente 0 , torniamo indietro dalla ricorsione. Il primo argomento della prima chiamata era n , il secondo n + 1 , il terzo n + 1 + 2 , fino a quando infine n 0 = n + 1 +… k 0 -1 . Si noti che n 0 - n è un numero triangolare.

Allo stesso modo, tutti questi numeri interi verranno aggiunti al valore di ritorno più interno ( 0 ), quindi il risultato della chiamata iniziale f (n) è n 0 - n , come desiderato.


Se aumenti anche la nricorrenza, puoi scrivere npiuttosto che (n+k).
xnor


Wow, è molto più bello di quello che stavo provando.
xnor

2

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

Provalo online! Programma che accetta una stringa come input e output tramite Exit Code.

Salvataggio di 10 byte grazie a Kevin Cruijssen


1
Ciao, benvenuto in PPCG! Non è necessario un programma completo a meno che la sfida non indichi diversamente. L'impostazione predefinita è programma / funzione, quindi è consentita anche una lambda in C #. Ma se vuoi usare il programma, puoi giocare a golf con alcune cose nel tuo codice attuale: 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])} ");}}}( 281 byte )
Kevin Cruijssen,

@KevinCruijssen Grazie per il consiglio! usare for(;;)per fare un ciclo infinito è un bernoccolo, e mi assicurerò di pensare più attentamente se usare var sia effettivamente più efficiente che usare un tipo esplicito ma combinando le dichiarazioni, e immagino sia più diligente nel rimuovere parentesi non necessarie. Per quanto riguarda il programma vs. la funzione, ho iniziato con un lambda ma non sono riuscito a farlo funzionare in TIO. So che un collegamento TIO non è effettivamente necessario, ma è qualcosa che mi piace vedere nelle risposte degli altri, quindi volevo almeno qualcosa di simile nel mio.
Kamil Drakari,

Inoltre non sono molto bravo in C # lambdas tbh, di solito codegolf in Java. Ma penso che questo dovrebbe essere corretto . ( 252 byte ). Inoltre, nel caso in cui non l'avessi ancora visto: i suggerimenti per giocare a codice in C # e i suggerimenti per giocare a golf in <tutte le lingue> potrebbero essere interessanti da leggere. Ancora benvenuto e +1 da parte mia. Bella prima risposta. Goditi la permanenza. :)
Kevin Cruijssen il

2

JavaScript (ES7), 46 44 byte

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

Provalo

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>


1
Funzionerebbe r=x=0?
Kritixi Lithos,

Purtroppo no, @KritixiLithos.
Shaggy,

1

05AB1E , 8 byte

ÝηODI-Ãн

Provalo online! o come una suite di test

Spiegazione

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

1

Dyalog APL, 19 byte

6 byte salvati grazie a @KritixiLithos

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

Provalo online!

Come?

o←0,+\⍳⍵- assegnare oi primi numeri triangolari

o/⍨- filtra oper

o∊⍨⍵+o- i numeri triangolari che si sommano con producono triangolari

- e prendi il primo


+\⍳⍵dovrebbe funzionare invece di quello che stai usando per generare i numeri triangolari.
Kritixi Lithos,

Penso che ⌊/
funzioni



1

Aggiungere ++ , 68 byte

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

Provalo online!o vedere la suite di test !

Anche Java mi sta picchiando. Ho davvero bisogno di aggiungere alcuni comandi impostati per aggiungere ++

Come funziona

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]

1

R , 46 44 43 41 byte

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

Provalo online!

Una funzione anonima con un argomento obbligatorio x,; calcola i primi x+1numeri triangolari come argomento facoltativo per estrarre alcune parentesi graffe. Ho usato chooseprima di vedere la risposta Octave di Luis Mendo .

Mi sono rasato alcuni byte della risposta di Luis Mendo ma ho dimenticato di usare la stessa idea nella mia risposta.





0

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)

Scegli il tuo preferito :) I loop potrebbero essere più brevi ...


0

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

Provalo online

Questo è stato creato modificando questa risposta dalla domanda correlata.


non funziona per 8192
Jörg Hülsermann,

Non funziona neanche per quello sulla domanda correlata, a causa della profondità della ricorsione. Non sono sicuro di quale sia il consenso al riguardo.
mbomb007,

Alcune altre risposte hanno lo stesso problema.
Fornisco
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.