Lass uns zählen...

Zähle bis zu 2 und zurück bis zu 1
Zähle bis zu 4 und zurück bis zu 1
Zähle bis zu 6 und zurück bis zu 1
... ok du hast es verstanden ...

Füge all diese zusammen und du erhältst die folgende Sequenz

 {1,2,1,2,3,4,3,2,1,2,3,4,5,6,5,4,3,2,1,2,3,4,5,6,7,8,7,6,5,4,3,2,1,2,3...}

Herausforderung
Geben Sie bei einer Ganzzahl n>0für 1-indiziert (oder n>=0für 0-indiziert) den n-ten Term dieser Sequenz aus

Testfälle

Input->Output  

1->1  
68->6  
668->20  
6667->63  
10000->84

Regeln

Ihr Programm muss in der Lage sein, in weniger als einer Minute Lösungen bis zu n = 10000 zu berechnen

Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes!

JavaScript (ES7),  59 ... 44  43 Bytes

Dank Titus 1 Byte gespeichert

Erwartete Eingabe: 1-indiziert.

n=>(n-=(r=(~-n/2)**.5|0)*r*2)<++r*2?n:r*4-n

Anfänglich inspiriert von einer Formel für A004738 , die eine ähnliche Sequenz darstellt. Aber am Ende habe ich es komplett umgeschrieben.

Testfälle

let f=

n=>(n-=(r=(~-n/2)**.5|0)*r*2)<++r*2?n:r*4-n

console.log(f(1))     // -> 1
console.log(f(68))    // -> 6
console.log(f(668))   // -> 20
console.log(f(6667))  // -> 63
console.log(f(10000)) // -> 84

Wie?

Die Sequenz kann als Dreieck angeordnet werden, wobei der linke Teil in aufsteigender Reihenfolge und der rechte Teil in absteigender Reihenfolge angeordnet werden.

Unten sind die ersten 4 Zeilen mit den ersten 32 Begriffen aufgeführt:

            1 | 2
        1 2 3 | 4 3 2
    1 2 3 4 5 | 6 5 4 3 2
1 2 3 4 5 6 7 | 8 7 6 5 4 3 2

Lassen Sie uns nun einige Variablen einführen:

 row  | range   | ascending part              | descending part
 r    | x to y  | 1, 2, ..., i                | 4(r+1)-(i+1), 4(r+1)-(i+2), ...
------+---------+-----------------------------+-----------------------------------------
  0   |  1 -  2 |                           1 | 4-2
  1   |  3 -  8 |                   1   2   3 | 8-4  8-5  8-6
  2   |  9 - 18 |           1   2   3   4   5 | 12-6 12-7 12-8  12-9  12-10
  3   | 19 - 32 |   1   2   3   4   5   6   7 | 16-8 16-9 16-10 16-11 16-12 16-13 16-14

Wir beginnen mit 2 Elementen oben und fügen jeder neuen Zeile 4 Elemente hinzu. Daher kann die Anzahl der Elemente in der mit 0 indizierten Zeile r ausgedrückt werden als:

a(r) = 4r + 2

Die 1-indizierte Startposition x der Zeile r ergibt sich aus der Summe aller vorangegangenen Terme dieser Rechenreihe plus eins, was zu Folgendem führt:

x(r) = r * (2 + a(r - 1)) / 2 + 1
     = r * (2 + 4(r - 1) + 2) / 2 + 1
     = 2r² + 1

Umgekehrt kann bei einer 1-indizierten Position n in der Sequenz die entsprechende Zeile gefunden werden mit:

r(n) = floor(sqrt((n - 1) / 2))

oder als JS-Code:

r = (~-n / 2) ** 0.5 | 0

Sobald wir r (n) kennen , subtrahieren wir die Startposition x (r) minus eins von n :

n -= r * r * 2

Wir vergleichen n mit a (r) / 2 + 1 = 2r + 2, um herauszufinden, ob wir uns im aufsteigenden Teil oder im absteigenden Teil befinden:

n < ++r * 2 ?

Wenn dieser Ausdruck wahr ist, geben wir n zurück . Andernfalls geben wir 4 (r + 1) - n zurück . Da jedoch r bereits in der letzten Anweisung inkrementiert wurde, wird dies vereinfacht als:

n : r * 4 - n

Haskell , 37 Bytes

(!!)$do k<-[1,3..];[1..k]++[k+1,k..2]

Probieren Sie es online!

Nullindexiert. Erzeugt die Liste und indiziert sie. Vielen Dank an Ørjan Johansen für das Speichern von 2 Bytes!

Haskell , 38 Bytes

(!!)[min(k-r)r|k<-[0,4..],r<-[1..k-2]]

Probieren Sie es online!

Nullindexiert. Erzeugt die Liste und indiziert sie.

Haskell , 39 Bytes

n%k|n<k=1+min(k-n)n|j<-k+4=(n-k)%j
(%2)

Probieren Sie es online!

Nullindexiert. Eine rekursive Methode.

Python , 46 Bytes

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

Probieren Sie es online!

Null indiziert.

Schale , 8 Bytes

!…ṁoe1DN

1-indiziert. Probieren Sie es online!

Erläuterung

!…ṁoe1DN  Implicit input (an integer).
       N  Positive integers: [1,2,3,4,...
  ṁo      Map and concatenate
      D   double: [2,4,6,8,...
    e1    then pair with 1: [1,2,1,4,1,6,1,8,...
 …        Fill gaps with ranges: [1,2,1,2,3,4,3,2,1,2,3,4,5,6,...
!         Index with input.

Perl 6 , 29 Bytes

{({|(1...$+=2...2)}...*)[$_]}

Probieren Sie es online aus

0-basiert

Erweitert:

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

  (
    # generate an outer sequence

    {           # bare block lambda

      |(        # flatten into outer sequence

        # generate an inner sequence

        1       # start at 1

        ...     # go (upward) towards:

        $       # an anonymous state variable (new one for each outer sequence)
          += 2  # increment by 2

        ...     # go (downward) towards:

        2       # stop at 2 (1 will come from the next inner sequence)

      )
    }

    ...         # keep generating the outer sequence until:
    *           # never stop

  )[ $_ ]       # index into outer sequence
}

Die innere Sequenz 1...$+=2...2erzeugt

(1, 2).Seq
(1, 2, 3, 4, 3, 2).Seq
(1, 2, 3, 4, 5, 6, 5, 4, 3, 2).Seq
(1, 2, 3, 4, 5, 6, 7, 8, 7, 6, 5, 4, 3, 2).Seq
(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 5, 4, 3, 2).Seq
...

Fügen Sie 0,vor dem zweiten {oder -1nach dem zweiten hinzu , damit es 1-basiert wird$_

R, 64 Bytes

function(n)unlist(sapply(seq(2,n,2),function(x)c(2:x-1,x:2)))[n]

Funktion, die ein Argument annimmt n. Es wird ein Vektor 2:nmit Inkrementen von 2 erstellt. Für jeden von diesen wird der Vektor 1:(x-1)und x:2erstellt. Dies wird insgesamt länger sein als n. Wir unlistes, einen Vektor zu bekommen und den n-ten Eintrag zu nehmen.

Python 2 , 56 Bytes

def f(x):n=int((x/2)**.5);print 2*n-abs(2*n*n+2*n+1-x)+2

Probieren Sie es online!

Dies ist 0-indiziert.

-1 Byte dank @JustinMariner

Wie das funktioniert

Wir stellen fest, dass die 1-indizierte- nte Gruppe ( 1, 2, ... 2n ..., 2, 1) aus Elementen besteht, die mit 0-indiziert 2(n-1)^2bis nummeriert sind 2n^2.

Um das Element am Index zu finden x, können wir die Gruppennummer finden, in der nes sich xbefindet. Daraus berechnen wir den Abstand vom Mittelpunkt der Gruppe, die sich xbefindet. (Dieser Abstand ist abs(2*n**2+2*n+2-x)).

Da die Elemente jedoch weiter vom Zentrum einer Gruppe entfernt abnehmen , subtrahieren wir den Abstand vom Maximalwert der Gruppe.

05AB1E , 8 Bytes

Code:

ÅÈ€1Ÿ¦¹è

Verwendet die 05AB1E- Codierung. Probieren Sie es online!

Erläuterung:

ÅÈ           # Get all even numbers until input (0, 2, ..., input)
  €1         # Insert 1 after each element
    Ÿ        # Inclusive range (e.g. [1, 4, 1] -> [1, 2, 3, 4, 3, 2, 1])
     ¦       # Remove the first element
      ¹è     # Retrieve the element at the input index

JavaScript, 39 Bytes

f=(n,t=2)=>n>t?f(n-t,t+4):n>t/2?t-n+2:n

Jelly , 10 , 9 Bytes

ḤŒḄṖµ€Fị@

Probieren Sie es online!

Auch 1 indiziert und endet ziemlich schnell.

Ein Byte gespart dank @ErikTheOutgolfer!

Erläuterung:

Nehmen wir an, die Eingabe ( a) ist hypothetisch 3.

    µ€      # (Implicit) On each number in range(a):
            #
Ḥ           # Double
            #   [2, 4, 6]
            #
 ŒḄ         # Convert to a range, and Bounce
            #   [[1, 2, 1], [1, 2, 3, 4, 3, 2, 1], [1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1]]
            #
   Ṗ        # Pop
            #   [[1, 2], [1, 2, 3, 4, 3, 2], [1, 2, 3, 4, 5, 6, 5, 4, 3, 2]]
            #
     F      # Flatten
            #   [1, 2, 1, 2, 3, 4, 3, 2, 1, 2, 3, 4, 5, 6, 5, 4, 3, 2]
            #
      ị@    # Grab the item[a]
            #   1
            #

MATL , 15 Bytes

li:"@EZv4L)]vG)

1-basiert.

Probieren Sie es online!

Dies ist eine Zeitüberschreitung für die größten Testfälle in TIO, die jedoch auf meinem Desktop-Computer (Compiler unter MATLAB R2017a) rechtzeitig beendet wird. Fügen Sie Z`am Ende des Codes hinzu, um die abgelaufene Zeit anzuzeigen .

>> matl 'li:"@EZv4L)]vG)Z`'
> 10000
84
15.8235379852476

Erläuterung

Der Code generiert viel mehr Begriffe als nötig. Insbesondere werden n"Stücke" der Sequenz berechnet , wobei jedes Stück hoch und zurück zu 1 gezählt wird.

l       % Push 1
i       % Push input, n
:       % Range [1 2 ...n]
"       % For each k in that range
  @E    %   Push 2*k
  Zv    %   Symmetric range: [1 2 ... 2*k-1 2*k 2*k-1 ... 2 1]
  4L)   %   Remove last entry: [1 2 ... 2*k-1 2*k 2*k-1 ... 2]
]       % End
v       % Concatenate all stack contents into a column vector
G)      % Get n-th entry. Implicitly display

Schale , 12 10 Bytes

!ṁ§¤+hḣṫİ0

Probieren Sie es online!

1-indiziert, arbeitet recht schnell

Erläuterung

!ṁ§¤+hḣṫİ0
 ṁ      İ0    Map the following function over the even numbers and concatenate the results together
  §   ḣṫ      Get the ranges 1-n and n-1, then... 
   ¤+h         remove the last element from both of them and concatenate them together
!             Return the element of the resulting list at the given index

Mathematica, 90 Bytes

Flatten[{1}~Join~Table[Join[Rest[p=Range@i],Reverse@Most@p],{i,2,Round[2Sqrt@#],2}]][[#]]&

Probieren Sie es online!

Netzhaut , 62 Bytes

.+
$*
^((^.|\2..)*)\1.
6$*1$2$2;1
(?=.+;(.+))\1(.+).*;\2.*
$.2

Probieren Sie es online! Link enthält Testfälle. Die Eingabe ist 1-indiziert. Die erste Stufe ist nur eine Dezimalzahl zur unären Konvertierung. In der zweiten Stufe liegt die höchste Quadratzahl bei sgenau weniger als der Hälfte n; $1ist s², während $2ist 2s-1. Es berechnet zwei Werte, zunächst die Anzahl der Zahlen in der aktuellen Aufwärts- / Abwärtsfahrt, die ist 4(s+1) = 4s+4 = 2$2+6, und zweitens die Position innerhalb dieses Laufes, das ist n-2s² = n-(2$1+1)+1 = n-$&+1, was nur erfordert 1für die zu machen , 1die strenge Ungleichheit zu erzwingen verwendet. Die letzte Stufe zählt dann von dieser Position bis zum Start und zum Ende des Laufs, nimmt das niedrigere Ergebnis und konvertiert es in Dezimalzahlen.

Mathematica, 67 Bytes

(t=z=1;While[(x=3-4t+2t^2)<#,t++;z=x];If[#-z>2t-2,4t-5+z-#,#-z+1])&

Probieren Sie es online!

Perl 5 , 43 + 1 (-p) = 44 Bytes

$_=($n=2*int sqrt$_/2)+2-abs$n/2*$n+$n+1-$_

Probieren Sie es online!

Ich arbeitete an einer Formel, um das n-te Element direkt zu berechnen. Dann sah ich, dass @ fireflame241 diese Arbeit erledigt hatte, und ich spielte sie in Perl ein.

# Perl 5 , 50 + 1 (-n) = 51 Bytes

push@r,1..++$",reverse 2..++$"while@r<$_;say$r[$_]

Probieren Sie es online!

Die Ergebnisse sind 0 indiziert.

Haskell , 115-81 Bytes

y%x=snd(span(<x)$scanl(+)y[y+1,y+3..])!!0
g 1=1
g x|1%x>2%x=1+g(x-1)|1>0=g(x-1)-1

Probieren Sie es online!

Hier ist etwas Magisches los. Könnte wahrscheinlich kürzer sein, wenn ich einen normalen Ansatz hätte.

Erläuterung

Zuerst definieren wir %. %ist eine Funktion, die zwei Variablen akzeptiert x, und y. Es erstellt eine Liste scanl(+)y[y+1,y+3..]und findet das erste Element dieser Liste größer als x. scanl(+)Führt einfach iterative Summen durch, um die dreieckigen Zahlen zu erhalten, die wir machen würden scanl(+)0[1..], um die quadratischen Zahlen zu erhalten, die wir machen würden scanl(+)0[1,3..]. Insbesondere die beiden Listen, die wir erstellen werden, sind scanl(+)2[3,5..]undscanl(+)1[2,4..] dies sind die Wendepunkte des Musters.

Nun definieren wir die Hauptfunktion, gdie eine x. Wenn xes eins ist, kehren wir zurück, 1weil das der erste Wert ist. Andernfalls überprüfen wir die nächsten beiden Wendepunkte. Wenn die Abwärtswende größer ist, geben 1%x>2xwir den Nachfolger von zurück. g$x-1Andernfalls geben wir den Vorgänger von zurück g$x-1.

Ok, aber warum funktioniert das?

Zuallererst "Was ist mit der Art und Weise, wie wir Eckpunkte finden?". Es ist wichtig, den Abstand zwischen aufeinanderfolgenden Scheitelpunkten des gleichen Typs zu notieren. Sie werden feststellen, dass die Unterschiede jedes Mal um 2 zunehmen. Dies ist sinnvoll, da die Basis der Dreiecke jedes Mal um 2 breiter wird. Wir können mit einem Listenliteral wie diesem einen konstanten Unterschied zwischen Listen machen [2,4..]und verwendenscanl(+) Listen machen und diese Listen anhand der Position des ersten Scheitelpunkts und des ersten Unterschieds in unsere Scheitelpunktlisten umwandeln.

Nachdem wir nun die Möglichkeit haben, Scheitelpunkte nach oben und unten zu finden, können wir diese Informationen verwenden, um die Werte abzurufen. Wir sagen, der erste Wert ist, dass 1wir entweder den Nachfolger oder den Vorgänger nehmen müssen. Wenn der nächste Eckpunkt aufwärts ist, möchten wir den Vorgänger übernehmen, andernfalls übernehmen wir den Nachfolger.

Haskell , 56 51 46 Bytes

Hier ist meine bessere Lösung mit weniger Mathematik und weniger Bytes.

d x|e<-[1..x-1]=e++map(x+1-)e
(([1..]>>=d)!!0)

Probieren Sie es online!

Pyke , 14 Bytes

SF}SDtO_+)sQt@

Probieren Sie es hier aus!

S              -    range(1, input)
 F}SDtO_+)     -   for i in ^:
  }            -      ^ * 2
   S           -     range(1, ^)
        +      -    ^ + v
     tO_       -     ^[1:-1:-1]
          s    -  sum(^)
           Qt@ - ^[input-1]

C # (.NET Core) , 120 Byte

Erklärung: Ziemlich einfach, die erste verschachtelte Schleife steigt bis zu unserem Maximum an, die zweite steigt bis zu 2 zurück. Die Wiederholung für jedes Vielfache von 2.

x=>{var a=0;for(int i=2,j=0;j<x;i+=2){for(var b=1;b<=i&j<x;b++,j++){a=b;}for(var c=i-1;c>1&j<x;c--,j++){a=c;}}return a;}

Probieren Sie es online!

Ruby , 78 75 Bytes

1 Byte dank Step Hen gespeichert

1 Byte gespart dank Mr. Xcoder

->n{a=0;b=2;c=1;n.times{if a==b then c=0;b+=2;end;c=1if a<2;a+=c<1?-1:1};a}

Probieren Sie es online!

Hoffentlich kann ich ein paar Tipps bekommen, um den bytecount weiter herunter zu ziehen. Ich habe versucht, einen einfachen Ansatz zu wählen.

Java (OpenJDK 8) , 53 Byte

n->{int i=2;for(;n>i;i+=4)n-=i;return n>i/2?i-n+2:n;}

Probieren Sie es online!

-2 Bytes dank Nevay.

1-indiziert.

TL; DR Wir teilen die Sequenz in bequeme Chunks auf, finden den Chunk nund dann die nthPosition im Chunk.

Hier können wir die Sequenz wie [[1,2],[1,2,3,4,3,2],[1,2,3,4,5,6,5,4,3,2],...]folgt aufteilen , wodurch wir Brockengrößen von erhalten 4i-2. Beginnend mit i=2, subtrahieren wir ivon n, im wesentlichen nach oben ein Stück zu einer Zeit bewegen. Sobald wir zufrieden sind n<=i, wissen wir, dass njetzt die Position des korrekten Werts im aktuellen Block ist.

Wir erhalten dann den Wert, indem wir ihn nmit ider Größe des Blocks vergleichen. Der Mittelpunkt jedes Chunks ist gleich i/2+1; Wenn nweniger ist, kehren wir einfach zurück n. Wenn ngrößer ist, kehren wir zurück i-n+2.

Beispiel

n = 16, i = 2

Is n > i? Yes, n = n - 2 = 14, i = i + 4 = 6
Is n > i? Yes, n = n - 6 = 8, i = i + 4 = 10
Is n > i? No, stop looping.
10 / 2 + 1 = 6
Is n > 6? Yes, return i - n + 2 = 8 - 6 + 2 = 4

Python 2 , 5! Bytes (120 Bytes: P)

r=range
a=[]
for i in r(2,998,2): 
	for j in r(1,i+1): a.append(j)
	for j in r(i-1,1,-1): a.append(j)
print a[input()-1]

Probieren Sie es online!

Einfach, macht die Liste und nimmt dann das eingabe'te Element

Python 3 , 184 156 Bytes

l,n,r=list,next,range
h=lambda x:l(r(1,x))+l(r(x-2,1,-1))
def g():
	x=3
	while True:yield from h(x);x+=2
def f(i):
	x=g()
	for _ in r(i-1):n(x)
	return n(x)

Probieren Sie es online!

Golf mit Python-Generator für "faule" Auswertung

QBIC , 47 Bytes

g=q{p=p+1~p=:|_Xg\g=g+q~g=1or g>=r|r=r+1┘q=q*-1

Erläuterung

g=q         var g is the current value of the sequence; set to 1 at the start
{           DO infinitely
p=p+1       raise the step counter (var p)
~p=:|_Xg    IF p equals the input term a (read from cmd line) THEN QUIT, printing g
\           ELSE
g=g+q       raise (or decrement) g by q (q is 1 at the start of QBIC)
~g=1        IF g is at the lower bound of a subsequence
    or g>=r OR g is at the upper bound (r start as 2 in QBIC)
|r=r+1      THEN increment r (this happens once on lower bound, and once on upper, 
            total of 2 raise per subsequence)
┘q=q*-1     and switch q from 1 to -1

Röda , 54 Bytes

f n{seq 1,n|{|i|seq 1,2*i;seq 2*i-1,2}_|head n+2|tail}

Probieren Sie es online!

Rufen Sie an mit: try f(n)

Diese Funktion gibt schnell die Antwort zurück, führt danach jedoch einige unnötige Berechnungen durch und hat möglicherweise keinen Speicher mehr.

Da die Funktion die eigentliche Antwort kurz nach dem Aufruf zurückgibt (deutlich unter einer Minute), halte ich diese Antwort für gültig.

(In Röda können Funktionen Werte zurückgeben, bevor sie aufgrund von Parallelität beendet werden.)

C # (.NET Core) , 99 95 86 Bytes

n=>{int i=1,t=2,d=0;for(;n>1;){i+=1-2*d;if(i==t){d++;t+=2;}if(i==1)d--;n--;}return i;}

Probieren Sie es online!

Lambda-Funktion, die eine Ganzzahl annimmt und zurückgibt. Einzelne Schleife, die das Auf- und Abzählen übernimmt.

PHP, 65 + 1 Bytes

for($x=$d=$z=1;--$argn;)$d=($x+=$d)>1?$x>$z?-1:$d:!!$z+=2;echo$x;

Laufen Sie als Pipe mit -Roder versuchen Sie es online (oder entfernen Sie eine der anderen Versionen).

Ein Port von tshs rekursivem JavaScript benötigt 66 Bytes:

function f($n,$t=2){return$t<2*$n?$t<$n?f($n-$t,$t+4):$t-$n+2:$n;}

Ein Port von Arnauld´s Lösung benötigt 62 + 1:

$n=$argn;echo($n-=($r=(~-$n/2)**.5|0)*$r*2)<++$r*2?$n:$r*4-$n;

Ein Golf-Port von Xanderhalls Java hat den bisher kürzesten Code (55 + 1 Byte):

for($n=$argn;$n+2>$i+=4;)$n-=$i-2;echo$n*2>$i?$i-$n:$n;

Pyth ,  19  18 Bytes

-yhKs@/Q2 2a*yKhKt

Probieren Sie es hier aus!