배경

당신은 평판이 좋은 주식 회사보다 약간 적은 거래자입니다. 귀하는 모두 하나의 특정 주식에만 집중하는 거래자 그룹의 일부입니다.

매 시간 각 거래자는 X 주식을 매수하거나 X 주식을 매도 할 수 있습니다. 라운드 당 50 시간, 경기당 3 라운드가 있습니다. 모든 라운드가 끝나면 평균값이 가장 높은 트레이더가 자메이카로 여행을 이깁니다!

게임 플레이

각각 50 회전의 3 라운드가 있습니다.

각 트레이더는 $ 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 디렉토리 외부의 항목을 엉망으로 만들지 않고 라운드 / 턴 내내 지속적인 정보를 위해 파일을 자유롭게 만들 수 있습니다.

의도적으로 시뮬레이션을 중단시키는 프로그램을 만들지 마십시오.

항목이 별도 엔티티로 작동하는 한 사용자 당 여러 항목을 허용합니다 (내부자 거래 없음).

리더 보드

[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

첫 번째 숫자는 라운드 수이고, 두 번째 숫자는 라운드 당 회전이며, 각 플레이어를 실행하는 명령이 이어집니다.

앰퍼샌드로 공백을 교체하십시오! ( '&')

~이 게시물의 문구를 개선하고 행복한 거래를 할 수 있는지 알려주세요!

나는 항상 자고 물건을 사거나 파는 것을 잊어 버린 '일상 몽상가'를 선물한다. 그는 다른 플레이어가 순손실을 갖기를 희망합니다. 파이썬 코드 :

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

}

골프 스크립트

이것은 동일한 코드이지만 선호하는 경우입니다. 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로 실행하십시오.

알프레드 페니 워스 -파이썬 2

내가 어느 날 밤 순찰에 나갔을 때 Alfred는 몰래 주식 거래 프로그램을 만들려고 노력했다. 그는 나에게서 그것을 숨길 수 있다고 생각했지만, 나는 그것을 발견하고 그것이 무엇을했는지 알아 냈습니다. 나는 배트맨이기 때문에. 이제 나는 그에게 레슨을 가르치기 위해 경쟁에 들어가기로 결정했습니다.

내가 부자이기 때문에 돈은 알프레드에게 아무런 문제가 없지만, 그는 여전히 그의 거래에 대해 똑똑합니다. 주식이 부족하면 시장 가격에 관계없이 감당할 수있는만큼 구매합니다. 그런 다음 시장 가격이 구매 한 가격보다 높을 때마다 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은이 모든 "주식 시장"hooplah에 새로운 것입니다. 그는 가격이 올라가면 구매해야하고 가격이 내려 가면 판매해야한다고 가정합니다. 그러나 그는 수액이 아니며 소매를 비웃습니다! 그는 자신이 감당할 수있는 것의 절반 만 구매하고, 소유 한 것의 절반 만 판매합니다.

더 이상 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 / max가 될 때까지 기다리십시오
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플래그를 추가하십시오 .

편집하다:

"최적화"는 이제 가격이 같을 때 모든 것을 판매합니다 Integer.MAX_VALUE.

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

지진

모든 것을 구매하고 모든 것을 판매 (또는 하나)하는 것의 대안. 다른 사람들을 방해하는 것만 큼이기는 것을 목표로하지는 않습니다.

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로 컴파일하십시오 . 으로 실행 자바 -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 (자바, 보수적)

규칙 변경은 이제 우리가 일부 주식으로 시작한다는 것을 의미하므로 더 이상 최고의 첫 번째 움직임이 보장되지 않으므로 첫 번째 차례의 특수 사례를 제거하여이를 단순화했습니다.

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

현금은 왕이다-Python 2 또는 3

이 사람은 주식 시장에 대해 매우 비관적입니다. 차라리 돈을 현금으로 두어 매트리스 밑에 안전하게 보관할 수 있습니다.

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

천천히, 차분하게

돈이있는 한 165 달러 상당의 주식을 산다. 그렇지 않으면 더 많은 돈을 벌고 더 많은 주식을 사기 위해 모든 주식을 판매합니다. 50 라운드에서는 모든 주식을 팔아야합니다. 결국 우리는 현금을 원하기 때문입니다.

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.math.BigInteger;
import java.nio.file.Files;
import java.nio.file.Paths;

public class SlowAndSteady{
    public static void main(String[] args) {
        BigInteger price = new BigInteger(args[0]);
        BigInteger cash= new BigInteger(args[1]);
        long shares= Long.parseLong(args[2]);
        BigInteger number = new BigInteger("165");
        String count = "0";


        try {
            count = new String(Files.readAllBytes(Paths.get("counter.txt")));
        } catch (IOException e) {

        }

        int c = Integer.parseInt(count)+1;

        if (c >= 50)
        {
            System.out.println("S" + shares);
            c=0;
        }

        else if(cash.compareTo(number) > 0)     System.out.println("B" + (number.divide(price)));

        else System.out.println("S" + shares);


        try {
            Writer wr = new FileWriter("counter.txt");
            wr.write(Integer.toString(c));
            wr.close();
        } catch (IOException e) {
        }
   }
}

javac SlowAndSteady.java로 컴파일하십시오. java -cp "SlowAndSteady"SlowAndSteady로 실행하십시오. 카운터는 라운드간에 재설정되어야하지만 파일이 삭제되면 작동합니다.

BuyHighSellLow

시장 이력을 추적하고 가격이 낮을 때 구매하고 높은 가격에 판매합니다.

import sys

storage = 'BuyHighSellLow'
turn = 0
turns = 50
max_start_price = 150
limit = 0.25

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

# Calculate average price
with open(storage+'/history', mode='a') as f:
            pass # Create file if it doesn't exist
with open(storage+'/history', mode='r') as f:
    values = list((int(line) for line in f))
    turn = len(values) + 1
    if turn > turns: turn = 1
    if turn == 1:
            average = max_start_price + 1
            turn = 1
    else:
            average = sum((value / turn for value in values))

# Buy low and sell high
if price < average:
    print('B' + str(int(limit * money / price)))
elif price > average:
    print('S' + str(int(limit * shares)))
else:
    print('W')

# Save history
if turn == 1: mode='w'
else: mode = 'a'
with open(storage+'/history', mode=mode) as f:
    print(price, file=f)

로 실행 :

python3 BuyHighSellLow/buyhighselllow.py

시간이 옳다-Python 3

지루 해져서 다른 참가자를 썼습니다 ...

이 젊은 기업가는 시계로 그의 삶을 산다. 때가되면 결정을 내립니다. 그는 또한 성가신 언어로 프랑스어를 사용합니다 ...;)

운영:

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

암호:

import sys, time

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

lheure = int(time.time())

if lheure % 3 == 0:
    print('S'+str(int(shares/4)))
elif lheure % 3 == 1:
    print('B'+str(int(money/4*price)))
else:
    print('W')

올 타이머-포트란 77

이 노인은 60 년 동안 사무 직원으로 일한 후 연금을 낭비하게됩니다. 그러나 나이가 들어서서 그는 장님이 되었기 때문에 각 논쟁의 첫 번째 숫자 만 볼 수 있었기 때문에 가격을 추정했습니다. Ol 'Timer가 조금 더 부주의하다는 점을 제외하면 그의 방법은 Walt와 비슷합니다.

Fortran 인쇄 문제로 인해 도움이 될 Python 프로그램을 작성했습니다. 프로그램은 제공된 인수를 사용하여 포트란 프로그램으로 전달합니다. 그런 다음 Python 프로그램은 출력을 예상 형식으로 다시 포맷합니다.

엮다:

gfortran oltimer.for -o oltimer.exe

운영:

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

파이썬 어시스턴트 코드 :

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

포트란 주요 코드 :

      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

비슷하지만 Tommy의 사본은 아닙니다. 공황 구매를 최대한 많이하는 것과 모든 것을 판매하는 것의 대안. BuyAndSell이 모든 주식을 판매하는 동안 하나의 주식을 유지하는 대지진의 복제본. BuyAndSell은 판매 할 주식이 없지만 한 주식을 구입할 충분한 돈이없는 경우 조치를 취하지 않습니다.

/* BuyAndSell
 * Code revised from OptoKopper's WaitForCrash.c and my BuyAndHold.c
 * Alternates between buying as many shares as possible and selling everything
 * Run it as ./buyandsell PRICE MONEY SHARES
 */
int main(int argc, char *argv[]) {
    long long int share_price = strtoll(argv[1], NULL, 0);
    long long int money = strtoll(argv[2], NULL, 0);
    long long int shares = strtoll(argv[3], NULL, 0);

    if (money >= share_price) {
        printf("B%lld\n", money / share_price);
    } else {
        if (money == 0) {
            printf("S%lld\n", shares);
        } else {
            printf("W\n");
        }
    }

    return 0;
}

"gcc buyandsell.c -o buyandsell"로 컴파일

"./buyandsell PRICE MONEY SHARES로 실행

협곡 소로스

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