PEMBERITAHUAN: Tantangan ini sekarang sudah ditutup: Saya tidak akan lagi memperbarui papan peringkat dan tidak akan mengubah jawaban yang diterima. Namun, Anda bebas menjalankan controller dan memperbarui sendiri leaderboard, jika diinginkan.

Bergabunglah dengan obrolan!

pengantar

Selamat malam, pedagang! Anda semua adalah pedagang untuk perusahaan golf PPCG. Tugas Anda adalah menghasilkan uang sebanyak mungkin.

Tantangan

Tulis sebuah program yang membeli dan menjual saham di Stack Exchange Stock Exchange dengan tujuan menghasilkan uang sebanyak mungkin.

Gameplay

Semua pemain akan mulai dengan 5 saham dan $ 100 di bank mereka. Permainan selalu dimulai dengan harga saham $ 10.

Setiap permainan akan memiliki 1000 putaran di mana babak pertama adalah putaran 1. Dalam setiap putaran, program Anda akan diberikan empat argumen sebagai input: harga saham saat ini, jumlah saham yang Anda miliki, jumlah uang yang Anda miliki dan jumlah putaran (1-diindeks).

Misalnya, jika program saya adalah test1.py, harga sahamnya 100, jumlah saham yang saya pegang 3, jumlah uang yang saya miliki 1200, dan angka bulatnya 576, program saya akan dijalankan seperti ini:

python test1.py 100 3 1200 576

Dalam satu putaran, harga saham yang diberikan kepada masing-masing pemain akan sama. Ini tidak berubah sampai akhir putaran.

Sebagai tanggapan, pemain harus mencetak perintah mereka. Ada dua opsi:

• Beli saham: Perintah ini diberikan di bnmana njumlah saham yang ingin Anda beli. Misalnya, jika Anda ingin membeli 100 saham, Anda akan menampilkan:

b100

Saat membeli saham, Anda diizinkan cerukan hingga $ 1000. Jika Anda mencoba membeli saham yang melebihi cerukan ini (saldo bank Anda di bawah $ -1000), Anda akan dinyatakan pailit. Ini berarti bahwa Anda akan kehilangan semua saham Anda dan saldo Anda akan ditetapkan menjadi $ 50.

Harga saham tidak akan terpengaruh oleh perintah Anda jika Anda bangkrut.

(Jika saldo Anda $ -1000, Anda tidak bangkrut. Namun jika saldo Anda $ -1001, Anda bangkrut)

• Jual saham: Perintah ini diberikan di snmana njumlah saham yang ingin Anda jual. Misalnya, jika Anda ingin menjual 100 saham, Anda akan menampilkan:

s100

Anda tidak boleh menjual lebih banyak saham daripada yang Anda miliki. Jika Anda mencoba melakukan ini, permintaan Anda akan ditolak, dan Anda akan melewatkan putaran.

Jika Anda ingin melewatkan putaran dan tidak melakukan apa pun, output salah satu b0atau s0.

Permintaan Anda akan ditolak jika Anda mencoba membeli atau menjual sejumlah saham negatif dan / atau jumlah saham non-integer.

Setelah 5 putaran, pada akhir setiap putaran, semua pemain akan dibayar dividen, nilainya 5% dari rata-rata harga saham dari 5 putaran terakhir.

Bagaimana cara kerjanya?

Awalnya harga saham akan menjadi $ 10. Pada akhir setiap putaran, itu akan dihitung ulang menggunakan rumus:

Harga saham akan terbatas sehingga tidak pernah jatuh di bawah $ 1.

Untuk mencegah perubahan yang terlalu cepat, perubahan harga saham dibatasi hingga maksimum .$\pm$200$

Aturan

• Program Anda harus memiliki nama

• Program Anda diperbolehkan satu file teks untuk penyimpanan data. Itu harus disimpan dalam folder yang sama dengan program Anda

• Masukkan rincian jawaban Anda tentang cara menjalankan program Anda

• KotH ini terbuka untuk semua bahasa pemrograman yang bebas digunakan dan dapat dijalankan di Windows 10

• Skor Anda hanya didasarkan pada isi saldo Anda. Uang yang dikunci dalam saham tidak akan dihitung

• Anda dapat mengedit program Anda kapan saja. Sebelum setiap pertandingan, kode terbaru akan disimpan dan dikompilasi

• Anda tidak boleh menulis kode yang secara khusus menargetkan bot lain.

Pengendali

Pengontrol ditulis dalam Python dan dapat ditemukan di sini: https://gist.github.com/beta-decay/a6abe40fc9f4ff6cac443395377ec31f

Pada akhirnya itu akan mencetak papan peringkat dan menampilkan grafik tentang bagaimana harga saham berubah sepanjang permainan.

Misalnya, ketika dua bot acak diputar

Kemenangan

Pemain dengan jumlah uang tertinggi dalam saldo mereka pada akhir pertandingan terakhir menang.

Papan peringkat

Game 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

Lihat grafik masing-masing kontestan

_{Terkait tetapi gameplay dan kriteria kemenangan sangat berbeda dengan tantangan ini.}

Idiot Greedy yang berpengalaman

PHP, diuji pada PHP> = 7, harus bekerja pada yang sebelumnya juga.

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

Versi terbaru "The Greedy Idiot" dengan perilaku terstruktur dan perbaikan bug yang terkait dengan bekerja dengan jumlah besar.

Catatan:

• Simpan dalam file dan jalankan seperti ini: php C:\path\path\stack_exchange.php 10 5 100 1
• Skrip ini membuat file teks dengan nama yang sama dengan file skrip dan .txtditambahkan ke akhir. Jadi silakan jalankan dengan pengguna dengan izin menulis yang sesuai di jalur skrip.
• Cara mudah menginstal PHP 7.2 di windows: http://www.dorusomcutean.com/how-to-install-php-7-2-on-windows/
• Untuk bekerja dengan angka yang sangat besar, saya harus menggunakan GMP , jadi dua baris ini php.iniharus tidak dikomentari (titik koma pada awal baris harus dihapus, jika belum):
  • ; extension_dir = "ext"
  • ;extension=gmp

Simpanse Pada Mesin Ketik

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

Simpanse lebih pintar daripada monyet, mereka tidak akan membeli saham yang tidak mampu mereka beli, atau menjual saham yang tidak mereka miliki.

Namun masih cukup acak.

Jalankan dengan python3, tetapi seharusnya (?) Bekerja dengan python2 juga

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)

Mengikuti pepatah lama "miliki umur Anda dalam ikatan," program ini mencoba melakukan hal yang sama. Dengan cara ini kita tidak akan terpengaruh oleh volatilitas pasar di akhir pertandingan.

Sunting: Melihat controller itu menunjukkan bahwa kita hanya dapat membeli / menjual saham penuh, tetapi dapat memiliki saldo akun fraksional.

Seorang akuntan yang sendirian

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

Tidak menyimpan apa pun di buy-sell.txt.

Dalam putaran aneh, ia membeli sebanyak mungkin saham. Bahkan dalam putaran, ia menjual semua sahamnya.

Tujuannya adalah untuk pertama-tama menaikkan harga saham dengan membeli sebanyak mungkin saham, dan kemudian menjual saham itu untuk mendapatkan lebih banyak uang. Ini berhasil karena babak final genap (putaran 1000).

Meskipun harga saham akan tetap sama ( 5) setelah setiap putaran (dengan asumsi bot itu sendiri, oleh karena itu Lone Accountant ), saldo bot meningkat, karena harga jual lebih tinggi dari harga beli, dan lebih banyak saldo mengarah ke kemampuan membeli lebih banyak saham. Ini adalah lingkaran setan, tetapi dengan cara yang baik (untuk saya).

Kerentanan utama datang dengan bot jahat bermain bersama, menjual untuk menurunkan harga saham (tidak yakin apakah itu baik untuk mereka juga). Dalam hal ini, bot mungkin tetap dengan saldo $ -890, asalkan ada cukup banyak bot jahat. Akuntan ini benar-benar menginginkan ketenangan pikiran. ;-)

Trader Pasif

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

Orang ini tidak besar dalam hal "saham" ini, tetapi dia mendengar bahwa jika dia hanya menghabiskan sedikit uang sekarang, dia akan mendapatkan sedikit uang dari waktu ke waktu yang akan menambah lebih dari yang dia belanjakan.

Dia akan membeli cukup stok untuk mencapai $ 0 (tidak ada cerukan untuk orang ini, dia tidak gunna menempatkan dirinya dalam hutang untuk sedikit keuntungan), kemudian duduk dan membiarkan dividen bertambah.

Jalankan dengan python3, tetapi seharusnya (?) Bekerja dengan python2 juga.

Persentase Trader Python3

(mungkin bekerja di 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))

Petunjuk menjalankan

• Simpan sebagai filename.py
• Jalankan dengan python filename.py price #shares balance round #

Bagaimana itu bekerja

• Babak pertama pembelian bot sebanyak saham yang mampu.
• Jika harga naik, bot menjual persentase saham yang sama dengan persentase kenaikan harga (dihitung dari nilai baru)
• Jika harga menurun, bot membeli persentase dari saham maksimum yang bisa dibelinya sama dengan persentase penurunan harga (dihitung dari nilai sebelumnya)
• Menjual semuanya di babak 1000

Perubahan diharapkan semoga menghilangkan masalah yang disebabkan oleh divisi floating point

Statistician Naïve

Dibuat untuk Python 3, mungkin berfungsi di 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:]))

Ini adalah ahli statistik yang naif yang mencoba memprediksi harga saham dengan hanya membeli / menjual jika harga telah naik / turun lebih lama dari biasanya, sementara juga membeli saham jika harganya turun ke satu dan menjual semua saham pada putaran terakhir.

Dollar Cost Averager

(diuji dengan Python 3.7)

Posting pertama di codegolf jadi katakan padaku jika aku melakukan sesuatu yang salah.

Ide dasarnya adalah membeli satu saham setiap putaran jika memungkinkan dan menjual semua saham pada akhirnya.

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

Equalizer

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

Partisi sumber keuangannya secara merata antara uang tunai dan saham di setiap putaran kecuali yang terakhir. Saya percaya strategi ini menjadi cara yang logis secara matematis untuk menghasilkan setidaknya sejumlah uang, tetapi saya mungkin terbukti salah.

Mungkin ada atau tidak ada bug yang belum saya tangkap. Juga agak golf.

Monyet Pada Mesin Ketik

import random

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

Ini sekelompok monyet di mesin tik. Menjual atau membeli saham X secara acak, di mana:
0 <= X <= 1,000,000

Jalankan dengan python3, tetapi seharusnya (?) Bekerja dengan python2 juga

Beli Rendah

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

Penjudi yang Gagal

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

Petani 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 yang membeli setiap kemungkinan saham pada putaran pertama, dan hanya menjual ketika harga saham saat ini lebih tinggi dari harga yang mereka beli. Setelah menjual, bot hanya akan membeli saham yang lebih murah daripada harga saham yang dijual terakhir.

Itu karena akuntan petani mengatakan kepadanya bahwa itulah cara Anda melakukan perdagangan saham. "Beli rendah, jual tinggi" dan semua itu.

Penolakan

Ini adalah upaya pertama saya pada tantangan KotH, dan karena saya pada dasarnya hanya melakukan APL di sini, saya memutuskan untuk melanjutkannya.

Yang mengatakan, saya tidak sepenuhnya yakin apakah ini akan dapat berjalan bersama bot lain, karena ini adalah Tradfn dan tidak dapat dimasukkan langsung ke dalam CMD / Bash shell.

Jadi, untuk menjalankan ini di Bash, Anda memerlukan perintah berikut:

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

Dimana:

apl_stock_farmer adalah nama fungsi, yang ada di baris kode pertama.

argsadalah vektor dari argumen yang dipisahkan oleh ruang (di babak pertama, itu akan menjadi 10 5 100 1).

dyalog adalah jalan menuju executable Dyalog

'stock_exchange.dws'adalah nama (atau jalur, jika file tidak di direktori yang sama shell telah terbuka) dari ruang kerja yang berisi fungsi. File ruang kerja itu dapat diperoleh dengan membuka ruang kerja yang jelas, mengetik )ed apl_stock_farmer, menempelkan kode di atas dan kemudian melakukan a )save <path>. Saya juga bisa menyediakan file ruang kerja ini jika itu akan lebih mudah.

-script hanyalah sebuah argumen yang membuat dyalog mengeksekusi kode yang diberikan dan mencetak ke stdout tanpa benar-benar membuka REPL.

Sayangnya, saya belum menemukan cara untuk membuatnya bekerja dengan Windows CMD atau Powershell, jadi saya menjalankannya menggunakan Git Bash. Saya tidak yakin seberapa layak untuk menempatkan bot ini di kompetisi, tapi saya suka cara kode ini terlalu banyak untuk tidak mempostingnya.

Investor Dividen Buta

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

Dengan asumsi setelah dividen, orang memiliki lebih banyak uang tunai, sehingga mereka akan lebih cenderung untuk membeli. Jual tepat sebelum dividen, beli tepat setelah. Melewati satu siklus jual / beli lainnya dalam 3 putaran lainnya.

Beli / investasi ulang sebanyak mungkin!

Mirip dengan Dollar-Cost Averager saya, yang mengejutkan, cukup rata-rata, ini membeli setiap ronde sebanyak saham yang terjangkau dan hanya menjualnya di ronde terakhir.

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

Novice Broker (tetapi mendapat ide dasarnya)

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

Tunggu hingga harga berbalik, lalu beli / jual semuanya. Maksudku, itulah yang harus dilakukan di Day Trading for Dummies. ^{Catatan: ini mungkin buku nyata, dan itu mungkin sesuatu yang mungkin didapat seseorang darinya} .

Menyimpan data dalam se_stock_exchange.data. Jalankan dengan ruby se_stock_exchange.rb ${SHARE_PRICE} ${SHARES} ${MONEY} ${ROUND}(mengganti nilai yang sesuai).

Setengah Lebih atau Tidak Ada

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

Saya jarang menggunakan Python, beri tahu saya jika ini menghasilkan kesalahan di suatu tempat.

Strateginya adalah menunggu sampai harga saham setidaknya 50% lebih besar dari harga pada saat bying mereka, kemudian menjualnya, kemudian segera membeli saham baru sehingga dapat menunggu kenaikan harga saham baru.

Mudah-mudahan, simpanse orang tidak akan mulai menjual saham mendekati akhir ... (tampaknya sebagian besar bot hanya menunggu saat yang tepat, apa pun itu)

Fibonacci

Saya telah menulis ulang ini dalam Python 3 untuk mempermudah. Semoga!

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

Ia membeli setengah jumlah maksimum saham yang terjangkau ketika putaran sama dengan angka Fibonacci aneh dan menjual setengah dari saham yang tersedia ketika putaran sama dengan angka Fibonacci genap dan juga setiap 100 putaran. Menjual semua saham pada putaran 1000. Jika tidak, ia hanya menunggu. Hanya membeli saham ketika saldo positif.

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

Dia akan masuk semua ketika murah dan menjual semuanya begitu harga naik ...

Robot Analisis Teknis

Saya belajar ekonomi bisnis, jadi saya mencoba merealisasikan metode paling sederhana untuk menganalisis pasar saham (analisis teknis). Menurut teori Anda hanya perlu menganalisis semua minimum grafik untuk melihat apakah ada tren (naik ke bawah). Selama tren naik Anda harus membeli dan selama tren turun Anda harus menjual.

Saya tidak berpikir bahwa metode ini akan bekerja dengan baik tetapi mari kita coba :)

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)

Diuji dengan python3

Lucky Number 6

EDIT: Oh ffs, saya pikir saya tidak mengubah jumlah penjualan ke int adalah salah satu masalah saya, yah kita mulai lagi.

Mungkin kontribusi terakhir saya, kecuali saya bosan di tempat kerja dan membuat sesuatu yang sedikit lebih canggih, tetapi saya jatuh seperti bot canggih yang sudah mengisi celah.

Orang ini pada dasarnya menjual sebagian sahamnya setiap 6 putaran, karena hei 6 adalah angka keberuntungannya.

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