tło

Wszyscy jesteście traderami dla nieco mniej renomowanej firmy giełdowej. Wszyscy jesteście częścią grupy traderów, którzy koncentrują się tylko na jednym konkretnym akcie.

Co godzinę każdy trader ma szansę na zakup X akcji lub sprzedaż X akcji. Istnieje 50 godzin na rundę i 3 rundy na zawody. Pod koniec wszystkich rund handlowiec o najwyższej średniej wartości wygrywa wycieczkę na Jamajkę!

Rozgrywka

Istnieją 3 rundy po 50 tur każda.

Każdy inwestor rozpoczyna rundę z 5000 $ i losową liczbą akcji od 20 do 30 akcji. Cena akcji zaczyna się od przypadkowej liczby od 10 do 150.

W każdej turze każdy handlowiec może kupić dowolną liczbę akcji, na jaką może sobie pozwolić, lub sprzedać dowolną liczbę aktualnie posiadanych akcji, każdą za bieżącą cenę za akcję.

Cena za akcję wzrasta o losową liczbę od 1 do 5 za każdy zakupiony udział i maleje o losową wartość od 2 do 6 za każdy sprzedany udział. Cena minimalna to 1 USD.

Ważne jest, aby pamiętać, że wszyscy handlowcy przetwarzają swoje transakcje w tym samym czasie, co oznacza, że ​​każdy handlowiec kupujący / sprzedający akcje nie wpłynie na cenę do następnej tury.

Gracz z najwyższą średnią wartością na koniec 3 rund wygrywa. Wartość jest ustalana na podstawie ilości pieniędzy pozostałych na koniec rundy i dodanej liczby akcji posiadanych przez zamykającą cenę rynkową tradera *.

Argumenty

Twój program zostanie uruchomiony ponownie na początku każdej tury, otrzymując aktualną cenę rynkową, bieżącą kwotę pieniężną tradera i liczbę akcji posiadanych przez tego tradera.

Dawny:

120 5000 0

Wydajność

Twój program tradera musi wypisać literę odpowiadającą akcji, którą chciałby podjąć, a następnie ilość.

Dawny:

B10 //Buy 10 shares

lub

S3 //Sell 3 shares

Inwestor ma również opcję, aby nie robić nic, co się zmieni. Można tego dokonać, wysyłając W lub dowolne inne polecenie, które nie jest „B> amnt <” lub „S> amnt <”

Zgłoszenia

Twój program będzie w katalogu „odtwarzacze /> nazwa twojego programu <”:

+-- players
|   +-- BotNameFolder
|       +-- BotProgram   

Podaj swój kod wraz z argumentem wiersza poleceń, aby uruchomić go z katalogu „odtwarzaczy”. Na przykład można uruchomić tradera Test1java -cp "Test1" Test1

Dodatkowe zasady

Śmiało, zastrzel się EmoWolf, Idc.

Bez bałaganu z niczym poza katalogiem BotNameFolder, możesz tworzyć tam pliki, aby uzyskać trwałe informacje podczas rund / tur.

Nie twórz celowo programów, które mogą zawiesić symulację.

Przyjmę wiele wpisów na użytkownika, o ile będą one działały jako osobne podmioty (bez wykorzystywania informacji poufnych).

Tabela liderów

[java&-cp&"TestPlayer"&Test1]:$10027395221
[python&daydreamer/daydreamer.py]:$5000
[java&-cp&"DayTrader"&DayTrader]:$4713199930331196453

Spróbuję zaktualizować tabelę wyników przynajmniej raz dziennie

Kontroler

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Queue;
import java.util.Random;


public class Controller {

    public static BigInteger marketValue = BigInteger.valueOf(100);
    public static BigInteger newValue = BigInteger.valueOf(100);

    public static final char BUY = 'B';
    public static final char SELL = 'S';

    public static final int MARKET_INDEX = 1;
    public static final int MONEY_INDEX = 2;
    public static final int SHARE_INDEX = 3;

    public static int numRunning = 0;
    public static final int MAX_RUNNING = 10;

    public static void main(String[] args){
        try {
            BufferedReader br1 = new BufferedReader(new InputStreamReader(new FileInputStream("resources/config")));

            int numRounds = Integer.parseInt(br1.readLine());
            int turnsPerRound = Integer.parseInt(br1.readLine());

            //Create the array of players
            List<String> players = new LinkedList<String>();
            String line1 = null;
            while((line1 = br1.readLine()) != null){
                players.add(line1);
            }
            BigInteger[] totalVals = new BigInteger[players.size()];
            for(int i = 0; i < totalVals.length; i++){
                totalVals[i] = BigInteger.valueOf(0);
            }
            br1.close();

            //Begin processing
            for(int round = 0; round < numRounds; round++){
                //Create players' shares and currency array
                Map<String,BigInteger[]> vals = new HashMap<String, BigInteger[]>();
                for(int i = 0; i < players.size(); i++){
                    vals.put(players.get(i), new BigInteger[]{BigInteger.valueOf(5000), BigInteger.valueOf(getRandInt(20,30))});
                }
                marketValue = BigInteger.valueOf(getRandInt(10,150));
                newValue = marketValue;
                for(int turn = 0; turn < turnsPerRound; turn++){
                    marketValue = newValue;
                    Queue<Object[]> processQueue = new LinkedList<Object[]>();
                    for(String playerKey : vals.keySet()){
                        BigInteger[] valSet = vals.get(playerKey);
                        String[] pkParts = playerKey.split("&");
                        String[] parts = new String[pkParts.length + 3];
                        for(int i = 0; i < pkParts.length; i++){
                            parts[i] = pkParts[i];
                        }
                        parts[pkParts.length] = marketValue + "";
                        parts[pkParts.length + 1] = valSet[0] + "";
                        parts[pkParts.length + 2] = valSet[1] + "";
                        processQueue.add(new Object[]{playerKey, parts});
                    }

                    while(!processQueue.isEmpty() || numRunning > 0){
                        if(numRunning < MAX_RUNNING && !processQueue.isEmpty()){
                            numRunning++;
                            Object[] o = processQueue.poll();
                            String pKey = (String)(o[0]);
                            String[] p = (String[])(o[1]);
                            try {
                                Process proc = new ProcessBuilder(p).directory(new File("resources/players").getAbsoluteFile()).start();
                                BufferedReader br = new BufferedReader(new InputStreamReader(proc.getInputStream()));
                                String line = br.readLine();
                                br.close();
                                switch(line.charAt(0)){
                                case BUY :
                                    BigInteger numShares = new BigInteger(line.substring(1).trim());
                                    if(numShares.multiply(marketValue).compareTo(vals.get(pKey)[0]) <= 0){
                                        BigInteger[] tempVals = vals.get(pKey);
                                        tempVals[0] = tempVals[0].subtract(numShares.multiply(marketValue));
                                        tempVals[1] = tempVals[1].add(numShares);
                                        vals.put(pKey, tempVals);
                                        newValue = newValue.add(numShares.multiply(BigInteger.valueOf(getRandInt(0,2))));
                                        if(newValue.compareTo(BigInteger.valueOf(Integer.MAX_VALUE)) >= 1){
                                            newValue = BigInteger.valueOf(Integer.MAX_VALUE - 1);
                                        }
                                    }
                                    break;
                                case SELL:
                                    BigInteger shares = new BigInteger(line.substring(1).trim());
                                    if(shares.compareTo(vals.get(pKey)[1]) <= 0){
                                        BigInteger[] tempVals = vals.get(pKey);
                                        tempVals[0] = tempVals[0].add(shares.multiply(marketValue));
                                        tempVals[1] = tempVals[1].subtract(shares);
                                        vals.put(pKey, tempVals);
                                        newValue = newValue.subtract(shares.multiply(BigInteger.valueOf(getRandInt(5,10))));
                                        if(newValue.compareTo(BigInteger.valueOf(1)) <= -1){
                                            newValue = BigInteger.valueOf(1);
                                        }
                                    }
                                    break;
                                }
                            } catch (Exception e) {
                                System.err.println("[" + pKey + "] threw error:");
                                e.printStackTrace();
                            } finally{
                                numRunning--;
                            }
                        }else{
                            try{
                                Thread.sleep(50);
                                continue;
                            }catch(InterruptedException e){
                                continue;
                            }
                        }
                    }
                    System.out.println("Turn " + turn + " over: " + marketValue);
                }
                System.out.println("End of round market value is: " + marketValue);
                int count = 0;
                for(String player : vals.keySet()){
                    totalVals[count] = totalVals[count].add(vals.get(player)[0].add(vals.get(player)[1].multiply(marketValue)));
                    count++;
                }
                newValue = BigInteger.valueOf(100);
            }
            for(int i = 0; i < players.size(); i++){
                System.out.println("[" + players.get(i) + "]:$" + (totalVals[i].divide(BigInteger.valueOf(numRounds))));
            }
        } catch (Exception e) {
            System.err.println("An exception occured while running the controller.");
            e.printStackTrace();
        }
    }
    public static Random r = new Random(new Date().getTime());
    public static int getRandInt(int min, int max){
        return r.nextInt(max - min) + min;
    }
}

Skompiluj to java Controller.javai uruchom z katalogu zawierającego katalog taki jak poniżej:

+-- resources
|   +-- config
|   +-- players
|       +-- Player1Folder
|           +-- Player1Program
|       +-- Player2Folder
|           +-- Player2Program

Plik configpowinien wyglądać mniej więcej tak:

3
50
java&-cp&"TestPlayer"&Test1
python&daydreamer/daydreamer.py
java&-cp&"DayTrader"&DayTrader

Pierwsza liczba to liczba rund, druga to liczba rund na rundę, a następnie polecenia uruchomienia każdego gracza.

Zastąp spacje znakami ampersands! („&”)

~ Daj mi znać, czy w ogóle mogę poprawić treść tego postu i życzę szczęśliwego handlu!

Przedstawiam „marzyciela”, który zawsze śpi i zapomina kupić lub sprzedać cokolwiek. Ma nadzieję, że inni gracze stracą netto. Kod Python:

if __name__ == "__main__":
    print "W"

działaj z python daydreamer\daydreamer.py 120 5000 0dowolnymi wartościami.

Później odpowiem bardziej poważnie, to po prostu żeby piłka się potoczyła :)

DayTrader

_{Zaktualizowano dla zmiany zasad dokonanej w dniu 21.08.2014, w której gracze zaczynają teraz od 20-30 akcji.}

Kupuje jak najwięcej, a następnie sprzedaje jak najwięcej.

Filozofia

Mamy nadzieję, że poniższy wzór będzie się powtarzał w kółko. Pamiętaj, że przestrzegając tego wzoru, również się do niego przyczyniamy.

• Każdy może kupić lub zatrzymać tylko w pierwszej rundzie. Wartość może tylko wzrosnąć, więc kupujemy.
• Każdy może kupić więcej, wstrzymać lub sprzedać w drugiej rundzie. Nie oczekujemy, że wielu graczy dokona zakupu w drugiej rundzie, więc sprzedajemy.

Wzór na początku jest krystalicznie czysty. Wartość będzie wzrastać po pierwszej rundzie. Powinien się zmniejszyć po drugiej rundzie. Poza tym projekcje stają się rozmyte. Spodziewam się, że dobrze poradzę sobie na początku rundy, zanim rynek się ustabilizuje.

import java.math.BigInteger;

/**
 * Submission for http://codegolf.stackexchange.com/q/36515/18487
 * @author Rainbolt
 */
public class DayTrader {

    /**
     * @param args the command line arguments containing the current 
     * market value, our current money, and our current shares
     */
    public static void main(String[] args) {
        BigInteger marketValue = new BigInteger(args[0]);
        BigInteger myMoney = new BigInteger(args[1]);
        BigInteger myShares = new BigInteger(args[2]);

        // If we have less than or equal to 30 shares, buy as much as possible
        if (myShares.compareTo(new BigInteger("30")) <= 0) {
            System.out.println("B" + myMoney.divide(marketValue).toString());
        // Otherwise, sell as much as possible
        } else {
            System.out.println("S" + myShares.toString());
        }
    }

}

Kompiluj z javac DayTrader.java. Uruchom z java -cp "DayTrader" DayTrader.

Walt Disney - Python 3

Walt czeka, aż akcje osiągną dno, a następnie kupuje tyle, ile pozwalają mu pieniądze. Następnie, gdy cena rośnie, sprzedaje je wszystkie.

Oparty na strategii Disneya, kiedy „przeżył” podczas katastrofy na Wall Street. Niestety mój program nie może budować parków rozrywki ... Jeśli tylko ...

Biegać:

python3 waltdisney.py

Kod:

from sys import argv
import os

price=int(argv[1])
money=int(argv[2])
share=int(argv[3])

if os.path.exists('./buyingprice.txt'):
    f = open('buyingprice.txt', 'r')
    buyingprice=int(f.read())
    f.close()
else:
    buyingprice=0

if share > 0:
    if price > buyingprice*10:
        print('S'+str(share))
    else:
        print('W')
elif money > 0:
    if buyingprice==0:
        print('B10')
        m=open('buyingprice.txt', 'w')
        m.write(str(price))
        m.close()
    elif price <= buyingprice:
        print('B'+str(int(money/price)))
        g=open('buyingprice.txt', 'w')
        g.write(str(price))
        g.close()
    else:
        print('W')

Tommy

wie tylko, co ma, ale jest zdecydowany zaryzykować wszystko na rynku. Jeśli będzie mógł kupić, zrobi to. Jeśli nie może, sprzedaje wszystko, co ma, aby mógł w następnej turze. (Będzie to działać dobrze z ekstremalnymi, takimi jak DayTrader, ale będzie autokorekty, jeśli wartość spadnie, gdy myśli, że wzrośnie.)

import java.math.BigInteger;

public class Tommy {
    public static void main(String[] args) {
        BigInteger Value = new BigInteger(args[0]);
        BigInteger Money = new BigInteger(args[1]);
        BigInteger Shares = new BigInteger(args[2]);

       if (Money.compareTo(Value)<1) {
           System.out.print("S" + Shares.toString());
       } else {
           System.out.print("B" + Money.divide(Value).toString());
       }
    }

}

Golfscript

To jest ten sam kod, ale jeśli jest to preferowane. Napisałem po Javie na wypadek, gdyby potrzebna była sprawa BigInteger. Używaj tego, co jest łatwiejsze.

2$2$>{@@;;"S"\}{;\/"B"\} if

BuyAndHold - C

#include <stdio.h>
#include <stdlib.h>

/* BuyAndHold
 * Code revised from OptoKopper's WaitForCrash.c
 */
int main(int argc, char *argv[]) {
    long long int share_price = strtoll(argv[1], NULL, 0);
    long long int money = strtoll(argv[2], NULL, 0);

    if (money >= share_price) {
        printf("B%lld\n", money / share_price);
    } else {
        printf("W\n");
    }

    return 0;
}

Skompiluj z: gcc buyandhold.c -o buyandhold

Uruchom z ./buyandhold AKCJE PIENIĘŻNE CENY

Alfred Pennyworth - Python 2

Pewnej nocy, kiedy byłem na patrolu, Alfred próbował stworzyć program handlu akcjami bez mojej wiedzy. Myślał, że może to przede mną ukryć, ale znalazłem to i zorientowałem się, co to zrobiło. Ponieważ jestem Batmanem. Teraz postanowiłem wziąć udział w konkursie, aby nauczyć go lekcji.

Pieniądze nie są przedmiotem Alfreda, ponieważ NAPRAWDĘ jestem bogaty, ale nadal jest mądry w swoim handlu. Kiedy nie ma akcji, kupuje tyle, ile może sobie pozwolić, bez względu na cenę rynkową. Następnie sprzedaje 10 (lub wszystkie pozostałe) akcje za każdym razem, gdy cena rynkowa jest wyższa niż cena, za którą została zakupiona.

import argparse

parser = argparse.ArgumentParser(description="This is a private matter, Master Bruce. Learn how to make your own bed and I will tell you.")
parser.add_argument("Stuff", type=int, nargs='+', help="You don't need to know, Master Bruce.")

args=parser.parse_args()
vals=[]
for x in args:
    vals.append(x)

a=vals[0]
b=vals[1]
c=vals[2]

if c==0:
    x=1
    while x*a<b:
        x+=1
    print "B"+str(x)
    with open("lastval.txt", w) as f:
        f.write(a)

else:
    lastval=next(open("lastval.txt"))
    if a>lastval:print "S10" if c>10 else "S"+str(c)
    else:print 'W'

Biegnij z: python GoAwayMasterBruce.py <args>

NaiveBot

NaiveBot jest nowy w całym tym „giełdzie”. Po prostu zakłada, że ​​gdy cena rośnie, powinien kupować, a gdy cena spada, powinien sprzedawać. Ale nie jest sokiem, ma podstęp w rękawie! Kupuje tylko połowę tego, na co go stać, i tylko sprzedaje połowę tego, co ma.

NaiveBot nigdy więcej nie mieszka w pudełku pod autostradą!

<?php
$cur = array('price' => $argv[1], 'funds' => $argv[2], 'shares' => $argv[3]);

$cachefile = 'cache.json';
if( ! file_exists($cachefile) ) { $cache = array(); }
else { $cache = json_decode(file_get_contents($cachefile), true); }

// determine action
if( empty($cache) ) {
    $action = 'buy'; // always buy on first turn
} else if( $cur['price'] > $cache[count($cache)-1]['price'] ) {
    $action = 'buy';
} else if( $cur['price'] < $cache[count($cache)-1]['price'] ) {
    $action = 'sell';
} else {
    $action = 'hold';
}

// determine volume
if( $action == 'hold' ) {
    $volume = 0;
} else if( $action == 'buy' ) {
    // spend half my money on shares!
    $volume = floor(($cur['funds']/2)/$cur['price']);
} else if( $action == 'sell' ) {
    // sell half my shares!
    $volume = floor($cur['shares']/2);
}

// do a thing!
if( $action == 'hold' ) { echo 'W'; }
else if( $action == 'buy' ) { echo "B $volume"; }
else { echo "S $volume"; }
echo "\n";

$cache[] = $cur;
if( count($cache) == 50 ) { unlink($cachefile); } // wipe cache on last turn
else { file_put_contents($cachefile,json_encode($cache)); } // write cache

Uruchom z php Naivebot.php $1 $2 $3, tworzy cache.jsonw bieżącym folderze.

Zysk - Haskell

1. Poczekaj, aż cena wyniesie 1 / maxValue
2. Kup / sprzedaj wszystko
3. ????
4. ZYSK!!!

import System.Environment (getArgs)

main = putStrLn . trade . map read =<< getArgs

trade :: [Integer] -> String
trade [p,m,s] -- not intended
  | p == 1 = "B" ++ (show m)
  | p == (fromIntegral $ (maxBound::Int) - 1) = "S" ++ (show s)
  | otherwise = "W"

Kompiluj ghc profit.hsi uruchamiaj z ./profit price money stock.

Jeśli nie jest wystarczająco wydajny, dodaj -O3flagę, chociaż prawdopodobnie jest to przesada: D

Edytować:

„zoptymalizowany”, teraz sprzedaje wszystko, gdy cena jest równa Integer.MAX_VALUE.

WaitForCrash

EDYCJA: naprawiono błąd w koncepcji

EDYCJA: teraz używając long long int

To moja pierwsza próba. Zachowuje się bardzo prosto i pozwala jednemu udziałowi rozróżnić, czy jest to pierwsza runda, czy później. W pierwszej rundzie nic nie można stracić, więc kupuje akcje. Jeśli ma akcje, to je sprzedaje. Jeśli ostatecznie ceny akcji spadną do 10, kupi ponownie.

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[]) {
    long long int share_price = strtoll(argv[1], NULL, 0);
    long long int money = strtoll(argv[2], NULL, 0);
    long long int shares_owned = strtoll(argv[3], NULL, 0);

    if(shares_owned > 1) {
        printf("S%lld\n", shares_owned - 1);
    } else if (shares_owned == 0 || share_price == 10) {
        printf("B%lld\n", money / share_price);
    } else {
        printf("W\n");
    }

    return 0;
}

Połącz z: gcc waitforcrash.c -o waitforcrash

uruchom to jako ./waitforcrash PRICE MONEY SHARES

Trzęsienie ziemi

Alternatywą jest kupowanie wszystkiego i sprzedawanie wszystkiego (oprócz jednego). Tak naprawdę nie ma na celu wygrania tak bardzo, jak zakłóca wszystkich innych.

using System;
using System.IO;

namespace Earthquaker
{
    class Program
    {
        static void Main(string[] args)
        {
            if (args.Length < 3)
                return;

            int stockPrice = int.Parse(args[0]);
            int money = int.Parse(args[1]);
            int stocks = int.Parse(args[2]);

            bool shouldBuy = true;

            if (stocks != 0)
            {
                StreamReader sr = new StreamReader("brain.txt");
                if (sr.ReadLine() == "B")
                    shouldBuy = false;
                else
                    shouldBuy = true;
                sr.Close();
            }

            if (shouldBuy)
                Console.Write("B" + (money / stockPrice));
            else
                Console.Write("S" + (stocks - 1));

            StreamWriter sw = new StreamWriter("brain.txt", false);
            sw.Write(shouldBuy ? 'B' : 'S');
            sw.Close();
        }
    }
}

Kompiluj z csc Earthquaker.cs. Uruchom z Earthquaker.

MonkeyTrader (w JAVA)

Jest takie powiedzenie, że małpy są dobrymi kupcami. Robię dowód. Decyzje między „kup” a „sprzedaj” są całkowicie losowe.

import java.math.BigInteger;
import java.util.Random;

public class MonkeyTrader {
    /**
     * @param args the command line arguments containing the current 
     * market value, our current money, and our current shares
     */
    public static void main(String[] args) {
        BigInteger marketValue = new BigInteger(args[0]);
        BigInteger myMoney = new BigInteger(args[1]);
        BigInteger myShares = new BigInteger(args[2]);
        Random random=new Random();

        switch (random.nextInt(2)) {
        case 0:
            System.out.println("B" + myMoney.divide(marketValue));
            break;
        case 1:
            System.out.println("S" + myShares);
            break;
        }
    }
}

IntelliTrader

W pierwszej rundzie sprzedaje swoje akcje, jeśli są w dobrej cenie: 80 USD lub więcej. Następnie sprzedaje się, jeśli cena jest taka sama lub lepsza niż ostatnia cena, w której sprzedawał, kup, jeśli cena jest taka sama lub niższa niż ostatnia cena, którą kupił.

IntelliTrader.java

import java.io.*;
import java.math.BigInteger;
import java.util.Properties;

public class IntelliTrader {

    private static final String ROUND_NUM = "roundNum";
    private static final String LAST_BUY = "lastBuy";
    private static final String LAST_SELL = "lastSell";
    private static final String FILE = "IntelliTrader/memory.txt";

    private Properties memory;
    private int roundNum;

    private IntelliTrader(Properties memory) {
        this.memory = memory;
        roundNum = new Integer(memory.getProperty(ROUND_NUM, "0"));
    }

    public String evaluate(BigInteger market, BigInteger money, BigInteger shares) {
        String command = "W";
        if (roundNum == 0) {
            if (market.intValue() > 80) {
                command = sell(market, shares);
            } else {
                command = buy(market, money);
            }
        } else {
            if (market.compareTo(new BigInteger(memory.getProperty(LAST_SELL, "0"))) >= 0) {
                command = sell(market, shares);
            } else if (market.compareTo(new BigInteger(memory.getProperty(LAST_BUY, "999999999"))) <= 0) {
                command = buy(market, money);
            }
        }
        return command;
    }

    private String buy(BigInteger cost, BigInteger money) {
        memory.setProperty(LAST_BUY, cost.toString());
        return "B" + money.divide(cost).toString();
    }

    private String sell(BigInteger cost, BigInteger shares) {
        memory.setProperty(LAST_SELL, cost.toString());
        return "S"+shares.toString();
    }


    public static void main(String[] args) {    
        BigInteger marketValue = new BigInteger(args[0]);
        BigInteger myMoney = new BigInteger(args[1]);
        BigInteger myShares = new BigInteger(args[2]);

        Properties memory = new Properties();
        try {
            memory.load(new FileReader(FILE));
        } catch (IOException e) {
            //ignore, file probably doesn't exist yet
        }

        int roundNum = new Integer(memory.getProperty(ROUND_NUM, "0"));
        if (roundNum > 49) {
            roundNum = 0;
            memory.setProperty(ROUND_NUM, "0");
            memory.setProperty(LAST_BUY, "0");
            memory.setProperty(LAST_SELL, "0");
        }

        IntelliTrader it = new IntelliTrader(memory);
        String command = it.evaluate(marketValue, myMoney, myShares);
        System.out.println(command);

        roundNum++;
        memory.setProperty(ROUND_NUM, ""+roundNum);
        try {
            memory.store(new FileWriter(FILE), "IntelliTrader memory properties");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Kompiluj z javac IntelliTrader . Uruchom z java -cp „IntelliTrader” IntelliTrader

theAnswerOfLifeIs42.py

Mój program uwielbia liczbę 42

Zasada jest prosta: mogę kupić 42 akcje lub sprzedać 42 akcje.

import sys
price, money, shares = [int(arg) for arg in sys.argv[1:]]

if money>42*price:
 print "B 42"
else:
 print "S 42"

LeesonLearnt v1.1 (Java, konserwatywny)

Ponieważ zmiana reguły oznacza, że ​​zaczynamy teraz od niektórych akcji, nie ma już gwarantowanego najlepszego pierwszego ruchu, więc uprościłem to, usuwając specjalny przypadek dla pierwszej tury.

import java.math.BigInteger;

public class LeesonLearnt {
    private static final BigInteger THRESHOLD = new BigInteger("100");

    public static void main(String[] args){
        BigInteger price = new BigInteger(args[0]);
        BigInteger capital = new BigInteger(args[1]);
        BigInteger shareholding = new BigInteger(args[2]);

        BigInteger affordable = capital.divide(price);

        // In the long run, the shares will probably lose all their value.
        // But if they're cheap, buying them will pump them and they can be sold at a profit.
        // The target amount of our value held in shares varies exponentially with their price.
        BigInteger targetShareholding = price.compareTo(THRESHOLD) > 0
            ? BigInteger.ZERO
            : affordable.add(shareholding).shiftRight(price.intValue() - 1);
        if (targetShareholding.compareTo(shareholding) <= 0) {
            System.out.println("S" + shareholding.subtract(targetShareholding));
        }
        else {
            BigInteger diff = targetShareholding.subtract(shareholding);
            System.out.println("B" + diff.min(affordable));
        }
    }
}

Wywołaj jako

java -cp LeesonLearnt LeesonLearnt <price> <capital> <shareholding>

Uśrednianie kosztów dolara - Python 3

Ta strategia próbuje wykorzystać uśrednianie kosztu dolara, kupując (tak blisko, jak to możliwe) stałą ilość pieniędzy (arbitralnie ustaloną na 150, aby prawdopodobnie zużyła większość swoich pieniędzy do końca) w każdej turze.

import sys
price, money, shares = [int(arg) for arg in sys.argv[1:]]
target_per_day = 150
buy = round(min(target_per_day, money) / price)
if buy * price > money:
    buy -= 1
if buy > 0:
    print("B" + str(buy))
else:
    print("W")

Cash Is King - Python 2 lub 3

Ten facet jest bardzo pesymistycznie nastawiony do rynku akcji. Wolałby przechowywać pieniądze w gotówce, gdzie mógłby je bezpiecznie przechowywać pod swoim materacem.

import sys
shares = int(sys.argv[3])
if shares > 0:
    print("S" + str(shares))
else:
    print("W")

Powoli i spokojnie

Tak długo, jak ma pieniądze, kupuje akcje warte 165 USD. W przeciwnym razie sprzedaje wszystkie swoje akcje, aby uzyskać więcej pieniędzy i kupić więcej akcji. W 50 rundzie zapewnia sprzedaż wszystkich akcji, ponieważ ostatecznie chcemy gotówki.

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.math.BigInteger;
import java.nio.file.Files;
import java.nio.file.Paths;

public class SlowAndSteady{
    public static void main(String[] args) {
        BigInteger price = new BigInteger(args[0]);
        BigInteger cash= new BigInteger(args[1]);
        long shares= Long.parseLong(args[2]);
        BigInteger number = new BigInteger("165");
        String count = "0";


        try {
            count = new String(Files.readAllBytes(Paths.get("counter.txt")));
        } catch (IOException e) {

        }

        int c = Integer.parseInt(count)+1;

        if (c >= 50)
        {
            System.out.println("S" + shares);
            c=0;
        }

        else if(cash.compareTo(number) > 0)     System.out.println("B" + (number.divide(price)));

        else System.out.println("S" + shares);


        try {
            Writer wr = new FileWriter("counter.txt");
            wr.write(Integer.toString(c));
            wr.close();
        } catch (IOException e) {
        }
   }
}

Skompiluj z javac SlowAndSteady.java. Uruchom z java -cp „SlowAndSteady” SlowAndSteady. Licznik powinien się resetować między rundami, ale jeśli plik zostanie usunięty, będzie również działał.

BuyHighSellLow

Śledzi historię rynku i kupuje, gdy cena jest niska, i sprzedaje, gdy jest wysoka.

import sys

storage = 'BuyHighSellLow'
turn = 0
turns = 50
max_start_price = 150
limit = 0.25

price = int(sys.argv[1])
money = int(sys.argv[2])
shares = int(sys.argv[3])

# Calculate average price
with open(storage+'/history', mode='a') as f:
            pass # Create file if it doesn't exist
with open(storage+'/history', mode='r') as f:
    values = list((int(line) for line in f))
    turn = len(values) + 1
    if turn > turns: turn = 1
    if turn == 1:
            average = max_start_price + 1
            turn = 1
    else:
            average = sum((value / turn for value in values))

# Buy low and sell high
if price < average:
    print('B' + str(int(limit * money / price)))
elif price > average:
    print('S' + str(int(limit * shares)))
else:
    print('W')

# Save history
if turn == 1: mode='w'
else: mode = 'a'
with open(storage+'/history', mode=mode) as f:
    print(price, file=f)

Biegnij z:

python3 BuyHighSellLow/buyhighselllow.py

Czas jest właściwy - Python 3

Nudziłem się, więc napisałem kolejny uczestnik ...

Ten młody przedsiębiorca żyje przez całą dobę. Kiedy nadejdzie właściwy czas, podejmuje decyzję. Irytująco używa francuskiego poza kontekstem ...;)

Biegać:

python3 timeisright.py [arg1] [arg2] [arg3]

Kod:

import sys, time

price = int(sys.argv[1])
money = int(sys.argv[2])
shares = int(sys.argv[3])

lheure = int(time.time())

if lheure % 3 == 0:
    print('S'+str(int(shares/4)))
elif lheure % 3 == 1:
    print('B'+str(int(money/4*price)))
else:
    print('W')

Timer Ol '- Fortran 77

Ten starzec zmarnuje swoją emeryturę po sześćdziesięciu latach pracy jako urzędnik biurowy. Jednak w podeszłym wieku stał się dość ślepy, więc widzi tylko pierwszą liczbę każdego argumentu, więc szacuje cenę. Jego metoda jest podobna do metody Walta, z tym wyjątkiem, że Ol 'Timer jest trochę bardziej nieostrożny.

Z powodu problemów z drukowaniem w Fortranie napisałem program w Pythonie, który pomoże. Program pobiera dostarczone argumenty i przekazuje je do programu Fortran. Następnie program Python ponownie formatuje dane wyjściowe do oczekiwanego formatu.

Skompilować:

gfortran oltimer.for -o oltimer.exe

Biegać:

python3 assistant.py [arg1] [arg2] [arg3]

Kod asystenta Python:

from subprocess import Popen, PIPE
import sys, re

ret = Popen('./oltimer.exe '+sys.argv[1]+' '+sys.argv[2]+' '+sys.argv[3], stdout=PIPE, shell=True).communicate()[0].decode('utf-8')
value=re.findall(r'\d+',ret)

if 'W' in ret:
     print('W')

elif 'B' in ret:
     print('B'+str(value[0]))

elif 'S' in ret:
     print('S'+str(value[0]))

Główny kod FORTRAN:

      PROGRAM OLTIMER
C DEFINE VARIABLES
          INTEGER :: PRICE
          INTEGER :: STOCK
          INTEGER :: MONEY
          INTEGER :: INTBUFFER
          CHARACTER :: BUFFER
C GET CMD ARGUMENTS & CONVERT TO INT
          CALL getarg(1, BUFFER)
          READ (BUFFER, '(i10)') PRICE
          CALL getarg(2, BUFFER)
          READ (BUFFER, '(i10)') MONEY
          CALL getarg(3, BUFFER)
          READ (BUFFER, '(i10)') STOCK
C EVALUATE SITUTATION AND MAKE DECISION
          IF (PRICE.LT.5) THEN
            IF (MONEY.GT.0) THEN
                INTBUFFER=(MONEY*50)/(5-PRICE)
                PRINT*,'B',INTBUFFER
            ELSE
                PRINT*,'W'
            END IF
          ELSE
            IF (PRICE.GT.9) THEN
                IF (STOCK.GT.0) THEN
                    INTBUFFER=STOCK/(PRICE-9)
                    PRINT*,'S',INTBUFFER
                ELSE
                    PRINT*,'W'
                END IF
            ELSE
                PRINT*,'W'
            END IF
          END IF      
      END PROGRAM

Test1 Trader

public class Test1 {

    public static void main(String[] args){
        int marketValue = Integer.parseInt(args[0]);
        int myMoney = Integer.parseInt(args[1]);
        int myShares = Integer.parseInt(args[2]);

        //Buy 10 if we don't have any.
        if(myShares <= 0){
            System.out.println("B10");
        }else{
            System.out.println("S1");
        }
    }
}

Kompiluj z javac Test1.javauruchom zjava -cp "Test1" Test1

Jeż - python2.7

Ma to głównie na celu zastrzeżenie nazwy

from __future__ import print_function
from sys import argv

storage = 'prices.txt'
price,cash,shares = map(long, argv[1:])
turn = 1
buy = lambda x: print('B%d' % long(x))
sell = lambda x: print('S%d' % long(x))
cashtoshares = lambda c: long(c/price)
TURN,PRICE,CASH,SHARES=range(4)

try:   
    data = [map(long, line.split()) for line in open(storage)]
    if data:
        turn = data[-1][TURN] + 1
except IOError:
    pass
with open(storage, 'a') as pricelist:
    pricelist.write('%d %d %d %d\n' % (turn, price, cash, shares))

if turn == 1:
    buy(cashtoshares(cash)) # convert all cash into shares
elif price == 1:
    buy(cashtoshares(cash)) # cannot buy at a better deal
elif price < 10:
    buy(cashtoshares(cash/2))
elif shares < 10:
    buy(cashtoshares(cash/2))
else:
    sell(shares/2)

Uruchom jako

python hedgehog.py PRICE CASH SHARES

BuyAndSell - C

Podobny, ale nie duplikat Tommy'ego. Na przemian można kupować jak najwięcej paniki i sprzedawać wszystko. Prawie duplikat Earthquakera, który zachowuje jedną akcję, podczas gdy BuyAndSell sprzedaje wszystkie akcje. BuyAndSell nie podejmuje żadnych działań, gdy nie ma akcji do sprzedaży, ale nie ma wystarczającej ilości pieniędzy, aby kupić jedną akcję.

/* BuyAndSell
 * Code revised from OptoKopper's WaitForCrash.c and my BuyAndHold.c
 * Alternates between buying as many shares as possible and selling everything
 * Run it as ./buyandsell PRICE MONEY SHARES
 */
int main(int argc, char *argv[]) {
    long long int share_price = strtoll(argv[1], NULL, 0);
    long long int money = strtoll(argv[2], NULL, 0);
    long long int shares = strtoll(argv[3], NULL, 0);

    if (money >= share_price) {
        printf("B%lld\n", money / share_price);
    } else {
        if (money == 0) {
            printf("S%lld\n", shares);
        } else {
            printf("W\n");
        }
    }

    return 0;
}

Skompiluj z „gcc buyandsell.c -o buyandsell”

Uruchom jako „./buyandsell AKCJE PIENIĘŻNE CENY

Gorge Soros

price = ARGV.shift
money = ARGV.shift
stock = ARGV.shift
if price*10<money
  puts "B10"
else
  puts "S#{stock}"
end

Kupuje powoli, niż sprzedaje wszystko, próbując załamać rynek.

Biegnij z:Soros.rb price money stock