Hintergrund

Sie sind alle Händler für eine etwas weniger als seriöse Aktiengesellschaft. Sie alle gehören zu einer Gruppe von Händlern, die sich nur auf eine bestimmte Aktie konzentrieren.

Jeder Händler hat stündlich die Möglichkeit, X Aktien zu kaufen oder X Aktien zu verkaufen. Es gibt 50 Stunden pro Runde und 3 Runden pro Wettbewerb. Am Ende aller Runden gewinnt der Trader mit dem höchsten Durchschnittswert eine Reise nach Jamaika!

Gameplay

Es gibt 3 Runden à 50 Runden.

Jeder Händler beginnt die Runde mit 5000 $ und einer zufälligen Anzahl von Aktien zwischen 20 und 30 Aktien. Der Kurs der Aktien beginnt bei einer Zufallszahl zwischen 10 und 150.

In jeder Runde kann jeder Händler eine beliebige Anzahl von Aktien kaufen, die er sich leisten kann, oder eine beliebige Anzahl von Aktien verkaufen, die er derzeit hält, jeweils zum aktuellen Preis pro Aktie.

Der Preis pro Aktie erhöht sich um eine Zufallszahl zwischen 1 und 5 für jede gekaufte Aktie und verringert sich um einen Zufallswert zwischen 2 und 6 für jede verkaufte Aktie. Der Mindestpreis beträgt 1 US-Dollar.

Es ist wichtig zu beachten, dass alle Händler ihre Transaktionen zur gleichen Zeit abwickeln, was bedeutet, dass jeder Händler, der Aktien kauft / verkauft, den Preis erst in der nächsten Runde beeinflusst.

Der Spieler mit dem höchsten Durchschnittswert am Ende der 3 Runden gewinnt. Der Wert wird bestimmt, indem der am Ende der Runde verbleibende Geldbetrag addiert wird und die Anzahl der Aktien addiert wird, die sich im Besitz des Händlers befinden.

Argumente

Ihr Programm wird zu Beginn jeder Runde erneut ausgeführt und erhält den aktuellen Marktpreis, den aktuellen Geldbetrag des Händlers und die Anzahl der Aktien, die dieser Händler besitzt.

Ex:

120 5000 0

Ausgabe

Ihr Händlerprogramm muss einen Brief ausgeben, der der Aktion entspricht, die es ausführen möchte, gefolgt von der Menge.

Ex:

B10 //Buy 10 shares

oder

S3 //Sell 3 shares

Der Händler hat auch die Möglichkeit, in dieser Runde nichts zu tun. Dies kann erreicht werden, indem ein W oder ein anderer Befehl ausgegeben wird, der nicht 'B> amnt <' oder 'S> amnt <' ist.

Einreichungen

Ihr Programm befindet sich in einem Verzeichnis "players /> your program name <":

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

Bitte geben Sie Ihren Code zusammen mit einem Befehlszeilenargument an, um ihn im Verzeichnis "players" auszuführen. Zum Beispiel könnte der Test1-Händler mit ausgeführt werdenjava -cp "Test1" Test1

Zusätzliche Regeln

Mach weiter, erschieß dich selbst EmoWolf, Idc.

Sie dürfen nichts außerhalb Ihres BotNameFolder-Verzeichnisses ändern. Sie können jedoch auch Dateien darin erstellen, um über Runden / Runden hinweg beständige Informationen zu erhalten.

Erstellen Sie keine Programme, um die Simulation zum Absturz zu bringen.

Ich akzeptiere mehrere Einträge pro Benutzer, solange die Einträge als separate Einheiten fungieren (kein Insiderhandel).

Bestenliste

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

Ich werde versuchen, die Bestenliste mindestens einmal am Tag zu aktualisieren

Regler

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;
    }
}

Kompilieren Sie dies mit java Controller.javaund führen Sie es aus einem Verzeichnis aus, das ein Verzeichnis wie das folgende enthält:

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

Die Datei configsollte ungefähr so ​​aussehen:

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

Die erste Zahl ist die Anzahl der Runden, die zweite Zahl ist die Anzahl der Runden, gefolgt von den Befehlen zum Ausführen der einzelnen Spieler.

Ersetzen Sie Leerzeichen durch Et-Zeichen! ('&')

~ Lass es mich wissen, wenn ich den Wortlaut dieses Beitrags überhaupt verbessern kann und viel Spaß beim Handeln!

Ich präsentiere 'Tagträumer', der immer schläft und vergisst, etwas zu kaufen oder zu verkaufen. Er hofft, dass andere Spieler einen Nettoverlust haben werden. Python-Code:

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

Laufen Sie mit python daydreamer\daydreamer.py 120 5000 0oder mit beliebigen Werten.

Ich werde später eine ernstere Antwort posten, dies ist nur, um den Ball ins Rollen zu bringen :)

Day-Trader

_{Aktualisiert für die Regeländerung am 21.08.2014, bei der Spieler jetzt mit 20 bis 30 Anteilen beginnen.}

Kauft so viel wie möglich und verkauft dann so viel wie möglich.

Philosophie

Wir hoffen, dass sich das folgende Muster immer wieder wiederholt. Beachten Sie, dass wir durch die Einhaltung dieses Musters auch dazu beitragen.

• Jeder kann nur die erste Runde kaufen oder halten. Der Wert kann nur steigen, also kaufen wir.
• Jeder kann in Runde zwei mehr kaufen, halten oder verkaufen. Wir erwarten nicht, dass viele Spieler in Runde zwei kaufen, also verkaufen wir.

Das Muster ist am Anfang kristallklar. Wert wird nach Runde eins erhöhen. Es sollte nach Runde zwei abnehmen. Darüber hinaus verschwimmen die Projektionen. Ich gehe davon aus, dass ich mich in den ersten Runden gut behaupten kann, bevor sich der Markt stabilisiert.

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());
        }
    }

}

Kompilieren mit javac DayTrader.java. Laufen Sie mit java -cp "DayTrader" DayTrader.

Walt Disney - Python 3

Walt wartet, bis die Aktien den Tiefpunkt erreicht haben, und kauft dann so viel, wie sein Geld erlaubt. Dann, wenn der Preis steigt, verkauft er sie alle.

Basierend auf Disneys Strategie, als er den Wall Street Crash überlebt hat. Leider kann mein Programm keine Themenparks bauen ... Wenn nur ...

Lauf:

python3 waltdisney.py

Code:

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

weiß nur, was er hat, ist aber entschlossen, alles auf dem Markt zu riskieren. Wenn er kaufen kann, wird er. Wenn er nicht kann, verkauft er alles, was er hat, damit er weiter machen kann. (Dies funktioniert gut mit extremen wie DayTrader, korrigiert sich jedoch automatisch, wenn der Wert sinkt, wenn er glaubt, dass er wachsen wird.)

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

Dies ist derselbe Code, aber falls gewünscht. Ich schrieb das Java danach, falls das BigInteger-Ding benötigt wurde. Verwenden Sie, was einfacher ist.

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;
}

Kompilieren Sie mit: gcc buyandhold.c -o buyandhold

Führen Sie es mit ./buyandhold PRICE MONEY SHARES aus

Alfred Pennyworth - Python 2

Während ich eines Nachts auf Patrouille war, versuchte Alfred ohne mein Wissen ein Aktienhandelsprogramm zu erstellen. Er dachte, er könnte es vor mir verstecken, aber ich fand es und fand heraus, was es tat. Weil ich Batman bin. Jetzt habe ich beschlossen, an einem Wettbewerb teilzunehmen, um ihm eine Lektion zu erteilen.

Geld ist Alfred egal, denn ich bin WIRKLICH reich, aber er ist immer noch schlau in Bezug auf seinen Handel. Wenn er keine Aktien mehr hat, kauft er so viele, wie er sich leisten kann, unabhängig vom Marktpreis. Dann verkauft er 10 (oder alle verbleibenden) Aktien jedes Mal, wenn der Marktpreis höher ist als der Preis, zu dem er gekauft wurde.

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'

Laufen mit: python GoAwayMasterBruce.py <args>

NaiveBot

NaiveBot ist neu für all diesen "Börsen" -Rummel. Er geht einfach davon aus, dass er kaufen sollte, wenn der Preis steigt, und verkaufen sollte, wenn der Preis fällt. Aber er ist kein Trottel, er hat einen Trick im Ärmel! Er kauft immer nur die Hälfte von dem, was er sich leisten kann, und verkauft immer nur die Hälfte von dem, was er hat.

Kein Leben mehr in einer Kiste unter der Autobahn für NaiveBot!

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

Ausführen mit php Naivebot.php $1 $2 $3, macht ein cache.jsonin seinem aktuellen Ordner.

Gewinn - Haskell

1. Warten Sie, bis der Preis 1 / maxValue ist
2. Kaufe / verkaufe alles
3. ????
4. PROFITIEREN!!!

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"

Kompiliere mit ghc profit.hsund starte mit./profit price money stock .

Wenn es nicht effizient genug ist, füge -O3flag hinzu, obwohl es wahrscheinlich zu viel ist: D

Bearbeiten:

"optimiert" verkauft jetzt alles, wenn der Preis gleich ist Integer.MAX_VALUE.

WaitForCrash

EDIT: Fehler im Konzept behoben

EDIT: jetzt mit long long int

Dies ist mein erster Versuch. Es verhält sich sehr einfach und behält einen Anteil, um zu unterscheiden, ob es die erste Runde oder eine spätere ist. In der ersten Runde kann nichts verloren gehen, es werden also Aktien gekauft. Wenn es Aktien hat, verkauft es sie. Wenn der Aktienkurs irgendwann auf 10 fällt, kauft er wieder.

#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;
}

kompilieren mit: gcc waitforcrash.c -o waitforcrash

lass es laufen als ./waitforcrash PRICE MONEY SHARES

Erdbeben

Wechselt zwischen Kauf und Verkauf von allem (außer einem). Es zielt nicht wirklich darauf ab, so viel zu gewinnen, wie es alle anderen stört.

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();
        }
    }
}

Kompilieren mit csc Earthquaker.cs. Laufen Sie mit Earthquaker.

MonkeyTrader (in Java)

Es gibt ein Sprichwort, dass Affen gute Händler sind. Ich mache den Beweis. Entscheidungen zwischen "Kaufen" und "Verkaufen" sind völlig zufällig.

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

In der ersten Runde wird er seine Aktien verkaufen, wenn sie einen guten Preis haben: 80 USD oder mehr. Dann wird er verkaufen, wenn der Preis gleich oder besser ist als der letzte Preis, zu dem er verkauft hat, und kaufen, wenn der Preis gleich oder niedriger ist als der letzte Preis, zu dem er gekauft hat.

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();
        }
    }
}

Kompilieren Sie mit javac IntelliTrader . Führen Sie mit Java-CP "IntelliTrader" IntelliTrader

theAnswerOfLifeIs42.py

Mein Programm liebt die Nummer 42

Die Regel ist einfach: Ich kann entweder 42 Aktien kaufen oder 42 Aktien verkaufen.

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

Da die Regeländerung bedeutet, dass wir jetzt mit einigen Aktien beginnen, gibt es keinen garantierten besten ersten Zug mehr. Deshalb habe ich dies vereinfacht, indem ich den Sonderfall für die erste Runde entferne.

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

Aufrufen als

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

Dollar Cost Averager - Python 3

Bei dieser Strategie wird versucht, die Durchschnittskosten in US-Dollar zu berechnen, indem in jeder Runde ein fester Geldbetrag (willkürlich auf 150 festgelegt) gekauft wird.

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 oder 3

Dieser Typ sieht die Börse sehr pessimistisch. Er möchte sein Geld lieber in bar aufbewahren, wo er es sicher unter seiner Matratze aufbewahren kann.

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

Langsam und stetig

Solange es Geld hat, kauft es Aktien im Wert von 165 USD. Andernfalls verkauft es alle seine Aktien, um mehr Geld zu verdienen und mehr Aktien zu kaufen. In der 50. Runde wird sichergestellt, dass alle Aktien verkauft werden, weil wir am Ende Bargeld wollen.

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

Kompilieren Sie mit javac SlowAndSteady.java. Führen Sie mit Java -cp "SlowAndSteady" SlowAndSteady. Der Zähler sollte zwischen den Runden zurückgesetzt werden, aber wenn die Datei gelöscht wird, funktioniert dies auch.

BuyHighSellLow

Verfolgt die Marktgeschichte und kauft, wenn der Preis niedrig ist und verkauft, wenn er hoch ist.

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)

Laufen mit:

python3 BuyHighSellLow/buyhighselllow.py

Die Zeit ist reif - Python 3

Mir wurde langweilig und ich schrieb einen anderen Teilnehmer ...

Dieser junge Unternehmer lebt sein Leben nach der Uhr. Wenn die Zeit reif ist, trifft er eine Entscheidung. Er benutzt auch ärgerlicherweise Französisch außerhalb des Kontexts ...;)

Lauf:

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

Code:

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

Alter Timer - Fortran 77

Dieser alte Mann wird seine Rente verschwenden, nachdem er sechzig Jahre als Bürokaufmann gearbeitet hat. Im Alter wurde er jedoch ziemlich blind, sodass er nur die erste Nummer jedes Arguments sehen kann und den Preis schätzt. Seine Methode ähnelt der von Walt, nur dass Ol 'Timer ein wenig nachlässiger ist.

Wegen der Probleme mit dem Fortran-Druck habe ich ein Python-Programm geschrieben, das helfen wird. Das Programm übernimmt die angegebenen Argumente und leitet sie an das Fortran-Programm weiter. Anschließend formatiert das Python-Programm die Ausgabe in das erwartete Format um.

Kompilieren:

gfortran oltimer.for -o oltimer.exe

Lauf:

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

Python-Assistentencode:

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

FORTRAN-Hauptcode:

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

Kompiliere mit javac Test1.javarun withjava -cp "Test1" Test1

Igel - Python2.7

Dies dient hauptsächlich der Namensreservierung

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)

Rennen wie

python hedgehog.py PRICE CASH SHARES

BuyAndSell - C

Ähnlich, aber kein Duplikat von Tommy. Wechselt zwischen Panik, wenn man so viel wie möglich kauft und alles verkauft. Fast ein Duplikat von Earthquaker, das eine Aktie behält, während BuyAndSell alle Aktien verkauft. BuyAndSell ergreift keine Maßnahmen, wenn es keine Aktien zum Verkauf hat, aber nicht genug Geld hat, um eine Aktie zu kaufen.

/* 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;
}

Kompiliere mit "gcc buyandsell.c -o buyandsell"

Führen Sie den Befehl "./buyandsell PRICE MONEY SHARES" aus

Schlucht Soros

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

Kauft langsam und verkauft dann alles, um den Markt zum Absturz zu bringen.

Laufen mit:Soros.rb price money stock