sfondo

Siete tutti commercianti per una società per azioni poco meno che rispettabile. Siete tutti parte di un gruppo di operatori che si concentrano solo su uno stock specifico.

Ogni ora ogni operatore ha la possibilità di acquistare azioni X o vendere azioni X. Ci sono 50 ore per round e 3 round per competizione. Alla fine di tutti i round il commerciante con il valore medio più alto vince un viaggio in Giamaica!

gameplay

Ci sono 3 round da 50 turni ciascuno.

Ogni operatore inizia il round con $ 5000 e un numero casuale di azioni tra 20 e 30 azioni. Il prezzo delle azioni inizia con un numero casuale compreso tra 10 e 150.

Ogni turno ogni operatore può acquistare un numero qualsiasi di azioni che possono permettersi o vendere un numero qualsiasi di azioni che attualmente detengono, ciascuna per il prezzo corrente per azione.

Il prezzo per azione aumenta di un numero casuale compreso tra 1 e 5 per ciascuna azione acquistata e diminuisce di un valore casuale tra 2 e 6 per ogni azione venduta. Il prezzo minimo è di $ 1.

È importante notare che tutti i trader elaborano le loro transazioni contemporaneamente, il che significa che qualsiasi operatore che acquista / vende azioni non influenzerà il prezzo fino al turno successivo.

Vince il giocatore con il valore medio più alto alla fine dei 3 round. Il valore viene determinato prendendo la quantità di denaro rimasta alla fine del round e aggiungendo il numero di azioni possedute dal trader * che chiude il prezzo di mercato.

argomenti

Il tuo programma verrà rieseguito all'inizio di ogni turno ricevendo l'attuale prezzo di mercato, la quantità di denaro corrente del trader e il numero di azioni possedute da quel trader.

Ex:

120 5000 0

Produzione

Il programma del trader deve emettere una lettera corrispondente all'azione che vorrebbe intraprendere seguita dalla quantità.

Ex:

B10 //Buy 10 shares

o

S3 //Sell 3 shares

Il trader ha anche la possibilità di non fare nulla in quel turno. Ciò può essere realizzato emettendo una W o qualsiasi altro comando che non sia 'B> amnt <' o 'S> amnt <'

Inseriti

Il tuo programma sarà all'interno di una directory 'players /> nome del tuo programma <':

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

Fornisci il tuo codice insieme a un argomento della riga di comando per eseguirlo dall'interno della directory "players". Ad esempio, è possibile eseguire il trader Test1java -cp "Test1" Test1

Regole aggiuntive

Vai avanti, sparati a EmoWolf, Idc.

Non scherzare con nulla al di fuori della tua directory BotNameFolder, sentiti libero di creare file lì dentro per informazioni persistenti durante round / giri.

Non creare intenzionalmente programmi per interrompere la simulazione.

Accetterò più voci per utente, purché le voci fungano da entità separate (nessun insider trading).

Classifica

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

Proverò ad aggiornare la classifica almeno una volta al giorno

controllore

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

Compilalo con java Controller.javaed eseguilo da una directory contenente una directory come di seguito:

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

Il file configdovrebbe essere simile al seguente:

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

Il primo numero è il numero di round, il secondo numero è il turno per round, seguito dai comandi per eseguire ciascun giocatore.

Sostituisci gli spazi con e commerciali! ( '&')

~ Fammi sapere se posso migliorare la formulazione di questo post e buon trading!

Vi presento "sognatore ad occhi aperti", che dorme sempre e dimentica di comprare o vendere qualsiasi cosa. Spera che gli altri giocatori abbiano una perdita netta. Codice Python:

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

corri con python daydreamer\daydreamer.py 120 5000 0o qualunque valore tu voglia.

In seguito posterò una risposta più seria, questo è solo per far rotolare la palla :)

DayTrader

_{Aggiornato per il cambio di regola fatto il 21/08/2014, dove i giocatori ora iniziano con 20-30 azioni.}

Acquista il più possibile, quindi vende il più possibile.

Filosofia

Speriamo che lo schema seguente si ripeta più e più volte. Notare che aderendo a questo modello, contribuiamo anche ad esso.

• Tutti possono acquistare o conservare solo il primo round. Il valore può solo aumentare, quindi acquistiamo.
• Tutti possono acquistare di più, trattenere o vendere al secondo round. Non ci aspettiamo che molti giocatori acquistino al secondo round, quindi vendiamo.

Il modello è cristallino all'inizio. Valore farà aumentare dopo un giro. Dovrebbe diminuire dopo il secondo round. Oltre a ciò, le proiezioni diventano confuse. Mi aspetto di fare bene nei primi round, prima che il mercato si stabilizzi.

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

}

Compila con javac DayTrader.java. Corri con java -cp "DayTrader" DayTrader.

Walt Disney - Python 3

Walt aspetta fino a quando le azioni non toccano il fondo e poi compra quanto i suoi soldi lo consentono. Quindi, quando il prezzo sale, li vende tutti.

Basato sulla strategia Disney quando è "sopravvissuto" a Wall Street Crash. Sfortunatamente, il mio programma non può costruire parchi a tema ... Se solo ...

Correre:

python3 waltdisney.py

Codice:

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

sa solo quello che ha ma è determinato a rischiare tutto sul mercato. Se può comprare, lo farà. Se non può, vende tutto ciò che ha in modo da poterlo fare nel turno successivo. (Funzionerà bene con quelli estremi come DayTrader ma correggerà automaticamente se il valore diminuisce quando pensa che crescerà.)

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

Questo è lo stesso codice, ma se preferito. Ho scritto il java dopo nel caso fosse necessaria la cosa di BigInteger. Usa tutto ciò che è più 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;
}

Compilare con: gcc buyandhold.c -o buyandhold

Eseguilo con ./buyandhold PREZZO SOLDI AZIONI

Alfred Pennyworth - Python 2

Una sera, mentre ero fuori di pattuglia, Alfred ha provato a creare un programma di scambio di azioni a mia insaputa. Pensava di potermelo nascondere, ma l'ho trovato e ho capito cosa faceva. Perché sono Batman. Ora ho deciso di partecipare a un concorso per insegnargli una lezione.

Il denaro non è un oggetto per Alfred perché sono DAVVERO ricco, ma è ancora intelligente nel suo trading. Quando non ha più azioni, ne compra quante ne può permettersi, indipendentemente dal prezzo di mercato. Quindi vende 10 (o tutte le rimanenti) azioni ogni volta che il prezzo di mercato è superiore al prezzo a cui è stato acquistato.

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'

Corri con: python GoAwayMasterBruce.py <args>

NaiveBot

NaiveBot è nuovo in tutto questo hooplah "borsa". Suppone solo che quando il prezzo sta salendo dovrebbe comprare, e quando il prezzo scende dovrebbe vendere. Ma non è una linfa, ha un asso nella manica! Compra solo la metà di ciò che può permettersi e vende solo la metà di ciò che possiede.

Non vivere più in una scatola sotto l'autostrada per 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

Esegui con php Naivebot.php $1 $2 $3, crea un cache.jsonnella sua cartella corrente.

Profitto - Haskell

1. Attendere fino a quando il prezzo è 1 / maxValue
2. Compra / Vendi tutto
3. ????
4. PROFITTO!!!

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"

Compilare ghc profit.hsed eseguire con ./profit price money stock.

Se non è abbastanza efficiente, aggiungi -O3flag, anche se probabilmente è eccessivo: D

Modificare:

"ottimizzato", ora vende tutto quando il prezzo è uguale a Integer.MAX_VALUE.

WaitForCrash

EDIT: difetto fisso nel concetto

EDIT: ora usando long long int

Questo è il mio primo tentativo. Si comporta in modo molto semplice e mantiene una parte per distinguere se è il primo round o uno successivo. Nel primo round nulla può essere perso, quindi acquista quote. Se ha azioni, le vende. Se alla fine i prezzi delle azioni scenderanno a 10, acquisterà di nuovo.

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

compilare con: gcc waitforcrash.c -o waitforcrash

eseguilo come ./waitforcrash PRICE MONEY SHARES

Earthquaker

Si alterna tra l'acquisto di tutto e la vendita di tutto (tranne uno). In realtà non mira a vincere tanto quanto disturba tutti gli altri.

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

Compila con csc Earthquaker.cs. Corri con Earthquaker.

MonkeyTrader (in JAVA)

C'è un detto che le scimmie sono buoni commercianti. Faccio la prova. Le decisioni tra "compra" e "vendi" sono totalmente casuali.

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

1 ° round venderà le sue azioni se sono un buon prezzo: $ 80 o più. Quindi svenderà se il prezzo è uguale o migliore dell'ultimo prezzo a cui ha venduto, acquista se il prezzo è uguale o inferiore all'ultimo prezzo a cui ha acquistato.

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

Compilare con javac IntelliTrader . Esegui con IntelliTrader "IntelliTrader" di java -cp

theAnswerOfLifeIs42.py

Il mio programma ama il numero 42

La regola è semplice: posso acquistare 42 azioni o vendere 42 azioni.

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

Dato che la modifica della regola significa che ora iniziamo con alcune condivisioni, non c'è più una prima mossa migliore garantita, quindi l'ho semplificata rimuovendo il caso speciale per il primo turno.

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

Invoke as

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

Dollar Cost Averager - Python 3

Questa strategia tenta di utilizzare la media dei costi in dollari acquistando (il più vicino possibile) un importo fisso di denaro (fissato arbitrariamente a 150 in modo che probabilmente utilizzerà la maggior parte del suo denaro entro la fine) ogni turno.

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

Questo ragazzo è molto pessimista riguardo al mercato azionario. Preferirebbe tenere i suoi soldi in contanti dove può tenerli al sicuro sotto il suo materasso.

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

Lento e costante

Finché ha denaro, acquista azioni per un valore di $ 165. Altrimenti vende tutte le sue azioni per ottenere più denaro, per acquistare più azioni. Al 50 ° round si assicura di vendere tutte le azioni, perché alla fine vogliamo contanti.

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

Compilare con javac SlowAndSteady.java. Esegui con java -cp "SlowAndSteady" SlowAndSteady. Il contatore dovrebbe essere reimpostato tra i round, ma se il file viene eliminato, funzionerà anche.

BuyHighSellLow

Tiene traccia della storia del mercato e acquista quando il prezzo è basso e vende quando è alto.

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)

Corri con:

python3 BuyHighSellLow/buyhighselllow.py

Time is Right - Python 3

Mi sono annoiato e ho scritto un altro concorrente ...

Questo giovane imprenditore vive la sua vita a tutte le ore. Quando è il momento giusto, prende una decisione. Usa anche noiosamente il francese fuori dal contesto ...;)

Correre:

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

Codice:

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

Vecchio timer - Fortran 77

Questo vecchio sprecherà la pensione dopo sessant'anni di lavoro come impiegato. Durante la sua vecchiaia, tuttavia, divenne piuttosto cieco, quindi può vedere solo il primo numero di ogni argomento, quindi stima il prezzo. Il suo metodo è simile a quello di Walt, tranne per il fatto che Ol 'Timer è un po' più imprudente.

A causa dei problemi con la stampa Fortran, ho scritto un programma Python che mi aiuterà. Il programma prende gli argomenti forniti e li reindirizza al programma Fortran. Quindi, il programma Python riformatta l'output nel formato previsto.

Compilare:

gfortran oltimer.for -o oltimer.exe

Correre:

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

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

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

Compilare con javac Test1.javaEsegui conjava -cp "Test1" Test1

Riccio - pitone2.7

Questo è principalmente per riservare il nome

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)

Correre come

python hedgehog.py PRICE CASH SHARES

BuyAndSell - C

Simile ma non un duplicato di Tommy. Si alterna tra panico, acquisto il più possibile e vendita di tutto. Quasi un duplicato di Earthquaker che conserva una quota mentre BuyAndSell vende tutte le azioni. BuyAndSell non interviene se non ha azioni da vendere ma non ha abbastanza denaro per acquistare una azione.

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

Compilare con "gcc buyandsell.c -o buyandsell"

Esegui come "./buyandsell PREZZO SOLDI AZIONI

Gorge Soros

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

Compra lentamente, poi vende tutto nel tentativo di far crollare il mercato.

Corri con:Soros.rb price money stock