バックグラウンド

あなたはすべて、評判の良い株式会社よりもわずかに少ないトレーダーです。あなたはすべて、特定の1つの銘柄のみに焦点を当てるトレーダーのグループの一員です。

1時間ごとに、各トレーダーはX株を購入するか、X株を売るチャンスがあります。ラウンドごとに50時間、競技ごとに3ラウンドがあります。すべてのラウンドの最後に、平均値が最も高いトレーダーがジャマイカへの旅行に勝ちます！

ゲームプレイ

それぞれ50ターンの3ラウンドがあります。

各トレーダーは、5000ドルと20〜30株の間のランダムな数の株でラウンドを開始します。株式の価格は10から150の間の乱数から始まります。

各トレーダーは、各トレーダーが購入できる株をいくつでも購入したり、現在保有している株を何株でも売ったりすることができます。

1株当たりの価格は、購入した各株式について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

追加の規則

さあ、エモウルフ、Idcを撃ってください。

BotNameFolderディレクトリ以外のものをいじることはありません。ラウンド/ターン中の永続的な情報のためにファイルを作成してください。

シミュレーションをクラッシュさせるプログラムを意図的に作成しないでください。

エントリが個別のエンティティとして機能する限り（インサイダー取引なし）、ユーザーごとに複数のエントリを受け入れます。

リーダーボード

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

少なくとも1日に1回リーダーボードを更新しようとします

コントローラ

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

最初の数はラウンドの数、2番目の数はラウンドごとのターン、その後に各プレイヤーを実行するコマンドが続きます。

スペースをアンパサンドに置き換えてください！（ '＆'）

〜この投稿の文言を改善できるかどうか、そして幸せな取引を教えてください！

いつも眠っていて、何かを買うことも売ることも忘れている「夢想家」を紹介します。彼は、他のプレイヤーが純損失になることを望んでいます。Pythonコード：

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

python daydreamer\daydreamer.py 120 5000 0または任意の値で実行します。

私は後でもっと真剣な答えを投稿します、これは単にボールを転がすためです:)

DayTrader

_{2014年8月21日に行われたルール変更のために更新され、プレイヤーは20〜30株で開始するようになりました。}

可能な限り購入してから、可能な限り販売します。

哲学

以下のパターンが何度も繰り返されることを願っています。このパターンを順守することで、私たちもそれに貢献することに注意してください。

• 誰でもラウンド1でのみ購入または保持できます。値は増加するだけなので、購入します。
• 誰もがラウンド2で追加購入、保有、または販売できます。多くのプレイヤーがラウンド2で購入することを期待していないので、売ります。

パターンは最初は透明です。ラウンド1の後に値が増加します。ラウンド2後に減少するはずです。それを超えると、投影はあいまいになります。市場が安定する前の早い段階でうまくいくと思います。

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

}

Golfscript

これは同じコードですが、必要に応じてこれを行います。BigIntegerが必要な場合に備えてjavaを書きました。より簡単なものを使用してください。

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 PRICE MONEY SHARESで実行します

アルフレッドペニーワース-Python 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現在のフォルダーにが作成されます。

利益-ハスケル

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。

WaitForCrash

編集：コンセプトの欠陥を修正

編集：long long intを使用するようになりました

これが私の最初の試みです。それは本当にシンプルに動作し、最初のラウンドかそれ以降のラウンドかを区別するために1つの共有を保持します。最初のラウンドでは何も失われないため、株式を購入します。株式がある場合は販売します。最終的に株価が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

地震学者

すべてを購入し、すべてを販売することを交互に行います（ただし、1つ）。他の人を混乱させるほど、勝つことを目指していません。

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で実行します。カウンターはラウンド間でリセットする必要がありますが、ファイルが削除されても機能します。

購入する

市場の歴史を追跡し、価格が低い場合は購入し、価格が高い場合は販売します。

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

オルタイマー-Fortran 77

この老人は、事務員として60年働いた後、年金を無駄にしようとしています。しかし、彼の老年期には、彼はまったく盲目になったので、彼は各議論の最初の数しか見ることができないので、彼は価格を推定します。彼の方法はウォルトの方法と似ていますが、Ol 'Timerの方が少し不注意です。

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トレーダー

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

ハリネズミ-python2.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

トミーの複製ではなく類似しています。可能な限りパニックで購入し、すべてを販売することを交互に行います。BuyAndSellがすべての株式を販売する間、1つの株式を保持するEarthquacerのほぼ複製。BuyAndSellは、売却する株式がなく、1株を購入するのに十分なお金がない場合、アクションを実行しません。

/* 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 MONEYシェアとして実行

ゴージ・ソロス

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