fundo

Vocês são todos comerciantes de uma firma de ações um pouco menos que respeitável. Vocês todos fazem parte de um grupo de traders que se concentram apenas em uma ação específica.

A cada hora, cada operador tem a chance de comprar ações X ou vender ações X. Existem 50 horas por rodada e 3 rodadas por competição. No final de todas as rodadas, o profissional com o maior valor médio ganha uma viagem à Jamaica!

Jogabilidade

Existem 3 rodadas de 50 turnos cada.

Cada trader começa a rodada com $ 5000 e um número aleatório de ações entre 20 e 30 ações. O preço das ações começa em um número aleatório entre 10 e 150.

A cada turno, cada operador pode comprar qualquer número de ações que puderem comprar ou vender qualquer número de ações que possua atualmente, cada uma pelo preço atual por ação.

O preço por ação aumenta em um número aleatório entre 1 e 5 para cada ação comprada e diminui em um valor aleatório entre 2 e 6 para cada ação vendida. O preço mínimo é de US $ 1.

É importante observar que todos os traders processam suas transações ao mesmo tempo, o que significa que qualquer trader que compre / venda ações não afetará o preço até o próximo turno.

O jogador com o maior valor médio no final das 3 rodadas vence. O valor é determinado pegando a quantia restante em dinheiro no final da rodada e adicionando o número de ações de propriedade do trader * no preço de mercado.

Argumentos

Seu programa será executado novamente no início de cada turno, recebendo o preço atual de mercado, a quantidade atual de dinheiro do trader e o número de ações pertencentes a esse trader.

Ex:

120 5000 0

Saída

Seu programa de trader deve emitir uma letra correspondente à ação que você deseja executar, seguida pela quantidade.

Ex:

B10 //Buy 10 shares

ou

S3 //Sell 3 shares

O comerciante também tem a opção de não fazer nada que vire. Isso pode ser realizado com a saída de um W ou de qualquer outro comando que não seja 'B> amnt <' ou 'S> amnt <'

Submissões

Seu programa estará dentro de um diretório 'players /> nome do seu programa <':

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

Forneça seu código junto com um argumento de linha de comando para executá-lo dentro do diretório 'players'. Por exemplo, o comerciante Test1 pode ser executado comjava -cp "Test1" Test1

Regras adicionais

Vá em frente, atire em si mesmo EmoWolf, Idc.

Não mexa com nada fora do diretório BotNameFolder, sinta-se à vontade para criar arquivos lá para informações persistentes durante as rodadas / turnos.

Não crie intencionalmente programas para travar a simulação.

Aceitarei várias entradas por usuário, desde que as entradas atuem como entidades separadas (sem informações privilegiadas).

Entre os melhores

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

Vou tentar atualizar a tabela de classificação pelo menos uma vez por dia

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 java Controller.javae execute a partir de um diretório que contém um diretório como abaixo:

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

O arquivo configdeve se parecer com isso:

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

O primeiro número é o número de rodadas, o segundo número é o turno por rodada, seguido pelos comandos para executar cada jogador.

Substitua espaços por e comercial! ('E')

~ Deixe-me saber se eu posso melhorar a redação deste post e uma negociação feliz!

Apresento 'sonhador', que está sempre dormindo e esquece de comprar ou vender qualquer coisa. Ele espera que outros jogadores tenham uma perda líquida. Código Python:

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

executar com python daydreamer\daydreamer.py 120 5000 0ou quaisquer valores que você desejar.

Vou postar uma resposta mais séria mais tarde, isso é apenas para fazer a bola rolar :)

DayTrader

_{Atualizado para alteração de regra feita em 21/08/2014, onde os jogadores agora começam com 20 a 30 compartilhamentos.}

Compra o máximo possível e depois vende o máximo possível.

Filosofia

Esperamos que o padrão abaixo se repita repetidamente. Observe que, aderindo a esse padrão, também contribuímos para ele.

• Todos podem comprar ou manter apenas a primeira rodada. O valor só pode aumentar, então compramos.
• Todos podem comprar mais, reter ou vender na segunda rodada. Não esperamos que muitos jogadores comprem na segunda rodada, então vendemos.

O padrão é claro no começo. Valor vai aumentar após uma rodada. Deve diminuir após a segunda rodada. Além disso, as projeções ficam confusas. Espero me sair bem nas primeiras rodadas, antes que o mercado se estabilize.

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

}

Compile com javac DayTrader.java. Corra com java -cp "DayTrader" DayTrader.

Walt Disney - Python 3

Walt espera até que as ações cheguem ao fundo do poço e depois compre o quanto o dinheiro permitir. Então, quando o preço sobe, ele vende todos eles.

Baseado na estratégia da Disney quando ele 'sobreviveu' ao acidente de Wall Street. Infelizmente, meu programa não pode construir parques temáticos ... Se apenas ...

Corre:

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

só sabe o que tem, mas está determinado a arriscar tudo no mercado. Se ele puder comprar, ele fará. Se ele não puder, ele vende tudo o que tem para poder no próximo turno. (Isso funcionará bem com situações extremas como o DayTrader, mas será corrigido automaticamente se o valor cair quando ele achar que vai aumentar.)

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 é o mesmo código, mas se preferir isso. Eu escrevi o java depois, caso a coisa do BigInteger fosse necessária. Use o que for mais 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 com: gcc buyandhold.c -o buyandhold

Execute-o com ./buyandhold AÇÕES DE PREÇO EM DINHEIRO

Alfred Pennyworth - Python 2

Enquanto eu estava em patrulha uma noite, Alfred tentou criar um programa de negociação de ações sem o meu conhecimento. Ele pensou que poderia esconder de mim, mas eu encontrei e descobri o que fazia. Porque eu sou o Batman. Agora eu decidi participar de uma competição para ensinar uma lição a ele.

Dinheiro não é problema para Alfred, porque eu sou REALMENTE rico, mas ele ainda é esperto em suas negociações. Quando ele está sem ações, ele compra o máximo que pode pagar, independentemente do preço de mercado. Em seguida, ele vende 10 (ou todas as demais) ações toda vez que o preço de mercado for superior ao preço pelo qual foi 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'

Correr com: python GoAwayMasterBruce.py <args>

NaiveBot

O NaiveBot é novo em toda essa brincadeira de "mercado de ações". Ele apenas supõe que quando o preço está subindo, ele deve comprar e quando o preço cai, ele deve vender. Mas ele não é idiota, ele tem um truque na manga! Ele só compra metade do que pode pagar e só vende metade do que tem.

Não há mais morar em uma caixa sob a rodovia para o 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

Executar com php Naivebot.php $1 $2 $3, cria um cache.jsonem sua pasta atual.

Lucro - Haskell

1. Aguarde até que o preço seja 1 / maxValue
2. Comprar / Vender tudo
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.hse executar com ./profit price money stock.

Se não for suficientemente eficiente, adicione -O3sinalizador, embora provavelmente seja um exagero: D

Editar:

"otimizado", agora vende tudo quando o preço é igual a Integer.MAX_VALUE.

WaitForCrash

EDIT: falha corrigida no conceito

EDIT: agora usando long long int

Esta é a minha primeira tentativa. Comporta-se realmente simples e mantém uma ação para distinguir se é a primeira rodada ou a posterior. No primeiro turno, nada pode ser perdido, por isso compra ações. Se tem ações, as vende. Se, eventualmente, os preços das ações caírem para 10, será comprado novamente.

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

ajuntar com: gcc waitforcrash.c -o waitforcrash

executá-lo como ./waitforcrash PRICE MONEY SHARES

Terremoto

Alterna entre comprar e vender tudo (menos um). Realmente não pretende ganhar tanto, como atrapalha todos os outros.

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

Compile com csc Earthquaker.cs. Corra com Earthquaker.

MonkeyTrader (em JAVA)

Há um ditado que diz que os macacos são bons comerciantes. Eu faço a prova. As decisões entre "comprar" e "vender" são totalmente aleatórias.

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

Na primeira rodada, ele venderá suas ações se tiverem um bom preço: US $ 80 ou mais. Então ele venderá se o preço for igual ou melhor que o último preço vendido, comprará se o preço for igual ou inferior ao último preço comprado.

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 com o javac IntelliTrader . Execute com java -cp "IntelliTrader" IntelliTrader

theAnswerOfLifeIs42.py

Meu programa ama o número 42

A regra é simples: posso comprar 42 ações ou vender 42 ações.

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)

Como a mudança de regra significa que agora começamos com alguns compartilhamentos, não há mais o melhor primeiro movimento garantido, então simplifiquei isso removendo o caso especial do primeiro 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>

Avaliador de Custos em Dólares - Python 3

Essa estratégia tenta usar a média dos custos em dólares comprando (o mais próximo possível) uma quantia fixa de dinheiro (arbitrariamente estabelecida em 150, de modo que provavelmente gastará a maior parte do seu dinheiro no final) a 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 ou 3

Esse cara é muito pessimista em relação ao mercado de ações. Ele prefere manter o dinheiro em dinheiro, onde pode mantê-lo seguro debaixo do colchão.

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

Lento e estável

Contanto que tenha dinheiro, compra 165 dólares em ações. Caso contrário, vende todas as suas ações para obter mais dinheiro e comprar mais ações. Na 50ª rodada, ele garante a venda de todas as ações, porque no final queremos dinheiro.

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 com javac SlowAndSteady.java. Execute com java -cp "SlowAndSteady" SlowAndSteady. O contador deve ser redefinido entre as rodadas, mas se o arquivo for excluído, ele também funcionará.

BuyHighSellLow

Rastreia o histórico do mercado e compra quando o preço baixo e vende quando está 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)

Correr com:

python3 BuyHighSellLow/buyhighselllow.py

O tempo está certo - Python 3

Fiquei entediado, então escrevi outro participante ...

Este jovem empresário vive sua vida 24 horas por dia. Quando é a hora certa, ele toma uma decisão. Ele também irrita o francês fora de contexto ...;)

Corre:

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 velho vai gastar sua pensão após sessenta anos de trabalho como balconista de escritório. Durante a velhice, no entanto, ele ficou bastante cego, para poder ver apenas o primeiro número de cada argumento e estimar o preço. Seu método é semelhante ao de Walt, exceto que o Ol 'Timer é um pouco mais descuidado.

Por causa dos problemas com a impressão do Fortran, escrevi um programa Python que ajudará. O programa pega os argumentos fornecidos e os canaliza para o programa Fortran. Em seguida, o programa Python reformata a saída no formato esperado.

Compilar:

gfortran oltimer.for -o oltimer.exe

Corre:

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

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

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

Compilar com javac Test1.javaexecutar comjava -cp "Test1" Test1

Ouriço - python2.7

Isso é principalmente para reservar o 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)

Correr como

python hedgehog.py PRICE CASH SHARES

BuyAndSell - C

Semelhante, mas não uma duplicata de Tommy. Alterna entre comprar pânico o máximo possível e vender tudo. Quase uma duplicata do Earthquaker, que retém uma ação enquanto a BuyAndSell vende todas as ações. BuyAndSell não toma nenhuma ação quando não possui ações para vender, mas não tem dinheiro suficiente para comprar uma ação.

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

Compile com "gcc buyandsell.c -o buyandsell"

Executar como "./buyandsell AÇÕES DE PREÇO EM DINHEIRO

Gorge Soros

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

Compra devagar, do que vende tudo, na tentativa de quebrar o mercado.

Correr com:Soros.rb price money stock