Dalam balapan di mana pembalap berkeliling setidaknya satu putaran lintasan melengkung, posisi awal untuk setiap pembalap terhuyung, sehingga setiap pembalap menempuh jarak yang sama di lintasan (jika tidak, pembalap di jalur terdalam akan memiliki keuntungan besar. ).

Mengingat panjang sumbu utama dan minor (atau semi-mayor dan semi-minor, jika Anda mau) dari lintasan elips dan jumlah lajur di lintasan, output jarak dari titik awal lajur terdalam jalur yang setiap lajur harus terhuyung.

Spesifikasi

• Setiap jalur adalah elips dengan sumbu semi mayor 5 unit lebih panjang dari jalur terpendek berikutnya. Untuk kesederhanaan, asumsikan bahwa jalur memiliki lebar 0.
• Jalur terdalam selalu dimulai pada 0, dan setiap titik awal lainnya adalah bilangan bulat positif lebih besar dari atau sama dengan titik awal sebelumnya.
• Input dan output mungkin dalam format yang mudah dan masuk akal.
• Masukan akan selalu berupa bilangan bulat.
• Anda harus menghitung keliling lintasan ke dalam 0,01 unit dari nilai aktual.
• Keluaran harus dibulatkan ke bilangan bulat terdekat (lantai).
• Garis finish adalah titik awal untuk pembalap terdalam. Hanya ada satu putaran dalam lomba.
• Panjang sumbu diukur menggunakan jalur terdalam trek.
• Mengeluarkan 0 untuk offset jalur paling dalam adalah opsional.

Uji Kasus

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

Kasus uji ini dibuat dengan skrip Python 3 berikut, yang menggunakan perkiraan keliling elips yang dirancang oleh Ramanujan:

#!/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:]])))

Perkiraan yang digunakan adalah:

Akhirnya, berikut adalah diagram yang membantu untuk memahami perhitungan offset:

05AB1E , 43 byte

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

Penjelasan

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

Cobalah online!

Haskell, 103 98 byte

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 byte

Terima kasih kepada @ Adám dan @Mego untuk masing-masing -2 byte

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

Sebuah fungsi fyang mengambil input melalui argumen dan mengembalikan daftar offset lajur, termasuk 0untuk lajur terdalam.

Bagaimana itu bekerja

Ini menggunakan perkiraan Ramanujan. Kami cukup mendefinisikan fungsi hdan Cuntuk menghitung parameter dan keliling, kemudian kurangi panjang jalur paling dalam dari panjang jalur dan lantai saat ini, untuk semua jalur.

Cobalah di Ideone

Dyalog APL , 45 byte

Anjuran untuk n , maka untuk sebuah b . Membutuhkan ⎕IO←0yang default pada banyak sistem.

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

⍳⎕meminta n , lalu berikan {0, 1, 2, ..., n −1)

5×kalikan dengan lima untuk mendapatkan {0, 5, 10, ..., 5 n -5}

⎕∘.+cepat untuk sebuah dan b , kemudian membuat tabel Selain itu:
  a , a 5, sebuah 10, ... sebuah 5 n -5
  b , b 5, b 10, ... b 5 n −5

(... )⌿menerapkan fungsi kurung untuk setiap pasangan vertikal, yaitu
  f ( a , b ), f ( a +5, b +5), f ( a +10, b +10), ..., f ( a + 5 n -5, b 5 n -5)
  di mana f ( x , y ) adalah *

○ kali pi

+×( x + y ) kali

1+ satu ditambah

h÷ h ( x , y ) [fungsi h akan ditentukan kemudian] dibagi dengan

10+ sepuluh plus

.5*⍨ akar kuadrat dari

4- empat minus

h← h ( x , y ), yaitu

3× tiga kali

2*⍨ kuadrat dari

-÷( x - y ) dibagi dengan

+ x + y

(⊢-⊃) pada hasil fungsi yang diterapkan untuk masing-masing pasangan, kurangi nilai hasil pertama

1↓ hapus yang pertama (nol)

⌊ bulat ke bawah

TryAPL online!

* Dalam bahasa prosedural:

-÷+temukan fraksi perbedaan antara dan jumlah x dan y

2*⍨ kuadrat fraksi itu

3× kalikan kuadrat itu dengan tiga

h←tetapkan produk itu ke h

4- kurangi produk itu dari empat

.5*⍨ ambil akar kuadrat dari perbedaan itu

10+ tambahkan sepuluh ke akar kuadrat itu

h÷bagi h dengan jumlah itu

1+ tambahkan satu ke fraksi itu

+×kalikan jumlah itu dengan jumlah x dan y

○ kalikan produk itu dengan pi