DİKKAT: Bu zorluk artık kapandı: Artık lider panosunu güncellemeyeceğim ve kabul edilen cevabı değiştirmeyeceğim. Ancak, denetleyiciyi çalıştırmakta ve dilerseniz lider panosunu kendiniz güncellemekte özgürsünüz.

Sohbete katılın!

Giriş

İyi akşamlar, tüccarlar! Hepiniz golf şirketi PPCG'nin yatırımcılarısınız. Göreviniz mümkün olduğunca çok para kazanmak.

Meydan okuma

Mümkün olduğunca çok para kazanmak amacıyla Borsa Menkul Kıymetler Borsasında hisse satın alan ve satan bir program yazın.

Oynanış

Tüm oyuncular, bankalarında 5 hisse ve 100 $ ile başlayacak. Oyun her zaman 10 dolarlık bir hisse fiyatı ile başlar.

Her oyunda ilk turun yuvarlak olduğu 1000 tur olacak 1. Her rauntta, programınıza girdi olarak dört argüman verilecektir: mevcut hisse fiyatı, sahip olduğunuz hisse sayısı, sahip olduğunuz para miktarı ve raunt numarası (1 indeksli).

Örneğin, eğer programım, test1.pyhisse fiyatı, 100sahip olduğum hisse sayısı, 3sahip olduğum para miktarı 1200ve yuvarlak sayı ise 576, programım şu şekilde çalıştırılır:

python test1.py 100 3 1200 576

Bir turda, her oyuncuya verilen hisse fiyatı aynı olacaktır. Bu, turun sonuna kadar değişmiyor.

Cevap olarak, oyuncu kendi emrini basmalıdır. İki seçenek var:

• Satın hisseleri: Bu komut olarak verilir bnnereye nSatın almak istediğiniz hisse senedi sayısıdır. Örneğin, 100 hisse satın almak istiyorsanız, aşağıdakileri elde edersiniz:

b100

Hisseler satın alırken, 1000 $ 'a varan fazla para çekmenize izin verilir. Bu fazla ödemeyi aşacak kadar hisse satın almaya çalışırsanız (banka bakiyeniz -1000 $ 'ın altına düşerse) iflas ilan edilir. Bu, tüm hisselerinizi kaybedeceğiniz ve bakiyenizin 50 ABD Doları olarak belirleneceği anlamına gelir.

İflas ederseniz, hisse fiyatı emrinizden etkilenmeyecektir.

(Bakiyeniz -1000 ABD Doları ise, iflas etmiş değilsiniz. Ancak bakiyeniz -1001 ABD Doları ise iflas etmiş demektir)

• Satış hisse: Bu komut olarak verilir snnereye nSatmak istediğiniz hisse senedi sayısıdır. Örneğin, 100 hisse satmak istiyorsanız, aşağıdakileri elde edersiniz:

s100

Sahip olduğunuzdan daha fazla hisse satamazsınız. Bunu yapmaya çalışırsanız, isteğiniz reddedilecek ve raundu atlayacaksınız.

Eğer yuvarlak atlamak istiyorsanız ve hiçbir şey, çıkış ya yaparsanız b0veya s0.

Negatif sayıda hisse ve / veya tamsayı olmayan hisse senedi satın almaya veya satmaya çalışırsanız, isteğiniz reddedilir.

5 turdan sonra, her turun sonunda, tüm oyunculara değeri, son 5 turdaki ortalama ortalama hisse fiyatının% 5'i olan bir temettü ödenir.

O nasıl çalışır?

Başlangıçta hisse fiyatı 10 $ olacak. Her turun sonunda, aşağıdaki formül kullanılarak yeniden hesaplanacaktır:

Hisse fiyatı sınırlı olacak ve hiçbir zaman 1 doların altına düşmeyecek.

Aşırı hızlı değişimi önlemek için, hisse fiyatındaki değişiklik en fazla ile sınırlıdır .$\pm$200$

kurallar

• Programınızın bir adı olmalı

• Programınıza veri depolama için tek bir metin dosyasına izin verilir. Programınızla aynı klasörde saklanmalıdır.

• Programınızı nasıl çalıştıracağınıza dair cevap ayrıntılarınıza ekleyin

• Bu KotH, kullanımı kolay ve Windows 10'da çalıştırılabilen tüm programlama dillerine açıktır.

• Puanınız yalnızca bakiyenizin içeriğine dayanmaktadır. Hisselere kilitlenmiş hiçbir para sayılmaz

• Programınızı istediğiniz zaman düzenleyebilirsiniz. Her oyundan önce, en son kod kaydedilir ve derlenir

• Özellikle başka bir botu hedef alan kod yazmamalısınız.

kontrolör

Kontrolör Python ile yazılmıştır ve burada bulunabilir: https://gist.github.com/beta-decay/a6abe40fc9f4ff6cac443395377ec31f

Sonunda bir skor tablosu basacak ve hisse fiyatının oyun boyunca nasıl değiştiğine dair bir grafik gösterecektir.

Örneğin, iki rastgele bot oyun oynarken

Kazanan

Son oyunun sonunda dengelerinde en yüksek paraya sahip olan oyuncu kazanır.

Liderler Sıralaması

Oyun 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

Her yarışmacının grafiklerini görüntüleyin

_{İlgili ancak oyun ve kazanan kriter bu zorluğa göre çok farklı.}

Tecrübeli Açgözlü Salak

PHP> = 7'de test edilen PHP, öncekilerde de çalışmalıdır.

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

Yeniden yapılandırılmış davranış ve büyük sayılarla çalışmakla ilgili hata düzeltmeleri içeren "Greedy Idiot" 'un güncellenmiş bir sürümü.

Notlar:

• Bir dosyaya kaydedin ve şöyle çalıştırın: php C:\path\path\stack_exchange.php 10 5 100 1
• Bu komut dosyası, komut dosyası dosyasıyla aynı adda .txtve sonuna eklenen bir metin dosyası oluşturur . Bu nedenle, lütfen komut dosyası yolunda uygun yazma iznine sahip bir kullanıcıyla çalıştırın.
• PHP 7.2'nin Windows'a nasıl yükleneceği basit: http://www.dorusomcutean.com/how-to-install-php-7-2-on-windows/
• Süper büyük sayılarla çalışmak için GMP kullanmak zorunda kaldım , bu yüzden bu iki satır açıklanmamalı php.ini(satırın başında bulunan yarı-kolon kaldırılmalı, eğer değilse):
  • ; extension_dir = "ext"
  • ;extension=gmp

Daktiloda Şempanze

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

Şempanzeler maymunlardan daha zekidir, karşılayamayacakları hisse senetlerini almazlar veya sahip olmadıkları hisse senetlerini satmazlar.

Yine de yine de oldukça rastgele.

Python3 ile çalıştırın, ancak (?) Python2 ile de çalışmalı

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)

Eski "tahvillerde kendi yaşına sahip ol" derken bu program aynı şeyi yapmaya çalışır. Bu şekilde oyunun sonunda piyasadaki oynaklığa maruz kalmıyoruz.

Düzenleme: Denetleyiciye baktığımızda, yalnızca tam hisseler alabileceğimizi / satabileceğimizi, ancak kesirli bir hesap bakiyesi alabileceğimizi gösteriyor.

Yalnız Muhasebeci

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

İçinde hiçbir şey saklamaz buy-sell.txt.

Tek turlarda, olabildiğince çok hisse satın alır. Hatta turlarda, tüm hisselerini satar.

Amaç, önce mümkün olduğunca çok hisse satın alarak hisse fiyatını yükseltmek ve daha sonra daha fazla para elde etmek için bu hisse senetlerini satmak. İşe yarıyor, çünkü son tur bile (1000 tur).

Hisse fiyatı aynı kalsa da ( 5) her tur çiftinden sonra (botun yalnız olduğu varsayılırsa, bu nedenle Lone Muhasebeci ), botun bakiyesi artar, çünkü satış fiyatı alış fiyatından daha yüksektir ve daha fazla denge Daha fazla hisse satın alma yeteneği. Bu bir kısır döngü, ama iyi bir şekilde (benim için).

Başlıca güvenlik açığı, hisse senedi fiyatını düşürmek için satış yaparak (birlikte ya da iyi olup olmadığından emin değiliz) birlikte satış yaparak kötü robotlarla gelir. Bu durumda bot, yeterince kötü bot olması durumunda -890 dolarlık bir bakiye ile kalabilir. Bu muhasebeci gerçekten iç huzurunu istiyor. ;-)

Pasif Trader

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

Bu adam bütün bu "Hisse Senetleri" işinde büyük değil, ama şimdi biraz para harcarsa, zaman içinde harcadığından daha fazlasını artıracak küçük paralar alacağını duydu.

0 $ 'a çıkacak kadar hisse senedi alacak (bu adam için fazla para çekme yok, borcunu küçük bir kâr için borçlandırmıyor), sonra da temettülerin oluşmasına izin vermek için oturup

Python3 ile çalıştırın, ancak (?) Python2 ile de çalışmalıdır.

Yüzde Tüccar Python3

(belki python2'de çalışır)

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

Koşma ile ilgili talimatlar

• Dosyaadı.py olarak kaydet
• Python dosyaadı.py ile çalıştırın price # # hisse senetleri bakiyesi #

Nasıl çalışır

• İlk turda bot alabileceği kadar hisse alıyor.
• Fiyat artarsa, bot fiyat artış yüzdesine eşit bir hisse yüzdesi satar (yeni değerden hesaplanır)
• Fiyat düşerse, bot fiyattaki yüzde düşüşe eşit alabileceği maksimum hisselerin bir yüzdesini alır (önceki değerden hesaplanır)
• 1000'inci turdaki her şeyi satıyor

Değişiklikler, kayan nokta bölünmesinden kaynaklanan sorunları gidermelidir

Naif İstatistiği

Python 3 için yapılmış, Python 2'de çalışabilir

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

Bu, stok fiyatlarını yalnızca fiyat normalden daha uzun bir süre arttıysa / düşerse alım satım yaparak tahmin etmeye çalışan naif bir istatistikçiyken, aynı zamanda eğer fiyat düşerse ve son raunttaki tüm stokları satarak hisse senetlerini satın alır.

Dolar Maliyet Ortalama

(Python 3.7 ile test edilmiştir)

Codegolf'taki ilk mesaj bu yüzden yanlış bir şey yapıp yapmadığımı söyle.

Temel fikir, mümkünse her turda bir hisse almak ve sonunda tüm hisseleri satmaktır.

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

Ekolayzer

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

Mali kaynaklarını, son hariç her turdaki nakit para ve hisse senetleri arasında eşit olarak paylaştırır. Bu stratejinin en azından bir miktar para kazanmanın matematiksel olarak sağlam bir yolu olduğuna inanıyorum , ancak yanlış olduğumu kanıtlayabilirim.

Yakalamadığım böcekler olabilir veya olmayabilir. Ayrıca biraz golf oynadım.

Daktilodaki Maymunlar

import random

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

Bu daktiloda bulunan bir grup maymun. Rastgele X hisse senetleri satar veya satın alır, burada:
0 <= X <= 1,000,000

Python3 ile çalıştırın, ancak (?) Python2 ile de çalışmalı

Düşük Al

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

Fallacious Gambler

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

(Dyalog) APL Çiftçisi

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

İlk turda mümkün olan her hisseyi alan bir TradFn, ancak hisselerin mevcut fiyatı, satın alındıkları fiyattan yüksek olduğunda satıyor. Sattıktan sonra, bot yalnızca en son sattığı fiyattan daha ucuz olan hisseleri satın alacaktır.

Çünkü çiftçinin muhasebecisi ona borsa işlemlerini nasıl yaptığını söyledi. "Düşük al, yüksek sat" ve her şey.

feragat

Bu benim bir KotH yarışmasında ilk girişimdi ve temelde burada sadece APL yaptığım için devam etmeye karar verdim.

Bununla birlikte, bunun diğer botlarla birlikte çalışıp çalışamayacağından emin değilim, çünkü bu bir Tradfn ve doğrudan bir CMD / Bash kabuğuna beslenemiyor.

Yani, bunu Bash'de çalıştırmak için aşağıdaki komuta ihtiyacınız var:

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

Nerede:

apl_stock_farmer kodun ilk satırında bulunan işlevin adıdır.

argsuzayın ayrılmış argümanlarının bir vektörüdür (ilk turda, olacaktır 10 5 100 1).

dyalog Dyalog yürütülebilir dosyasının yolu

'stock_exchange.dws'işlevi içeren çalışma alanının adı (veya dosya, dosyanın açık olduğu dizinde değilse). Bu çalışma alanı dosyası, açık bir çalışma alanı açılarak, yazılarak )ed apl_stock_farmer, yukarıdaki kodu yapıştırarak ve ardından a ile elde edilebilir )save <path>. Eğer daha kolay olsaydı, bu çalışma alanı dosyasını da sağlayabilirim.

-script dyalog'un verilen kodu çalıştırmasını ve REPL'i açmadan stdout'a yazdırmasını sağlayan sadece bir argümandır.

Ne yazık ki, Windows CMD veya Powershell ile çalışmasını sağlayacak bir yol bulamadım, bu yüzden Git Bash kullanarak çalıştırdım. Bu botu rekabete sokmanın ne kadar mümkün olduğundan emin değilim, ancak bu kodu göndermemeyi çok seviyorum.

Okuma Yazma Temettü Yatırımcı

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

Temettülerden sonra, insanların daha fazla nakitlerinin olduğunu, dolayısıyla satın alma olasılıklarının daha yüksek olacağını varsayar. Temettülerden hemen önce satılır, hemen sonra satın alınır. Diğer 3 turdaki diğer bir alış / satış döngüsünden geçer.

Mümkün olduğunca satın alın / toplayın!

Şaşırtıcı derecede, oldukça ortalama olan Dolar-Maliyet Ortalamam gibi, bu da her turu uygun fiyata olduğu kadar çok hisse satın alır ve sadece son turda satar.

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

Acemi Broker (ama temel fikri alır)

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

Fiyat dolana kadar bekler, sonra her şeyi alır / satar. Demek istediğim, Aptallar Günü Ticaretinde yapılması gerekenler bunu yazıyor. ^{Not: Bu muhtemelen gerçek bir kitap ve muhtemelen ondan birinin alabileceği bir şey} .

Veri kaydeder se_stock_exchange.data. ruby se_stock_exchange.rb ${SHARE_PRICE} ${SHARES} ${MONEY} ${ROUND}(Uygun değerleri kullanarak) ile çalıştırın .

Yarım veya Hiçbir Şey

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'u nadiren kullanıyorum, bu bir yerde bir hata oluşturursa bana bildirin.

Strateji, hisse senedinin fiyatın bying anındaki fiyattan en az% 50 daha büyük olmasını beklemek, daha sonra onları satmak ve hemen yeni hisse senetleri almak, böylece yeni hisse senedinin yükselmesini beklemek.

Umarım, insanlar şempanzelerin sonuna kadar hisse satmaya başlamaz ... (çoğu botun sadece doğru zamanı beklediği anlaşılıyor)

Fibonacci

İşleri kolaylaştırmak için bunu Python 3'te yeniden yazdım. İnşallah!

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

Tur tek bir Fibonacci sayısına eşit olduğunda uygun fiyatlı maksimum hisse senetlerinin yarısını alır ve tur bir Fibonacci sayısına eşit olduğunda ve aynı zamanda her 100 turda da mevcut hisse senetlerinin yarısını satar. 1000'in üzerindeki hisse senetlerinin tamamını satıyor. Aksi takdirde, sadece bekler. Sadece bakiye pozitif olduğunda hisse satın alır.

Açgözlü 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:]))  

Ucuz olduğu zaman girip fiyatı yükseldiğinde hepsini satacak ...

Teknik Analiz Robotu

İşletme ekonomisi okuyorum, bu yüzden borsa analizinde en basit yöntemi (teknik analiz) gerçekleştirmeye çalıştım. Teoriye göre, bir eğilim olup olmadığını görmek için grafiğin tüm minimumlarını analiz etmeniz gerekir (yukarı veya aşağı). Yükselme eğilimi sırasında satın almanız ve düşme eğilimi sırasında satmanız gerekir.

Bu yöntemin çok işe yarayacağını sanmıyorum ama bir deneyelim :)

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 ile test edildi

Şanslı Sayı 6

EDIT: Oh ffs, satış sayısını int'ye çevirmemek benim sorunlarımdan biriydi, işte yine başlıyoruz.

Muhtemelen işten sıkılmadığım ve biraz daha sofistike bir şey yapmadığım sürece son katkım, ama sofistike botların zaten nişleri doldurduğu gibi düştüm.

Bu adam temel olarak her 6 turda hisselerinin bir kısmını satıyor, çünkü hey 6 onun şanslı sayısı.

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