टाइम ट्रैवलिंग स्टॉक ट्रेडर

Question

कहानी
बहुत समय पहले बॉबी ने 1 सतोशी (1e-8 BTC, सबसे छोटी मुद्रा इकाई) के साथ एक बिटकॉइन वॉलेट बनाया और इसके बारे में भूल गया। कई अन्य लोगों की तरह उन्होंने बाद में "लानत है, अगर केवल मैंने और अधिक निवेश किया तो ..."।
दिवास्वप्न पर रोक नहीं, वह अपना सारा समय और पैसा समय मशीन बनाने में लगाता है। वह अपना अधिकतर समय अपने गैराज में बिताता है, दुनियादारी के मामलों से अनजान और उसके बारे में घूमती अफवाहें। वह एक दिन पहले प्रोटोटाइप पूरा कर लेता है क्योंकि उसकी बिजली मिस्ड भुगतान के कारण बंद होने वाली है। अपने कार्यक्षेत्र से ऊपर उठकर, वह एक पुलिस वैन को अपने घर तक खींचता हुआ देखता है, ऐसा लगता है कि उसके पड़ोसी ने सोचा था कि वह अपने गैरेज में एक मेथ लैब चला रहा है और पुलिस को बुलाता है।
परीक्षणों को चलाने का कोई समय नहीं होने के कारण, वह पिछले वर्षों के विनिमय दर के आंकड़ों के साथ एक यूएसबी-स्टिक पकड़ता है, फ्लक्स कैपेसिटर को क्वांटम डिस्कॉमब्युलेटर से जोड़ता है और खुद को उस दिन वापस ले जाता है जब उसने अपना बटुआ बनाया था

टास्क
विनिमय दर डेटा को देखते हुए, यह पता करें कि बॉबी कितना पैसा कमा सकता है। वह एक बहुत ही सरल नियम का पालन करता है: "कम खरीदें - उच्च बेचें" और जब से वह एक असीम रूप से छोटी पूंजी के साथ शुरू होता है, हम मानते हैं कि उसके कार्यों का भविष्य से विनिमय दरों पर कोई प्रभाव नहीं पड़ेगा।

इनपुट
फ़्लोट्स की एक सूची> 0, या तो एक स्ट्रिंग को एक एकल वर्ण (न्यूलाइन, टैब, स्पेस, सेमीकोलन, जिसे आप पसंद करते हैं) द्वारा अलग किया जाता है, प्रोग्राम में कमांड लाइन तर्क के रूप में पारित किया गया, एक टेक्स्टफिल या एसटीडीआईएन से पढ़ा गया या एक पैरामीटर के रूप में पारित किया गया। एक समारोह के लिए। आप एक स्ट्रिंग के बजाय संख्यात्मक डेटाटेस या सरणियों का उपयोग कर सकते हैं क्योंकि इसकी मूल रूप से ब्रैकेट्स के साथ एक स्ट्रिंग है।

आउटपुट
वह कारक जिसके द्वारा बॉबबीस पूंजी को व्यापार के अंत तक गुणा किया जाता है।

उदाहरण

Input:  0.48 0.4 0.24 0.39 0.74 1.31 1.71 2.1 2.24 2.07 2.41

विनिमय दर: 0.48 $ / BTC, क्योंकि यह ड्रॉप करने वाला है, हम 4.8 बिटकॉइन के लिए सभी Bitcoins बेचते हैं। कारक = १ विनिमय दर: ०.४, कुछ भी न करें
विनिमय दर: ०.२४ $ / बीटीसी और बढ़ती: सभी $ २ सेशियो में परिवर्तित करें। कारक = 1 (डॉलर मूल्य अभी भी अपरिवर्तित है)
विनिमय दर: 0.39 - 2.1 $ / BTC:
विनिमय दर कुछ भी न करें : 2.24 $ / BTC: ड्रॉप से ​​पहले सब कुछ बेच दें। 44.8 नैनोडॉलर, कारक = 9.33
विनिमय दर: 2.07 $ / BTC: खरीद 2.164 सतोशी, कारक = 9.33
विनिमय दर: 2.41 $ / BTC: खरीदें 52.15 नैनोडॉलर, कारक = 10.86

Output: 10.86

अतिरिक्त विवरण
आप निरंतर इनपुट, शून्य- या नकारात्मक मान, केवल एक इनपुट नंबर आदि जैसे अजीब किनारे के मामलों को अनदेखा कर सकते हैं,
वास्तविक स्टॉक चार्ट्स का परीक्षण या उपयोग करने के लिए अपने स्वयं के यादृच्छिक संख्या उत्पन्न करने के लिए स्वतंत्र महसूस करते हैं। यहाँ परीक्षण के लिए एक लंबा इनपुट है (अपेक्षित आउटपुट लगभग। 321903884.638)
संक्षेप में बताएं कि आपका कोड
ग्राफ़ की सराहना करता है लेकिन आवश्यक नहीं है

Comments

यदि हम फ़ंक्शन तर्क के माध्यम से संख्या लेते हैं, तो क्या यह अभी भी एक स्ट्रिंग है, या क्या हम सीधे एक सरणी ले सकते हैं?

— मार्टिन एंडर

@ MartinBüttner I ने कुछ समय के लिए इसके बारे में विचार किया, चाहे इनपुट एक स्ट्रिंग हो, एक संख्यात्मक सरणी या एक मुफ्त विकल्प हो, हमेशा कुछ भाषाएं होती हैं जिनका लाभ मिलता है। इस पर एक आम सहमति नहीं लगती है, और दो प्रोग्राम लिखना, एक संख्यात्मक के लिए- और एक स्ट्रिंग इनपुट के लिए और दोनों स्कोर औसत औसत ओवरकिल की तरह लगता है।

— डेन्डेनडू

असीम इम्प्रूवबिलिटी ड्राइव के बारे में क्या? :)

— दरवाज़े

समस्या पर वापस आते हुए, क्या हमें किसी पुनरावृत्ति पर, BTC और / या $ मानों को चक्कर लगाने की आवश्यकता है? उदाहरण के लिए, वास्तविक दुनिया में किसी व्यक्ति के बीटीसी वॉलेट को सातोशी के लिए गोल किया जाना चाहिए। इससे फर्क पड़ता है, क्योंकि आपके उदाहरण में, 2.07 पर आप केवल 2s खरीद सकते हैं (2.164 नहीं); फिर 2.41 पर आपके 2s आपको 48.2 n $ (52.15 नहीं) खरीदते हैं, इसलिए कारक 10.04 (10.86 नहीं) है। जब तक आप बदलाव के साथ एक अलग $ बटुआ नहीं रखते हैं और इसे हर बार वापस जोड़ने की आवश्यकता होती है। डॉलर के बारे में क्या? क्या आज कोई भी एक नैनो-कॉलर होने का दावा कर सकता है? मेरा मानना ​​है कि जो सबसे छोटी राशि है वह 1 amount हो सकती है।

— तोबिया

@CortAmmon: आप कह रहे हैं कि बीटीसी ट्रेडिंग अराजक नहीं है ? ;-)

— स्टीव जेसप

Answer 1

एपीएल, 16 वर्ण

{×/1⌈÷/⊃⍵,¨¯1⌽⍵}

यह संस्करण @Frxstrem के सरल एल्गोरिथ्म और @xnor के max(r,1)विचार का उपयोग करता है।

यह भी मानता है कि श्रृंखला समग्र रूप से बढ़ रही है, अर्थात्, पहला बिटकॉइन मूल्य पिछले एक की तुलना में छोटा है। यह समस्या वर्णन के अनुरूप है। अधिक सामान्य सूत्र प्राप्त करने के लिए, पहले दो दरों को गिराना चाहिए, 2 वर्ण जोड़ने:{×/1⌈÷/⊃1↓⍵,¨¯1⌽⍵}

उदाहरण:

    {×/1⌈÷/⊃⍵,¨¯1⌽⍵}  0.48 0.4 0.24 0.39 0.74 1.31 1.71 2.1 2.24 2.07 2.41
10.86634461
    {×/1⌈÷/⊃⍵,¨¯1⌽⍵}  (the 1000 array from pastebin)
321903884.6

स्पष्टीकरण:

विनिमय दर डेटा से शुरू करें:

    A←0.48 0.4 0.24 0.39 0.74 1.31 1.71 2.1 2.24 2.07 2.41

पूर्ववर्ती के साथ प्रत्येक संख्या को जोड़ो (पहले को अंतिम के साथ जोड़ा जाएगा) और उन्हें एक मैट्रिक्स में डालें:

    ⎕←M←⊃A,¨¯1⌽A
0.48 2.41
0.4  0.48
0.24 0.4
0.39 0.24
0.74 0.39
1.31 0.74
1.71 1.31
2.1  1.71
2.24 2.1
2.07 2.24
2.41 2.07

विभाजन द्वारा प्रत्येक पंक्ति को कम करें, उन अनुपात> 1 के साथ रखें, और अनुपात द्वारा गुणन को संयोजित करें। यह लगातार बढ़ती दरों की एक पंक्ति में किसी भी दोहराए जाने वाले कारकों को समाप्त करेगा, साथ ही साथ पहले और अंतिम विनिमय दरों के बीच का सहज अनुपात:

    ×/1⌈÷/M
10.86634461

Comments

आपकी यह धारणा कि आपको हमेशा पहली स्थिति में बेचना चाहिए, लंबे इनपुट को विफल बनाता है और 1 से कम संख्या देता है (जो कि स्पष्ट रूप से असंभव है)।

— 18

@Frxstrem धन्यवाद, निश्चित। अब यह आपकी स्क्रिप्ट के समान परिणाम देता है। यह अधिक उपयोगी होता यदि ओपी हमें परिणामों के साथ कुछ परीक्षण मामले देता!

— तोबिया

मुझे अच्छे एपीएल समाधान पसंद हैं क्योंकि, जब भी मैं उन्हें देखता हूं, तो वे मेरे "यह बाइनरी फ़ाइल जिबरिश" फ़िल्टर को ट्रिगर करते हैं और मैं इसे खोलने के तरीके का पता लगाने के लिए एक फ़ाइल एक्सटेंशन की तलाश शुरू करता हूं।

— Cort Ammon - मोनिका

@CortAmmon यह बिल्कुल निराधार नहीं है: APL कई दर्जन ग्राफिक ऑपरेटरों को नियुक्त करता है; सतह पर वे आपको 8-बिट डॉस चरित्र सेट से प्रतीकों की याद दिला सकते हैं। यह एक बहुत ही कठिन भाषा भी है, जिसका अर्थ है कि एपीएल की एक पंक्ति में बहुत अधिक जानकारी दर्ज है। ये दो विशेषताएं एक डॉस विंडो में डंप की गई बाइनरी फ़ाइल की भावना को ट्रिगर करने के लिए जोड़ती हैं। लेकिन यह केवल तब तक रहता है जब तक आप एपीएल के प्रतीकों और वाक्य रचना की सुंदरता की सराहना करना नहीं सीखते।

— टोबिया

Answer 2

अजगर, ४ 47

f=lambda t:2>len(t)or max(t[1]/t[0],1)*f(t[1:])

उदाहरण परीक्षण मामले पर चलाया जाता है ।

फ़्लोट्स की एक सूची लें। पहले दो तत्वों से लाभ कारक पर पुनरावर्ती गुणक दो गुणा से कम रहता है। आधार मामले के लिए, Trueजो बराबरी देता है 1।

प्रयोग popकरने से समान संख्या में वर्ण मिलते हैं।

f=lambda t:2>len(t)or max(t[1]/t.pop(0),1)*f(t)

तो सूची के अंत से जा रहा है।

f=lambda t:2>len(t)or max(t.pop()/t[-1],1)*f(t)

तुलना के लिए, पायथन 2 में मेरा पुनरावृत्ति कोड 49 वर्ण, 2 वर्ण लंबा है

p=c=-1
for x in input():p*=max(x/c,1);c=x
print-p

के साथ शुरू c=-1काल्पनिक पहली "चाल" बनाने के लिए एक हैक है एक लाभ कभी नहीं दिखा। उत्पाद को शुरू करने के -1बजाय 1हमें दोनों तत्वों को एक साथ असाइन करने की अनुमति देता है, और हम इसे प्रिंट करने से पहले मुफ्त में नकारात्मक करते हैं।

Comments

लंबा टेस्टकेस डिफ़ॉल्ट पुनरावृत्ति सीमा को 1. f (x [: 999]) से अधिक कर देता है, फिर भी सही परिणाम देता है। लंबे समय तक इनपुट के लिए आप इसे विखंडू में विभाजित कर सकते हैं ([n:(n+1)*500 + 1] for n in range(N_elem/500) )और आंशिक कारकों को गुणा कर सकते हैं

— DenDenDo

पुनरावृत्ति सीमा कार्यान्वयन निर्भर है; इससे बचने के लिए आप स्टैकलेस पायथन का उपयोग कर सकते हैं ।

— xnor

या बस sys.setrecursionlimit(

— CPththon में

Answer 3

पायथन, 79 81 76 77 बाइट्स

f=lambda x:reduce(float.__mul__,(a/b for a,b in zip(x[1:],x[:-1]) if a>b),1.)

xसूची के रूप में एन्कोड किया गया इनपुट है फ़ंक्शन कारक लौटाता है।

Comments

हो सकता है कि यह सिर्फ मेरा पायथन संस्करण है, लेकिन मुझे फ़ंक्शन के अंत के 1.बजाय इसका उपयोग करना था 1, अन्यथा मुझे टाइपइर्रर मिलता है: विवरणक ' mul ' को एक 'फ्लोट' ऑब्जेक्ट की आवश्यकता होती है, लेकिन

— टोबिया

BTW, स्मार्ट एल्गोरिथ्म!

— तोबिया

आपको उस f=भाग की आवश्यकता नहीं है ।

— wizzwizz4

Answer 4

CJam, 33 बाइट्स

q~{X1$3$-:X*0>{\;}*}*](g\2/{~//}/

इसे और आगे बढ़ाया जा सकता है।

STDIN से इनपुट लेता है, जैसे

[0.48 0.4 0.24 0.39 0.74 1.31 1.71 2.1 2.24 2.07 2.41]

और कारक को STDOUT की तरह, आउटपुट करता है

10.866344605475046

इसे यहाँ ऑनलाइन आज़माएँ

Answer 5

अजगर , १,

u*GeS,1ceHhHC,QtQ1

स्पष्टीकरण:

u                 reduce, G is accumulator, H iterates over sequence
 *G               multiply G by
   eS             max(               
     ,1               1,
       ceHhH            H[1]/H[0])
 C                H iterates over zip(
  ,QtQ                                Q,Q[1:])
 1                G is initialized to 1

max(H[1]/H[0],1) @xnor को धन्यवाद

Answer 6

सी #, 333 , 313

मेरा पहला प्रयास। शायद इसे और अधिक अनुकूलित कर सकते हैं, लेकिन जैसा मैंने कहा कि पहला प्रयास तो इसे लटका मिलेगा!।

double a(double [] b){var c=0.0;var d=1;for(int i=0;i<b.Count();i++){c=(d==1)?(((i+1)<b.Count()&&b[i+1]<=b[i]&&d==1)?((c==0)?b[i]:b[i]*c):((i+1)>=b.Count()?(c*b[i])/b[0]:c)):((i+1)<b.Count()&&b[i+1]>b[i]&&d==0)?c/b[i]:c;d=((i+1)<b.Count()&&b[i+1]<b[i]&&d==1)?0:((i+1)<b.Count()&&b[i+1]>b[i]&&d==0)?1:d;}return c;}

इनपुट

0.48, 0.4, 0.24, 0.39, 0.74, 1.31, 1.71, 2.1, 2.24, 2.07, 2.41

उत्पादन

10.86

संपादित करें: गणित का उपयोग करने के सुझाव के लिए DenDenDo को धन्यवाद। गोल काटने के लिए बूल के बजाय गोल और int का उपयोग करने के लिए। भविष्य की पहेली के लिए याद होगा!

Comments

अरे, सुझाव के लिए धन्यवाद। मैंने सुझाव के अनुसार अपडेट किया।

— डैरेन ब्रिन

ऐसा लगता है कि आप दो अंकों में चक्कर लगा रहे हैं, Math.Floor(...)जिसकी आवश्यकता नहीं है। इसके अलावा, मैं चाहे सी # में इसके संभावित पता नहीं है, लेकिन आम तौर पर आप के लिए 1 और 0 का उपयोग कर सकते trueहैं और false।

— डेनडेनडो

क्षमा करें, सोचा था कि 2 के लिए गोलाई आवश्यक थी क्योंकि हर कोई 10.86 प्रिंट कर रहा था और मुझे 10.866 मिल रहा था और गोल हो रहा था। आप अन्य c भाषाओं के लिए कर सकते हैं लेकिन C # के लिए नहीं। हालाँकि इसने मुझे एक विचार दिया था इसलिए अब मैं अपनी बूलियन जाँच के लिए 1 और 0 का उपयोग कर रहा हूँ। इसे थोड़ा और कम कर दिया। धन्यवाद!

— डेरेन ब्रिन