चौंका देने वाला प्रारंभ

Question

दौड़ में, जिसमें रेसर एक घुमावदार ट्रैक के कम से कम एक मोड़ के आसपास जाते हैं, प्रत्येक रेसर के लिए शुरुआती स्थिति डगमगा जाती है, जिससे प्रत्येक रेसर ट्रैक के चारों ओर एक ही दूरी की यात्रा करता है (अन्यथा, अंतरतम लेन में रेसर को एक बड़ा फायदा होगा )।

प्रमुख और छोटी कुल्हाड़ियों की लंबाई (या अर्ध-प्रमुख और अर्ध-माइनर, यदि आप चाहें तो) को देखते हुए एक अण्डाकार ट्रैक और ट्रैक में लेन की संख्या, अंतरतम लेन के शुरुआती बिंदु से दूरी को आउटपुट करें: प्रत्येक लेन कंपित होना चाहिए।

विशेष विवरण

• प्रत्येक लेन अगले-सबसे छोटी लेन की तुलना में 5 प्रमुख अर्ध-कुल्हाड़ियों वाली दीर्घवृत्त है। सादगी के लिए, मान लें कि गलियों की चौड़ाई 0 है।
• अंतरतम लेन हमेशा 0 से शुरू होती है, और प्रत्येक अन्य प्रारंभिक बिंदु एक सकारात्मक पूर्णांक है जो पिछले प्रारंभिक बिंदु से अधिक या उसके बराबर है।
• इनपुट और आउटपुट किसी भी सुविधाजनक और उचित प्रारूप में हो सकते हैं।
• इनपुट हमेशा पूर्णांक होंगे।
• आपको वास्तविक मान के 0.01 इकाइयों के भीतर ट्रैक की परिधि की गणना करनी चाहिए।
• आउटपुट को निकटतम पूर्णांक (फ्लोर्ड) पर गोल किया जाना है।
• फिनिश लाइन अंतरतम रेसर के लिए शुरुआती बिंदु है। दौड़ में केवल एक ही गोद है।
• कुल्हाड़ियों की लंबाई ट्रैक के अंतरतम लेन का उपयोग करके मापा जाता है।
• अंतरतम लेन की ऑफसेट के लिए 0 को आउटपुट करना वैकल्पिक है।

परीक्षण के मामलों

प्रारूप: 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

ये परीक्षण मामले निम्नलिखित पायथन 3 स्क्रिप्ट के साथ उत्पन्न हुए थे, जो रामानुजन द्वारा तैयार किए गए एक दीर्घवृत्त की परिधि के एक सन्निकटन का उपयोग करता है:

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

सन्निकटन का उपयोग किया जाता है:

अंत में, यहाँ ऑफसेट की गणना को समझने के लिए एक उपयोगी आरेख है:

Comments

मैं रामानुजन के सन्निकटन का उपयोग करता हूं जैसे आपने किया। क्या यह है कि हम क्या करने वाले हैं, या क्या आप चाहते हैं कि हम अनंत श्रृंखला के अभिसरण का मूल्यांकन करें?

— आदम

@ Adám आप जो कुछ भी कर सकते हैं वह आवश्यक परिशुद्धता प्राप्त करने के लिए करता है। रामानुजन सन्निकटन कई मूल्यों के लिए अच्छा है क्योंकि इसकी त्रुटि आदेश के आधार पर है h**5, जो 0.01मूल्यों की एक विस्तृत श्रृंखला के लिए अच्छी तरह से है।

— Mego

इनपुट आकार पर कोई बाध्य न होने पर न्यूनतम सटीकता क्या है?

— feersum

Answer 1

05AB1E , 43 बाइट्स

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

व्याख्या

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

इसे ऑनलाइन आज़माएं!

Answer 2

हास्केल, 103 98 बाइट्स

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

Answer 3

पायथन 3, 168 164 बाइट्स

-2 बाइट्स के लिए @ Adám और @Mego को धन्यवाद

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

एक फ़ंक्शन fजो तर्क के माध्यम से इनपुट लेता है और 0अंतरतम लेन के लिए लेन ऑफसेट की एक सूची देता है ।

यह काम किस प्रकार करता है

यह रामानुजन के लगभग शब्द का उपयोग करता है। हम बस कार्यों को परिभाषित करते हैं hऔर Cपैरामीटर और परिधि की गणना के लिए, फिर सभी लेन के लिए, वर्तमान लेन और फर्श की लंबाई से अंतरतम लेन की लंबाई घटाते हैं।

Ideone पर इसे आज़माएं

Comments

sqrt(4-3*h(a,b))के रूप में कम है (4-3*h(a,b))**.5, और floorद्वारा प्रतिस्थापित किया जा सकता है int। उन दोनों का मतलब है कि आपको आयात करने की आवश्यकता नहीं है math।

— मेगो

@ मेगो धन्यवाद। जब तक मैं बेवकूफ नहीं हो रहा हूँ, क्या वे पहले दो समान लंबाई नहीं हैं? हालांकि, यदि आयात विवरण हटा दिया जाता है, तो पीआई को परिभाषित करने की समस्या है।

— TheBikingViking

शामिल करके 3*में h, आप दो बाइट्स को बचाने चाहिए।

— अदम

मैं पूरी तरह से चूक गया कि आप उपयोग करते हैं piआप इसे पर्याप्त सटीकता के साथ हार्डकोड करने में सक्षम हो सकते हैं। और हाँ, पहले दो समान लंबाई हैं - मेरा मतलब आयात के बिना था, बिल्कुल! : पी

— मेगो

@ Adám कि बाहर इशारा करने के लिए धन्यवाद।

— TheBikingViking

Answer 4

दिल्लोग एपीएल , 45 बाइट्स

एन के लिए संकेत , फिर एक बी के लिए । ⎕IO←0कई सिस्टम पर डिफ़ॉल्ट की आवश्यकता होती है।

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

⍳⎕एन के लिए शीघ्र , फिर {0, 1, 2, ..., n )1) दें

5×पांच से गुणा पाने के लिए {0, 5, 10, ..., 5 एन -5}

⎕∘.+के लिए शीघ्र एक और ख , तो एक अतिरिक्त तालिका बनाने:
  एक , एक 5, एक 10, ... एक 5 एन -5
  ख , ख 5, बी 10, ... ख +5 n -5

(... )⌿प्रत्येक वर्टिकल जोड़ी, यानी
  f ( a , b ), f ( a +5, b +5), f ( a +10, b +10), ..., f ( a + 5 एन -5, बी 5 एन -5)
  जहां च ( एक्स , वाई ) है *

○ पाई बार

+×( x + y ) बार

1+ एक प्लस

h÷ h ( x , y ) [फ़ंक्शन h को बाद में परिभाषित किया जाएगा] द्वारा विभाजित

10+ दस प्लस

.5*⍨ का वर्गमूल

4- चार माइनस

h← h ( x , y ), जो है

3× तीन बार

2*⍨ का वर्ग

-÷( x - y ) द्वारा विभाजित

+ x + y

(⊢-⊃) प्रत्येक जोड़े पर लागू फ़ंक्शन के परिणाम पर, पहले परिणाम के मूल्य को घटाएं

1↓ पहला (शून्य) निकालें

⌊ नीचे घूमो

TryAPL ऑनलाइन!

---

* प्रक्रियात्मक भाषा में:

-÷+x और y के बीच के अंतर का अंश ज्ञात कीजिए

2*⍨ वर्ग कि अंश

3× उस वर्ग को तीन से गुणा करें

h←उस उत्पाद को h पर असाइन करें

4- उस उत्पाद को चार से घटाएं

.5*⍨ उस अंतर का वर्ग-मूल लें

10+ उस वर्ग-मूल में दस जोड़ें

h÷उस योग से एच को विभाजित करें

1+ उस अंश में एक जोड़ें

+×उस योग को x और y के योग से गुणा करें

○ उस उत्पाद को पाई से गुणा करें