Фон

Ви всі торговці трохи менше, ніж авторитетна акціонерна фірма. Ви всі є частиною групи торговців, яка зосереджується лише на одному конкретному складі.

Щогодини кожен торговець має шанс придбати X акцій або продати X акцій. Проводиться 50 годин на раунд і 3 тури на змагання. В кінці всіх раундів, трейдер з найвищим середнім значенням виграє поїздку на Ямайку!

Ігровий процес

Проводиться 3 раунди по 50 витків у кожному.

Кожен трейдер розпочинає раунд з $ 5000 та випадковою кількістю акцій від 20 до 30 акцій. Ціна акцій починається з випадкового числа між 10 і 150.

Кожен поворот кожен трейдер може придбати будь-яку кількість акцій, яку може собі дозволити, або продати будь-яку кількість акцій, які вони зараз мають, кожна за поточною ціною за акцію.

Ціна на одну акцію збільшується випадковим числом від 1 до 5 для кожної купленої акції і зменшується на випадкове значення між 2 і 6 для кожної проданої акції. Мінімальна ціна - 1 долар.

Важливо зазначити, що всі торговці обробляють свої операції одночасно, це означає, що будь-який трейдер, який купує / продає акції, не вплине на ціну до наступної черги.

Гравець з найвищим середнім значенням в кінці 3 раундів виграє. Цінність визначається, беручи суму грошей, що залишилася в кінці раунду, і додаючи кількість акцій, що належать торговцю *, закриваючи ринкову ціну.

Аргументи

Ваша програма буде відтворена на початку кожного кроку, отримуючи поточну ринкову ціну, поточну суму торговця та кількість акцій, що належать цьому торговцю.

Наприклад:

120 5000 0

Вихідні дані

Ваша програма трейдера повинна вивести лист, відповідний дії, яку він хотів би вжити, а потім кількість.

Наприклад:

B10 //Buy 10 shares

або

S3 //Sell 3 shares

У торговця також є можливість не робити нічого, що обертається. Це можна досягти, вивівши W або будь-яку іншу команду, яка не є 'B> amnt <' або 'S> amnt <'

Подання

Ваша програма буде знаходитись у каталозі "гравці /> назва вашої програми <":

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

Введіть свій код разом із аргументом командного рядка, щоб запустити його всередині каталогу 'гравців'. Наприклад, трейдер Test1 може бути запущенийjava -cp "Test1" Test1

Додаткові правила

Вперед, знімати себе EmoWolf, Idc.

Не возитися ні з чим за межами каталогу BotNameFolder, не соромтесь створювати там файли, хоча для постійної інформації протягом усіх турів / оборотів.

Не навмисно створюйте програми для збоїв моделювання.

Я приймаю кілька записів на кожного користувача, доки записи виступають як окремі суб'єкти (Без інсайдерської торгівлі).

Таблиця лідерів

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

Я спробую оновлювати таблицю лідерів принаймні один раз на день

Контролер

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

Скомпілюйте це java Controller.javaта запустіть із каталогу, що містить каталог, як показано нижче:

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

Файл configповинен виглядати приблизно так:

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

Перше число - це кількість раундів, друге число - повороти на раунд, після чого - команди для запуску кожного гравця.

Замініть простір амперсандами! ('&')

~ Повідомте мене, чи можу я взагалі покращити формулювання цієї посади та щасливої ​​торгівлі!

Я представляю 'daydreamer', який завжди спить і забуває щось купити або продати. Він сподівається, що інші гравці матимуть чисту втрату. Код Python:

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

запустити з python daydreamer\daydreamer.py 120 5000 0будь-якими значеннями, які ви хочете

Пізніше я викладу більш серйозну відповідь, це лише для того, щоб м'яч прокатувався :)

DayTrader

_{Оновлено зміну правил, здійснене 21.08.2014, де гравці зараз починають з 20-30 акцій.}

Купує якомога більше, потім продає якнайбільше.

Філософія

Ми сподіваємось, що наведена нижче модель повторюватиметься знову і знову. Зауважте, що, дотримуючись цього шаблону, ми також сприяємо цьому.

• Кожен може придбати або утримати лише круглий. Значення може тільки збільшуватися, тому ми купуємо.
• Кожен може придбати більше, утримати або продати на другому раунді. Ми не очікуємо, що багато гравців купуватимуть у другому раунді, тому ми продаємо.

Шаблон на початку кристально чистий. Значення буде збільшуватися після першого раунду. Він повинен зменшитися після другого раунду. Крім того, прогнози стають нечіткими. Я сподіваюся, що добре зробиться на ранніх етапах, до того, як ринок стабілізується.

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

}

Компілювати з javac DayTrader.java. Бігайте з java -cp "DayTrader" DayTrader.

Уолт Дісней - Python 3

Уолт чекає, поки акції потраплять на дно скелі, а потім купує стільки, скільки дозволяють його гроші. Потім, коли ціна зростає, він продає їх усіх.

Спираючись на стратегію Діснея, коли він "вижив" через крах на Уолл-стріт. На жаль, моя програма не може створити тематичні парки ... Якби ...

Виконати:

python3 waltdisney.py

Код:

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

Томмі

знає лише, що він має, але налаштований ризикувати всім на ринку. Якщо він зможе купити, він буде. Якщо він не може, він продає все, що є, щоб він міг наступний поворот. (Це буде добре працювати з такими екстремальними, як DayTrader, але автоматично виправить, якщо значення впаде, коли він думає, що він зросте.)

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

}

Гольфскрипт

Це той самий код, але якщо він надає перевагу цьому. Я написав Java після того, як потрібна річ BigInteger. Використовуйте все, що простіше.

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

Компілюйте з: gcc buyandhold.c -o buyandhold

Запустіть його ./buyandhold ЦІННІ АКЦІЇ НА ГРОШІ

Альфред Пенніворт - Пітон 2

Поки я однієї ночі був у патрулі, Альфред намагався створити програму торгівлі акціями, не знаючи про це. Він думав, що він може це приховати від мене, але я знайшов це і зрозумів, що це робить. Тому що я Бетмен. Тепер я вирішив взяти його на змагання, щоб навчити його уроку.

Гроші не є об’єктом для Альфреда, тому що я ДУЖЕ багатий, але він все ще спритний щодо своєї торгівлі. Коли у нього немає акцій, він купує стільки, скільки може собі дозволити, незалежно від ринкової ціни. Потім він продає 10 (або всі залишилися) акції щоразу, коли ринкова ціна перевищує ціну, за яку вона була придбана.

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'

Виконати з: python GoAwayMasterBruce.py <args>

NaiveBot

NaiveBot є новим для всього цього "фондового" хула. Він просто припускає, що коли ціна зростає, він повинен купувати, а коли ціна падає, він повинен продавати. Але він не сок, у нього рукав трюк! Він купує лише половину того, що може собі дозволити, і продає лише половину того, що має.

Більше не живеш у коробці під автострадою для 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

Виконати з php Naivebot.php $1 $2 $3, вводить cache.jsonу свою поточну папку.

Прибуток - Haskell

1. Зачекайте, поки ціна не стане 1 / maxValue
2. Купувати / продавати все
3. ????
4. ПРИБУТ !!!

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"

Компілюйте ghc profit.hsі запускайте з ./profit price money stock.

Якщо він недостатньо ефективний, додайте -O3прапор, хоча він, ймовірно, є надмірним: D

Редагувати:

"оптимізований", зараз продає все, коли ціна дорівнює Integer.MAX_VALUE.

ЗачекайForCrash

EDIT: виправлений недолік у концепції

EDIT: тепер використовується довгий довгий int

Це моя перша спроба. Він поводиться по-справжньому просто і зберігає одну частку, щоб відрізнити, чи це перший тур, чи пізніший. У першому турі нічого не можна втратити, тому він купує акції. Якщо він має акції, він продає їх. Якщо в підсумку ціни на акції знизяться до 10, вони знову купуватимуться.

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

компілювати з: gcc waitforcrash.c -o waitforcrash

запустити його як ./waitforcrash PRICE MONEY SHARES

Землетрус

Замінник покупки всього та продажу всього (але одного). Це насправді не має на меті виграти стільки, скільки зриває всіх інших.

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

Компілювати з csc Earthquaker.cs. Бігайте з Earthquaker.

MonkeyTrader (в JAVA)

Є приказка, що мавпи - хороші торговці. Я роблю доказ. Рішення між "купувати" та "продавати" абсолютно випадкові.

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-го туру він продасть свої акції, якщо вони будуть вигідними: 80 доларів або більше. Тоді він продаватиметься, якщо ціна однакова чи краща, ніж остання ціна, яку він продав, купує, якщо ціна однакова чи нижча, ніж остання ціна, яку він купив.

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

Компілюйте з javac IntelliTrader . Запуск із java -cp "IntelliTrader" IntelliTrader

theAnswerOfLifeIs42.py

Моя програма любить число 42

Правило просте: я можу або купити 42 акції, або продати 42 акції.

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, консервативний)

Оскільки зміна правила означає, що зараз ми починаємо з деяких акцій, більше немає гарантованого найкращого першого кроку, тому я спростив це, видаливши спеціальний випадок для першого кроку.

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

Викликати як

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

Середня вартість долара - Python 3

Ця стратегія намагається використати усереднення вартості долара, купуючи (наскільки це можливо) фіксовану суму грошей (довільно встановлену на рівні 150, так що вона, ймовірно, витратить більшу частину своїх грошей до кінця) кожного кроку.

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 або 3

Цей хлопець дуже песимістично ставиться до фондового ринку. Він вважає за краще зберігати свої гроші готівкою, де він може зберігати їх під матрацом.

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

Повільний і стійкий

Поки у нього є гроші, він купує акції на суму 165 доларів. Інакше вона продає всі свої акції, щоб отримати більше грошей, щоб придбати більше акцій. На 50-му раунді він обов’язково продає всі акції, адже врешті-решт ми хочемо готівку.

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

Компілюйте з javac SlowAndSteady.java. Запустити з java -cp "SlowAndSteady" SlowAndSteady. Лічильник повинен скинутись між раундами, але якщо файл буде видалений, він також буде працювати.

BuyHighSellLow

Відстежує історію ринку і купує, коли ціна низька, і продається, коли вона висока.

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)

Виконати з:

python3 BuyHighSellLow/buyhighselllow.py

Час настає - Python 3

Мені стало нудно, тому я написав іншого абітурієнта ...

Цей молодий підприємець живе своїм життям цілодобово. Коли настає час, він приймає рішення. Він також дратівливо використовує французьку мову поза контекстом ...;)

Виконати:

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

Код:

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

Таймер Оль - Фортран 77

Цей старий збирається витратити пенсію після шістдесяти років роботи офісним діловодом. Однак на старості він став зовсім сліпим, тому він може бачити лише перший номер кожного аргументу, тому він оцінює ціну. Його метод схожий на метод Уолта, за винятком того, що Оль Таймер трохи більш недбалий.

Через проблеми з друком Fortran я написав програму Python, яка допоможе. Програма бере аргументи, що подаються, і передає їх у програму Fortran. Потім програма Python переформатує вихід у очікуваний формат.

Збірка:

gfortran oltimer.for -o oltimer.exe

Виконати:

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

Код помічника 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]))

Основний код 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");
        }
    }
}

Компілюйте із javac Test1.javaзапуском ізjava -cp "Test1" Test1

Їжак - пітон2.7

Це здебільшого для резервування назви

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)

Виконати як

python hedgehog.py PRICE CASH SHARES

BuyAndSell - C

Подібний, але не дублікат Томмі. Замінники паніки купують якомога більше і продають все. Майже дублікат Earthquaker, який зберігає одну акцію, поки BuyAndSell продає всі акції. BuyAndSell не вживає жодних дій, коли не має акцій для продажу, але не має достатньо грошей, щоб купити одну акцію.

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

Компілюйте з "gcc buyandsell.c -o buyandsell"

Запустити як "./buyandsell ЦІННІ АКЦІЇ НА ГРОШІ

Ущелина Сорос

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

Купує повільно, ніж продає все, намагаючись зірвати ринок.

Виконати з:Soros.rb price money stock