Bei Rennen, bei denen die Rennfahrer mindestens eine Kurve einer gekrümmten Strecke zurücklegen, sind die Startpositionen für jeden Rennfahrer gestaffelt, sodass jeder Rennfahrer die gleiche Strecke auf der Strecke zurücklegt (andernfalls hätte der Rennfahrer auf der innersten Spur einen großen Vorteil ).

Ausgehend von der Länge der Haupt- und Nebenachse (oder der Halb-Haupt- und Halb-Nebenachse, wenn Sie dies vorziehen) einer elliptischen Spur und der Anzahl der Spuren in der Spur geben Sie die Abstände vom Startpunkt der innersten Spur für jede Spur aus sollte gestaffelt sein.

Spezifikationen

• Jede Spur ist eine Ellipse mit halbrunden Achsen, die 5 Einheiten länger sind als die nächstkürzere Spur. Nehmen Sie der Einfachheit halber an, dass die Fahrspuren eine Breite von 0 haben.
• Die innerste Spur beginnt immer bei 0, und jeder zweite Startpunkt ist eine positive ganze Zahl, die größer oder gleich dem vorherigen Startpunkt ist.
• Die Ein- und Ausgabe kann in jedem geeigneten und vernünftigen Format erfolgen.
• Die Eingaben sind immer Ganzzahlen.
• Sie müssen den Umfang der Spur auf 0,01 Einheiten vom tatsächlichen Wert aus berechnen.
• Die Ausgaben sind auf die nächste Ganzzahl (Floored) abzurunden.
• Die Ziellinie ist der Startpunkt für den innersten Rennfahrer. Es gibt nur eine Runde im Rennen.
• Die Längen der Achsen werden auf der innersten Spur der Spur gemessen.
• Die Ausgabe der 0 für den Versatz der innersten Spur ist optional.

Testfälle

Format: a, b, n -> <list of offsets, excluding innermost lane>

20, 10, 5 -> 30, 61, 92, 124
5, 5, 2 -> 31
15, 40, 7 -> 29, 60, 91, 121, 152, 183
35, 40, 4 -> 31, 62, 94

Diese Testfälle wurden mit dem folgenden Python 3-Skript generiert, das eine von Ramanujan entwickelte Annäherung des Umfangs einer Ellipse verwendet:

#!/usr/bin/env python3

import math

a = 35 # semi-major axis
b = 40 # semi-minor axis
n = 4  # number of lanes
w = 5  # spacing between lanes (constant)

h = lambda a,b:(a-b)**2/(a+b)**2
lane_lengths = [math.pi*(a+b+w*i*2)*(1+3*h(a+w*i,b+w*i)/(10+math.sqrt(4-3*h(a+w*i,b+w*i)))) for i in range(n)]

print("{}, {}, {} -> {}".format(a, b, n, ', '.join([str(int(x-lane_lengths[0])) for x in lane_lengths[1:]])))

Die verwendete Annäherung ist:

Schließlich ist hier ein hilfreiches Diagramm zum Verständnis der Berechnungen der Offsets:

05AB1E , 43 Bytes

UVFXY-nXY+WZn/3*©T4®-t+/>Z*žq*5DX+UY+V})¬-ï

Erläuterung

UV                                           # X = a, Y = b
  F                                   }      # n times do
   XY-n                                      # (a-b)^2
       XY+W                                  # Z = (a + b)
             /                               # divide (a-b)^2
           Zn                                # by (a+b)^2
              3*                             # multiply by 3
                ©                            # C = 3h
                       /                     # 3h divided by 
                 T                           # 10
                      +                      # +
                  4®-t                       # sqrt(4-3h)
                        >                    # increment
                         Z*žq*               # times (a + b)*pi
                              5DX+UY+V       # increase a and b by 5
                                       )     # wrap in list of circumferences
                                        ¬-   # divide by inner circumference
                                          ï  # floor
                                             # implicitly display

Probieren Sie es online!

Haskell, 103 98 Bytes

c!d|h<-3*d*d/c/c=pi*c*(1+h/(10+sqrt(4-h)))
f a b n|x<-a-b=[floor$(a+b+10*w)!x-(a+b)!x|w<-[1..n-1]]

Python 3, 168 164 Bytes

Vielen Dank an @ Adám und @ Mego für jeweils -2 Bytes

from math import*
h=lambda a,b:3*(a-b)**2/(a+b)**2;C=lambda a,b:pi*(a+b)*(1+h(a,b)/(10+sqrt(4-h(a,b))))
f=lambda a,b,n:[int(C(a+i*5,b+i*5)-C(a,b))for i in range(n)]

Eine Funktion f, die Eingaben über Argumente entgegennimmt und eine Liste von Spurversätzen zurückgibt, auch 0für die innerste Spur.

Wie es funktioniert

Dies verwendet Ramanujans Annäherung. Wir definieren einfach Funktionen hund Cfür die Berechnung des Parameters und Umfang, dann ziehen Sie die Länge der innersten Spur von der Länge der aktuellen Spur und Boden, für alle Spuren.

Probieren Sie es auf Ideone

Dyalog APL , 45 Bytes

Fragt nach n , dann nach a b . Benötigt, ⎕IO←0was auf vielen Systemen Standard ist.

⌊1↓(⊢-⊃)(○+×1+h÷10+.5*⍨4-h←3×2*⍨-÷+)⌿⎕∘.+5×⍳⎕

⍳⎕Eingabeaufforderung für n , dann geben Sie {0, 1, 2, ..., n −1)

5×von fünf multiplizieren erhalten {0, 5, 10, ..., 5 n -5}

⎕∘.+Eingabeaufforderung für ein und b , so ist ein Additionstabelle machen:
  a , a 5, a + 10, ... a +5 n -5
  b , b +5, b + 10, ... b +5 n −5

(... )⌿wende die Funktion in Klammern auf jedes vertikale Paar an, dh
  f ( a , b ), f ( a +5, b +5), f ( a +10, b +10), ..., f ( a +) 5 n -5, b +5 n - 5) ,
  wo f ( x , y ) ist *

○ pi mal

+×( x + y ) mal

1+ eins plus

h÷ h ( x , y ) [die Funktion h wird später definiert] geteilt durch

10+ zehn plus

.5*⍨ die Quadratwurzel von

4- vier minus

h← h ( x , y ), das ist

3× drei Mal

2*⍨ das Quadrat von

-÷( x - y ) geteilt durch

+ x + y

(⊢-⊃) Subtrahieren Sie für das Ergebnis der auf jedes Paar angewendeten Funktion den Wert des ersten Ergebnisses

1↓ entferne die erste (Null)

⌊ abrunden

TryAPL online!

* In Verfahrenssprache:

-÷+Finden Sie den Bruchteil der Differenz zwischen und der Summe von x und y

2*⍨ Quadrieren Sie diesen Bruch

3× multiplizieren Sie dieses Quadrat mit drei

h← Weisen Sie dieses Produkt zu h

4- subtrahieren Sie das Produkt von vier

.5*⍨ Nimm die Quadratwurzel dieses Unterschieds

10+ Addiere zehn zu dieser Quadratwurzel

h÷teile h durch diese Summe

1+ addiere eins zu diesem Bruch

+×multiplizieren Sie diese Summe mit der Summe von x und y

○ Multiplizieren Sie dieses Produkt mit pi