ประกาศ:ความท้าทายนี้ปิดแล้ว: ฉันจะไม่อัปเดตกระดานผู้นำอีกต่อไปและจะไม่เปลี่ยนคำตอบที่ยอมรับได้ อย่างไรก็ตามคุณมีอิสระในการใช้งานคอนโทรลเลอร์และอัปเดตกระดานผู้นำด้วยตัวเองหากคุณต้องการ

เข้าร่วมการแชท!

บทนำ

สวัสดีตอนเย็นเทรดเดอร์! คุณเป็นเทรดเดอร์ทั้งหมดสำหรับ บริษัท กอล์ฟ PPCG งานของคุณคือทำเงินให้ได้มากที่สุด

ท้าทาย

เขียนโปรแกรมที่ซื้อและขายหุ้นในตลาดหลักทรัพย์ Exchange โดยมีจุดประสงค์เพื่อสร้างรายได้ให้มากที่สุด

เพลย์

ผู้เล่นทุกคนจะเริ่มต้นด้วย 5 หุ้นและ $ 100 ในธนาคารของพวกเขา เกมเริ่มต้นด้วยราคาหุ้น $ 10 เสมอ

แต่ละเกมจะมี 1000 1รอบที่รอบแรกเป็นรอบ ในแต่ละรอบโปรแกรมของคุณจะให้ข้อโต้แย้งสี่ข้อเป็นอินพุท: ราคาหุ้นปัจจุบันจำนวนหุ้นที่คุณถือจำนวนเงินที่คุณเป็นเจ้าของและจำนวนรอบ (ดัชนี 1 รายการ)

ตัวอย่างเช่นหากโปรแกรมของฉันคือtest1.pyราคาหุ้น100จำนวนหุ้นที่ฉันถืออยู่คือ3จำนวนเงินที่ฉันมี1200และจำนวนรอบคือ576โปรแกรมของฉันจะทำงานดังนี้:

python test1.py 100 3 1200 576

ในรอบราคาหุ้นที่ให้กับผู้เล่นแต่ละคนจะเท่ากัน สิ่งนี้จะไม่เปลี่ยนแปลงจนกว่าจะหมดรอบ

ในการตอบสนองผู้เล่นจะต้องพิมพ์คำสั่งของพวกเขา มีสองตัวเลือก:

• สิทธิการซื้อหุ้น: คำสั่งนี้จะได้รับเป็นbnที่nคือจำนวนหุ้นที่คุณต้องการที่จะซื้อ ตัวอย่างเช่นหากคุณต้องการซื้อ 100 หุ้นคุณจะได้ผลลัพธ์:

b100

เมื่อซื้อหุ้นคุณอนุญาตให้มีวงเงินเบิกเกินบัญชีสูงถึง $ 1,000 หากคุณพยายามที่จะซื้อหุ้นที่มากเกินกว่าเงินเบิกเกินบัญชีนี้ (ยอดเงินธนาคารของคุณต่ำกว่า $ -1000) คุณจะถูกล้มละลาย ซึ่งหมายความว่าคุณจะสูญเสียหุ้นทั้งหมดและยอดคงเหลือของคุณจะถูกตั้งไว้ที่ $ 50

ราคาหุ้นจะไม่ได้รับผลกระทบจากคำสั่งของคุณหากคุณล้มละลาย

(หากยอดเงินของคุณคือ $ -1000 คุณจะไม่ล้มละลายอย่างไรก็ตามหากยอดเงินของคุณคือ $ -1001 คุณจะล้มละลาย)

• ขายหุ้น: คำสั่งนี้จะได้รับตามsnที่nเป็นจำนวนหุ้นที่คุณต้องการขาย ตัวอย่างเช่นหากคุณต้องการขาย 100 หุ้นคุณจะได้ผลลัพธ์:

s100

คุณไม่สามารถขายหุ้นได้มากกว่าที่คุณเป็นเจ้าของ หากคุณพยายามทำเช่นนี้คำขอของคุณจะถูกปฏิเสธและคุณจะข้ามรอบ

หากคุณต้องการที่จะข้ามรอบและทำอะไรออกอย่างใดอย่างหนึ่งหรือb0s0

คำขอของคุณจะถูกปฏิเสธหากคุณพยายามซื้อหรือขายจำนวนหุ้นที่ติดลบและ / หรือจำนวนหุ้นที่ไม่ใช่จำนวนเต็ม

หลังจาก 5 รอบในตอนท้ายของแต่ละรอบผู้เล่นทุกคนจะได้รับการจ่ายเงินปันผลมูลค่าซึ่งเท่ากับ 5% ของราคาเฉลี่ยเฉลี่ยของ 5 รอบสุดท้าย

มันทำงานยังไง?

ในขั้นแรกราคาหุ้นจะเท่ากับ $ 10 ในตอนท้ายของแต่ละรอบจะมีการคำนวณใหม่โดยใช้สูตร:

ราคาหุ้นจะถูก จำกัด เพื่อไม่ให้ต่ำกว่า $ 1

เพื่อป้องกันการเปลี่ยนแปลงอย่างรวดเร็วมากเกินไปการเปลี่ยนแปลงราคาหุ้นจะถูก จำกัด ไว้ที่สูงสุด$\pm$200$

กฎระเบียบ

• โปรแกรมของคุณต้องมีชื่อ

• โปรแกรมของคุณได้รับอนุญาตให้ใช้ไฟล์ข้อความเดียวสำหรับการจัดเก็บข้อมูล จะต้องเก็บไว้ในโฟลเดอร์เดียวกับโปรแกรมของคุณ

• รวมไว้ในรายละเอียดคำตอบเกี่ยวกับวิธีการเรียกใช้โปรแกรมของคุณ

• KotH นี้เปิดให้ทุกภาษาโปรแกรมที่ใช้งานได้ฟรีและสามารถใช้งานได้บน Windows 10

• คะแนนของคุณขึ้นอยู่กับเนื้อหาของยอดคงเหลือของคุณเท่านั้น เงินใด ๆ ที่ถูกล็อคไว้ในหุ้นจะไม่ถูกนับ

• คุณสามารถแก้ไขโปรแกรมได้ตลอดเวลา ก่อนแต่ละเกมรหัสล่าสุดจะถูกบันทึกและรวบรวม

• คุณไม่ควรเขียนโค้ดที่กำหนดเป้าหมายไปที่บ็อตอื่นโดยเฉพาะ

ตัวควบคุม

คอนโทรลเลอร์เขียนด้วย Python และอยู่ที่นี่: 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

ดูกราฟของผู้แข่งขันแต่ละคน

_{ที่เกี่ยวข้องแต่การเล่นเกมและเกณฑ์การชนะแตกต่างกันมากกับความท้าทายนี้}

คนโลภที่มีประสบการณ์

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

เวอร์ชัน "The Greedy Idiot" ที่ได้รับการอัพเดตพร้อมการปรับโครงสร้างพฤติกรรมและแก้ไขข้อผิดพลาดที่เกี่ยวข้องกับการทำงานกับตัวเลขจำนวนมาก

หมายเหตุ:

• บันทึกในไฟล์และเรียกใช้ดังนี้: php C:\path\path\stack_exchange.php 10 5 100 1
• สคริปต์นี้สร้างไฟล์ข้อความที่มีชื่อเดียวกับไฟล์สคริปต์และ.txtต่อท้าย ดังนั้นโปรดเรียกใช้กับผู้ใช้ที่มีสิทธิ์เขียนที่เหมาะสมบนเส้นทางสคริปต์
• วิธีการติดตั้ง PHP 7.2 อย่างง่ายบน windows: http://www.dorusomcutean.com/how-to-install-php-7-2-on-windows/
• ในการทำงานกับจำนวนที่มากเป็นพิเศษฉันต้องใช้GMPดังนั้นจึงphp.iniควรยกเลิกการแสดงความคิดเห็นสองบรรทัดนี้(เซมิโคลอนที่จุดเริ่มต้นของบรรทัดควรถูกลบออกหากยังไม่ได้ทำ):
  • ; extension_dir = "ext"
  • ;extension=gmp

ชิมแปนซีบนเครื่องพิมพ์ดีด

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 ด้วย

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)

ตามคำพูดเดิมของ "เป็นเจ้าของอายุของคุณในพันธบัตร" โปรแกรมนี้พยายามที่จะทำเช่นเดียวกัน วิธีนี้เราไม่ต้องเผชิญกับความผันผวนของตลาดในช่วงท้ายเกม

แก้ไข:มองไปที่คอนโทรลเลอร์แสดงว่าเราสามารถซื้อ / ขายหุ้นเต็มเท่านั้น แต่สามารถมียอดคงเหลือในบัญชีเศษส่วน

Lone Accountant

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เลย

ในรอบคี่มันจะซื้อหุ้นให้มากที่สุดเท่าที่จะทำได้ ในรอบแม้จะขายหุ้นทั้งหมด

ความตั้งใจคือการเพิ่มราคาหุ้นโดยการซื้อหุ้นให้ได้มากที่สุดก่อนจากนั้นจึงขายหุ้นเหล่านั้นเพื่อรับเงินมากขึ้น มันใช้งานได้เพราะรอบสุดท้ายคือเท่ากัน (รอบ 1,000)

แม้ว่าราคาหุ้นจะยังคงเหมือนเดิม ( 5) หลังจากแต่ละรอบของคู่ (สมมติว่า ธ ปท. เป็นคนเดียวดังนั้นLone Accountant ) ความสมดุลของบอทเพิ่มขึ้นเนื่องจากราคาขายสูงกว่าราคาซื้อและความสมดุลมากขึ้นนำไปสู่ ความสามารถในการซื้อหุ้นเพิ่มเติม มันเป็นวงจรอุบาทว์ แต่เป็นวิธีที่ดี (สำหรับฉัน)

ช่องโหว่ที่สำคัญนั้นมาพร้อมกับบ็อตชั่วร้ายที่เล่นเคียงข้างกันขายเพื่อลดราคาหุ้น (ไม่แน่ใจว่ามันดีสำหรับพวกเขาเช่นกัน) ในกรณีนี้บอตอาจยังคงมียอดคงเหลืออยู่ที่ $ -890 หากมีบอทชั่วร้ายเพียงพอ นักบัญชีคนนี้ต้องการความสงบของจิตใจจริงๆ ;-)

ผู้ซื้อขายประจำ

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 (ไม่มีเงินเบิกเกินบัญชีสำหรับ fella นี้เขาไม่ gunna ทำให้ตัวเองเป็นหนี้เพื่อผลกำไรเล็ก ๆ น้อย ๆ ) แล้วนั่งรอบ ๆ เพื่อให้การสร้างเงินปันผล

รันด้วย python3 แต่ควร (?) ทำงานกับ python2 ด้วย

ร้อยละผู้ซื้อขาย Python3

(อาจทำงานได้ใน 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
• ทำงานด้วย python filename.py ราคา #shares balance round #

มันทำงานอย่างไร

• รอบแรก ธ ปท. จะซื้อหุ้นให้ได้มากที่สุด
• หากราคาเพิ่มขึ้นบอทจะขายหุ้นที่เท่ากับเปอร์เซ็นต์ของราคาที่เพิ่มขึ้น (คำนวณจากมูลค่าใหม่)
• หากราคาลดลงบ็อตจะซื้อเปอร์เซ็นต์ของหุ้นสูงสุดที่สามารถซื้อได้เท่ากับราคาที่ลดลง (คำนวณจากมูลค่าก่อนหน้า)
• ขายทุกอย่างในรอบ 1,000

หวังว่าการเปลี่ยนแปลงควรขจัดปัญหาที่เกิดจากการแบ่งจุดลอยตัว

นักสถิติชาวNaïve

สร้างขึ้นสำหรับ Python 3 อาจทำงานใน Python 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:]))

นี่คือนักสถิติไร้เดียงสาที่พยายามคาดการณ์ราคาหุ้นโดยการซื้อ / ขายเท่านั้นหากราคาปรับตัวสูงขึ้น / ลดลงนานกว่าปกติขณะเดียวกันก็ซื้อหุ้นด้วยหากราคาลดลงเหลือเพียงหนึ่งและขายหุ้นทั้งหมดในรอบสุดท้าย

ค่าเงินดอลลาร์เฉลี่ย

(ทดสอบด้วย Python 3.7)

โพสต์ครั้งแรกใน codegolf ดังนั้นบอกฉันว่าฉันทำอะไรผิด

แนวคิดพื้นฐานคือการซื้อหนึ่งหุ้นในแต่ละรอบหากเป็นไปได้และขายหุ้นทั้งหมดในตอนท้าย

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

ควอไลเซอร์

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

จัดสรรทรัพยากรทางการเงินอย่างเท่าเทียมกันระหว่างเงินสดและหุ้นในทุก ๆ รอบยกเว้นรอบสุดท้าย ผมเชื่อว่ากลยุทธ์นี้จะเป็นวิธีที่เสียงทางคณิตศาสตร์ในการทำอย่างน้อยบางส่วนเงิน แต่ผมอาจจะพิสูจน์ความผิด

อาจมีหรือไม่มีข้อบกพร่องที่ฉันไม่ได้จับ ยังเล่นกอล์ฟบ้าง

Monkeys บนเครื่องพิมพ์ดีด

import random

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

มันเป็นพวงของลิงบนเครื่องพิมพ์ดีด ขายหรือซื้อหุ้น X แบบสุ่มโดยที่:
0 <= X <= 1,000,000

รันด้วย python3 แต่ควร (?) ทำงานกับ python2 ด้วย

ซื้อต่ำ

(Python 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:]])

นักพนันที่เข้าใจผิด

(Python 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:]])

APL ชาวนา (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 ที่ซื้อหุ้นที่เป็นไปได้ทั้งหมดในรอบแรกและขายเฉพาะเมื่อราคาหุ้นปัจจุบันสูงกว่าราคาที่ซื้อ หลังการขายบ็อตจะซื้อเฉพาะหุ้นที่ถูกกว่าราคาที่ขายครั้งสุดท้ายเท่านั้น

นั่นเป็นเพราะนักบัญชีของเกษตรกรบอกเขาว่าเป็นวิธีการซื้อขายหุ้น "ซื้อต่ำขายสูง" และทุกอย่างนั้น

คำปฏิเสธ

นี่เป็นความพยายามครั้งแรกของฉันที่ความท้าทาย KotH และเนื่องจากโดยทั่วไปฉันทำเฉพาะ APL ที่นี่ฉันจึงตัดสินใจดำเนินการต่อไป

ที่กล่าวว่าฉันไม่แน่ใจว่าจะสามารถทำงานร่วมกับบ็อตอื่น ๆ ได้หรือไม่เนื่องจากเป็น Tradfn และไม่สามารถป้อนเข้าสู่เชลล์ CMD / Bash ได้โดยตรง

ดังนั้นหากต้องการรันสิ่งนี้ใน Bash คุณต้องมีคำสั่งต่อไปนี้:

$ 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 รันโค้ดที่กำหนดและพิมพ์ไปยัง stdout โดยไม่ต้องเปิด REPL

น่าเสียดายที่ฉันไม่พบวิธีที่จะทำงานกับ Windows CMD หรือ Powershell ดังนั้นฉันจึงใช้ Git Bash ฉันไม่แน่ใจว่าจะเป็นไปได้อย่างไรที่จะนำบอทนี้ไปแข่งขัน แต่ฉันชอบโค้ดนี้มากเกินไปที่จะไม่โพสต์มัน

นักลงทุนที่ไม่รู้หนังสือ

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 รอบ

ซื้อ / ลงทุนใหม่ให้มากที่สุด!

เช่นเดียวกับ Dollar Averager ของฉันที่ทำโดยเฉลี่ยแล้วค่อนข้างน่าแปลกใจที่ซื้อในแต่ละรอบให้มากที่สุดเท่าที่จะทำได้และขายได้ในรอบสุดท้ายเท่านั้น

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

นายหน้าสามเณร (แต่รับแนวคิดพื้นฐาน)

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

รอจนกว่าราคาจะกลับมาแล้วซื้อ / ขายทุกอย่าง ผมหมายถึงว่าเป็นสิ่งที่มันบอกว่าจะทำอย่างไรในวันซื้อขายวันสำหรับ Dummies ^{หมายเหตุ:} นี้น่าจะเป็นหนังสือจริงและนั่นอาจจะเป็นสิ่งที่บางคนอาจจะได้รับจากมัน

se_stock_exchange.dataบันทึกข้อมูลใน ทำงานด้วยruby se_stock_exchange.rb ${SHARE_PRICE} ${SHARES} ${MONEY} ${ROUND}(แทนค่าที่เหมาะสม)

ครึ่งหนึ่งมากกว่าหรือไม่มีอะไรเลย

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

ฉันไม่ค่อยได้ใช้ Python บอกให้ฉันรู้ว่ามันเกิดข้อผิดพลาดที่ไหนสักแห่ง

กลยุทธ์คือการรอจนกว่าราคาหุ้นจะสูงกว่าราคาอย่างน้อย 50% ในขณะที่พวกเขาขายแล้วขายทันทีจากนั้นซื้อหุ้นใหม่ทันทีเพื่อรอการขึ้นราคาใหม่

หวังว่าผู้คนจะไม่ยอมขายหุ้นใกล้จะจบ ... (ดูเหมือนว่าบอทส่วนใหญ่จะรอช่วงเวลาที่เหมาะสมไม่ว่าจะเป็นอะไรก็ตาม)

fibonacci

ฉันเขียนมันใหม่ใน Python 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 รอบ ขายหุ้นทั้งหมดในรอบ 1,000 มิฉะนั้นจะรอ ซื้อหุ้นเมื่อยอดเงินเป็นบวกเท่านั้น

โลภ B ***** d

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

เขาจะเข้าไปข้างในเมื่อมันถูกและขายหมดเมื่อราคาสูงขึ้น ...

หุ่นยนต์วิเคราะห์ทางเทคนิค

ฉันศึกษาเศรษฐศาสตร์ธุรกิจดังนั้นฉันจึงพยายามตระหนักถึงวิธีที่ง่ายที่สุดในการวิเคราะห์ตลาดหุ้น (การวิเคราะห์ทางเทคนิค) ตามทฤษฎีคุณต้องวิเคราะห์ค่าต่ำสุดของกราฟทั้งหมดเพื่อดูว่ามีแนวโน้มหรือไม่ ในช่วงเทรนด์ขาขึ้นคุณต้องซื้อและในช่วงขาลงคุณต้องขาย

ฉันไม่คิดว่าวิธีนี้จะใช้งานได้ดี แต่ลองทำดู :)

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)

ทดสอบกับ python3

นำโชคเลข 6

แก้ไข: โอ้ ffs ฉันคิดว่าฉันไม่ได้แปลงจำนวนการขายเป็น int เป็นหนึ่งในปัญหาของฉันที่นี่เราไปอีกครั้ง

อาจมีส่วนร่วมครั้งสุดท้ายของฉันจนกว่าฉันจะเบื่อในการทำงานและทำบางสิ่งบางอย่างที่ซับซ้อนมากขึ้น แต่ฉันก้มเหมือนบอทที่ซับซ้อนแล้วกรอกซอก

โดยทั่วไปผู้ชายคนนี้ขายหุ้นของเขาบางส่วนทุก 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")