Stack Exchange Stock Exchange ~ Пересмотрено [закрыто]

35

Задний план

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

Каждый час у каждого трейдера есть шанс купить 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 /> Ваше имя программы <»:

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

Пожалуйста, предоставьте свой код вместе с аргументом командной строки, чтобы запустить его из каталога 'Players'. Например, трейдер Test1 может работать сjava -cp "Test1" Test1

Дополнительные правила

Давай, стреляй в себя EmoWolf, Idc.

Не связывайтесь ни с чем вне вашей директории BotNameFolder, не стесняйтесь создавать файлы там, хотя для постоянной информации в течение раундов / ходов.

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

Я приму несколько записей на пользователя, если записи действуют как отдельные объекты (без инсайдерской торговли).

Leaderboard

[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

Первое число - это количество раундов, второе число - количество ходов за раунд, за которыми следуют команды для запуска каждого игрока.

Замените пробелы амперсандами! ( '&')

~ Дайте мне знать, если я смогу улучшить формулировку этого поста, и счастливой торговли!

spocot
источник
4
Похоже, что долгосрочная тенденция на оживленном рынке приведет к тому, что доля будет иметь отрицательное значение.
Питер Тейлор
6
Не могли бы вы поставить свою программу контроллера на что-то вроде Github и добавить ссылку, чтобы мы могли протестировать ее дома?
Питер Тейлор
6
Глядя на таблицу лидеров, я думаю, что игра в настоящее время имеет недостатки. Например, начать с $ 14 / sh, купить 357 (собственный 357, $ 0 в банке). Выберите случайное число (3). Цена увеличивается на 3 * 357 до $ 1085 / ш. Следующий раунд. Продать все 357 акций (собственные 0, 387 345 долларов в банке). Выберите случайное число (3). Цена снижается на 3 * 357 до 14 долл. / Ш. Следующий раунд. После двух раундов цена не изменилась, и ваш банк увеличился в 77 раз (аналогичные, но менее драматичные результаты могут быть получены с другими начальными случайными переменными). Я предлагаю изменить для каждой транзакции, а не для каждой акции для более разумных значений.
4
Или просто построить настоящую книгу заказов.
о0 '.
3
Зачем начинать со случайного числа акций?
Аверроэс

Ответы:

18

Я представляю «мечтателя», который всегда спит и забывает купить или продать что-нибудь. Он надеется, что у других игроков будет чистый убыток. Код Python:

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

работать с python daydreamer\daydreamer.py 120 5000 0или какими-либо значениями, которые вы хотите.

Позже я опубликую более серьезный ответ, это просто для того, чтобы начать игру :)

stokastic
источник
3
Я не думаю, что это будет работать - вам нужно сделать отступ для отпечатка.
Исаак
6
Учитывая, что цена акций будет иметь тенденцию к снижению в долгосрочной перспективе, отличной стратегией может быть не торговля.
5
Странная игра: единственный выигрышный ход - не играть. Как насчет хорошей игры в шахматы?
Тим С.
13

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.

Rainbolt
источник
1
Уу ява! Мне легче бежать.
spocot
6
Ваш бот заставил рынок выйти за пределы максимального числа целых чисел, поэтому я внедрил BigIntegers в код. Поскольку в каждом коде использовались целые числа, он почти полностью потерпел неудачу, если не считать, что каждый мечтатель мечтает об этом
спокот
@spocot Я отредактировал свою реализацию, чтобы использовать BigInteger. Надеюсь, это поможет.
Rainbolt
5
Я думаю, что это неотъемлемая проблема в правилах. Если один трейдер получит около 140 акций, он сможет сам контролировать рынок. В двух раундах он может купить акции по 10 каждый и продать их по 140 каждый, что приведет к выигрышу в 1300% (при условии, что никто не сделает обратного). Это будет расти примерно до 5000 * 13 ^ 25, что является большим.
Оптокоппер
2
@spocot Я просто хотел пропинговать тебя, потому что я изменил свое представление после твоего недавнего изменения правила.
Rainbolt
9

Уолт Дисней - Питон 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')
Бета распад
источник
Вам не хватает закрывающей скобки в первой строке печати.
supersam654
@ supersam654 О, да, спасибо
Beta Decay
Можете ли вы указать источник вашего утверждения, что Уолт Дисней действительно использовал эту стратегию. Учитывая, что на фондовой бирже есть компания Walt Disney Co, ее трудно найти, и на странице Википедии Уолта об этом нет упоминания.
Майкл
@Michael investopedia.com/articles/financial-theory/11/…
бета-распад
@ Майкл Я получил информацию изначально от своего учителя истории, так что извините, если источник немного слаб.
бета-распад
8

Томми

знает только то, что у него есть, но полон решимости рисковать всем на рынке. Если он может купить, он сделает. Если он не может, он продает все, что у него есть, чтобы он мог следующий ход. (Это будет хорошо работать с экстремальными, такими как 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());
       }
    }

}

Golfscript

Это тот же код, но если это предпочтительнее. Я написал Java после того, как вещь BigInteger была необходима. Используйте то, что проще.

2$2$>{@@;;"S"\}{;\/"B"\} if
Кэйн
источник
Для дальнейшего использования все числа в GS являются большими целыми числами.
Питер Тейлор
Думаю, я мог бы просто опубликовать оригинал, не беспокоясь об этом! Хорошие новости.
Кейн
Первоначально я отметил, что я думаю, что это дубликат DayTrader, но потом я понял, что поведение только из-за обстоятельств, и что они могут расходиться при других обстоятельствах. Извините, если я кого-то обидел. Давайте разбогатеть вместе!
Rainbolt
@Rainbolt Я написал это GolfScript, прочитал ваш файл в поисках дубликатов перед отправкой и фактически использовал некоторый или ваш код для написания Java-версии. Основная часть не является дубликатом (или я бы не представил его), но в итоге оказывается симулированной на этих нестабильных рынках. Я не обижаюсь, но если вы чувствуете, что это слишком близко, я попрошу его дисквалифицировать (но код остался, я узнал что-то написав это, и в этом весь смысл). Поскольку у вас есть приоритет, я бы не обиделся даже в этом случае. Обратите внимание, что Earthquakers почти идентичны вашим, но делает это по-другому (сохраняет в файл).
Кейн
@ нет Нет, не удаляйте его. Как я уже сказал, я думал , что они были дубликатами, но они определенно нет . Они похожи по поведению только из-за обстоятельств. Я был неправ, оставив комментарий, утверждая, что они были дубликатами, прежде чем я полностью понял, что делает ваш.
Rainbolt
6

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 АКЦИИ ЦЕНА ДЕНЬГИ

Гленн Рандерс-Персон
источник
1
Хаха, я надеялся, что кто-нибудь дополнит DayTrader BuyAndHold. Отлично сработано!
Rainbolt
6

Альфред Пенниворт - Питон 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>

RageCage
источник
AttributeError: 'ArgumentParser' object has no attribute 'parseargs'Какая версия Python ему нужна?
Питер Тейлор
Моя ошибка, есть подчеркивание. parse_args()
RageCage
5

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в своей текущей папке.

Sammitch
источник
5

Прибыль - Хаскелл

  1. Подождите, пока цена не станет 1 / maxValue
  2. Купить / продать все
  3. ????
  4. PROFIT !!!

import System.Environment (getArgs)

main = putStrLn . trade . map read =<< getArgs

trade :: [Integer] -> String
trade [p,m,s] -- not intended
  | p == 1 = "B" ++ (show m)
  | p == (fromIntegral $ (maxBound::Int) - 1) = "S" ++ (show s)
  | otherwise = "W"

Скомпилировать ghc profit.hsи запустить с./profit price money stock .

Если это недостаточно эффективно, добавьте -O3флаг, хотя это, вероятно, излишне: D


Редактировать:

«оптимизированный», теперь продает все, когда цена равна Integer.MAX_VALUE.

ThreeFx
источник
Почему нет main = putStrLn . trade . map read =<< getArgs? Менее шумно
recursion.ninja
@awashburn Потому что я не очень хорошо читаю в отношении монад;)
ThreeFx
Надеюсь, мой комментарий помог вам узнать что-то новое!
recursion.ninja
@ThreeFx есть программа для этого cabal install pointfree, теперь все будут думать, что вы едите монады на завтрак.
Шон Д
@SeanD Спасибо, я посмотрю на это
ThreeFx
4

WaitForCrash

РЕДАКТИРОВАТЬ: исправлена ​​ошибка в концепции

РЕДАКТИРОВАТЬ: теперь, используя long long 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

Optokopper
источник
Надеюсь, вы не возражаете, я пролистал ваш код, чтобы использовать его в качестве основы для решения BuyAndHold. Кстати, с длинными длинными целочисленными значениями% d должен быть% Ld, чтобы избежать предупреждений (или это% lld? Ни одно из них не дает мне предупреждение).
Гленн Рандерс-Персон
Все нормально. Да, у меня был% lld в моем коде, должно быть, я забыл их в обновлении, ты.
Оптокоппер
3

Earthquaker

Чередуется между покупкой и продажей всего (кроме одного). На самом деле цель не в том, чтобы побеждать, а в том, что она мешает другим.

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.

Шон Лэтэм
источник
.Net has System.IO.File.ReadAllText and WriteAllText, so you can simplify your history tracking slightly.
Peter Taylor
Это происходит сбой, если он не находит свой brain.txtфайл.
Питер Тейлор
3

MonkeyTrader (in 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;
        }
    }
}
Боб Геном
источник
3

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

Benny
источник
In my tests this seems to be the second best trader.
Peter Taylor
2

theAnswerOfLifeIs42.py

My program loves the number 42

The rule is simple: I can either buy 42 stock or sell 42 stock.

import sys
price, money, shares = [int(arg) for arg in sys.argv[1:]]

if money>42*price:
 print "B 42"
else:
 print "S 42"
Realdeo
источник
2

LeesonLearnt v1.1 (Java, conservative)

Since the rule change means that we now start with some shares, there's no longer a guaranteed best first move, so I've simplified this by removing the special case for the first turn.

import java.math.BigInteger;

public class LeesonLearnt {
    private static final BigInteger THRESHOLD = new BigInteger("100");

    public static void main(String[] args){
        BigInteger price = new BigInteger(args[0]);
        BigInteger capital = new BigInteger(args[1]);
        BigInteger shareholding = new BigInteger(args[2]);

        BigInteger affordable = capital.divide(price);

        // In the long run, the shares will probably lose all their value.
        // But if they're cheap, buying them will pump them and they can be sold at a profit.
        // The target amount of our value held in shares varies exponentially with their price.
        BigInteger targetShareholding = price.compareTo(THRESHOLD) > 0
            ? BigInteger.ZERO
            : affordable.add(shareholding).shiftRight(price.intValue() - 1);
        if (targetShareholding.compareTo(shareholding) <= 0) {
            System.out.println("S" + shareholding.subtract(targetShareholding));
        }
        else {
            BigInteger diff = targetShareholding.subtract(shareholding);
            System.out.println("B" + diff.min(affordable));
        }
    }
}

Invoke as

java -cp LeesonLearnt LeesonLearnt <price> <capital> <shareholding>
Peter Taylor
источник
1

Dollar Cost Averager - Python 3

This strategy attempts to use dollar cost averaging by buying (as close as it can to) a fixed amount of money (arbitrarily set at 150 so that it'll probably use up most of its money by the end) each turn.

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")
Tim S.
источник
1

Cash Is King - Python 2 or 3

This guy is very pessimistic about the stock market. He'd rather keep his money in cash where he can keep it safe under his mattress.

import sys
shares = int(sys.argv[3])
if shares > 0:
    print("S" + str(shares))
else:
    print("W")
Tim S.
источник
1

Slow and Steady

As long as it has money, it buys $165 worth of shares. Otherwise it sells all of its shares to get more money, to buy more shares. On the 50th round it makes sure to sell all shares, because in the end we want cash.

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 with javac SlowAndSteady.java. Run with java -cp "SlowAndSteady" SlowAndSteady. Counter should reset between rounds, but if the file is deleted, it will also work.

Red_Shadow
источник
1

BuyHighSellLow

Tracks the market history and buys when the price low and sells when it's high.

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)

Run with:

python3 BuyHighSellLow/buyhighselllow.py
ccarton
источник
1

Time is Right - Python 3

I got bored so I wrote another entrant...

This young entrepeneur lives his life by the clock. When the time is right, he makes a decision. He also annoyingly uses French out of context... ;)

Run:

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

Code:

import sys, time

price = int(sys.argv[1])
money = int(sys.argv[2])
shares = int(sys.argv[3])

lheure = int(time.time())

if lheure % 3 == 0:
    print('S'+str(int(shares/4)))
elif lheure % 3 == 1:
    print('B'+str(int(money/4*price)))
else:
    print('W')
Beta Decay
источник
1

Ol' Timer - Fortran 77

This old man is going to waste away his pension after sixty years of working as an office clerk. During his old age, however, he became quite blind, so he can only see he first number of each argument, so he estimates the price. His method is similar to that of Walt's, except Ol' Timer is a little more careless.

Because of the problems with the Fortran printing, I've written a Python program which will help. The program takes the arguments supplied and pipes them through to the Fortran program. Then, the Python program reformats the output to the expected format.

Compile:

gfortran oltimer.for -o oltimer.exe

Run:

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

Python Assistant Code:

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 Main Code:

      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
Beta Decay
источник
1
Given that you need Python anyway, and that there are other answers in Python but none in Fortran, do you not think it would make sense to implement the whole thing in Python and reduce the burden of compilers which OP has to install?
Peter Taylor
@Peter I would but I thought it'd be fun to have a completely different language and see how it performs.
Beta Decay
0

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

Compile with javac Test1.java run with java -cp "Test1" Test1

spocot
источник
0

Hedgehog - python2.7

This is mostly to reserve the name

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)

Run as

python hedgehog.py PRICE CASH SHARES
Moop
источник
0

BuyAndSell - C

Similar but not a duplicate of Tommy. Alternates between panic buying as much as possible and selling everything. Almost a duplicate of Earthquaker which retains one share while BuyAndSell sells all shares. BuyAndSell takes no action when it has no shares to sell but hasn't got enough money to buy one share.

/* 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 with "gcc buyandsell.c -o buyandsell"

Run as "./buyandsell PRICE MONEY SHARES

Glenn Randers-Pehrson
источник
0

Gorge Soros

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

Buys slowly, than sells everything in an attempt to crash the market.

Run with:Soros.rb price money stock

MegaTom
источник
1
It explicitly says in the question text Do not intentionally create programs to crash the simulation.
Beta Decay
@BetaDecay I meant dont try to crash the controller. Trying to crash the market is part of the game.
spocot
@spocot Oh, I thought that you meant to not create programs to crash the market. You should phrase that differently to prevent more confusion.
Beta Decay