Latar Belakang

Anda semua adalah pedagang untuk perusahaan saham yang sedikit kurang dari yang memiliki reputasi baik. Anda semua adalah bagian dari kelompok pedagang yang hanya fokus pada satu saham tertentu.

Setiap jam, setiap pedagang memiliki kesempatan untuk membeli saham X atau menjual saham X. Ada 50 jam per putaran dan 3 putaran per kompetisi. Pada akhir dari semua putaran, trader dengan nilai rata-rata tertinggi memenangkan perjalanan ke Jamaika!

Gameplay

Ada 3 putaran 50 putaran masing-masing.

Setiap trader memulai putaran dengan $ 5000 dan Sejumlah saham acak antara 20 dan 30 saham. Harga saham dimulai pada angka acak antara 10 dan 150.

Setiap belokan, setiap pedagang dapat Membeli sejumlah saham yang mereka mampu atau Jual sejumlah saham yang mereka miliki, masing-masing dengan harga saat ini per saham.

Harga per saham meningkat dengan angka acak antara 1 dan 5 untuk setiap saham yang dibeli dan berkurang dengan nilai acak antara 2 dan 6 untuk setiap saham yang dijual. Harga minimum adalah $ 1.

Penting untuk dicatat bahwa semua pedagang memproses transaksi mereka pada saat yang sama, artinya setiap pedagang yang membeli / menjual saham tidak akan mempengaruhi harga hingga belokan berikutnya.

Pemain dengan nilai rata-rata tertinggi di akhir 3 putaran menang. Nilai ditentukan dengan mengambil jumlah uang yang tersisa pada akhir putaran dan menambahkan jumlah saham yang dimiliki oleh pedagang * menutup harga pasar.

Argumen

Program Anda akan dijalankan kembali pada setiap awal giliran menerima harga pasar saat ini, jumlah uang pedagang saat ini dan jumlah saham yang dimiliki oleh pedagang itu.

Ex:

120 5000 0

Keluaran

Program pedagang Anda harus mengeluarkan surat yang sesuai dengan tindakan yang ingin diambil diikuti oleh kuantitas.

Ex:

B10 //Buy 10 shares

atau

S3 //Sell 3 shares

Pedagang juga memiliki opsi untuk tidak melakukan apa pun yang berubah. Itu bisa dicapai dengan mengeluarkan W atau perintah lain yang bukan 'B> amnt <' atau 'S> amnt <'

Pengajuan

Program Anda akan berada di dalam direktori 'players /> nama program Anda <':

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

Harap berikan kode Anda bersama dengan argumen baris perintah untuk menjalankannya dari dalam direktori 'pemain'. Misalnya pedagang Test1 dapat dijalankanjava -cp "Test1" Test1

Aturan tambahan

Silakan, tembak dirimu EmoWolf, Idc.

Tidak main-main dengan apa pun di luar direktori BotNameFolder Anda, jangan ragu untuk membuat file di sana untuk info persisten sepanjang putaran / putaran.

Jangan sengaja membuat program untuk menghentikan simulasi.

Saya akan menerima beberapa entri per pengguna, selama entri tersebut bertindak sebagai entitas yang terpisah (Tidak ada perdagangan orang dalam).

Papan peringkat

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

Saya akan mencoba memperbarui leaderboard setidaknya sekali sehari

Pengendali

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

Kompilasi ini dengan java Controller.javadan jalankan dari direktori yang berisi direktori seperti di bawah ini:

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

File configakan terlihat seperti ini:

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

Angka pertama adalah jumlah putaran, angka kedua adalah putaran per putaran, diikuti oleh perintah untuk menjalankan setiap pemain.

Ganti spasi dengan ampersand! ('&')

~ Beri tahu saya jika saya dapat meningkatkan kata-kata dari posting ini sama sekali, dan selamat berdagang!

Saya hadirkan 'lamunan', yang selalu tertidur dan lupa membeli atau menjual apa pun. Dia berharap pemain lain akan mengalami kerugian bersih. Kode python:

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

dijalankan dengan python daydreamer\daydreamer.py 120 5000 0atau nilai apa pun yang Anda inginkan.

Saya akan mengirim jawaban yang lebih serius nanti, ini hanya untuk membuat bola bergulir :)

DayTrader

_{Diperbarui untuk perubahan aturan yang dibuat pada 8/21/2014, di mana pemain sekarang mulai dengan 20-30 saham.}

Beli sebanyak mungkin, lalu jual sebanyak mungkin.

Filsafat

Kami berharap pola di bawah ini akan berulang berulang kali. Perhatikan bahwa dengan mengikuti pola ini, kami juga berkontribusi padanya.

• Semua orang hanya bisa membeli atau bertahan di ronde pertama. Nilainya hanya dapat meningkat, jadi kami membeli.
• Setiap orang dapat membeli lebih banyak, memegang, atau menjual pada putaran kedua. Kami tidak berharap banyak pemain untuk membeli di babak kedua, jadi kami menjual.

Polanya jernih di awal. Nilai akan meningkat setelah satu putaran. Seharusnya berkurang setelah putaran kedua. Di luar itu, proyeksi menjadi kabur. Saya berharap untuk melakukannya dengan baik di putaran awal, sebelum pasar stabil.

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

}

Kompilasi dengan javac DayTrader.java. Jalankan dengan java -cp "DayTrader" DayTrader.

Walt Disney - Python 3

Walt menunggu sampai saham mencapai titik terendah dan kemudian membeli sebanyak uangnya memungkinkan. Lalu, ketika harganya melambung, dia menjual semuanya.

Berdasarkan strategi Disney ketika dia 'selamat' melalui Wall Street Crash. Sayangnya, program saya tidak dapat membangun taman hiburan ... Jika saja ...

Menjalankan:

python3 waltdisney.py

Kode:

from sys import argv
import os

price=int(argv[1])
money=int(argv[2])
share=int(argv[3])

if os.path.exists('./buyingprice.txt'):
    f = open('buyingprice.txt', 'r')
    buyingprice=int(f.read())
    f.close()
else:
    buyingprice=0

if share > 0:
    if price > buyingprice*10:
        print('S'+str(share))
    else:
        print('W')
elif money > 0:
    if buyingprice==0:
        print('B10')
        m=open('buyingprice.txt', 'w')
        m.write(str(price))
        m.close()
    elif price <= buyingprice:
        print('B'+str(int(money/price)))
        g=open('buyingprice.txt', 'w')
        g.write(str(price))
        g.close()
    else:
        print('W')

Tommy

hanya tahu apa yang dia miliki tetapi bertekad untuk mempertaruhkan segalanya di pasar. Jika dia bisa membeli, dia akan melakukannya. Jika dia tidak bisa, dia menjual semua yang dia miliki sehingga dia bisa giliran berikutnya. (Ini akan bekerja dengan baik dengan yang ekstrem seperti DayTrader tetapi akan mengoreksi otomatis jika nilainya turun ketika ia berpikir itu akan tumbuh.)

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

}

Naskah Golf

Ini adalah kode yang sama tetapi jika lebih suka ini. Saya menulis java setelah dalam kasus hal BigInteger diperlukan. Gunakan apa pun yang lebih mudah.

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

Kompilasi dengan: gcc buyandhold.c -o buyandhold

Jalankan dengan ./buyandhold HARGA UANG SAHAM

Alfred Pennyworth - Python 2

Ketika saya sedang berpatroli suatu malam, Alfred mencoba membuat program perdagangan saham tanpa sepengetahuan saya. Dia pikir dia bisa menyembunyikannya dari saya, tetapi saya menemukannya dan mencari tahu apa fungsinya. Karena aku Batman. Sekarang saya telah memutuskan untuk memasukkannya ke dalam kompetisi untuk memberinya pelajaran.

Uang bukan masalah bagi Alfred karena saya BENAR-BENAR kaya, tetapi dia masih pintar tentang perdagangannya. Ketika dia kehabisan saham, dia membeli sebanyak yang dia mampu, terlepas dari harga pasar. Kemudian dia menjual 10 (atau semua yang tersisa) saham setiap kali harga pasar lebih tinggi dari harga yang dibeli.

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'

Jalankan dengan: python GoAwayMasterBruce.py <args>

NaifBot

NaiveBot adalah baru untuk semua ini "pasar saham" hooplah. Dia hanya berasumsi bahwa ketika harga naik dia harus membeli, dan ketika harga turun dia harus menjual. Tapi dia bukan getah, dia punya trik di lengan bajunya! Dia hanya pernah membeli setengah dari apa yang dia mampu, dan hanya pernah menjual setengah dari apa yang dia miliki.

Tidak lagi tinggal di dalam kotak di bawah jalan bebas hambatan untuk 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

Jalankan dengan php Naivebot.php $1 $2 $3, buat cache.jsondi folder saat ini.

Keuntungan - Haskell

1. Tunggu sampai harganya 1 / maxValue
2. Beli / Jual semuanya
3. ????
4. KEUNTUNGAN!!!

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"

Kompilasi dengan ghc profit.hsdan jalankan./profit price money stock .

Jika tidak cukup efisien, tambahkan -O3flag, meskipun mungkin berlebihan: D

Edit:

"dioptimalkan", sekarang menjual semuanya ketika harganya sama dengan Integer.MAX_VALUE.

WaitForCrash

EDIT: cacat tetap dalam konsep

EDIT: sekarang menggunakan int panjang

Ini adalah percobaan pertamaku. Berperilaku sangat sederhana dan membuat satu bagian untuk membedakan apakah itu babak pertama atau yang berikutnya. Di babak pertama tidak ada yang bisa hilang, jadi ia membeli saham. Jika memiliki saham, mereka menjualnya. Jika pada akhirnya harga saham turun menjadi 10, itu akan membeli lagi.

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

kompilasi dengan: gcc waitforcrash.c -o waitforcrash

jalankan sebagai ./waitforcrash PRICE MONEY SHARES

Gempa bumi

Bergantian antara membeli segala sesuatu dan menjual segala sesuatu (kecuali satu). Itu tidak benar-benar bertujuan untuk menang sebanyak itu mengganggu orang lain.

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

Kompilasi dengan csc Earthquaker.cs. Jalankan dengan Earthquaker.

MonkeyTrader (dalam JAWA)

Ada pepatah yang mengatakan bahwa monyet adalah pedagang yang baik. Saya buktikan. Keputusan antara "beli" dan "jual" benar-benar acak.

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

Putaran pertama ia akan menjual sahamnya jika harganya bagus: $ 80 atau lebih. Kemudian dia akan menjual jika harganya sama atau lebih baik dari harga terakhir yang dijualnya, beli jika harganya sama atau lebih rendah dari harga terakhir yang dibelinya.

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

Kompilasi dengan javac IntelliTrader . Jalankan dengan java -cp "IntelliTrader" IntelliTrader

theAnswerOfLifeIs42.py

Program saya suka nomor 42

Aturannya sederhana: Saya bisa membeli 42 saham atau menjual 42 saham.

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 (Jawa, konservatif)

Karena perubahan aturan berarti bahwa kita sekarang mulai dengan beberapa saham, tidak ada lagi langkah pertama yang dijamin terbaik, jadi saya telah menyederhanakan ini dengan menghapus kasing khusus untuk belokan pertama.

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

Diminta sebagai

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

Dollar Cost Averager - Python 3

Strategi ini mencoba untuk menggunakan rata-rata biaya dolar dengan membeli (sedekat mungkin) sejumlah uang tetap (ditetapkan secara sewenang-wenang pada 150 sehingga mungkin akan menggunakan sebagian besar uangnya pada akhir) setiap belokan.

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 atau 3

Lelaki ini sangat pesimis dengan pasar saham. Dia lebih suka menyimpan uangnya di kas di mana dia bisa menyimpannya dengan aman di bawah kasurnya.

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

Pelan dan pasti

Selama punya uang, ia membeli saham senilai $ 165. Kalau tidak, ia menjual semua sahamnya untuk mendapatkan lebih banyak uang, untuk membeli lebih banyak saham. Pada putaran ke-50 itu memastikan untuk menjual semua saham, karena pada akhirnya kami ingin uang tunai.

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

Kompilasi dengan javac SlowAndSteady.java. Jalankan dengan java -cp "SlowAndSteady" SlowAndSteady. Penghitung harus diatur ulang di antara putaran, tetapi jika file dihapus, itu juga akan berfungsi.

BeliHighMenjual Rendah

Telusuri sejarah pasar dan beli saat harga rendah dan jual saat tinggi.

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)

Jalankan dengan:

python3 BuyHighSellLow/buyhighselllow.py

Waktu Tepat - Python 3

Saya bosan jadi saya menulis peserta lain ...

Pengusaha muda ini menjalani hidupnya setiap saat. Ketika waktunya tepat, dia membuat keputusan. Dia juga menggunakan bahasa Prancis di luar konteks ...;)

Menjalankan:

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

Kode:

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

Pengatur Waktu Ol - Fortran 77

Orang tua ini akan menyia-nyiakan pensiunnya setelah enam puluh tahun bekerja sebagai pegawai kantor. Namun, selama usia tuanya, dia menjadi sangat buta, jadi dia hanya bisa melihat dia nomor pertama dari setiap argumen, jadi dia memperkirakan harganya. Metodenya mirip dengan Walt, kecuali Timer Ol 'sedikit lebih ceroboh.

Karena masalah dengan pencetakan Fortran, saya telah menulis program Python yang akan membantu. Program mengambil argumen yang disediakan dan mengirimkannya ke program Fortran. Kemudian, program Python memformat ulang output ke format yang diharapkan.

Menyusun:

gfortran oltimer.for -o oltimer.exe

Menjalankan:

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

Kode Asisten 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 Kode Utama:

      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

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

Kompilasi dengan javac Test1.javarun withjava -cp "Test1" Test1

Landak - python2.7

Ini sebagian besar untuk memesan nama

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)

Jalankan sebagai

python hedgehog.py PRICE CASH SHARES

BuyAndSell - C

Mirip tapi bukan duplikat Tommy. Berganti-ganti antara panik membeli sebanyak mungkin dan menjual semuanya. Hampir duplikat Earthquaker yang mempertahankan satu saham sementara BuyAndSell menjual semua saham. BuyAndSell tidak melakukan tindakan ketika tidak memiliki saham untuk dijual tetapi tidak punya cukup uang untuk membeli satu saham.

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

Kompilasi dengan "gcc buyandsell.c -o buyandsell"

Jalankan sebagai "./buyandsell PRICE MONEY SHARES

Gorge Soros

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

Beli perlahan, daripada menjual segala sesuatu dalam upaya menghancurkan pasar.

Jalankan dengan:Soros.rb price money stock