(Herausforderung aus einem Multiplayer-Spiel (Clash of Code) bei codingame.com )

Die Herausforderung

Suchen Sie den n- ten Term der folgenden Sequenz: 1, 1, 2, 1, 2, 3, 1, 2, 3, 4...oder, um es offensichtlicher zu machen,{1}, {1,2}, {1,2,3}, {1,2,3,4}...

Die Sequenz besteht aus verketteten Bereichen von 1 bis x , beginnend von 1 bis unendlich.

Regeln / IO

Eingabe und Ausgabe können in einem beliebigen Format erfolgen, sofern dies unterscheidbar ist. Die Eingabe kann aus jeder geeigneten Quelle erfolgen: STDIN, Datei usw.

Die Eingabe kann 0- oder 1-indiziert sein, und die ausgewählte Indizierung muss im Beitrag erwähnt werden.

Sie müssen mindestens bis zu einem Ergebnis von 255 einschließlich verarbeiten (dh die 0-indizierte maximale Eingabe beträgt 32640). Alles, was darüber hinausgeht, muss behandelt werden, wenn Ihre Sprache dies unterstützt.

Dies ist code-golfso, dass die kürzeste Anzahl von Bytes gewinnt!

Testfälle (0-basierte Indizierung)

0 -> 1
1 -> 1
5 -> 3
10 -> 1
59 -> 5
100 -> 10
1001 -> 12

05AB1E , 5 Bytes

Das Programm ist 0-indiziert, Code:

ÌLL¹è

Erläuterung:

Ì       # Double increment the input
 LL     # List of list on the input
   ¹è   # Get nth element

Verwendet die CP-1252- Codierung. Probieren Sie es online!

Haskell , 27 26 Bytes

([z|k<-[1..],z<-[1..k]]!!)

Probieren Sie es online!

Danke @DanD. für -1 Byte!

Dies ist eine anonyme Funktion, die unendliche Folge der Schaffung eines nur das zurückkehr n-te Element davon [[1..k]| k<-[1..]]erzeugt eine unendliche Liste der Liste: [[1],[1,2],[1,2,3],[1,2,3,4],...]. Um diese zu verketten, können wir schreiben, [z|k<-[1..],z<-[1..k]]was zur Eingabe führt, diese [1,1,2,1,2,3,1,2,3,4,...]schließlich (...!!)akzeptiert n(sinnlose Notation) und den n-ten Term zurückgibt (0-basiert).

JavaScript, 29 28 Bytes

-1 Byte Danke an Arnauld!

f=(n,m)=>n++<m?n:f(n+~m,-~m)

Verwendet die in OEIS gefundene 0-indizierte rekursive Formel.

Wenn wie erwartet mit 1 Argument aufgerufen wird, ist der Standardwert der Sekunde m,, undefined. Es wird jedoch -~undefined1 zurückgegeben, wodurch wir die Rekursion ohne ein explizites m = 1Argument in der Argumentliste ins Rollen bringen können (danke @Arnauld!)

Testschnipsel:

f=(n,m)=>n++<m?n:f(n+~m,-~m)

let examples = [0, 1, 5, 10, 15, 1000];

examples.forEach(function log(x) {
    console.log(x, " => ", f(x))
});

Alternativ können wir für die gleiche Anzahl von Bytes eine Curry-Funktion haben:

f=n=>m=>n++<m?n:f(n+~m)(-~m)

Sie können dies mit aufrufen f(5)()- es gibt eine Funktion zurück, die, wenn sie aufgerufen wird, das Ergebnis zurückgibt, wie in diesem Meta-Beitrag beschrieben .

Jelly , 5 Bytes, 1-indiziert

RRF³ị

Probieren Sie es online!

Erläuterung:

                                      (Assume N = 4 for the examples)
R      Generate a list of 1 to N      [1, 2, 3, 4]
 R     Generate new lists for each item on the previous list, with that item as N
                                      [[1], [1,2], ...]
  F    Flatten that list              [1, 1, 2, 1, 2, 3 ...]
   ³ị  Use the input number (³) as index (ị) on the list. 
       This is one-based:             [1, 1, 2, 1, 2, 3 ...] 
                                                ^

Oktave, 39 Bytes

@(z)z-(n=ceil((8*z+1)^.5/2-.5))*(n-1)/2

1-basierter Index

Erläuterung:

Betrachten Sie diese Reihenfolge:

1   1   2   1   2   3   1   2   3   4   1   2   3   4   5

Wenn wir die Anzahl der Elemente der Subsequenzen zählen, haben wir

1   2        3          4               5         

Mit der Gauß-Formel für die Dreieckszahl können wir also eine Formel für z bilden:

z=n*(n+1)/2

das ist eine quadratische Gleichung, wenn wir sie für n lösen, das wir haben

n=(sqrt(8*z+1)-1)/2

Probieren Sie es online!

Haskell, 25 24 Bytes

(!!)$[1..]>>= \x->[1..x]

Anwendungsbeispiel: ((!!)$[1..]>>= \x->[1..x]) 10-> 1. Probieren Sie es online! .

Ordnet die anonyme Funktion zum Erstellen einer Liste von 1 bis x \x->[1..x](die integrierte Funktion enumFromTo 1ist ein Byte länger) der unendlichen Liste zu [1..]und verknüpft die resultierenden Listen zu einer einzigen Liste. !!wählt das n-te Element aus.

Danke an @flawr für ein Byte.

Oktave , 39 Bytes

@(n){v=1:n,A=triu(v'+0*v),A(A>0)(n)}{3}

Probieren Sie es online!

Dies verwendet einen alternativen Ansatz.

Für zB n=1dies A=triu(v'+0*v)schafft die Matrix

1   1   1   1
0   2   2   2
0   0   3   3
0   0   0   4

Wenn Sie alle Nullelemente entfernen und die Spalten anhängen, A(A>0)erhalten Sie die folgende Reihenfolge:

1   1  2  1  2  3  1  2  3  4

Dann geht es nur darum, den n-ten Term dieser Sequenz zu extrahieren .

Python , 39 36 Bytes

-3 Bytes dank Dennis!

Ein rekursives Lambda, das eine auf 1 basierende Indizierung verwendet.

f=lambda n,m=1:n*(n<=m)or f(n-m,m+1)

Probieren Sie es online!

Wir verfolgen die aktuelle "Anstieg" Größe mit m. Wenn nkleiner oder gleich ist m, passt es in den aktuellen "Anstieg" und wir geben ihn zurück. Wenn es jedoch größer als ist m, nehmen wir es mweg, addieren 1 zu mund rufen die Funktion rekursiv auf (wobei wir zum nächsten Anstieg übergehen).

R, 25 Bytes

i=scan();sequence(1:i)[i]

Der Index basiert auf 1.

Pyth , 6 5 Bytes

1 Byte gespart dank @TheBikingviking!

@s._S

Dies verwendet eine 0-basierte Indizierung.

Probieren Sie es online!

Erläuterung

@          Index with implicit input into
   ._      all prefixes of
     S     1-based range of implicit input
 s         concatenated into an un-nested list

Mathematica, 27 24 Bytes

Danke @MartinEnder für 3 Bytes!

((r=Range)@r@#<>1)[[#]]&

1-indiziert. Dies löst Fehler aus, die ignoriert werden können.

Erläuterung

((r=Range)@r@#<>1)[[#]]&
  r=Range                 (* Store Range function in r *)
           r@#            (* Create list {1..n} *)
 (r      )@               (* For each element, generate {1..n} *)
              <>1         (* Join the lists and append a 1; throws errors *)
(                )[[#]]&  (* Take the nth element *)

Brainf * ck, 78 Bytes

,>+<[>[->>+>+<<<]>>>[-<<<+>>>]<<+[->->+<<]>[<<->>>[-<<+>>]<[-]]>[-]<<<+<-]>>+.

Nimmt Eingaben (0-basiert) und Ausgaben als Bytewerte.

Sie können es hier testen .

Die Eingabe erfordert eine \Vor-Dezimalzahl (zB \10für 10). Wenn die Ausgabe ein druckbares ASCII-Zeichen ist, sollte es angezeigt werden. Andernfalls drücken Sie Ansichtsspeicher -> endgültiger Speicherauszug. Der Wert, der gedruckt wurde, befindet sich in der 3. Zelle (Zellennummer 2).

Erläuterung:

Zelle 0 (EINGABE): ist der Eingang und wird jedes Mal um meine 1 durch die Schleife dekrementiert.

Zelle 1 (RESET): Inkrementiert sich jedes Mal um 1, wenn sie gleich TERM ist. Dazu addieren wir jedes Mal 1, und wenn sie nicht gleich sind, subtrahieren wir 1.

Zelle 2 (TERM): Inkrementiert jede Schleife um 1 und wird auf 0 gesetzt, wenn sie mit RESET übereinstimmt. Dazu kopiere ich den Wert nur dann von HOLD zurück, wenn diese Zelle nicht gleich RESET war.

Zelle 3 (EQUAL): wird verwendet, um zu überprüfen, ob RESET und TERM gleich sind.

Zelle 4 (HOLD): Dient zum Zurückkopieren der Werte von RESET und TERM nach der Gleichheitsprüfung.

,>+<              # get input and put a 1 in RESET
[                 # for INPUT to 0
  >[->>+>+<<<]    # copy RESET to EQUAL and HOLD
  >>>[-<<<+>>>]   # copy HOLD back into RESET
  <<+             # add 1 to TERM
  [->->+<<]       # subtract TERM from EQUAL and copy it to HOLD
  >[              # if RESET and TERM were not equal
    <<-           # subtract 1 from RESET
    >>>[-<<+>>]   # copy HOLD back to TERM
    <[-]          # zero out EQUAL
  ]               # end if
  >[-]            # zero out HOLD
  <<<+            # add 1 to RESET (this cancels out the subtraction if
                  #     RESET did not equal TERM)
  <-              # subtract 1 from INPUT
]>>+.             # end for and add 1 because the sequence resets to 1 not 0

Pyke, 6 Bytes

OmSsQ@

Probieren Sie es hier aus!

O      -    input+2
 mS    -   map(range(1,i+1), range(^))
   s   -  sum(^)
    Q@ - ^[input]

0-indiziert.

R 43 41 Bytes

Bearbeiten: Einen kürzeren rekursiven Ansatz mithilfe von A002262 + 1 (0 indiziert) gefunden:

f=function(n,m=1)`if`(n<m,n+1,f(n-m,m+1))

Alte Version:

n=scan();n-choose(floor((1+sqrt(8*n))/2),2)

1-indizierte Formel von OEIS.

Perl 6 , 21 Bytes

{map(|^*,^∞)[$_]+1}

0-indiziert. Probieren Sie es online!

Wie es funktioniert:

{                 }  # A lambda.
         ^∞          # Range from 0 to Inf-1. (Same byte count as 0..*, but cooler.)
 map( ^*,  )         # Map each number n to the range 0..(n-1),
     |               # And slip each range into the outer list.
            [$_]     # Index the sequence with the lambda argument.
                +1   # Add 1.

Perl 6 , 21 Bytes

{[\,](1..*).flat[$_]}

0-indiziert. Probieren Sie es online!

Wie es funktioniert:

{                   }  # A lambda.
      1..*             # Range from 1 to infinity.
 [ ,](    )            # Fold it with the comma operator,
  \                    # and return all intermediate results, e.g. (1), (1,2), (1,2,3)...
           .flat       # Flatten the sequence.
                [$_]   # Index it with the lambda argument.

Keine dieser Lösungen ist so kurz wie die von JungHawn Min , aber es handelt sich um alternative Ansätze, was ich denke. Beide sind unbenannte Funktionen, die eine (1-indizierte) positive Ganzzahleingabe annehmen und eine positive Ganzzahl zurückgeben.

Mathematica, 30 Bytes

-#^2-#&@⌈√(2#)-3/2⌉/2+#&

Eine tatsächliche mathematische Formel für diese Funktion! Hergestellt lesbar (teilweise durch Verschieben der 3-Byte - Zeichen ⌈, √und ⌉):

# - ((#^2 + #) / 2 &)[Ceiling[Sqrt[2 * #] - 3/2]] &

Ceiling[Sqrt[2 * #] - 1/2]teilt uns mit, auf welche Unterliste sich die Eingabe bezieht, von welcher wir eine subtrahieren, um uns mitzuteilen, welche Unterliste endet, bevor wir zur Eingabe gelangen; ((#^2 + #) / 2 &)berechnet dann, wie viele Elemente in allen Unterlisten vor dem uns interessierenden Element vorkommen, das wir von der Eingabe subtrahieren #, um unsere Antwort zu erhalten. (Einige werden die bekannte Formel (#^2 + #) / 2für die #dritte Dreieckszahl bemerken ; sie Ceiling[Sqrt[2 * #] - 1/2]ist im Wesentlichen die Umkehrfunktion.)

Mathematica, 32 Bytes

If[#2<=#,#2,#0[#+1,#2-#]]&[1,#]&

Rekursive Lösung, im Grunde die gleiche wie in Billywobs und anderen Antworten .

Brain-Flak , 46 Bytes

Null indiziert

(<>()){(({}())[()]){({}[()])<>}{}}<>([{}()]{})

Probieren Sie es online!

Stack Clean, 48 Bytes

(<>()){(({}())[()]){({}[()])<>}{}}{}<>([{}()]{})

Probieren Sie es online!

Erläuterung

Dies ist eine modifizierte Version der Modulo-Funktion . Anstatt eine konstante Zahl als Divisor zu verwenden, wird der Divisor jedes Mal erhöht, wenn der Divisor davon subtrahiert wird (einmal pro Iteration außerhalb der Schleife).

Kommentierter Code

(<>())       # Switch to the opposite stack and push 1 (the initial divisor)
{            # (outside loop) While top of stack is not 0...
  (          # Push...
    ({}())   # Push the divisor plus 1
  [()])      # ...minus one (ie push a copy of the original divisor
  {          # (inner loop) While the top of stack does not equal zero
    ({}[()]) # Decrement the top of the active stack
    <>       # Switch stacks
  }{}        # (inside loop) End loop and pop zero off the top of stack)
}            # (outside loop) End loop
<>           # Switch stacks (to the one with the divisor)
([{}()]{})   # Calculate the result

Java 8, 85 73 55 Bytes

n->f(n,1)+1int f(int n,int m){return n<m?n:f(n-m,m+1);}

0-indizierter rekursiver Ansatz mit der im OEIS angegebenen Formel :

a(n) = 1 + A002262(n).
A002262 : a(n)=f(n,1)mit f(n,m) = if n<m then n else f(n-m,m+1).

Probieren Sie es hier aus.

Alte Antwort ( 85 56 Bytes):

n->{int m=~-(int)Math.sqrt(8*n+1)/2;return n-m*-~m/2+1;}

Verwendete die andere 0-indizierte Formel, die im OEIS bereitgestellt wird :

n-ter Term ist n - m*(m+1)/2 + 1, wo m = floor((sqrt(8*n+1) - 1) / 2).

Probieren Sie es hier aus.

Perl , 30 Bytes

29 Byte Code + -pFlag.

map{$\-=$c++if$c<++$\}0..$_}{

Probieren Sie es online!

MATL, 8 Bytes

:"@:]vG)

Diese Lösung verwendet eine 1-basierte Indizierung

Probieren Sie es bei MATL Online aus

Erläuterung

        Implicitly grab input (N)
:       Create an array from [1...N]
"       For each element (A) in this array...
  @:    Create an array from [1....A]
]       End for loop
v       Vertically concatenate everything on the stack
G       Explicitly grab the input again
)       And use it to index into the vertically concatenated array
        Implicitly display the result

QBIC , 21 Bytes, 1-indiziert

:[a|[b|~q=a|_Xc\q=q+1

Erläuterung:

:      Get 'a' from the cmd line
[a|    FOR (b = 1; b <= a; b++) This creates an outer loop from 1 to N
[b|    FOR (c = 1; c <= b; c++) This creates an iteration, yielding the 1, 12, 123 pattern
       'q' stores how many terms we've seen. It starts at 1 b default.
~q=a   if we are at the desired term (q == a)
|_Xc   Then quit, and print 'c' (the current number in the sequence)
\q=q+1 Else, increase 'q' and run again.

Etwas interessanter Ansatz, aber 10 Bytes länger:

:{~b+q>=a|_xa-b|\b=b+q┘q=q+1

Dieses Programm berechnet fortlaufend die Gesamtzahl der Zahlen in dieser Klammer und aller vorherigen ( 1 at loop 1, 3 at loop 2, 6 at loop 3 ...). Wenn dieser Zähler den gesuchten Index N überschreitet, geben Sie X aus der aktuellen Klammer zurück, wobei X N minus der vorherigen Menge des Zählers ist.

Ruby, 30 Bytes

->n{(0..n).find{|x|0>=n-=x}+n}

1-basierte Indizierung

R, 37 Bytes

n=scan();for(i in 2:n)T=c(T,1:i);T[n]

Nimmt Eingaben von nund erstellt die Sequenz für die ersten nSequenzen. Dies macht es bei höheren Eingängen etwas ineffizient, sollte aber in Ordnung sein. Es gibt dann den n-ten Eintrag mit 1 Index zurück.

Verwendet einen netten kleinen Trick, indem Sie die Sequenz mit T( TRUEoder 1standardmäßig) beginnen.

C11, 48 Bytes

int f(int x){int q=1;while(x>q)x-=q++;return x;}

Probieren Sie es online!

Funktioniert auch in C ++ und Java.

Eine Alternative für die gleiche Byteanzahl:

int f(int x){int q=0;while(x>++q)x-=q;return x;}

Brainfuck, 141 Bytes

Ich weiß, ich bin zu spät für das Kopfgeld, aber ich wollte nur sehen, wie viele Bytes der Algorithmus, von dem ich dachte, am Ende sein würde.

Dieses Programm ist nullindexiert.

,>+<[[->>+>+<<<]>>[-<<+>>]<[->+>>+<<<]>[-<+>]>>+[[-<->>+<]>[-<+>]<<<<]>>[>>>]>[.[<<<]]<<<<<<<[[-]>>>[-<+<<+>>>]<[->+<]<<<<<]>>>[>>>]<<<]>[.>]

Probieren Sie es online aus

• Wählen Sie Dynamischer (unbegrenzter) Speicher , sonst funktioniert es nicht
• 255Ändern Sie zum Testen der Eingabewerte> die Zellengröße (Bits) auf 16 oder 32 .
• Der Dolmetscher erklärt, wie er Eingaben macht. Für die Dezimaleingabe verwenden Sie \5für die Eingabe von 5.
  • Der maximale Dezimalwert, mit dem Sie die Eingabe testen können, ist \999
  • Die hexadezimale Eingabe kann bis zur Zellengröße gehen.

Erläuterung:

Dies zeigt das schrittweise aufgebrochene Programm und zeigt, was bei der Eingabe von passiert 5. #werden an den idealen Speicherorten für den Interpreter abgelegt.

Sie werden wahrscheinlich das Kontrollkästchen Dump Memory at char: verwenden wollen,# wenn Sie diese Version ausführen . Dadurch wird der Speicher beim #Anschlagen entleert, sodass Sie den Wert auf dem Band sehen können, falls es sich um ein nicht druckbares Zeichen handelt, oder sehen können, was bei einem beliebigen Schritt geschieht. Die Zelle, auf der sich der Zeiger befindet, ist fett gedruckt.

,>+<                       (5) 1
[[->>+>+<<<]>>[-<<+>>]       5 1 (0) 5
<[->+>>+<<<]>[-<+>]>>+       5 1 0 5 (2)
[[-<->>+<]>[-<+>]<<<<] (0) 0 4 1 0 3 2 0 0
>>[>>>]                      4 1 0 3 2 0 (0) 0
                             1 1 0 (0) 2 0
>[.#[<<<]]<<<<                4 1 0 (3) 2 0 0 0
<<<[[-]>>>[-<+<<+>>>]<[->+<]<<<<<]>>> (3) 1 0 3 2 0 0 0
[>>>]<<<]>[.#>]

Tape structure:
    (cell_1 cell_2 temp), (cell_1 cell_2 temp), ...

Take Input;
If not zero:
  copy last pair to the right and add one to its cell_2
  subtract each cell_2 from each cell_1 (leaving each cell_2 intact)
  move checking from left to right: 
    If cell_1 is zero and cell_2 isn't:
      print cell_2
    Else:
      copy last cell_1 back, overwriting each previous cell_1
Else:
  right one and print result

Probieren Sie es online aus

• Wählen Sie Dynamischer (unbegrenzter) Speicher , sonst funktioniert es nicht
• Speicherauszug bei char: #

Anmerkungen:

• Um dies auf einem anderen Interpreter auszuführen, der es nicht erlaubt, sich links von der Startzelle zu bewegen (aus diesem Grund verwende ich Dynamic Memory), geben Sie >am Anfang eine Reihe von ein. Die erforderliche Anzahl kann je nach Eingabewert variieren, beträgt jedoch O (1).

tinylisp (repl), 90 Bytes (0-indiziert)

(d r(q((n j x)(i n(i(e j x)(r(s n 1)1(s x(s 0 1)))(r(s n 1)(s j(s 0 1))x))j
(q((n)(r n 1 1

Oder nicht konkurrierend (mit einer Funktion, die nach dem Posten dieser Herausforderung festgeschrieben wurde), 80 Byte :

(d r(q((n j x)(i n(i(e j x)(r(s n 1)1(a x 1))(r(s n 1)(a j 1)x))j
(q((n)(r n 1 1

Die erste Zeile definiert eine Hilfsfunktion rund die zweite Zeile ist eine unbenannte Funktion, die nden n-ten Term der Sequenz übernimmt und zurückgibt. Ich habe dies als Antwortübermittlung angegeben, da die Klammern für die automatische Vervollständigung am Ende jeder Zeile und nicht nur am Ende des Programms stehen. Mit diesen Vorbehalten ist hier eine Version, die für Try it online modifiziert wurde , und hier ist eine unbenutzte Version, die für die Eingaben 0 bis 54 ausgeführt wird.

Erläuterung

Ich werde hier die nicht konkurrierende Version verwenden. Der einzige Unterschied ist, dass die offizielle Version Addition als zwei Subtraktionen implementieren muss.

(d r           Define r to be:
 (q(           A lambda function (= a list of two elements, quoted to prevent evaluation):
  (n j x)       Arguments n, j (the range counter), and x (the range limit)
  (i n          If n is truthy, i.e. nonzero:
   (i(e j x)     If counter equals limit:
    (r            Call r recursively on:
     (s n 1)       n-1
     1             counter reset to 1
     (a x 1))      limit increased by 1
    (r           Else, call r recursively on:
     (s n 1)       n-1
     (a j 1)       counter increased by 1
     x))           same limit
   j))))        Else, we're done; return the counter value

(q(            Lambda function:
 (n)            Argument n
 (r n 1 1)))    Call r with n, counter = 1, range limit = 1

C 54 Bytes

Nicht die kürzeste C-Lösung, aber es hat den Vorteil, in konstanter Zeit zu laufen (keine Schleifen, nur Mathematik). Es verwendet eine nullbasierte Indizierung:

x;f(n){x=floor(sqrt(8*n+1)-1)/2;return 1+n-x*(x+1)/2;}

Ungolfed:

int f(int n) {
    int x = floor(sqrt(8*n+1)-1)/2; //calculate the number of the current subsequence (zero based)
    return 1+n-x*(x+1)/2;   //x*(x+1)/2 is the zero based index of the `1` starting the subsequence
}

Testen Sie mit:

#include <math.h>
#include <assert.h>
#include <stdio.h>

x;f(n){x=floor(sqrt(8*n+1)-1)/2;return 1+n-x*(x+1)/2;}

int main(){
    int i;
    for(i = 0; i < 10; i++) printf("%d ", f(i));
    printf("\n");

    assert(f(0) == 1);
    assert(f(1) == 1);
    assert(f(5) == 3);
    assert(f(10) == 1);
    assert(f(59) == 5);
    assert(f(100) == 10);
    assert(f(1001) == 12);
}

C 103 Bytes

Für einen Anfänger ist es okay, denke ich :).

int main(){int n,c,i,j;scanf("%d",&n);while(c<n){for(i=1;i<=j;i++){c++;if(c==n)printf("%d",i);}j++;}}

oder die formatierte Art und Weise

#include <stdio.h>

int main() {
    int n,c,i,j;
    scanf("%d",&n);
    while(c<n) 
    {
        for(i=1;i<=j;i++)
        {
            c++;
            if(c==n) printf("%d",i);
        }
        j++;
    }
}

Gleichstrom , 21 Bytes, 0-basierte Indizierung

?d8*1+v1-2/d1+*2/-1+p

Probieren Sie das DC-Programm online!

Erläuterung:

?      Push input number n.
d      Duplicate n at the top of the stack.
8*1+   Replace n at the top of the stack with 8n+1.
v      Replace 8n+1 at the top of the stack with the floor of its square root.
1-2/   Subtract 1, and divide by 2 (ignoring any fractional part).

Die Oberseite des Stapels enthält nun den Index k der größten Dreieckszahl, die <= n ist.

d1+*2/ Compute k(k+1)/2, which is the greatest triangular number <= n.
-      Subtract n-(the greatest triangular number <= n). The first n is on the stack in position 2, because the input number n was duplicated at the top of the stack at the very beginning of the program, and only one of the values was popped and used (until now).
1+     Add 1 because the desired sequence starts over again at 1 (not 0) at every triangular number.
p      Print the answer.

Dieses DC-Programm kann in ein Bash-Skript mit wettbewerbsfähiger Größe konvertiert werden:

Bash + Unix-Dienstprogramme, 28 Byte, 0-basierte Indizierung

dc -e"?d8*1+v1-2/d1+*2/-1+p"

Probieren Sie das Bash-Programm online aus!

C 81 44 Bytes

direkte iterative Methode, 0 indiziert und leicht massiert;

m=1,c=1;f(n){for(;n--;c=c^m?c+1:!!++m);c=c;}

Probieren Sie es online!