Fondo

Todos ustedes son comerciantes de una empresa de acciones un poco menos confiable. Todos ustedes son parte de un grupo de comerciantes que se enfocan solo en una acción específica.

Cada hora, cada operador tiene la oportunidad de comprar acciones X o vender acciones X. Hay 50 horas por ronda y 3 rondas por competencia. ¡Al final de todas las rondas, el operador con el valor promedio más alto gana un viaje a Jamaica!

Jugabilidad

Hay 3 rondas de 50 turnos cada una.

Cada operador comienza la ronda con $ 5000 y un número aleatorio de acciones entre 20 y 30 acciones. El precio de las acciones comienza en un número aleatorio entre 10 y 150.

Cada turno, cada operador puede comprar cualquier cantidad de acciones que pueda pagar o vender cualquier cantidad de acciones que posea actualmente, cada una por el precio actual por acción.

El precio por acción aumenta en un número aleatorio entre 1 y 5 por cada acción comprada y disminuye en un valor aleatorio entre 2 y 6 por cada acción vendida. El precio mínimo es de $ 1.

Es importante tener en cuenta que todos los comerciantes procesan sus transacciones al mismo tiempo, lo que significa que cualquier comerciante que compre / venda acciones no afectará el precio hasta el próximo turno.

El jugador con el valor promedio más alto al final de las 3 rondas gana. El valor se determina tomando la cantidad de dinero sobrante al final de la ronda y sumando el número de acciones que posee el comerciante * precio de mercado de cierre.

Argumentos

Su programa se volverá a ejecutar al comienzo de cada turno, recibiendo el precio de mercado actual, la cantidad actual de dinero del comerciante y la cantidad de acciones que posee ese comerciante.

Ex:

120 5000 0

Salida

Su programa de operador debe generar una carta correspondiente a la acción que le gustaría realizar, seguida de la cantidad.

Ex:

B10 //Buy 10 shares

o

S3 //Sell 3 shares

El comerciante también tiene la opción de no hacer nada en ese turno. Eso se puede lograr generando una W o cualquier otro comando que no sea 'B> amnt <' o 'S> amnt <'

Envíos

Su programa estará dentro de un directorio 'players /> su nombre de programa <':

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

Proporcione su código junto con un argumento de línea de comando para ejecutarlo desde dentro del directorio 'players'. Por ejemplo, el trader Test1 podría ejecutarse conjava -cp "Test1" Test1

Reglas Adicionales

Adelante, disparate EmoWolf, Idc.

No te metas con nada fuera de tu directorio BotNameFolder, siéntete libre de crear archivos allí para obtener información persistente durante rondas / turnos.

No cree programas intencionalmente para bloquear la simulación.

Aceptaré múltiples entradas por usuario, siempre que las entradas actúen como entidades separadas (sin información privilegiada).

Tabla de clasificación

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

Intentaré actualizar la tabla de clasificación al menos una vez al día

Controlador

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

Compile esto java Controller.javay ejecútelo desde un directorio que contenga un directorio como el siguiente:

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

El archivo configdebería verse así:

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

El primer número es el número de rondas, el segundo número es turnos por ronda, seguido de los comandos para ejecutar a cada jugador.

Reemplazar espacios con símbolos! ('Y')

~ Avísame si puedo mejorar la redacción de esta publicación, ¡y feliz negociación!

Les presento 'soñador', que siempre está dormido y se olvida de comprar o vender cualquier cosa. Espera que otros jugadores tengan una pérdida neta. Código de Python:

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

ejecutar con python daydreamer\daydreamer.py 120 5000 0o cualquier valor que desee.

Publicaré una respuesta más seria más tarde, esto es solo para que la pelota ruede :)

Comerciante del día

_{Actualizado para el cambio de reglas realizado el 21/08/2014, donde los jugadores ahora comienzan con 20-30 acciones.}

Compra tanto como sea posible, luego vende tanto como sea posible.

Filosofía

Esperamos que el siguiente patrón se repita una y otra vez. Tenga en cuenta que al cumplir con este patrón, también contribuimos a él.

• Todos solo pueden comprar o mantener la primera ronda. El valor solo puede aumentar, así que compramos.
• Todos pueden comprar más, retener o vender en la segunda ronda. No esperamos que muchos jugadores compren en la segunda ronda, así que vendemos.

El patrón es cristalino al principio. Valor se aumenta después de una ronda. Debería disminuir después de la segunda ronda. Más allá de eso, las proyecciones se vuelven borrosas. Espero hacerlo bien en las primeras rondas, antes de que el mercado se estabilice.

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

}

Compilar con javac DayTrader.java. Corre con java -cp "DayTrader" DayTrader.

Walt Disney - Python 3

Walt espera hasta que las acciones toquen fondo y luego compra tanto como su dinero lo permite. Luego, cuando el precio se dispara, los vende a todos.

Basado en la estrategia de Disney cuando "sobrevivió" a través del accidente de Wall Street. Desafortunadamente, mi programa no puede construir parques temáticos ... Si solo ...

Correr:

python3 waltdisney.py

Código:

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

solo sabe lo que tiene pero está decidido a arriesgarlo todo en el mercado. Si él puede comprar, lo hará. Si no puede, vende todo lo que tiene para poder pasar el próximo turno. (Esto funcionará bien con los extremos como DayTrader, pero se autocorregirá si el valor cae cuando cree que crecerá).

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

Este es el mismo código pero si lo prefiere. Escribí el java después en caso de que se necesitara lo de BigInteger. Usa lo que sea más fácil.

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

Compilar con: gcc buyandhold.c -o buyandhold

Ejecútelo con ./buyandhold PRECIO ACCIONES DINERO

Alfred Pennyworth - Python 2

Mientras estaba de patrulla una noche, Alfred intentó crear un programa de comercio de acciones sin que yo lo supiera. Pensó que podía ocultarlo, pero lo encontré y descubrí lo que hacía. Porque soy Batman. Ahora he decidido participar en una competencia para darle una lección.

El dinero no es un problema para Alfred porque soy REALMENTE rico, pero él todavía es inteligente con respecto a su comercio. Cuando se queda sin acciones, compra todas las que puede pagar, independientemente del precio de mercado. Luego vende 10 (o todas las acciones restantes) cada vez que el precio de mercado es más alto que el precio al que fue comprado.

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'

Corre con: python GoAwayMasterBruce.py <args>

NaiveBot

NaiveBot es nuevo en todo este alboroto del "mercado de valores". Simplemente asume que cuando el precio sube, debe comprar, y cuando baja el precio, debe vender. Pero él no es savia, ¡tiene un truco bajo la manga! Solo compra la mitad de lo que puede pagar, y solo vende la mitad de lo que tiene.

¡No más vivir en una caja debajo de la autopista para 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

Ejecutar con php Naivebot.php $1 $2 $3, hace un cache.jsonen su carpeta actual.

Beneficio - Haskell

1. Espere hasta que el precio sea 1 / maxValue
2. Compra / Vende todo
3. ????
4. ¡¡¡LUCRO!!!

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"

Compilar ghc profit.hsy ejecutar con ./profit price money stock.

Si no es lo suficientemente eficiente, agregue una -O3marca, aunque probablemente sea exagerado: D

Editar:

"optimizado", ahora vende todo cuando el precio es igual a Integer.MAX_VALUE.

WaitForCrash

EDITAR: error fijo en el concepto

EDITAR: ahora usando long long int

Este es mi primer intento. Se comporta de manera muy simple y mantiene un recurso compartido para distinguir si es la primera ronda o una posterior. En la primera ronda no se puede perder nada, por lo que compra acciones. Si tiene acciones, las vende. Si finalmente los precios de las acciones caen a 10, comprará nuevamente.

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

compilar con: gcc waitforcrash.c -o waitforcrash

ejecutarlo como ./waitforcrash PRICE MONEY SHARES

Earthquaker

Alterna entre comprar todo y vender todo (excepto uno). Realmente no pretende ganar tanto como perturba a todos los demás.

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

Compilar con csc Earthquaker.cs. Corre con Earthquaker.

MonkeyTrader (en JAVA)

Hay un dicho que dice que los monos son buenos comerciantes. Yo hago la prueba. Las decisiones entre "comprar" y "vender" son totalmente aleatorias.

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

En la primera ronda, venderá sus acciones si son un buen precio: $ 80 o más. Luego venderá si el precio es igual o mejor que el último precio al que vendió, comprará si el precio es igual o inferior al último precio que compró.

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

Compile con javac IntelliTrader . Ejecutar con java -cp "IntelliTrader" IntelliTrader

theAnswerOfLifeIs42.py

Mi programa ama el numero 42

La regla es simple: puedo comprar 42 acciones o vender 42 acciones.

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

Dado que el cambio de regla significa que ahora comenzamos con algunas acciones, ya no hay un mejor primer movimiento garantizado, por lo que he simplificado esto eliminando el caso especial para el primer 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));
        }
    }
}

Invocar como

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

Promedio del costo en dólares: Python 3

Esta estrategia intenta usar el promedio del costo en dólares comprando (lo más cerca posible) una cantidad fija de dinero (arbitrariamente establecida en 150 para que probablemente use la mayor parte de su dinero al final) cada 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

Este tipo es muy pesimista sobre el mercado de valores. Prefiere guardar su dinero en efectivo donde pueda mantenerlo seguro debajo de su colchón.

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

Lento pero seguro

Mientras tenga dinero, compra acciones por valor de $ 165. De lo contrario, vende todas sus acciones para obtener más dinero, para comprar más acciones. En la ronda 50 se asegura de vender todas las acciones, porque al final queremos efectivo.

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

Compile con javac SlowAndSteady.java. Ejecute con java -cp "SlowAndSteady" SlowAndSteady. El contador debe reiniciarse entre rondas, pero si se elimina el archivo, también funcionará.

Comprar alto vender

Rastrea la historia del mercado y compra cuando el precio es bajo y se vende cuando es 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)

Corre con:

python3 BuyHighSellLow/buyhighselllow.py

El tiempo es correcto - Python 3

Me aburrí, así que escribí otro participante ...

Este joven empresario vive su vida por el reloj. Cuando es el momento adecuado, toma una decisión. También usa molestamente el francés fuera de contexto ...;)

Correr:

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

Código:

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

Este viejo va a desperdiciar su pensión después de sesenta años de trabajo como empleado de oficina. Sin embargo, durante su vejez se quedó bastante ciego, por lo que solo puede ver el primer número de cada argumento, por lo que estima el precio. Su método es similar al de Walt, excepto que Ol 'Timer es un poco más descuidado.

Debido a los problemas con la impresión de Fortran, he escrito un programa Python que ayudará. El programa toma los argumentos suministrados y los canaliza al programa Fortran. Luego, el programa Python reformatea la salida al formato esperado.

Compilar:

gfortran oltimer.for -o oltimer.exe

Correr:

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

Código de asistente de 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]))

Código principal de 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");
        }
    }
}

Compilar con javac Test1.javaejecutar conjava -cp "Test1" Test1

Erizo - python2.7

Esto es principalmente para reservar el nombre

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)

Correr como

python hedgehog.py PRICE CASH SHARES

BuyAndSell - C

Similar pero no un duplicado de Tommy. Alterna entre el pánico comprando tanto como sea posible y vendiendo todo. Casi un duplicado de Earthquaker que retiene una acción mientras BuyAndSell vende todas las acciones. BuyAndSell no toma medidas cuando no tiene acciones para vender pero no tiene suficiente dinero para comprar una acción.

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

Compilar con "gcc buyandsell.c -o buyandsell"

Ejecutar como "./buyandsell PRECIO ACCIONES DINERO

Garganta Soros

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

Compra lentamente, que vende todo en un intento de colapsar el mercado.

Corre con:Soros.rb price money stock