गुरुत्वाकर्षण को अनुकरण करने में मदद करें!

Question

Notwen एक समान गुरुत्वाकर्षण क्षेत्र में बड़ी ऊंचाइयों से फेंके गए पिंडों के किनेमैटिक्स का अध्ययन करना चाहता है लेकिन दुर्भाग्य से उसके पास पर्याप्त ऊंचे स्थानों पर जाने और गिरने के दौरान वस्तुओं का निरीक्षण करने की तकनीकी संभावना नहीं है। लेकिन जो विज्ञान में अग्रिमों को देखना नहीं चाहता है, तो ... आइए, नॉटेन को एक गुरुत्वाकर्षण सिम्युलेटर बनाने में मदद करें!

भौतिक पृष्ठभूमि

एक समान गुरुत्वाकर्षण क्षेत्र में ऊँचाई ( प्रारंभिक वेग के बिना ) से एक वस्तु गिरा , वायुमंडलीय प्रभावों जैसे कि ड्रैग या विंड गेन वेग की उपेक्षा और समय के साथ जमीन की ओर गति। समय की एक इकाई में वेग के इस "परिवर्तन की दर" को गुरुत्वाकर्षण त्वरण कहा जाता है । पृथ्वी की सतह के पास, यह लगभग लगभग बराबर है , लेकिन इस चुनौती के प्रयोजनों के लिए हम मूल्य , जिसका अर्थ है कि एक सेकंड में, एक वस्तु अपने वेग को लगभग बढ़ाती है । ऊंचाई होने पर विचार करें , जो कि$h$$g\approx9.8\frac{m}{s^2}$$10\frac{m}{s^2}$$10 \frac{m}{s}$$h$$100m$और उस ऊंचाई को बराबर अंतराल में विभाजित करने की कल्पना करें, प्रत्येक मीटर लंबा। नॉटेन मापना चाहता है कि वस्तु को उन अंतरालों में से प्रत्येक के माध्यम से गिरने में कितना समय लगता है, इसीलिए हमारा उद्देश्य है कि हम भी गणना करें। आधुनिक कीनेमेटीक्स - स्किपिंग तकनीकी - हमें बताती है कि: जहां जो हमारे मामले में सभी मूल्यों के लिए है , प्रारंभिक है हमारे अंतराल और की शुरुआत में वेग की अवधि समय अंतराल (संदर्भ के लिए, अनुक्रमण से से शुरू होता है$100$

$$\Delta h_k=v_kt_k+\dfrac{1}{2}gt_k^2$$ $\Delta h_k\equiv\Delta h=100m$$k$$v_k$$k^\text{th}$$t_k$$k^\text{th}$$0$$v_0=0$)। हम यह भी जानते हैं कि की निम्न अभिव्यक्ति है: संख्यात्मक रूप से, हमें मिलता है। और पहले समीकरण में प्लगिंग और के लिए सुलझाने देता है इसलिए ऑब्जेक्ट में पहला अंतराल ( ) , दूसरा इंटरवल ( ) और इतने पर ( pastebin) यात्रा करता है अधिक मूल्यों के साथ)।$v_k$ $$v_k=\sqrt{2g(\Delta h_0+\Delta h_1+\cdots+\Delta h_{k-1})}=\sqrt{2gk\Delta h}$$ $v_k=\sqrt{2000k}\frac{m}{s}$$t_k$ $$\color{red}{\boxed{t_k=2\sqrt{5}\left(\sqrt{k+1}-\sqrt{k}\right)s}}\tag{*}$$ $k=0$$4.4721s$$k=1$$1.8524s$

चुनौती

इनपुट: ऊंचाई जहाँ से वस्तु या तो के रूप में फेंक दिया जाता है: की एक सकारात्मक पूर्णांक एकाधिक , या अंतराल की संख्या (ताकि या तो या कि मतलब होगा ) - कौन सा आप पर निर्भर है।$h$$100$$h$ $N=\frac{h}{100}$$700$$7$$h=700m$

आउटपुट: एक गिरती हुई वस्तु का एक ASCII कला एनीमेशन, एक ऊंचाई (नीचे विवरण) से गिरा दिया गया ।$h$

एक आउटपुट फ्रेम की संरचना निम्नानुसार होनी चाहिए:

• $N$"न्यू ग्राउंड" से पहले न्यूलाइन्स, कम से कम एक गैर-व्हाट्सएप चरित्र (जैसे @) द्वारा दर्शाया गया । जमीन के कम से कम एक पात्र को उस ऊर्ध्वाधर पर लेटना चाहिए जिस पर वस्तु गिरती है।
• एक और गैर-व्हाट्सएप चरित्र जो वस्तु का प्रतिनिधित्व करता है (जैसे X), जो आपने जमीन के लिए चुना था, उसके अलावा।
• वैकल्पिक रूप से , ऊर्ध्वाधर अक्ष या लाइनों पर बनी दीवार का प्रतिनिधित्व करने वाली प्रत्येक पंक्ति की शुरुआत में एक चरित्र । अग्रणी और अनुगामी रिक्त स्थान की कोई भी मात्रा तब तक ठीक है जब तक वे फ़्रेम के बीच संगत होते हैं, साथ ही दीवार और ऑब्जेक्ट के बीच किसी भी स्थान पर। मान्य फ्रेम के उदाहरणों में ¹ ( या ) शामिल हैं: $N$$h=700m$$N=7$

  | X                                       >
  |                             @           >   A
  |                                         >
  |        or            or           or    > 
  |               O                         >
  |                                         >
  |                                         >
  @@@             ^           -----            &&&
  

ऑब्जेक्ट को पहले फ्रेम की पहली पंक्ति पर शुरू करना चाहिए, फिर बाद आउटपुट को फ्लश किया जाना चाहिए और आपके प्रोग्राम को ऑब्जेक्ट को उसी ऊर्ध्वाधर लेकिन अगली पंक्ति में दूसरे फ्रेम में प्रदर्शित करना चाहिए; उसके बाद बाद आउटपुट को फिर से फ्लश किया जाना चाहिए और आपके प्रोग्राम को ऑब्जेक्ट को उसी वर्टिकल पर, लेकिन तीसरी लाइन में अगली लाइन पर और इसी तरह तब तक दिखाना चाहिए, जब तक ऑब्जेक्ट जमीन के ठीक ऊपर लाइन में न पहुंच जाए। उदाहरण:$t_0\approx 4.47s$$t_1\approx 1.85s$

नियम

• आउटपुट को कुछ पाठ होना चाहिए जो एक संवादात्मक (फ़्लेशबल) कंसोल, एक GIF, प्रत्येक फ़्रेम के लिए एक अलग फ़ाइल या आउटपुट की कुछ अन्य उचित तकनीक के लिए लिखा गया हो।
• प्रत्येक फ़्रेम को अंतिम फ़्रेम को पूरी तरह से लिखना चाहिए और उसी स्थान पर होना चाहिए।
• आप मान सकते हैं कि कंपाइलर / दुभाषिया को पाठ के आउटपुट के लिए आवश्यक समय नगण्य है और वर्गमूलों की गणना के लिए न्यूनतम सटीकता 2 दशमलव स्थानों तक है।
• आप इनपुट ले सकते हैं और किसी भी मानक विधि के माध्यम से आउटपुट प्रदान कर सकते हैं , जबकि ध्यान दें कि इन खामियों को डिफ़ॉल्ट रूप से मना किया गया है। ये हैकोड गोल्फ, इसलिए अपनी पसंद की भाषा में कम से कम बाइट्स में कार्य पूरा करने का प्रयास करें ।

---

^{1: मैं इस बात को लेकर निश्चिंत हूं कि एक वैध फ्रेम क्या है क्योंकि मैं आपके समाधान के लिए जो कुछ भी करना चाहता हूं उसे अनुमति देना चाहता हूं और मैं चुनौती के लिए शानदार सामान जोड़ने की कोशिश नहीं कर रहा हूं। यदि कुछ भी स्पष्ट नहीं है, तो टिप्पणियों में पूछें।}

Answer 1

जावास्क्रिप्ट (ES7) + CSS + HTML, 340 बाइट्स

f=n=>{o.style.height=n+'em';x.style.animationDuration=(n*20)**.5+'s';o.appendChild(x,x.remove())}

pre{position:relative;border:1px solid;height:5em;overflow:hidden}span{position:absolute;top:0;animation:x 10s cubic-bezier(0.33,0,0.67,0.33)both}@keyframes x{to{top:100%}}

<input type=number value=5 oninput=f(this.value)><pre id=o><span id=x>X

अगर मुझे अपनी रकम मिल गई है, तो एनीमेशन की अवधि और फिर सीएसएस क्यूबिक-बेज़ियर बाकी है।$\sqrt { 20 N }$

Answer 2

चारकोल , 28 बाइट्स

Ｎθ↓θ⁴Ｆθ«Ｊ²ιＰXＲ⌊×φ×₂²⁰⁻₂⊕ι₂ι 

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। नोट: अनुगामी स्थान। आप TIO पर देरी का निरीक्षण कर सकते हैं, लेकिन आप एनीमेशन नहीं देख सकते हैं, इसलिए आपको आउटपुट से कल्पना करनी होगी। Nइनपुट के रूप में लेता है । स्पष्टीकरण:

Ｎθ

इनपुट N।

↓θ⁴

दीवार और जमीन को प्रिंट करें, ताकि आउटपुट का आकार सुसंगत हो।

Ｆθ«

प्रत्येक अंतराल पर लूप।

Ｊ²ιＰX

Xउचित ऊंचाई पर रखें ।

Ｒ⌊×φ×₂²⁰⁻₂⊕ι₂ι

वर्तमान कैनवास सामग्री को आउटपुट करें और उचित मात्रा में समय की प्रतीक्षा करें (निकटतम मिलीसेकंड से कम)।

Xएक स्थान के साथ ओवरराइट करें ।

Answer 3

पर्ल 6 , 81 बाइट्स

{say "\e[s{"\n"x$_}-";map {say "\e[u{" \n"x 4.9e-6*$_²}o";sleep .01},^452*.sqrt}

"इसे ऑनलाइन आज़माएं!", लेकिन TIO एनीमेशन को संभाल नहीं सकता।

व्याख्या

मैंने थोड़ा अलग दृष्टिकोण चुना (और मुझे लगता है कि यह बेहतर है, हालांकि मुझे यकीन नहीं है)। ओपी में सूत्र द्वारा दिए गए समय के लिए सोने के बजाय, मैं सिर्फ उपयुक्त स्थिति "हर 10 एमएस" ( sleep। त्रुटियों से प्रेरित )।

इसका मतलब है कि एक सेकंड में 100 फ्रेम होते हैं, इसलिए यदि हम फ्रेम संख्या को दर्शाते हैं $k$, यह होना चाहिए $t=k/100$। और चूंकि हम ऊर्ध्वाधर दूरी को 100 मीटर ब्लॉकों में विभाजित करते हैं, इसलिए हम ऊंचाई लिख सकते हैं$h = 100n$, कहाँ पे $n$ब्लॉक की संख्या है (इनपुट के रूप में दी गई है)। ऊंचाई समय में यात्रा की$t$ द्वारा दिया गया है $h = gt^2/2$, इसलिए यात्रा किए गए ब्लॉकों की संख्या है

$$n = \frac{1}{100} \tfrac 1 2 g t^2 = \tfrac 1 2 g \times 10^{-6} k^2 \approx 4.905\times 10^{-6} k^2.$$ हम इसे कुल फ्रेम की संख्या प्राप्त करने के लिए उल्टा कर सकते हैं, जिसे हमें प्रस्तुत करना होगा: $$k = \frac{\sqrt n}{\sqrt{4.905\times 10^{-6}}} \approx 452 \times \sqrt n.$$

यह फ़ंक्शन लिखने के लिए पर्याप्त है। यह एक तर्क लेता है, रेंडर करने के लिए ब्लॉक की संख्या यानी$n$। सबसे पहले, हम करते हैं say "\e[s{"\n"x$_}-"। वह ANSI एस्केप सीक्वेंस को सेव कर्सर प्रिंट करता है, फिर प्रिंट करता है$n$newlines, और उसके बाद, यह एक डैश (जमीन) और एक नई रेखा प्रिंट करता है। (यह पर्ल 6 में दोहरे उद्धरण चिह्नों की ठंडी सुविधा का उपयोग करता है: आप उस कोड को घुंघराले ब्रेसिज़ के अंदर लिखकर किसी भी कोड को स्ट्रिंग में सही कर सकते हैं।)

उसके बाद, हम 0 से एक अनुक्रम बनाते हैं $452\sqrt n$(स्वचालित रूप से पूर्णांक के लिए छोटा) ^452*.sqrt, और हम इस पर मैप करते हैं। प्रत्येक पुनरावृत्ति में, हम एक Unsave Cursor ANSI अनुक्रम प्रिंट करते हैं (जो कर्सर को उस स्थान पर रखता है जहाँ यह अंतिम था), लिखें$4.9\times 10^{-6} k^2$तार "स्पेस + न्यूलाइन" (स्वचालित रूप से एक बार फिर से काट दिया गया) और अंत में जो oकि ऑब्जेक्ट को दर्शाता है। फिर हम 10 एमएस के लिए सोते हैं, कुल्ला और दोहराते हैं।

स्वचालित ट्रंकेशन के कारण, यह सिर्फ द राइट थिंग ™ करता है और गिरावट के प्रत्येक पूर्ण 100 मीटर के बाद ही "ओ" को स्थानांतरित करता है।

Answer 4

हास्केल, 145 बाइट्स

import Control.Concurrent
a!b=[a..b]>>"\n"
f h=mapM(\k->putStr("\27[2J"++1!k++'O':k!h++"-")>>threadDelay(round$4472135*(sqrt(k+1)-sqrt k)))[1..h]

एक ANSI टर्मिनल में चलाने की आवश्यकता है। इनपुट अंतराल की संख्या है।

threadDelayनैनोमीटर में पैरामीटर है, इसलिए एक शाब्दिक 4472135से कम है 2*sqrt 5*10^6। दुर्भाग्य 46**4 = 4477456से आवश्यक परिशुद्धता की सीमा के भीतर नहीं है।

Answer 5

पायथन 2 , 117 120 123 बाइट्स

-3 बाइट्स "एक एक्स-ट्रिपल डॉट मत बनो" और "जोनाथन फ्रेच" के लिए धन्यवाद

import time
h=input()
for k in range(h):print'\33[2J'+'\n'*k+'O'+'\n'*(h-k)+'^';time.sleep(2*5**.5*((k+1)**.5-k**.5))

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

Comments

मेरे से +1, अच्छा समाधान! वास्तविक unprintable चरित्र का उपयोग करने के बजाय बाइट्स के एक जोड़े को बचाने नहीं होगा chr(27)?

— श्री एक्सकोडर

@ नॉटबीएक्स-ट्राइपोटॉट और यदि किसी को स्वयं चरित्र नहीं मिलता है, तब '\33'भी उसे छोटा होना चाहिए।

— जोनाथन फ्रीच

भी है, 2*5**.5है 20**.5।

— जोनाथन फ्रीच

@JonathanFrech 20 का वर्गमूल रूट 4.47 द्वारा प्रतिस्थापित

— mdahmoune

@ म्हदामौने खैर ... अगर वह सटीकता काफी अच्छी है, तो हां।

— जोनाथन फ्रीच

Answer 6

सी # (.NET कोर) , 201 , 180 + 13 = 193 बाइट्स

सिस्टम का उपयोग करने की आवश्यकता है; 13 अतिरिक्त बाइट्स के लिए।

अजीब तरह से, Console.Clear () TIO पर मेरे लिए काम नहीं कर रहा है। हालाँकि, यह VS2017 के तहत कंसोल ऐप में पूरी तरह से चलता है।

संपादित करें: लूप को छोटा करने के लिए इग्नोरेंस के अवतार के लिए धन्यवाद, मेरे अनावश्यक चर असाइनमेंट और सिस्टमट्रेडिंग का उपयोग करके अनावश्यक इंगित करना; बयान (वीएस कॉपी से बचे हुए), और इंगित करते हुए कि जमीन की आवश्यकता थी! कुल 8 बाइट्स इस प्रकार जमीन के जोड़ से दूर हैं। टाइ टाय!

x=>{for(var j=x;j>0;System.Threading.Thread.Sleep((int)(4470*(Math.Sqrt(x-j+1)-Math.Sqrt(x-j--))))){Console.Clear();Console.Write("X".PadLeft(x-j+1,'\n').PadRight(x+1,'\n')+"-");}}

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