Hier ist die Sequenz, über die ich spreche:

{1, 4, 5, 9, 10, 11, 16, 17, 18, 19, 25, 26, 27...}

Ausgehend von 1 behalten Sie 1, lassen Sie die nächsten 2 fallen, behalten Sie die nächsten 2, lassen Sie 3 fallen, behalten Sie 3 und so weiter. Ja, es ist auch auf OEIS (A064801) !

Die Herausforderung

n>0Suchen Sie bei einer Ganzzahl den n-ten Term der obigen Sequenz

Testfälle

Input -> Output       
1->1  
22->49  
333->683
4444->8908
12345->24747

Dies ist Codegolf, also gewinnt die kürzeste Antwort in Bytes! Viel Glück!

Java (OpenJDK 8) , 45 44 Bytes

n->{int i=0;for(;++i<n;n-=i);return~-n+i*i;}

Probieren Sie es online!

-1 Byte dank @Nevay

Nachdem ich eine Weile darauf gestarrt hatte, bemerkte ich ein Muster. Jedes Mal, wenn wir nZahlen fallen lassen , ist die nächste Zahl in der Folge ein perfektes Quadrat. Als ich das sah, zerlegte ich die Sequenz mental in bequeme Teile: [[1],[4,5],[9,10,11],...]Grundsätzlich ibeginnt der dritte Teil mit i*iund iteriert nach oben für iElemente.

Um die nth-Zahl in dieser Sequenz zu finden, wollen wir zuerst herausfinden, in welchem ​​Block sich die Zahl befindet und welche Position sie dann in dem Block einnimmt. Wir subtrahieren unsere Schrittzahl ivon nbis nweniger als i(was uns unsere Brocken gibt), und dann fügen Sie einfach n-1auf i*idie richtige zu bekommen positionim Chunk.

Beispiel:

n = 8
n > 1? Yes, n = n - 1 = 7
n > 2? Yes, n = n - 2 = 5
n > 3? Yes, n = n - 3 = 2
n > 4? No, result is 4 * 4 + 2 - 1 = 17

Haskell, 48 43 41 Bytes

n#l=[l..l+n]++(n+1)#(l+2*n+3)
((0:0#1)!!)

4 zusätzliche Bytes für 1-basierte Indexierung anstelle von 0-basierten. Eine unnötige Einschränkung, IMHO.

Probieren Sie es online!

n#l             -- n is one less than the number of element to keep/drop and
                -- l the next number where the keep starts
   [l..l+n]     -- keep (n+1) numbers starting at l
   ++           -- and append a recursive call
   (n+1)#       -- where n is incremented by 1 and
      (l+2*n+3) -- l skips the elements to keep & drop

0#1             -- start with n=1 and l=0 and
 0:             -- prepend a dummy value to shift from 0 to 1-based index
    !!          -- pick the i-th element from the list 

Python 3 , 47 46 Bytes

1 Byte danke an Herrn Xcoder.

def f(n):a=round((2*n)**.5);return~-n+a*-~a//2

Probieren Sie es online!

Sehr schnell für höhere Zahlen

Gelee , 8 Bytes

Ḷ+²µ€Ẏ⁸ị

Probieren Sie es online!

Haskell , 33 Bytes

Eine anonyme Funktion. Benutzen als((!!)$0:do n<-[1..];[n^2..n^2+n-1]) 1

(!!)$0:do n<-[1..];[n^2..n^2+n-1]

Probieren Sie es online!

• Konstruiert die Sequenz als unendliche Liste und indiziert sie anschließend mit !!. Das 0:ist ein Blindelement von 0- bis 1 basierte Indizierung einzustellen.
• Der Bereich [n^2..n^2+n-1]konstruiert eine lückenlose Folge, beginnend mit dem Quadrat mit nund enthaltend nZahlen.
• Die doNotation verkettet die konstruierten Bereiche für alle n>=1.

Python 3 , 46 Bytes

f=lambda x,y=0,z=0:y<x and f(x,y+z,z+1)or~-y+x

Probieren Sie es online!

Perl 6 , 43 Bytes

{(1..*).rotor({++$=>++$+1}...*).flat[$_-1]}

Probier es aus

Erweitert:

{  # bare block lambda with implicit parameter ｢$_｣

  ( 1 .. * )                  # range starting from 1

  .rotor(                     # break it into chunks

    { ++$  =>  ++$ + 1} ... * # infinite Seq of increasing pairs
    #   1  =>    1 + 1    ==>   1 => 2 ( grab 1 skip 2 )
    #   2  =>    2 + 1    ==>   2 => 3
    #   3  =>    3 + 1    ==>   3 => 4
    # ...  =>  ... + 1

  ).flat\                     # reduce the sequence of lists to a flat sequence
  [ $_ - 1 ]                  # index into the sequence
                              # (adjusting to 0-based index)
}

(1..*).rotor({++$=>++$+1}...*) produziert:

(
 (1,),
 (4, 5),
 (9, 10, 11),
 (16, 17, 18, 19),
 (25, 26, 27, 28, 29),
 ...
).Seq

TeX, 166 Bytes

\newcommand{\f}[1]{\count0=0\count1=0\loop\advance\count0 by\the\count1\advance\count1 by1\ifnum\count0<#1\repeat\advance\count0 by#1\advance\count0 by-1
\the\count0}

Verwendung

\documentclass[12pt,a4paper]{article}
\begin{document}
\newcommand{\f}[1]{\count0=0\count1=0\loop\advance\count0 by\the\count1\advance\count1 by1\ifnum\count0<#1\repeat\advance\count0 by#1\advance\count0 by-1
\the\count0}

\f{1}

\f{22}

\f{333}

\f{4444}

\f{12345}
\end{document}

Javascript, 43 38 Bytes

n=>eval("for(r=1;n>r;)n-=r++;r*r+n-1")

Probieren Sie es online!

Ich benutze die Tatsache, dass für jede dreieckige Zahl plus eins das Ergebnis eine quadratische Zahl ist.

Als Beispiel: Dreieckszahlen sind 0, 1, 3, 6, 10 ... also beobachten wir für 1, 2, 4, 7, 11 ... 1, 4, 9, 16, 25 ... in unserer Sequenz .

Wenn der Index irgendwo zwischen diesen bekannten Zahlen liegt, rücken die Elemente unserer Sequenz nur um eins vor. Um beispielsweise das Ergebnis für 10 zu berechnen, nehmen wir 7 (als Dreieckszahl plus eins), nehmen das Ergebnis (16) und addieren 10-7 = 3. Somit ist 16 + 3 = 19.

05AB1E , 12 Bytes

LεÝÁćn+}˜¹<è

Probieren Sie es online!

cQuents , 27 Bytes

#R(2B)^.5)|1:b~-B+A*-b~A//2

Probieren Sie es online!

Momentan ist es eine Portierung von Leakys Python-Antwort , aber ich denke, es gibt einen besseren Weg.

Schnelle 3 , 72 Bytes

Port meiner Python-Lösung .

func f(_ x:Int,_ y:Int=0,_ z:Int=0)->Int{return y<x ?f(x,y+z,z+1):y+x-1}

Test Suite.

C # (Mono) , 164 Bytes

using System.Linq;n=>{var a=new int[1]{1}.ToList();for(int i=1,m;a.Count<n;a.AddRange(new int[++i*2].Select((_,d)=>m+d+1).Skip(i).Take(i)))m=a.Max();return a[n-1];}

Probieren Sie es online!

Mathematica, 37 Bytes

Flatten[Range@#+#^2-1&~Array~#][[#]]&

Erläuterung

Range@#+#^2-1&

FunctionDies nimmt eine positive ganze Zahl an #und gibt die #Folge von aufeinanderfolgenden Zahlen in der Sequenz zurück.

...~Array~#

Erzeugt die Liste aller solcher Läufe bis zur Eingabe #

Flatten[...][[#]]

Flattensdie resultierende Liste und gibt das #th-Element zurück.

Perl 5 , 33 + 1 (-p) = 34 Bytes

$\+=$.--?1:2+($.=++$s)while$_--}{

Probieren Sie es online!

Tampio , 310 308 Bytes

n:n uni on n unena 1:lle
a unena k:lle on a vuona k:lla vähennettynä a:sta ja k
a vuona nollalla ja k on a
a vuona k:lla vähennettynä nollasta ja k on a
a vuona b:n seuraajalla ja k on yhteenlaskun kutsuttuna k:n kerrottuna 2:lla arvolla ja k:n vähennettynä a:sta arvolla unena k:n seuraajalle seuraaja

Verwendung: 4:n uniergibt 9.

Erläuterung:

n:n uni on n unena 1:lle
uni(n)  =  n `uni` 1

a unena k:lle on  a vuona  k:lla vähennettynä a:sta ja k
a `uni` k     =  (a `vuo` (k     `vähennetty` a)    )  k

 a vuona nollalla ja k on a
(a `vuo` 0        )  k =  a

 a vuona  k:lla vähennettynä nollasta ja k on a
(a `vuo` (k     `vähennetty` 0)       )  k =  a

 a vuona  b:n seuraajalla ja k on
(a `vuo` (b   + 1)        )  k =

 yhteenlaskun kutsuttuna k:n kerrottuna 2:lla arvolla
(yhteenlasku            (k   *          2     )

 ja k:n vähennettynä a:sta arvolla unena  k:n seuraajalle seuraaja
((  k   `vähennetty` a     )       `uni` (k   + 1)   )  ) + 1

Aus der Standardbibliothek:

a `vähennetty` b = b - a
yhteenlasku a b  = a + b

JavaScript (ES6), 33 Byte

Rekursive Lösung, inspiriert von Xanderhalls Beobachtungen .

f=(n,x=1)=>n<x?n+x*x-1:f(n-x,++x)

Versuch es

o.innerText=(
f=(n,x=1)=>n<x?n+x*x-1:f(n-x,++x)
)(i.value=12345);oninput=_=>o.innerText=f(+i.value)

<input id=i type=number><pre id=o>

Python 3 , 50 Bytes

def f(n):
 a=i=0
 while a<n:a+=i;i+=1
 return~-a+n

Probieren Sie es online!

Mathematica, 82 Bytes

Complement[Range[3#],Array[#+⌊((r=Sqrt[1+8#])-1)/2⌋⌊(r+1)/2⌋/2&,3#]][[#]]&

Python , 40 Bytes

lambda n:(round((2*n)**.5)+.5)**2//2+n-1

Probieren Sie es online!

Optimierung der Leaky Nonnen Ausdruck .

Python , 41 Bytes

f=lambda n,k=1:n*(n<=k)or-~f(n-k,k+1)+2*k

Probieren Sie es online!

Rekursiver Ausdruck.

Javascript (ES6) 100 98 Bytes

var k=n=>{var s=[],i=1,c=1,j;while(s.length<n){for(j=i;j<i+c;j++){s.push(j)}i+=c*2+1;c++}return s}

Ich wette, es gibt viel Raum für Verbesserungen, nur einfache Schleifen und Zähler.

Retina , 27 Bytes

.+
$*
((^1|1\2)+)1
$1$2$&
1

Probieren Sie es online! Port von @ LeakyNuns Python-Antwort. Die erste und letzte Stufe sind nur langweilige Dezimal-Unär-Konvertierungen. Die zweite Stufe funktioniert folgendermaßen: ((^1|1\2)+)ist ein Dreieckszahlenvergleicher; $1ist die übereinstimmende dreieckige Zahl, während $2ihr Index ist. Der 1nachlaufMittel paßt es die größte Dreieckszahl streng kleiner ist als der Eingang, also in genau einer Iteration weniger als der Pythons Schleife ergibt, was bedeutet , dass $1entsprechen a-iund $2zu i-1und ihre Summe ist a-1oder ~-anach Bedarf. ( $&Verhindert lediglich, dass die Übereinstimmung aus dem Ergebnis gelöscht wird.) Beachten Sie, dass bei einer Eingabe 1keine Übereinstimmung erfolgt und die Ausgabe einfach mit der Eingabe identisch ist. Wenn Sie pervers wären, könnten Sie verwenden^((^1|1\2)*)1 auch in diesem Fall zu entsprechen.

MATL , 12 Bytes

:"@U@:q+]vG)

Probieren Sie es online!

Erläuterung

:        % Push range [1 2 ... n], where n is implicit input
"        % For each k in that range
  @U     %   Push k^2
  @:     %   Push range [1 2 ... k]
  q      %   Subtract 1: gives [0 1 ... k-1]
  +      %   Add: gives [k^2 k^2+1 ... k^2+k-1]
]        % End
v        % Concatenate all numbers into a column vector
G)       % Get n-th entry. Implicitly display

C (gcc) , 38 Bytes

Verwenden Sie hier den @ Xanderhall-Algorithmus

i;f(n){for(i=0;++i<n;n-=i);n=n-1+i*i;}

Probieren Sie es online!

PHP, 48 42 37 + 1 Bytes

portiert aus Leaky Nuns Antwort

while($argn>$a+=$i++);echo$a+~-$argn;

Laufen Sie als Pipe mit -Foder versuchen Sie es online .

direkte Annäherung, 42 + 1 Bytes (portiert von der anderen Antwort von Leaky Nun )

<?=($a=(2*$argn)**.5+.5|0)*-~$a/2+~-$argn;

Als Rohr mit -nRoder ohne Kommentar über TiO verlegen.

ältere iterative Lösung, 48 + 1 Bytes

for(;$argn--;$n++)$c++>$z&&$n+=++$z+$c=1;echo$n;