Contexte

Vous êtes tous des commerçants pour une société d’achat peu réputée. Vous faites tous partie d'un groupe de commerçants qui se concentrent uniquement sur un stock spécifique.

Chaque heure, chaque opérateur a la possibilité d'acheter X actions ou de vendre X actions. Il y a 50 heures par tour et 3 tours par compétition. À la fin de tous les tours, le commerçant avec la valeur moyenne la plus élevée gagne un voyage en Jamaïque!

Gameplay

Il y a 3 tours de 50 tours chacun.

Chaque opérateur commence le tour avec 5000 $ et un nombre aléatoire d’actions entre 20 et 30 actions. Le prix des actions commence à un nombre aléatoire compris entre 10 et 150.

Chaque tour, chaque opérateur peut acheter n'importe quel nombre d'actions qu'il peut se permettre ou vendre n'importe quel nombre d'actions qu'il détient actuellement, chacun pour le prix actuel par action.

Le prix par action augmente d'un nombre aléatoire entre 1 et 5 pour chaque action achetée et diminue d'une valeur aléatoire entre 2 et 6 pour chaque action vendue. Le prix minimum est de 1 $.

Il est important de noter que tous les traders traitent leurs transactions en même temps, ce qui signifie que tout trader achetant / vendant des actions n'aura aucune incidence sur le prix jusqu'au prochain tour.

Le joueur avec la valeur moyenne la plus élevée à la fin des 3 tours gagne. La valeur est déterminée en prenant le montant restant à la fin du tour et en ajoutant le nombre d’actions possédées par le trader *.

Arguments

Votre programme sera relancé au début de chaque tour et recevra le prix du marché actuel, le montant actuel de l'argent du trader et le nombre d'actions qu'il possède.

Ex:

120 5000 0

Sortie

Votre programme de commerçant doit générer une lettre correspondant à l'action qu'il souhaite entreprendre, suivie de la quantité.

Ex:

B10 //Buy 10 shares

ou

S3 //Sell 3 shares

Le commerçant a également la possibilité de ne rien faire à son tour. Cela peut être accompli en émettant un W ou toute autre commande qui n'est pas 'B> amnt <' ou 'S> amnt <'

Les soumissions

Votre programme sera dans un répertoire 'players /> votre nom de programme <':

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

Veuillez fournir votre code avec un argument de ligne de commande pour l'exécuter à partir du répertoire "players". Par exemple, le commerçant Test1 pourrait être exécuté avecjava -cp "Test1" Test1

Règles additionnelles

Allez-y, tirez vous-même EmoWolf, Idc.

Pas de problème avec quoi que ce soit en dehors de votre répertoire BotNameFolder, n'hésitez pas à créer des fichiers là-bas pour des informations persistantes tout au long des tours.

Ne créez pas intentionnellement de programmes pour bloquer la simulation.

J'accepterai plusieurs entrées par utilisateur, à condition qu'elles agissent comme des entités distinctes (pas de délit d'initié).

Classement

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

Je vais essayer de mettre à jour le classement au moins une fois par jour

Manette

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

Compilez ceci avec java Controller.javaet lancez-le depuis un répertoire contenant un répertoire comme ci-dessous:

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

Le fichier configdevrait ressembler à ceci:

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

Le premier nombre est le nombre de tours, le second nombre est le nombre de tours par tour, suivi des commandes pour exécuter chaque joueur.

Remplacez les espaces par des esperluettes! ('&')

~ Faites-moi savoir si je peux améliorer la formulation de ce post du tout, et bon négoce!

Je vous présente 'rêveur', qui est toujours endormi et oublie d'acheter ou de vendre n'importe quoi. Il espère que les autres joueurs auront une perte nette. Code python:

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

courir avec python daydreamer\daydreamer.py 120 5000 0 ou quelles que soient les valeurs que vous voulez.

Je posterai une réponse plus sérieuse plus tard, ceci est juste pour faire avancer les choses :)

DayTrader

_{Mise à jour pour le changement de règle effectué le 21/08/2014, où les joueurs commencent maintenant avec 20-30 actions.}

Achète autant que possible, puis vend autant que possible.

Philosophie

Nous espérons que le schéma ci-dessous se répète encore et encore. Notez qu'en adhérant à ce modèle, nous y contribuons également.

• Tout le monde ne peut acheter ou conserver que le premier tour. La valeur ne peut qu'augmenter, alors nous achetons.
• Tout le monde peut acheter plus, détenir ou vendre au deuxième tour. Nous ne nous attendons pas à ce que beaucoup de joueurs achètent au deuxième tour, alors nous vendons.

Le motif est limpide au début. Valeur va augmenter après un tour. Il devrait diminuer après le deuxième tour. Au-delà, les projections deviennent floues. Je m'attends à bien réussir au début, avant que le marché ne se stabilise.

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

}

Compiler avec javac DayTrader.java. Courez avec java -cp "DayTrader" DayTrader.

Walt Disney - Python 3

Walt attend que les actions atteignent le fond, puis achète autant que son argent le permet. Puis, lorsque le prix augmente, il les vend tous.

Basé sur la stratégie de Disney lorsqu'il a "survécu" au crash de Wall Street. Malheureusement, mon programme ne peut pas construire de parcs à thème ... Si seulement ...

Courir:

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

sait seulement ce qu’il a mais est déterminé à tout risquer sur le marché. S'il peut acheter, il le fera. S'il ne peut pas, il vend tout ce qu'il a afin de pouvoir tourner. (Cela fonctionnera bien avec des extrêmes tels que DayTrader, mais se corrigera automatiquement si la valeur chute quand il pense que cela va augmenter.)

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

C'est le même code mais si préféré ceci. J'ai écrit le java après au cas où la chose BigInteger serait nécessaire. Utilisez ce qui est plus facile.

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

Compiler avec: gcc buyandhold.c -o buyandhold

Exécutez-le avec ./ ACHETER ET ACHETER DES ACTIONS

Alfred Pennyworth - Python 2

Alors que je partais en patrouille un soir, Alfred a essayé de créer un programme de négociation d'actions à mon insu. Il pensait qu'il pourrait me le cacher, mais je l'ai trouvé et j'ai compris ce qu'il en était. Car je suis batman. Maintenant, j'ai décidé de participer à un concours pour lui donner une leçon.

Alfred n’a aucun mal à gagner de l’argent parce que je suis VRAIMENT riche, mais il est toujours intelligent dans ses échanges commerciaux. Lorsqu'il n'a plus d'actions, il en achète autant qu'il peut se permettre, quel que soit le prix du marché. Ensuite, il vend 10 (ou toutes les actions restantes) chaque fois que le prix du marché est supérieur au prix auquel il a été acheté.

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'

Courir avec: python GoAwayMasterBruce.py <args>

NaiveBot

NaiveBot est nouveau pour tous ces hooplah "boursiers". Il suppose simplement que, lorsque le prix augmente, il devrait acheter et que, lorsque le prix baisse, il devrait vendre. Mais ce n'est pas une sève, il a un tour dans son sac! Il n'achète jamais que la moitié de ce qu'il peut se permettre et ne vend jamais que la moitié de ce qu'il a.

Plus besoin de vivre dans une boîte sous l'autoroute pour 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

Exécuter avec php Naivebot.php $1 $2 $3, crée un cache.jsondans son dossier actuel.

Bénéfice - Haskell

1. Attendez que le prix soit 1 / maxValue
2. Tout acheter / vendre
3. ????
4. PROFIT!!!

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"

Compiler avec ghc profit.hset courir avec./profit price money stock .

Si cela n’est pas assez efficace, ajoutez -O3flag, bien que ce soit probablement excessif: D

Modifier:

"optimisé", vend maintenant tout lorsque le prix est égal à Integer.MAX_VALUE.

WaitForCrash

EDIT: défaut de concept corrigé

EDIT: utilise maintenant long long int

Ceci est mon premier essai. Il se comporte très simplement et conserve une action pour distinguer s'il s'agit du premier tour ou d'un tour suivant. Au premier tour, rien ne peut être perdu, donc il achète des actions. S'il a des actions, il les vend. Si les prix des actions tombent finalement à 10, il achètera à nouveau.

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

compiler avec: gcc waitforcrash.c -o waitforcrash

l'exécuter comme ./waitforcrash PRICE MONEY SHARES

Earthquaker

Alternes entre tout acheter et tout vendre (sauf un). Il ne s'agit pas vraiment de gagner autant que de déranger tout le monde.

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

Compiler avec csc Earthquaker.cs. Courez avec Earthquaker.

MonkeyTrader (en JAVA)

Il y a un dicton qui dit que les singes sont de bons commerçants. Je fais la preuve. Les décisions entre "acheter" et "vendre" sont totalement aléatoires.

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

1er tour, il vendra ses actions si elles sont à un bon prix: 80 $ ou plus. Ensuite, il vendra si le prix est égal ou supérieur au dernier prix auquel il a vendu, achetez si le prix est identique ou inférieur au dernier prix auquel il a acheté.

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

Compiler avec javac IntelliTrader . Exécuter avec java-cp "IntelliTrader" IntelliTrader

theAnswerOfLifeIs42.py

Mon programme aime le nombre 42

La règle est simple: je peux acheter 42 actions ou en vendre 42 actions.

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

Étant donné que le changement de règle signifie que nous commençons avec certaines actions, il n'y a plus de garantie de meilleur premier mouvement, c'est pourquoi j'ai simplifié cela en supprimant le cas spécial du premier tour.

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

Invoquer comme

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

Dollar Averager - Python 3

Cette stratégie tente d’utiliser une moyenne monétaire en achetant (le plus près possible) un montant fixe (fixé arbitrairement à 150 afin qu’il utilise probablement la plus grande partie de son argent d’ici la fin) à chaque tour.

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

L'argent est roi - Python 2 ou 3

Ce gars est très pessimiste à propos du marché boursier. Il préfère garder son argent en espèces où il peut le garder en sécurité sous son matelas.

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

Lente et régulière

Tant qu'il a de l'argent, il achète des actions pour une valeur de 165 $. Sinon, il vend toutes ses actions pour obtenir plus d’argent, pour acheter plus d’actions. Au 50ème tour, il s'assure de vendre toutes les actions, car au final nous voulons de l'argent.

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

Compilez avec javac SlowAndSteady.java. Exécutez avec java -cp "SlowAndSteady" SlowAndSteady. Le compteur doit être réinitialisé entre les tours, mais si le fichier est supprimé, cela fonctionnera également.

BuyHighSellLow

Suit l'historique du marché et achète lorsque le prix est bas et vend quand il est élevé.

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)

Courir avec:

python3 BuyHighSellLow/buyhighselllow.py

Le temps est propice - Python 3

Je me suis ennuyé alors j'ai écrit un autre participant ...

Ce jeune entrepreneur vit sa vie à l'horloge. Quand le moment est venu, il prend une décision. Il utilise aussi le français hors contexte de manière agaçante ...;)

Courir:

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

Ol 'Timer - Fortran 77

Ce vieil homme va perdre sa pension après soixante ans de travail de commis de bureau. Au cours de sa vieillesse, cependant, il est devenu tout à fait aveugle. Il ne peut donc voir que le premier chiffre de chaque argument, il estime donc le prix. Sa méthode est similaire à celle de Walt, sauf qu'Ol 'Timer est un peu plus insouciant.

En raison des problèmes d'impression Fortran, j'ai écrit un programme Python qui aidera. Le programme prend les arguments fournis et les transmet au programme Fortran. Ensuite, le programme Python reformate la sortie au format attendu.

Compiler:

gfortran oltimer.for -o oltimer.exe

Courir:

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

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

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

Compiler avec javac Test1.javarun avecjava -cp "Test1" Test1

Hérisson - Python2.7

C'est surtout pour réserver le nom

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)

Courir comme

python hedgehog.py PRICE CASH SHARES

BuyAndSell - C

Semblable mais pas une copie de Tommy. Alterne entre la panique d'achat autant que possible et tout vendre. Presque un duplicata de Earthquaker qui conserve une action alors que BuyAndSell vend toutes ses actions. BuyAndSell ne prend aucune mesure lorsqu'il n'a pas d'actions à vendre mais qu'il ne dispose pas d'assez d'argent pour en acheter une.

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

Compiler avec "gcc buyandsell.c -o buyandsell"

Courir en tant que "./achatsetell PRIX ACTIONS D'ARGENT

Gorge Soros

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

Achète lentement, que vend tout pour tenter de faire planter le marché.

Courir avec:Soros.rb price money stock