स्टैक एक्सचेंज स्टॉक एक्सचेंज - V3

Question

सूचना: यह चुनौती अब बंद हो गई है: मैं अब लीडरबोर्ड को अपडेट नहीं करूंगा और स्वीकार किए गए उत्तर को नहीं बदलूंगा। हालाँकि, यदि आप चाहें तो आप नियंत्रक को चलाने और लीडरबोर्ड को अपडेट करने के लिए स्वतंत्र हैं।

चैट में शामिल हों!

परिचय

शुभ संध्या, व्यापारियों! आप गोल्फ कंपनी पीपीसीजी के लिए सभी व्यापारी हैं। आपका काम जितना संभव हो उतना पैसा बनाना है।

चुनौती

एक प्रोग्राम लिखें जो स्टैक एक्सचेंज स्टॉक एक्सचेंज पर शेयरों को खरीदता है और जितना संभव हो उतना पैसा बनाने के उद्देश्य से बेचता है।

खेल खेलते हैं

सभी खिलाड़ी अपने बैंक में 5 शेयरों और $ 100 के साथ शुरुआत करेंगे। खेल हमेशा $ 10 के शेयर मूल्य के साथ शुरू होता है।

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

उदाहरण के लिए, यदि मेरा कार्यक्रम है test1.py, तो शेयर की कीमत है 100, मेरे द्वारा धारण किए गए शेयरों की संख्या , मेरे पास कितना 3पैसा है 1200और गोल संख्या है 576, मेरा कार्यक्रम इस तरह चलाया जाएगा:

python test1.py 100 3 1200 576

एक दौर में, प्रत्येक खिलाड़ी को दिया जाने वाला शेयर मूल्य समान होगा। यह दौर के अंत तक नहीं बदलता है।

जवाब में, खिलाड़ी को अपनी कमांड प्रिंट करनी होगी। दो विकल्प हैं:

• शेयर खरीदें: यह कमांड दी गई है कि आपके द्वारा खरीदे जाने वाले शेयरों की संख्या bnकहां nहै। उदाहरण के लिए, यदि आप 100 शेयर खरीदना चाहते हैं, तो आप आउटपुट देंगे:

b100

शेयर खरीदते समय, आपको $ 1000 तक के ओवरड्राफ्ट की अनुमति दी जाती है। यदि आप इस ओवरड्राफ्ट से अधिक के शेयर खरीदने की कोशिश करते हैं (आपका बैंक बैलेंस $ -1000 से नीचे चला जाता है), तो आपको दिवालिया घोषित कर दिया जाएगा। इसका मतलब है कि आप अपने सभी शेयरों को खो देंगे और आपका शेष $ 50 पर सेट हो जाएगा।

यदि आप दिवालिया हो जाते हैं तो शेयर की कीमत आपके आदेश से अप्रभावित रहेगी।

(यदि आपका शेष राशि $ -1000 है, तो आप दिवालिया नहीं हैं। हालाँकि यदि आपका शेष $ -1001 है, तो आप दिवालिया हैं)

• शेयर बेचें: यह आदेश दिया गया है कि आपके द्वारा बेचने की इच्छा रखने वाले शेयरों की संख्या snकहां nहै। उदाहरण के लिए, यदि आप 100 शेयर बेचना चाहते हैं, तो आप आउटपुट देंगे:

s100

हो सकता है कि आप खुद से ज्यादा शेयर न बेचते हों। यदि आप ऐसा करने की कोशिश करते हैं, तो आपके अनुरोध को अस्वीकार कर दिया जाएगा, और आप दौर को छोड़ देंगे।

यदि आप राउंड को छोड़ना और कुछ भी नहीं करना चाहते हैं, तो आउटपुट b0या s0।

यदि आप शेयरों की एक नकारात्मक संख्या और / या शेयरों की एक गैर-पूर्णांक संख्या खरीदने या बेचने की कोशिश करते हैं तो आपके अनुरोध को अस्वीकार कर दिया जाएगा।

5 राउंड के बाद, प्रत्येक राउंड के अंत में, सभी खिलाड़ियों को एक लाभांश का भुगतान किया जाएगा, जिसका मूल्य पिछले 5 राउंड के औसत औसत शेयर मूल्य का 5% है।

यह कैसे काम करता है?

शुरुआत में शेयर की कीमत 10 डॉलर होगी। प्रत्येक दौर के अंत में, सूत्र का उपयोग करके इसे पुनर्गणना किया जाएगा:

$$\text{New Share Price} = \text{Old Share Price} + (\text{Number of shares bought}-\text{Number of shares sold})$$

शेयर की कीमत सीमित होगी ताकि यह कभी भी $ 1 से कम न हो।

अत्यधिक तेजी से परिवर्तन को रोकने के लिए, शेयर की कीमत में बदलाव अधिकतम तक सीमित है ।$\pm$200$

नियम

• आपके प्रोग्राम का एक नाम होना चाहिए

• आपके प्रोग्राम को डेटा संग्रहण के लिए एक एकल पाठ फ़ाइल की अनुमति है। इसे आपके प्रोग्राम के समान फ़ोल्डर में संग्रहीत किया जाना चाहिए

• अपने उत्तर विवरण में शामिल करें कि आपका कार्यक्रम कैसे चलाना है

• यह KotH उन सभी प्रोग्रामिंग भाषाओं के लिए खुला है जो फ्री-टू-यूज़ हैं और विंडोज 10 पर चलाई जा सकती हैं

• आपका स्कोर पूरी तरह से आपके बैलेंस की सामग्री पर आधारित है। शेयरों में बंद किसी भी पैसे को नहीं गिना जाएगा

• आप किसी भी समय अपने कार्यक्रम को संपादित कर सकते हैं। प्रत्येक गेम से पहले, नवीनतम कोड सहेजा और संकलित किया जाएगा

• आपको कोड नहीं लिखना चाहिए जो विशेष रूप से दूसरे बॉट को लक्षित करता है।

नियंत्रक

नियंत्रक पायथन में लिखा गया है और यहां पाया जा सकता है: https://gist.github.com/beta-decay/a6abe40fc9f4ff6cac443395377ec31f

अंत में यह एक लीडरबोर्ड को प्रिंट करेगा और एक ग्राफ प्रदर्शित करेगा कि पूरे खेल में शेयर की कीमत कैसे बदल गई।

उदाहरण के लिए, जब दो यादृच्छिक बॉट खेल रहे थे

जीतना

अंतिम गेम जीत के अंत में अपने शेष राशि में सबसे अधिक धनराशि वाला खिलाड़ी।

लीडरबोर्ड

गेम 4: 16:14 10/08/2018

Name                                Balance

Experienced Greedy Idiot            $14802860126910608746226775271608441476740220190868405578697473058787503167301288688412912141064764060957801420415934984247914753474481204843420999117641289792179203440895025689047561483400211597324662824868794009792985857917296068788434607950379253177065699908166901854516163240207641611196996217004494096517064741782361827125867827455285639964058498121173062045074772914323311612234964464095317202678432969866099864014974786854889944224928268964434751475446606732939913688961295787813863551384458839364617299883106342420461998689419913505735314365685264187374513996061826694192786379011458348988554845036604940421113739997490412464158065355335378462589602228039730
Equalizer                           $763185511031294813246284506179317396432985772155750823910419030867990447973211564091988995290789610193513321528772412563772470011147066425321453744308521967943712734185479563642323459564466177543928912648398244481744861744565800383179966018254551412512770699653538211331184147038781605464336206279313836606330
Percentage Trader                   $448397954167281544772103458977846133762031629256561243713673243996259286459758487106045850187688160858986472490834559645508673466589151486119551222357206708156491069820990603783876340193236064700332082781080188011584263709364962735827741094223755467455209136453381715027369221484319039100339776026752813930
OYAIB                               $8935960891618546760585096898089377896156886097652629690033599419878768424984255852521421137695754769495085398921618469764914237729576710889307470954692315601571866328742408488796145771039574397444873926883379666840494456194839899502761180282430561362538663182006432392949099112239702124912922930
Chimps on a Typewriter              $176504338999287847159247017725770908273849738720252130115528568718490320252556133502528055177870
Greedy B*****d                      $17689013777381240
Illiterate Dividend Investor        $2367418699671980
Lucky Number 6                      $4382725536910
Lone Accountant                     $90954970320
Buy/Reinvest                        $127330
Technical Analysis Robot            $126930
Dollar Cost Averager                $106130
Fibonacci                           $69930
Novice Broker                       $28130
Buy Low                             $6130
Naive Statistician                  $6130
Fallacious Gambler                  $6130
Passive Trader                      $4980
Half More or Nothing                $4920
Monkeys on a Typewriter             $66

प्रत्येक प्रतियोगी के रेखांकन देखें

---

_{संबंधित लेकिन गेमप्ले और जीतने की कसौटी इस चुनौती से बहुत अलग हैं।}

Comments

टिप्पणियाँ विस्तारित चर्चा के लिए नहीं हैं; इस वार्तालाप को बातचीत में स्थानांतरित कर दिया गया है ।

— डेनिस

मेरे लिए सूत्र लाल रंग में [मैथ प्रोसेसिंग त्रुटि] के रूप में दिखाता है । क्या यह दूसरों के लिए भी ऐसा ही है? यदि ऐसा है तो शायद यह सवाल के साथ एक मुद्दा है।

— कप्तान मैन

भाग्य के प्रभाव को कम करने के लिए 10-100 गेम पर यह औसत परिणाम के लायक हो सकता है। या हो सकता है कि यह चुनौती बहुत ज्यादा बदल रही हो।

— म्बिग

क्या स्कोर 2 / लॉग 10 होना संभव होगा? इससे स्कोर की तुलना करना बहुत आसान हो जाएगा। (मैं अपने फोन के साथ ब्राउज़ करता हूं, और

मुझे लगता है कि 10-100 भी बहुत कम है, लेकिन मुझे बहुत सारे खेल चलाना पसंद है । इसे संभव बनाने के लिए, आपको चुनौती के प्रारूप को बदलना होगा, जो अब दायरे से बाहर है।

— नाथन मेरिल

Answer 1

अनुभवी लालची बेवकूफ

PHP, PHP> = 7 पर परीक्षण किया गया, पिछले वाले पर भी काम करना चाहिए।

<?php

class StickExchange
{
    private $dbFile;
    private $sharePrice;
    private $shares;
    private $balance;
    private $overdraft;

    public function __construct($sharePrice, $shares, $balance, $round)
    {
        $this->dbFile = __FILE__ . '.txt';
        $this->sharePrice = gmp_init($sharePrice);
        $this->shares = gmp_init($shares);
        $this->balance = gmp_init($this->parseScientificNotationToInt($balance));
        $this->overdraft = gmp_init(1000);

        $action = 'b';

        if ($round == 1) {
            $this->buy();
        } elseif ($round == 1000) {
            $this->sell();
        } else {
            $content = $this->getDbContent();
            $lastPrice = gmp_init($content['price']);
            $secondLastPrice = gmp_init($content['last_price']);
            $lastAction = $content['action'];

            $shareAndLastCmp = gmp_cmp($this->sharePrice, $lastPrice);
            $lastAndSecondLastCmp = gmp_cmp($lastPrice, $secondLastPrice);

            if ($shareAndLastCmp > 0 && $lastAndSecondLastCmp > 0) {
                if ($lastAction == 'b') {
                    $this->sell();
                    $action = 's';
                } else {
                    $this->buy();
                }
            } elseif ($shareAndLastCmp < 0 && $lastAndSecondLastCmp < 0) {
                if ($lastAction == 'b') {
                    $this->sell();
                    $action = 's';
                } else {
                    $this->skip();
                }
            } elseif ($shareAndLastCmp > 0) {
                $this->sell();
                $action = 's';
            } elseif ($shareAndLastCmp < 0) {
                $this->buy();
            } else {
                $this->skip();
            }
        }

        $this->setDbContent([
            'action' => $action,
            'price' => gmp_strval($this->sharePrice),
            'last_price' => isset($lastPrice) ? gmp_strval($lastPrice) : '0',
        ]);
    }

    private function parseScientificNotationToInt($number)
    {
        if (strpos($number, 'e+') !== false) {
            $sParts = explode('e', $number);
            $parts = explode('.', $sParts[0]);
            $exp = (int)$sParts[1];

            if (count($parts) > 1) {
                $number = $parts[0] . $parts[1];
                $exp -= strlen($parts[1]);
            } else {
                $number = $parts[0];
            }

            $number = gmp_init($number);
            $pow = gmp_pow(gmp_init(10), $exp);
            return gmp_strval(gmp_mul($number, $pow));
        } elseif (strpos($number, 'e-') !== false) {
            return sprintf('%d', $number);
        } else {
            $parts = explode('.', $number);
            return $parts[0];
        }
    }

    private function getDbContent()
    {
        return unserialize(file_get_contents($this->dbFile));
    }

    private function setDbContent($content)
    {
        file_put_contents($this->dbFile, serialize($content));
    }

    private function buy()
    {
        $realBalance = gmp_add($this->balance, $this->overdraft);
        $sharesToBuy = gmp_div($realBalance, $this->sharePrice);
        $this->stdout('b' . gmp_strval($sharesToBuy));
    }

    private function sell()
    {
        $this->stdout('s' . gmp_strval($this->shares));
    }

    private function skip()
    {
        $this->stdout('b0');
    }

    private function stdout($string)
    {
        $stdout = fopen('php://stdout', 'w');
        fputs($stdout, $string);
        fclose($stdout);
    }
}

new StickExchange($argv[1], $argv[2], $argv[3], $argv[4]);

"लालची इडियट" का अपडेटेड वर्जन, री-स्ट्रक्चर्ड बिहेवियर और बग फिक्स के साथ बड़ी संख्या में काम करने से संबंधित है।

टिप्पणियाँ:

• एक फ़ाइल में सहेजें और इसे इस तरह से चलाएं: php C:\path\path\stack_exchange.php 10 5 100 1
• यह स्क्रिप्ट टेक्स्ट फ़ाइल को उसी नाम से बनाती है जैसे स्क्रिप्ट फ़ाइल और .txtअंत में संलग्न है। तो कृपया स्क्रिप्ट पथ पर उपयुक्त लेखन अनुमति वाले उपयोगकर्ता के साथ दौड़ें।
• खिड़कियों पर PHP 7.2 स्थापित करने का एक सरल तरीका: http://www.dorusomcutean.com/how-to-install-php-7-2-on- Windows /
• सुपर विशाल संख्याओं के साथ काम करने के लिए, मुझे GMP का उपयोग करना था , इसलिए इन दो पंक्तियों को php.iniबिना किसी टिप्पणी के किया जाना चाहिए (यदि लाइन की शुरुआत में अर्ध-बृहदान्त्र को हटाया जाना चाहिए, अगर यह पहले से ही नहीं है):
  • ; extension_dir = "ext"
  • ;extension=gmp

Comments

वाह, उस लिंक के लिए धन्यवाद! मैं सोच रहा था: D

— बीटा Decay

@BetaDecay: कोई बात नहीं, btw आपको केवल तब तक जाने की आवश्यकता है जब तक कि चरण 2 (टेस्ट PHP स्थापित नहीं हो जाता है) जहाँ आप इसके साथ इंस्टालेशन की जाँच करते हैं php -v। बाकी इसके लिए आवश्यक नहीं हैं। मेरा मानना ​​है कि आपको इस चुनौती के लिए कई अलग-अलग भाषाओं को स्थापित करने में बहुत परेशानी हो रही है! मैं इस तरह से कुछ करने की हिम्मत कभी नहीं करूँगा: D

— Night2

@ BetaDecay सिर्फ डॉकटर कंटेनर के रूप में TryItOnline स्थापित करना आसान नहीं होगा?

— NieDzejkob

@NieDzejkob संभवत: लेकिन यह शायद इन भाषाओं को स्थापित करने में काम आएगा

— बीटा

बधाई हो, आप लगातार हर दूसरे प्रतियोगी को हराते हैं!

— बीटा

Answer 2

एक टाइपराइटर पर चिंपियां

import random
from sys import argv

share_price = int(argv[1])
share_count = int(argv[2])
balance = float(argv[3])

x = random.random()
if x < 0.5:
    max_buy = balance / share_price
    buy_count = int(max_buy * random.random())
    print('b' + str(buy_count))
else:
    sell_count = int(share_count * random.random())
    print('s' + str(sell_count))

चिंपाजी बंदरों की तुलना में अधिक चालाक होते हैं, वे उन शेयरों को नहीं खरीदेंगे जिन्हें वे खरीद नहीं सकते हैं, या उन शेयरों को नहीं बेच सकते हैं जो उनके पास नहीं हैं।

अभी भी बहुत यादृच्छिक अन्यथा।

Python3 के साथ चलाएँ, लेकिन python2 के साथ भी (?) काम करना चाहिए

Comments

वे होशियार हो सकते हैं, लेकिन क्या वे भाग्यशाली हैं?

— वोयोहूजिन

मेरे सभी परीक्षणों में यह शीर्ष पर आया है, इसलिए हां

— स्किड्सदेव

मुझे बेहद उत्सुकता है कि इसने

— mbrig

मैं इसे सादगी की कला में लगाना पसंद करता हूं। बाकी सभी लोग अपने बॉट्स पर ओवर-इंजीनियरिंग कर रहे हैं।

— स्काईसदेव

इसे बहुत प्यार मिला, गलती से: पी

— नाइट 2

Answer 3

OYAIB

from sys import argv

share_price = float(argv[1])
shares      = int(argv[2])
cash        = float(argv[3])
cur_round   = int(argv[4])
tot_rounds  = 1000.0

investments = shares * share_price
total_assets = investments + cash

target_cash = round(cur_round / tot_rounds * total_assets)

if target_cash > cash:
  shares_to_sell = min(shares, round((target_cash - cash) / share_price))
  print('s%d' % shares_to_sell)
else:
  shares_to_buy = round((cash - target_cash) / share_price)
  print('b%d' % shares_to_buy)

"बांड में अपनी उम्र के मालिक" की पुरानी कहावत के बाद, यह कार्यक्रम भी ऐसा करने की कोशिश करता है। इस तरह हम अंत-खेल में बाजार की अस्थिरता के अधीन नहीं हैं।

संपादित करें: नियंत्रक को देखने से पता चलता है कि हम केवल पूर्ण शेयर खरीद / बेच सकते हैं, लेकिन एक आंशिक खाता शेष हो सकता है।

Comments

PPCG में आपका स्वागत है!

— बीटा डिके

धन्यवाद! पहली बार पोस्टिंग तो मुझे पता है कि कुछ भी जगह से बाहर है।

— just_browsing

आप एक अतिरिक्त शर्त जोड़ना चाह सकते हैं कि अंतिम दौर में, आप अपने सभी शेयर बेचते investmentsहैं (जैसा कि आपके स्कोर में नहीं गिना जाता)।

— बाइक

यह OYAIB की सुंदरता है, यह स्वचालित रूप से करता है। Target_cash कुल अंकों का प्रतिशत है, जो इस बात पर निर्भर करता है कि "जीवन" किस बिंदु पर है। जीवन के अंत में, target_cash कुल_assets का 100% है, इसलिए यह अपने द्वारा धारण किए गए किसी भी शेयर को बेच देगा।

— just_browsing

Answer 4

अकेला लेखाकार

buy-sell.py:

from sys import argv

Price = int(argv[1])
Shares = int(argv[2])
Balance = float(argv[3])
Round = int(argv[4])

if Round % 2 == 0: print('s' + str(Shares))
if Round % 2 == 1: print('b' + str(int((Balance + 1000) / Price)))

में कुछ भी संग्रहीत नहीं करता है buy-sell.txt।

विषम दौर में, यह जितने शेयर खरीद सकता है, उतने ही खरीद लेता है। यहां तक ​​कि दौर में, यह अपने सभी शेयरों को बेचता है।

इरादा सबसे पहले अधिक से अधिक शेयर खरीदकर शेयर की कीमत बढ़ाने का है, और फिर अधिक पैसा पाने के लिए उन शेयरों को बेच दें। यह काम करता है क्योंकि अंतिम दौर भी (दौर 1000) है।

हालांकि, 5प्रत्येक जोड़ी के दौर के बाद भी शेयर की कीमत समान रहेगी ( ), बॉट के अकेले होने के कारण (इसलिए लोन अकाउंटेंट है ), बॉट का बैलेंस बढ़ता है, क्योंकि बिक्री मूल्य खरीद मूल्य से अधिक होता है, और अधिक बैलेंस होता है। अधिक शेयर खरीदने की क्षमता। यह एक दुष्चक्र है, लेकिन एक अच्छे तरीके से (मेरे लिए)।

प्रमुख भेद्यता बुराई बॉट्स के साथ खेलती है, शेयर की कीमत कम करने के लिए बेचती है (यदि यह उनके लिए अच्छा है तो निश्चित नहीं)। इस मामले में, बॉट $ -890 के संतुलन के साथ बना रह सकता है, बशर्ते कि इसमें बहुत से दुष्ट बॉट हों। यह एकाउंटेंट वास्तव में उनके मन की शांति चाहता है। ;-)

Comments

1 पर 1 मुझे यकीन नहीं है कि अगर यह संभव है तो पिटाई होगी; यह आसान नहीं है, भले ही आप अकाउंटेंट एलए को पूरी तरह से समझें और इसका मुकाबला करने का प्रयास करें। एक बड़े पैमाने पर खेल में जहाँ आप निडर हैं, आप आउटमैन्यूवरेड हो सकते हैं।

— याकूब

@ यक दूसरों ने पहले ही मेरे टेस्ट रन में इसे हरा दिया है।

— आउटगॉल्फ

1 पर 1? मैं हैरान हूँ; मैं यह पता लगाने में असमर्थ हूं कि आप एक प्रतिद्वंद्वी को कैसे पर्याप्त रूप से समृद्ध कर सकते हैं जो मूल्य झूलों को उल्टा कर सकता है, या यहां तक ​​कि उन्हें संसाधनों के ढेर को जलाए बिना समय के साथ बढ़ने से रोक सकता है (इस बीच एलए बलिदान नहीं करता है, इसलिए कठिन हो जाता है रुकें)। क्या आप उस गेमप्ले से लिंक कर सकते हैं जिसे LA ने वन-वन खो दिया है?

— याकूब

@Yakk मैंने अभी तक इसका एक-एक परीक्षण नहीं किया है। इसके अलावा, यदि आप चाहें तो इस पर चर्चा करने के लिए हमारे लिए एक चैट रूम है ।

— आउटगोल्फर

यदि आपके पास शेयर हैं तो क्या कुछ नहीं करना अधिक मजबूत होगा और कीमत पिछले दौर की तुलना में कम है या आपके पास पैसा है और कीमत अधिक है? यह अन्य, समान बॉट्स के साथ सिंक से बाहर होने से बचाता है। इसके अलावा, मैं यह नहीं देखता कि यह एक-पर-एक कैसे पीटा जा सकता है।

— जॉलीजॉकर

Answer 5

निष्क्रिय व्यापारी

from sys import argv

share_price = int(argv[1])
balance = float(argv[3])
round_num = int(argv[4])

if round_num == 1:
    print('b%s' % str(int(balance / share_price)))
else:
    print('b0')

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

वह $ 0 पर जाने के लिए पर्याप्त स्टॉक खरीदेगा (इस फेला के लिए कोई ओवरड्राफ्ट नहीं, वह अपने आप को थोड़े लाभ के लिए खुद को कर्ज में नहीं डाल रहा है), फिर लाभांश बनाने दें

Python3 के साथ चलाएँ, लेकिन python2 के साथ भी (?) काम करना चाहिए।

Comments

मुझे लगता है कि आपको अपने 15 शेयरों को कम से कम अंतिम दौर में बेचना चाहिए।

— कलडो

@ कल्लो नाह, वह लंबे समय से इस बारे में भूल गया है कि एक बार उसने उस बिंदु से स्टॉक खरीदा था

— स्किड्सदेव

Answer 6

प्रतिशत ट्रेडर पायथन 3

(शायद python2 में काम करता है)

import sys
args=sys.argv

price=int(args[1])
held=int(args[2])
money=int(args[3])
roundNum=int(args[4])
prevPrice=0

if roundNum==1:
    print("b"+str((money+1000)//price))
else:
    if roundNum==1000:
        print("s"+str(held))
    else:
        with open("percentageTrader.dat","r") as f:
            prevPrice=int(f.read())
        if(price>prevPrice):
            toSell=int(held*int(1000000*(price-prevPrice))/(price))//1000000
            print("s"+str(toSell))
        if(price<prevPrice):
            toBuy=int(((money+1000)//price)*int(1000000*(prevPrice-price))//(prevPrice))//1000000
            print("b"+str(toBuy))
        if(price==prevPrice):
            print("b0")

with open("percentageTrader.dat","w") as f:
    f.write(str(price))

चलाने के निर्देश दिए

• Filename.py के रूप में सहेजें
• अजगर फ़ाइलनाम मूल्य के साथ चलाएं # शेष बैलेंस राउंड #

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

• पहले राउंड बॉट खरीद के रूप में कई शेयरों के रूप में यह बर्दाश्त कर सकते हैं।
• यदि मूल्य बढ़ता है, तो बॉट मूल्य में प्रतिशत वृद्धि (नए मूल्य से गणना) के बराबर शेयरों का एक प्रतिशत बेचता है
• यदि कीमत कम हो जाती है, तो बॉट अधिकतम शेयरों का एक प्रतिशत खरीदता है जो वह मूल्य में प्रतिशत कमी के बराबर खरीद सकता है (पिछले मूल्य के अनुसार गणना)
• 1000 के दौर में सब कुछ बेच देता है

परिवर्तन को अस्थायी बिंदु विभाजन के कारण होने वाली समस्याओं को उम्मीद से दूर करना चाहिए

Answer 7

द नाइव स्टेटिस्टिशियन

पायथन 3 के लिए बनाया गया, पायथन 2 में काम कर सकता है

from sys import argv
from math import floor

# Save an entry to the stock history
def save_history(price):
    with open('stockhistory.txt', 'a') as f:
        f.write(str(price) + '\n')

# Load the stock history
def load_history():
    with open('stockhistory.txt', 'r') as f:
        return [float(line.strip()) for line in f]

# Calculate average price rise/fall streak length
def average_streak(history, condition):
    streaks = []
    current_streak = 0
    last_price = history[0]
    for price in history[1:]:
        if condition(last_price, price):
            current_streak += 1
        elif current_streak:
            streaks += [current_streak]
            current_streak = 0
        last_price = price
    if current_streak:
        streaks += [current_streak]
    return sum(streaks) / len(streaks) if streaks else None

# Calculate the current streak length
def current_streak(history, condition):
    streak = 0
    while streak < len(history) - 1 and condition(history[-streak - 2], history[-streak - 1]):
        streak += 1
    return streak

def run(share_price, share_count, balance, round_number):
    save_history(share_price)

    # Sell all shares if it is the last round
    if round_number == 1000:
        print('s' + str(int(share_count)))
        return

    # Buy as many shares as possible if the price is down to one, as there's
    # nothing to lose
    if share_price == 1:
        buy_count = int(balance + 1000)
        print('b' + str(buy_count))
        return

    history = load_history()

    # Calculate the average and current rise/fall streaks
    average_rise = average_streak(history, lambda a, b: a <= b)
    current_rise = current_streak(history, lambda a, b: a <= b)
    average_fall = average_streak(history, lambda a, b: a >= b)
    current_fall = current_streak(history, lambda a, b: a >= b)

    # Do nothing if there's no analyzed data
    if not average_fall or not average_rise:
        print('b0')
        return

    # Buy shares if the current rise streak is as long as or longer than average
    if current_rise > current_fall and current_rise >= average_rise:
        buy_count = (balance + 1000) / share_price
        print('b' + str(int(buy_count)))
        return

    # Sell shares if the current fall streak is as long as or longer than average
    if current_fall > current_rise and current_fall >= average_fall:
        print('s' + str(int(share_count)))
        return

    # Otherwise, do nothing    
    print('b0')

run(*map(float, argv[1:]))

यह एक भोला-भाला सांख्यिकीविद् है जो केवल कीमत / सामान्य से अधिक समय तक गिरने पर स्टॉक की कीमतों की भविष्यवाणी करने की कोशिश करता है, जबकि अगर स्टॉक एक से नीचे है और अंतिम दौर में सभी शेयरों को बेच रहा है, तो शेयर भी खरीद सकता है।

Answer 8

डॉलर की लागत एवेरजेर

(पायथन 3.7 के साथ परीक्षण किया गया)

कोडगॉल्फ में पहली पोस्ट तो मुझे बताएं कि क्या मैंने कुछ गलत किया है।

मूल विचार यह है कि यदि संभव हो तो एक-एक शेयर खरीद लें और अंत में सभी शेयरों को बेच दें।

from sys import argv
share_price = int(argv[1])
share_count = int(argv[2])
balance = float(argv[3])
round = int(argv[4])

if round < 1000:
    if balance > share_price-1000:
        print("b1")
    else:
        print("b0")
else:
    print("s" + str(share_count))

Answer 9

तुल्यकारक

from sys import argv
p, n, b, r = map(int, argv[1:])
c = p*n
print "bs"[(c+b)/2>b] + str(int(abs(((c-b)/2)/p))) if r < 999.5 else "s" + str(int(n))

इसके वित्तीय संसाधनों को समान रूप से नकदी और स्टॉक के बीच हर दौर में अंतिम को छोड़कर। मेरा मानना ​​है कि इस रणनीति को कम से कम कुछ पैसे बनाने का एक गणितीय तरीका है, लेकिन मैं गलत साबित हो सकता हूं।

ऐसे कीड़े हो सकते हैं या नहीं जो मैंने नहीं पकड़े हैं। कुछ हद तक गोल्फ भी।

Comments

आपके कार्यक्रम में यहाँ शामिल बड़ी संख्या के साथ कठिनाइयाँ हो रही हैं, इसलिए मैं लाइन p, n, b, r = map(float, argv[1:])को बदलने का सुझाव p, n, b, r = map(int, argv[1:])

— बीटा डेके

@ बेताडे ने किया

— एफ पियर्स

Answer 10

एक टाइपराइटर पर बंदर

import random

cmd = ['b', 's'][int(random.random() * 2)]
num = str(int(random.random() * 1000000))
print("%s%s" % (cmd, num))

यह टाइपराइटर पर बंदरों का एक झुंड है। बेतरतीब ढंग से एक्स स्टॉक को बेचता या खरीदता है, जहां:
0 <= X <= 1,000,000

Python3 के साथ चलाएँ, लेकिन python2 के साथ भी (?) काम करना चाहिए

Comments

क्यों नहीं उपयोग cmd=random.choose(['b','s'])और num = str(random.randint(0, 1000000))?

— बीटा

क्योंकि मैं आलसी हूँ

— 23

क्यों नहींimport lazy

— Woohoojin

पूरी बात को कम किया जा सकता है from random import randint, choice;print("{}{}".format(choice(["b", "s"]), randint(0, 1e6)));

— आरोन एफ

हां, लेकिन यह गोल्फ चुनौती नहीं है

— स्काईसदेव

Answer 11

कम खरीदें

(अजगर 2 या 3)

import random

def run(price, shares, balance, round_):
    # We get no value from our leftover shares at the end, so sell them all.
    if round_ == 1000:
        print('s' + str(int(shares)))
        return

    # If the price is low enough, buy everything we can.
    if price <= 20 + round_ * 60:
        print('b' + str((balance + 1000) // price))
        return

    # If we have no shares, wait for the price to drop.
    if shares == 0:
        print('b0')
        return

    # Sometimes sell shares so we can buy if the price gets low again.
    if random.random() < 0.4:
        print('s1')
        return

    # Otherwise, just wait for a better price.
    print('b0')


if __name__ == '__main__':
    import sys
    run(*[float(x) for x in sys.argv[1:]])

Answer 12

विशाल जुआरी

(अजगर 2 या 3)

import random

def run(price, shares, balance, round_):
    # We get no value from our leftover shares at the end, so sell them all.
    if round_ == 1000:
        print('s' + str(int(shares)))
        return

    # For the first round, just watch.
    if round_ == 1:
        with open('fg.txt', 'w') as f:
            f.write('1 0 10')
        print('b0')
        return

    # Get the state.
    with open('fg.txt') as f:
        direction, streak, previous = map(int, f.read().strip().split())
    change = price - previous

    # If the market isn't moving, wait for it to get hot again.
    if change == 0:
        print('b0')
        return

    # Keep track of the market direction.
    if (change > 0) == (direction > 0):
        streak += 1
    else:
        streak = 0
        direction *= -1

    # If the market's been going one way for too long, it has to switch, right?
    if streak > 5:
        if direction > 0:
            print('s' + str(shares // 2))
        else:
            print('b' + str((balance + 1000) // price // 2))
    # Otherwise, the market's too volatile.
    else:
        print('b0')

    # Save the state.
    with open('fg.txt', 'w') as f:
        f.write('%d %d %d' % (direction, streak, price))


if __name__ == '__main__':
    import sys
    run(*[float(x) for x in sys.argv[1:]])

Answer 13

(Dyalog) एपीएल किसान

r←apl_stock_farmer args
 round←¯1↑args
 :If 1=round
     (buyPrice sellPrice)←10 0
     bought←1
     (currPrice shares balance)←3↑args
     r←'b10'
 :ElseIf 1000=round
     r←'s',⍕shares
 :Else
     (currPrice shares balance)←3↑args
     :If (currPrice>buyPrice)∧bought
         bought←0
         sellPrice←currPrice
         r←'s',⍕shares
     :ElseIf (currPrice<sellPrice)∧~bought
         bought←1
         buyPrice←currPrice
         r←'b',⍕⌊(1000+balance)÷currPrice
     :Else
         r←'b0'
     :End
 :End

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

ऐसा इसलिए है क्योंकि किसान के लेखाकार ने उससे कहा कि आप स्टॉक ट्रेडिंग कैसे करते हैं। "कम खरीदें, उच्च बेचें" और वह सब सामान।

अस्वीकरण

यह एक कोठ चुनौती पर मेरा पहला प्रयास है, और चूंकि मैं मूल रूप से केवल एपीएल ही करता हूं, इसलिए मैंने इसके साथ जाने का फैसला किया।

यह कहा, मुझे पूरी तरह से यकीन नहीं है कि यह अन्य बोट्स के साथ चलाया जा सकता है, क्योंकि यह एक Tradfn है और इसे सीधे सीएमडी / बैश शेल में नहीं खिलाया जा सकता है।

तो, इसे बैश में चलाने के लिए, आपको निम्न कमांड की आवश्यकता है:

$ echo apl_stock_farmer args | dyalog 'stock_exchange.dws' -script

कहाँ पे:

apl_stock_farmer फ़ंक्शन का नाम है, जो कोड की पहली पंक्ति में है।

argsअंतरिक्ष से अलग तर्कों का एक वेक्टर है (पहले दौर में, यह होगा 10 5 100 1)।

dyalog Dyalog निष्पादन योग्य के लिए रास्ता है

'stock_exchange.dws'वह नाम (या पथ है, यदि फ़ाइल उसी निर्देशिका में नहीं है जो शेल में खुला है) जिसमें कार्यक्षेत्र है। उस कार्यस्थान फ़ाइल को एक स्पष्ट कार्यक्षेत्र खोलकर, टाइप करके )ed apl_stock_farmer, ऊपर दिए गए कोड को चिपकाकर और फिर एक करके प्राप्त किया जा सकता है )save <path>। अगर यह आसान होगा तो मैं यह कार्यक्षेत्र फ़ाइल भी प्रदान कर सकता हूँ।

-script केवल एक तर्क है जो dyalog दिए गए कोड को निष्पादित करता है और वास्तव में REPL को खोले बिना stdout में प्रिंट करता है।

दुर्भाग्य से, मुझे इसे विंडोज सीएमडी या पॉवर्सशेल के साथ काम करने का तरीका नहीं मिला है, इसलिए मैंने इसे गिट बैश का उपयोग करके चलाया। मुझे यकीन नहीं है कि इस बॉट को प्रतियोगिता में लाना कितना संभव है, लेकिन मुझे यह पोस्ट पसंद है कि इसे पोस्ट न करें।

Comments

क्षमा करें, मेरे पास केवल Dyalog APL का अपंजीकृत संस्करण है, इसलिए मुझे यकीन नहीं है कि यह प्रतियोगिता में प्रवेश के रूप में काम करेगा

— Beta Decay

@BetaDecay मैं समझता हूं, वहां कोई समस्या नहीं है। मुझे यह भी पता चला कि आप इस कोड को चलाने के लिए Pynapl लाइब्रेरी का उपयोग कर सकते हैं । विवरण "पायथन से एपीएल तक पहुंच" के तहत हैं, विशेष रूप से "पायथन का उपयोग करके एक परंपरा को परिभाषित करना", और यह बहुत सीधा दिखता है।

— जे। सेले

Answer 14

अनपढ़ लाभांश निवेशक

import random
from sys import argv

price = float(argv[1])
shares = int(argv[2])
cash = float(argv[3])
round = int(argv[4])

# buy 1st round, sell last round
if round == 1:
    print('b' + str(int((cash + 1000) / price)))
elif round == 1000:
    print('s' + str(shares))

# round right before dividend: sell
elif round % 5 == 4:
    print('s' + str(shares))

# 1 round after dividend: buy
elif round % 5 == 0:
    print('b' + str(int((cash + 1000) / price)))

# 2 rounds after dividend: 50/50 sell/try to buy
elif round % 5 == 1:
    if random.random() < 0.5:
        print('s' + str(shares))
    else:
        print('b' + str(int((cash + 1000) / price)))

# 3 rounds after dividend: sell if own shares (didn't sell last round), else buy
elif round % 5 == 2:
    if shares > 0:
        print('s' + str(shares))
    else:
        print('b' + str(int((cash + 1000) / price)))

# otherwise, 4 rounds after dividend, buy
else:
    print('b' + str(int((cash + 1000) / price)))

लाभांश के बाद, लोगों के पास अधिक नकदी है, इसलिए उन्हें खरीदने की अधिक संभावना होगी। लाभांश से ठीक पहले बेचता है, उसके ठीक बाद खरीदता है। अन्य 3 राउंड में एक दूसरे को बेचने / खरीदने के चक्र के माध्यम से जाता है।

Comments

नियंत्रक को देखते हुए, लाभांश 4 वें के बाद हर दौर का भुगतान करता है, न केवल हर 5 वें दौर में। आपका चक्र अभी भी काम करना चाहिए, लेकिन शायद जैसा आपने इरादा नहीं किया था।

— Veskah

यदि आप अन्य लोगों को खरीदने के बाद खरीदते हैं तो अधिक महंगा होने पर आपको खरीदना बंद कर देते हैं।

— f --n 21tɪk

धन्यवाद @Veskah कुछ r1 / r1000 तर्क में भी जोड़ना था।

— bri_t

@ f @n thetɪk - मान लें कि लोग लाभांश के बाद गोल खरीदते हैं, तो आप भी उस दौर को खरीदना चाहेंगे और फिर बाद में बेचेंगे, नहीं?

— 21

डिविडेंड के बाद कोई राउंड भी नहीं होता है क्योंकि आपको 4 र के बाद हर राउंड में डिविडेंड मिलता है।

— f --n 21tɪk 21

Answer 15

जितना संभव हो उतना खरीदें / पुनर्निवेश!

मेरे डॉलर-कॉस्ट एवेरजेर के समान, आश्चर्यजनक रूप से, काफी औसत, यह प्रत्येक दौर को खरीदता है जितने शेयर सस्ते होते हैं और केवल उन्हें अंतिम दौर में बेचते हैं।

from sys import argv

share_price = int(argv[1])
share_count = int(argv[2])
balance = float(argv[3])
round = int(argv[4])


if round < 1000:
    if balance > share_price-1000:
        buy_count = int((balance+1000)/share_price)
        print("b"+str(buy_count))
    else:
        print("b0")
else:
    print("s" + str(share_count))

Comments

अरे, आपको यहाँ अपने इंडेंटेशन के साथ एक त्रुटि मिली है। आपको if balance > share_price-1000:ब्लॉक इंडेंट करने का मतलब था या नहीं?

— बीटा

हाँ। मेरे छोटे से संपादन ने मेरे स्वरूपण को बाधित कर दिया है। एक पीसी पर I'mback जैसे ही ठीक कर देंगे

— Barbarian772

Answer 16

Novice Broker (लेकिन मूल विचार प्राप्त करता है)

se_stock_exchange.rb:

DATA_FILE = $0.sub /\.rb$/, ".data"
NUM_ROUNDS = 1000

share_price, num_shares, money, round = ARGV.map &:to_i

order = "s0"

if round == NUM_ROUNDS
  puts "s#{num_shares}"
  exit
end

if File.exists? DATA_FILE
  last_price, trend, bought_price = File.read(DATA_FILE).lines.map &:to_i
else
  last_price = 0
  trend = -1
  bought_price = 0
end

if (new_trend = share_price <=> last_price) != trend
  case trend
  when -1
    order = "b#{(money + 1000) / share_price}"
    bought_price = [bought_price, share_price].max
  when 1
    if share_price > bought_price
      order = "s#{num_shares}"
      bought_price = 0
    end
  end
  trend = new_trend
end

File.open(DATA_FILE, "w") { |f| f.puts share_price, trend, bought_price }

puts order

जब तक कीमत घूमती है, तब तक इंतजार करती है, फिर सब कुछ खरीदती / बेचती है। मेरा मतलब है, कि डमीज ^{नोट के} लिए डे ट्रेडिंग में ऐसा करने के लिए कहते हैं ^{: यह शायद एक वास्तविक पुस्तक है, और शायद यह कुछ ऐसा है जो किसी से मिल सकता है} ।

में डेटा बचाता है se_stock_exchange.data। साथ चलाएं ruby se_stock_exchange.rb ${SHARE_PRICE} ${SHARES} ${MONEY} ${ROUND}(उपयुक्त मानों को प्रतिस्थापित करते हुए)।

Comments

यह KotH पर मेरा पहला छुरा है, इसलिए मुझे बताएं कि क्या मैं यह सब गलत कर रहा हूं।

— Inotnotmaynard

नाइस: amazon.co.uk/Day-Trading-Dummies-Ann-Logue/dp/047094272X

— Beta Decay

मुझे यह त्रुटि मिलती है:se_stock_exchange.rb:24:in `<main>': undefined method `+' for nil:NilClass (NoMethodError)

— एर्ग आउटफोलर

@ बेताडे: लेखक का मध्य नाम 'ए' से शुरू नहीं होता।

— 3D1T0R

@NieDzejkob: यदि यह एक 'ए' थे: "एन ए लॉग" है अनुरूप करने के लिए " एनालॉग "।

— 231 में 3D1T0R

Answer 17

आधा अधिक या कुछ भी नहीं

def run(price, shares, balance, cur_round):
    if cur_round==1000:
        print('s'+str(int(shares)))
        return

    if cur_round==1:
        with open('HalfMoreOrNothing.dat', 'w') as f:
            f.write(str(int(price)))
        print('b'+str(int((balance+1000)/price)))
        return

    if shares==0:
        with open('HalfMoreOrNothing.dat', 'w') as f:
            f.write(str(int(price)))
        print('b'+str(int((balance+1000)/price)))
        return

    with open('HalfMoreOrNothing.dat', 'r') as f:
        bought_price=int(f.read())
    if price>=bought_price*1.5:
        print('s'+str(int(shares)))
        return

    print('b0')

if __name__ == '__main__':
    import sys
    run(*[float(x) for x in sys.argv[1:]])

मैं शायद ही कभी पायथन का उपयोग करता हूं, मुझे बताएं कि क्या यह कहीं त्रुटि उत्पन्न करता है।

रणनीति तब तक इंतजार करना है जब तक शेयर की कीमत कीमत के मुकाबले कम से कम 50% बड़ी हो, तब उन्हें बेच दें, फिर तुरंत नए शेयर खरीद लें ताकि वह नए शेयर की कीमत बढ़ाने का इंतजार कर सके।

उम्मीद है, लोग चिंपेज़ को अंत तक शेयर बेचना शुरू नहीं करेंगे ... (ऐसा लगता है कि ज्यादातर बॉट सही समय का इंतजार करते हैं, जो भी हो)

Answer 18

फाइबोनैचि

मैंने चीज़ों को आसान बनाने के लिए पायथन 3 में इसे फिर से लिखा है। उम्मीद है कि!

import math
from sys import argv

price = float(argv[1])
shares = int(argv[2])
balance = float(argv[3])
roundNum = int(argv[4])

fibonacci = [2,3,5,8,13,21,34,55,89,144,233,377,610,987]
if (roundNum == 1):
    buy = int((balance+1000)/price)
    print('b' + str(buy))
elif (roundNum in fibonacci) and roundNum % 2 == 1 and balance > 0:
    buy = int((balance/price)/2)
    print('b' + str(buy))
elif ((roundNum in fibonacci) and roundNum % 2 == 0) or roundNum % 100 == 0:
    if (roundNum == 1000):
        sell = shares
        print('s' + str(sell))
    else:
        sell = math.ceil(shares/2)
        print('s' + str(sell))
else:
    print('b0')

यह आधे से अधिक शेयरों की खरीद करता है जो कि सस्ती होती है जब गोल एक विषम फाइबोनैचि संख्या के बराबर होता है और उपलब्ध शेयरों में से आधे तब बेचता है जब गोल एक समान फाइबोनैचि संख्या के बराबर होता है और प्रत्येक 100 राउंड भी। 1000 पर सभी शेयर बेचता है। अन्यथा, यह बस इंतजार करता है। बैलेंस पॉजिटिव होने पर ही शेयर खरीदते हैं।

Comments

अरे, मुझे त्रुटि मिलती हैError in roundNum%%2 : non-numeric argument to binary operator Execution halted

— बीटा डिके

@BetaDecay मैंने कोड को अपडेट किया जो समस्या को ठीक कर सकता है। मुझे बताएं।

— रॉबर्ट एस।

Answer 19

लालची बी ***** डी

# Gready one...
from sys import argv

SMA_PERIOD = 5
LAST_BUY_DAY = 985
LAST_SELL_DAY = 993

# Save an entry to the stock history
def save_history(price):
    with open('db.txt', 'a') as f:
        f.write(str(price) + '\n')

# Load the stock history
def load_history():
    with open('db.txt', 'r') as f:
        return [float(line.strip()) for line in f]

def get_sma(d, n):
    l = d[-n:]
    return int(sum(l) / len(l))


def buy(price, account):
    if account + 1000 > 0:
        print 'b' + str(int((account + 1000) / price))
        return
    print 'b0'

def sell(holdings):
    print 's'+ str(int(holdings))


def run(price, holdings, account, day):

    save_history(price)
    d = load_history()

    if price <= get_sma(d, SMA_PERIOD) and day < LAST_BUY_DAY:
        return buy(price, account)

    if price > get_sma(d, SMA_PERIOD):
        return sell(holdings)

    if day >= LAST_SELL_DAY:
        return sell(holdings)

    # Otherwise, do nothing    
    print 'b0'


run(*map(float, argv[1:]))  

वह सब तब चलेगा जब उसका सस्ता और दाम बढ़ने के बाद उसे सब बेच देगा ...

Comments

आपका कोड सभी जगह है। सबसे पहले, आप प्रिंट स्टेटमेंट वापस करते हैं, लेकिन आप तीन तर्क भी पास करते हैं sell()जिसमें केवल एक लेता है

— Beta Decay

तीनो के साथ टाइपो बेचने के लिए () ... अब प्रिंट स्टेटमेंट के साथ आपकी चिंता क्या है?

— एरक एस

बस वे अनावश्यक हैं

— बीटा डेके

कुछ वे पठनीयता के साथ मदद के लोगों का तर्क है

— Arek एस

आपने प्रिंट के कारण परिणामों में इसे शामिल नहीं किया? बिक्री में afaik टाइपो () परिभाषा यह काम करना बंद नहीं करेगा ... मैं उस तरह से ठीक कर रहा हूँ

— Arek S

Answer 20

तकनीकी विश्लेषण रोबोट

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

मुझे नहीं लगता कि यह तरीका बहुत अच्छा काम करेगा लेकिन चलो इसे आजमाएँ :)

import sys
from sys import argv

share_price = int(argv[1])
share_number = int(argv[2])
bank_account = float(argv[3])
round_number = int(argv[4])

max_buy_greedily = (1000 + bank_account) / share_price
minima = []

def log():
    f = open("log_technical_analysis.txt","a+")
    f.write("%d;" % share_price)

def analyze():
    f = open("log_technical_analysis.txt","r+")
    line = f.readline()
    values = line.split(";")
    values.pop()
    for i in range(len(values) - 1):
        if i > 0 and int(values[i-1]) > int(values[i]) and int(values[i+1]) > int(values[i]):
            minima.append(int(values[i]))
    if len(minima) >= 3 and minima[len(minima) - 1] > minima[len(minima) - 2] and minima[len(minima) - 2] > minima[len(minima) - 3]:
        print('b' + str(int(max_buy_greedily)))
    elif len(minima) >= 3 and minima[len(minima) - 1] < minima[len(minima) - 2] and minima[len(minima) - 2] < minima[len(minima) - 3]:
        print('s' + str(share_number))
    else:
        print('b0')

if round_number >= 994:
    print('s' + str(share_number))
    sys.exit(0)

if share_price <= 15:
    print('b' + str(int(max_buy_greedily)))
    log()
    sys.exit(0)

log()
analyze()
sys.exit(0)

पायथन 3 के साथ परीक्षण किया गया

Comments

सौभाग्य! यह एक सामान्य बाजार से दूर है: D

— Beta Decay

@BetaDecay haha ​​हाँ:] लेकिन आप सोच रहे होंगे कि अधिकांश लोग शेयर बाजार (या बिटकॉइन) में अपना पैसा कैसे खर्च करते हैं: D

— Solenya

Answer 21

भाग्यशाली संख्या 6

संपादित करें: ओह, मुझे लगता है कि मुझे इंट को बेचने की गिनती में परिवर्तित नहीं करना मेरी समस्याओं में से एक था, यहाँ हम फिर से जाते हैं।

शायद मेरा आखिरी योगदान, जब तक कि मैं काम से ऊब नहीं गया हूं और कुछ और अधिक परिष्कृत कर रहा हूं, लेकिन मैं गिर गया जैसे परिष्कृत बॉट पहले से ही niches को भरते हैं।

यह लड़का मूल रूप से हर 6 राउंड में अपने कुछ शेयर बेचता है, क्योंकि हे 6 उसका भाग्यशाली नंबर है।

from sys import argv
import random

share_price = int(argv[1])
share_count = int(argv[2])
balance = float(argv[3])
round = int(argv[4])
x = random.uniform(1,2)

if round == 1 or round == 1000:
    print("s"+str(share_count))
elif round % 6 == 0 and share_price >= 10:
    sell = int(share_count/x)
    print("s"+str(sell))
elif balance > share_price-1000:
    buy_count = int((balance+1000)/share_price)
    print("b"+str(buy_count))
else:
    print("b0")