Thị trường chứng khoán là tất cả về tốc độ của kiến ​​thức. Không giống như những thách thức trước đây, giá cổ phiếu hiện tại không phải là ngẫu nhiên: nó được xác định bởi những người chơi trò chơi. Nếu bạn có thể xác định một cổ phiếu có giá thấp hơn bất kỳ ai khác, thì bạn đã tự viết cho mình một chương trình kiếm tiền.

Giá đề cập đến số tiền mà mọi người đang giao dịch cổ phiếu, trong khi Giá trị đề cập đến số tiền mà cổ phiếu có giá trị vào cuối trò chơi.

Mỗi người chơi bắt đầu với 1000 mỗi cổ phiếu và 0 giá trị ròng tương đối. Mỗi cổ phiếu có một giá trị bí mật, và điểm số của bạn vào cuối trò chơi là(stockValue for each ownedStock) + netWorth . Giá trị ròng của bạn có thể là âm. Trong một trò chơi N-player, có N cổ phiếu.

Các bước:

Trò chơi làm theo các bước sau:

1. Bạn được trao giá trị bí mật của một cổ phiếu.
2. Bạn đưa ra lời đề nghị bán X cổ phiếu Y với giá $ Z
3. Tất cả người chơi được cung cấp các ưu đãi và mỗi người có thể chọn một để chấp nhận
4. Tất cả người chơi được thông báo về các đề nghị được chấp nhận
5. Quay trở lại bước 2

Mỗi bước được đưa ra chi tiết dưới đây:

1. void secretValue(int stockType, int value):

   • Giá trị bạn học được không được tiết lộ cho bất kỳ người chơi khác.
   • Giá trị nằm giữa 0và1000
   • Giá trị thấp giống như xảy ra hơn giá trị cao (phân phối đồng đều bình phương)

2. Offer makeOffer(List<Stock> currentStock)

   • Bạn có thể trở lại nullđể không cung cấp.

3. Offer acceptOffer(List<Offer> offers)

   • Bạn có thể quay lại nullđể chấp nhận không ai trong số họ
   • Nếu không có đề nghị có sẵn, điều này sẽ không được gọi
   • Nếu bạn chấp nhận, giá trị ròng của bạn giảm xuống $ Z (có thể âm) và nhận X của cổ phiếu Y. Điều ngược lại xảy ra với người bán.
   • Nếu bạn chấp nhận đề nghị, việc trao đổi sẽ diễn ra ngay lập tức và ưu đãi sẽ bị xóa để người chơi bổ sung không thể chấp nhận.

4. void acceptedOffers(List<Offer> offers)

   • Bao gồm các đề nghị được chấp nhận của bạn là tốt

Biến tĩnh hoặc ghi vào tệp không được phép. (Không có dữ liệu liên tục từ trò chơi này sang trò chơi khác) Các ứng cử viên không nghiêm trọng được cho phép.

Giao diện:

public final class Stock {
    public Stock(int stockType, int amount);
    public int getType();
    public int getAmount();
    public Stock minus(Stock other);
    public Stock plus(Stock other);
    public Stock minus(int amount);
    public Stock plus(int amount);
    public Stock setAmount(int amount);
}
public class Offer {
    public Offer(Stock offer, int payment);
    public Stock getOffer();
    public int getPayment();
}

Các bài nộp không phải của Java:

• Tất cả các cuộc gọi bao gồm hai dòng: Dòng đầu tiên là chức năng được gọi là: SecretValue, MakeOffer, AcceptOffer, AcceptedOffers, SetRandom, và dòng thứ hai chứa các dữ liệu thực tế.
• Cổ phiếu được định dạng với một :dấu phân cách : stockType:stockAmount.
• Phiếu mua hàng được định dạng với một @dấu phân cách:offer@price
• Danh sách được định dạng với một ;dấu phân cách
• SecretValueđược định dạng với một :dấu phân cách:stockType:value
• RandomSeedđược sử dụng để làm cho trình của bạn xác định. Nếu trình của bạn sử dụng tính ngẫu nhiên, vui lòng sử dụng giá trị số nguyên được truyền dưới dạng hạt giống!
• Tất cả các cuộc gọi chức năng cần một phản ứng. Nếu phản hồi là nullhoặc void, trả về một chuỗi trống.
• Vui lòng bao gồm một command.txtcung cấp các đối số dòng lệnh để chạy trình của bạn

Chấm điểm

Các trò chơi bao gồm 1000 lượt sẽ được chạy nhiều lần. Người chơi sẽ được ghi điểm theo hệ thống ELO và kết hợp với những người chơi có trình độ kỹ năng tương tự. Người chơi có số điểm ELO cuối cùng cao nhất sẽ thắng! (Tôi đã sửa đổi hệ thống để mỗi trò chơi, điểm ELO được cập nhật cho mỗi cặp người chơi)

Bộ điều khiển bao gồm một trình tải xuống tự động, vì vậy hãy bắt đầu gửi của bạn với một tiêu đề : Name, Language. Nếu trình của bạn không bằng Java, mỗi khối mã sẽ bắt đầu bằng tên của tệp. (không bao gồm tệp lệnh, phải là khối đầu tiên trong bài viết của bạn)

Đang chạy

Có 2 cách để chạy dự án này:

1. Tải về mã nguồn, biên dịch và chạy. Bạn có thể tìm thấy nguồn trên Github . Chạygit clone --recursive https://github.com/nathanmerrill/StockExchange.git

2. Tải về tệp thực thi JAR. Đệ trình nên được đặt trong /submissionsthư mục làm việc hiện tại của bạn trong thư mục. Bạn có thể tải xuống chỉ JAR , chỉ các bài nộp hoặc cả hai

runTruyền vào để chạy dự án (tùy chọn mặc định) hoặc chuyển qua downloadđể tải xuống tất cả các bài nộp cho đến nay từ câu hỏi này.

Bảng điểm

1.  1308.1220497323848  Cheater
2.  1242.0333695640356  InsideTrader
3.  1158.3662658295411  UncleScrooge
4.  1113.8344000358493  BlackMarket
5.  1051.8370015258993  DartMonkey
6.  983.0545446731494   WarGamer
7.  939.457423938002    Spammer
8.  901.4372529538886   DumbBot
9.  859.0519326039137   ShutUpAndTakeMyMoney
10. 852.9448222849587   VincentKasuga
11. 718.2112067329083   Profiteer

Gian lận, Java

Cố gắng để bán không có gì cho tiền.

import java.util.List;
import java.util.Random;
import com.ppcg.stockexchange.*;

public class Cheater extends Player {
    private Random random = new Random();

    public Offer acceptOffer(List<Offer> offers) {
        return null;
    }

    public Offer makeOffer(List<Stock> currentStock){
        Stock stock = randomStock();
        int price = random.nextInt(100) + 1;
        return new Offer(stock.setAmount(0), price);
    }
}

WarGamer, Java

Sau khi kiểm tra các quy tắc chiếu lệ, tôi đã quyết định rằng nước cờ chiến thắng chính không phải là để chơi. Bất cứ ai chào bán cổ phiếu đều có thể biết giá và sẽ thu được lợi nhuận từ việc bán. Nó có thể được bật để nó sẽ đưa ra lời đề nghị "đùa" để bán một cổ phiếu cho Integer.MAX_VALUE đô la với hy vọng im lặng và lấy tiền của tôi sẽ cắn.

import java.util.List;
import com.ppcg.stockexchange.*;
import com.ppcg.kothcomm.game.AbstractPlayer;
import com.ppcg.kothcomm.utils.Tools;

import java.util.List;

public class WarGamer extends Player {
static final boolean FRAUD = false;
    /**
     * @param offers All available offers
     * @return An offer you want to accept, or null if you want to accept neither.
     */
    public Offer acceptOffer(List<Offer> offers){
        return null;
    }

    public Offer makeOffer(List<Stock> currentStock){
    if(FRAUD)
    return new Offer(new Stock(0,1),Integer.MAX_VALUE);
        //defraud shut up and take my money            
    return null;
    }
}

ShutUpAndTakeMyMoney, Java

import java.util.List;
import com.ppcg.stockexchange.*;

public class ShutUpAndTakeMyMoney extends Player {
    public ShutUpAndTakeMyMoney() {}

    public Offer acceptOffer(List<Offer> offers) {
        try {
            return offers.get(0);
        } catch (Exception ex) {
            return null;
        }
    }
    public Offer makeOffer(List<Stock> stock) {
        return null;
    }
}

Nó chấp nhận bất kỳ lời đề nghị.

DumbBot, Java

Sử dụng bot này khi tạo của riêng bạn. Cung cấp cổ phiếu bí mật của nó ở một mức giá chiết khấu.

import java.util.List;
import com.ppcg.stockexchange.*;
public class DumbBot extends Player {
    public Offer acceptOffer(List<Offer> offers) {
        return null;
    }
    public Offer makeOffer(List<Stock> currentStock){
        return new Offer(currentStock.get(secretStockType).setAmount(1), Math.max(1, secretStockValue - 5));
    }
    public void secretValue(int stockType, int value) {
        super.secretValue(stockType, value);
    }
    public void acceptedOffers(List<Offer> acceptedOffers) {
    }
}

python_starter, Python 3

Sử dụng điều này như một điểm khởi đầu cho bất kỳ chương trình python (hoặc ngôn ngữ khác)

Chấp nhận một đề nghị ngẫu nhiên.

Tập tin lệnh:

python3 starter.py

Chương trình:

starter.py
import random
from functools import total_ordering


LIST_DELIMITER = ';'
STOCK_DELIMITER = ':'
OFFER_DELIMITER = '@'


@total_ordering
class Stock:
    @staticmethod
    def parse(string: str):
        return Stock(*map(int, string.split(STOCK_DELIMITER)))

    def __init__(self, stock_type: int, amount: int):
        self.type = stock_type
        self.amount = max(amount, 0)

    def __str__(self):
        return str(self.type)+STOCK_DELIMITER+str(self.amount)

    def __eq__(self, other):
        return self.amount == other.type

    def __lt__(self, other):
        return self.amount < other.amount

    def update(self, amount) -> 'Stock':
        return Stock(self.type, amount)

    def __mul__(self, other: int) -> 'Stock':
        return self.update(self.amount*other)

    def __floordiv__(self, other: int) -> 'Stock':
        return self.update(self.amount//other)

    def __add__(self, other: int) -> 'Stock':
        return self.update(self.amount+other)

    def __sub__(self, other: int) -> 'Stock':
        return self.update(self.amount-other)


class Offer:
    @staticmethod
    def parse(string: str) -> 'Offer':
        try:
            offer, payment = string.split(OFFER_DELIMITER)
        except ValueError:
            raise Exception("Cannot unpack "+string)
        return Offer(Stock.parse(offer), int(payment.strip()))

    def __init__(self, offer: Stock, payment: int):
        self.offer = offer
        self.payment = payment

    def __str__(self):
        return str(self.offer)+OFFER_DELIMITER+str(self.payment)


def read_stock_value(value: str):
    global hidden_price, hidden_stock
    stock, price = value.split(STOCK_DELIMITER)
    hidden_price = float(price)
    hidden_stock = int(stock)


def process_input():
    handlers = {
        "SecretValue": read_stock_value,
        "RandomSeed": read_seed,
        "MakeOffer": make_offer,
        "AcceptOffer": accept_offer,
        "AcceptedOffers": accepted_offers,
    }
    method = input().strip()
    data = input().strip()
    output = handlers[method](data)
    if output is not None:
        print(str(output))
    else:
        print()


def read_seed(seed: str):
    random.seed(int(seed))


def start():
    while True:
        process_input()


hidden_stock = None
hidden_price = None


def make_offer(current_stock: str):
    current_stock = map(Stock.parse, current_stock.split(LIST_DELIMITER))
    pass


def accept_offer(available_offers: str):
    available_offers = list(map(Offer.parse, available_offers.split(LIST_DELIMITER)))
    return random.sample(available_offers, 1)[0]


def accepted_offers(offers: str):
    offers = map(Offer.parse, offers.split(LIST_DELIMITER))
    pass


if __name__ == "__main__":
    start()

VincentKasuga, Java

Không chắc chắn nếu Java của tôi là hợp lệ. Vui lòng xem lại.

Làm thế nào nó hoạt động

- nếu bạn sở hữu tất cả các cổ phiếu, bạn có thể đặt giá của cổ phiếu. Bạn là người bán duy nhất. 1. Mua tất cả các cổ phiếu. 2. Đặt giá của tất cả các cổ phiếu là siêu cao ở lần đánh dấu cuối cùng. 3. LỢI NHUẬN! - Điều này thường không thể vì ...

• Giá được đặt một cách giả tạo ở mức tối đa bởi một số nhà nước vô chính phủ
• Điều này là xấu về kinh tế
• Bot không dự đoán - nó khai thác một lỗ hổng cố hữu trong cấu trúc của thị trường!

Làm

• Góc thị trường nhiều lần! Muahaha!

Câu hỏi thường gặp

Q: Vincent Kasuga là ai?

A: Anh ấy đã mua tất cả hành tây và hành tây tương lai ở Hoa Kỳ. (đặt tất cả chúng vào một nhà kho bí mật) Tổ chức ngành công nghiệp với số tiền chuộc - hãy cho tôi X triệu hoặc tôi sẽ đặt giá thấp và bạn sẽ phá sản.

Nhưng anh không dừng lại ở đó.

Sau đó, anh ta bí mật rút ngắn ETF hành tây (đặt cược rằng nó sẽ đi xuống). Ông đã bán tất cả hành tây cùng một lúc, giao chúng trong hàng ngàn xe tải cho sàn giao dịch chứng khoán. Các túi hành tây chi phí ít hơn so với hành tây. Ông đã kiếm được hàng triệu LẠI. Nói tóm lại, dòng sông Hudson tràn ngập hành tây.

Anh ấy là một người thực sự.

Mật mã

import com.ppcg.stockexchange.Offer;
import com.ppcg.stockexchange.Player;
import com.ppcg.stockexchange.Stock;

import java.util.List;

public class VincentKasuga extends Player {
    private int knownStock;
    private int knownPrice;
    private int corneredStockType = -1;
    private int corneredLikelehood = 0;
    private boolean marketCornered;
    private int ticks;

    public Offer acceptOffer(List<Offer> offers) {
        if (!marketCornered) {
            Offer maxOffer = null;
            int maxAmount = 0;
            if (corneredStockType == -1) {
                for (Offer offer: offers) {
                    if (offer.getOffer().getAmount() > maxAmount) {
                        maxAmount = offer.getOffer().getAmount();
                        maxOffer = offer;
                    }
                }
            } else {
                for (Offer offer: offers) {
                    if (offer.getOffer().getAmount() > maxAmount && offer.getOffer().getType() == corneredStockType) {
                        maxAmount = offer.getOffer().getAmount();
                        maxOffer = offer;
                    }
                }
            }


            if (maxOffer == null) {
                // may have cornered the market
                corneredLikelehood++;
                if (corneredLikelehood == 5) {
                    // probably cornered the market
                    marketCornered = true;
                }
            }
            return maxOffer;
        } else {
            // who needs offers when the market is cornered!?
            return null;
        }
    }

    public Offer makeOffer(List<Stock> currentStock) {
        ticks++;
        if (ticks >= 999) {
            // SELL SELL SELL!
            return new Offer(new Stock(corneredStockType, 1000), 1000);
        } else {
            return null;
        }
    }

    public void secretValue(int stockType, int value) {
        knownStock = stockType;
        knownPrice = value;
        if (stockType == corneredStockType) {
            if (knownPrice == 1000) {
                corneredLikelehood += 3;
            } else if (knownPrice < 900){
                // didn't corner the market.
                corneredLikelehood = 0;
            }
        }
    }
}

"Tôi đã dồn vào thị trường vàng, ông Bond!"

Người gửi thư rác, Java

import java.util.List;
import java.util.ArrayList;
import com.ppcg.stockexchange.*;

public class Spammer extends Player {
    private boolean panic = false;

    public Offer acceptOffer(List<Offer> offers) {
        for (Offer offer : offers) {
            if (this.panic || offer.getPayment() < 20)
                return offer;
        }
        return null;
    }
    public Offer makeOffer(List<Stock> currentStock) {
        if (currentStock.size() > 1) { // Don't sell all the stock
            this.panic = false;
            return new Offer(currentStock.get(secretStockType).setAmount(1), 1);
        }
        this.panic = true; // BUY
        return null;
    }
}

Spam thị trường với cổ phiếu thực sự rẻ, và chỉ mua cổ phiếu khi giá thấp hơn 20. Khi số lượng cổ phiếu giảm xuống 1, nó sẽ cố gắng mua bất cứ thứ gì.

DartMonkey, Java

(không thi đấu: Nó sẽ không thắng và tôi đã có câu trả lời khác)

Khỉ phi tiêu thích ném đồ đạc ... và có một đống gậy nhọn bên cạnh. Anh ta nhìn thấy một số giấy trên tường. Bế! Bế! Bế! Hoàn toàn không mất thời gian, Dart Monkey đã ném 80 phi tiêu! Một nửa phi tiêu có màu đỏ và nửa còn lại có màu xanh và có số ngẫu nhiên trên chúng! Khỉ phi tiêu nhìn thấy một máy tính ... phi tiêu khỉ gõ số. Khỉ phi tiêu thích số. Khỉ phi tiêu kiếm được một số tiền từ phi tiêu của mình ...

Nói một cách nghiêm túc, DartMonkey khởi tạo một mảng số nguyên có độ dài gấp đôi số lượng cổ phiếu. Anh ta lưu trữ một số cho số lượng cổ phiếu mà anh ta muốn mua / bán, và một số cho giá của cổ phiếu. Sau đó, anh ta thay thế bán cổ phiếu từ mảng và chấp nhận cung cấp theo mảng. Nếu anh ta không có cổ phiếu từ mảng, anh ta sẽ không cung cấp bất cứ thứ gì, và nếu anh ta không có đề nghị nào được cung cấp cho anh ta từ mảng, anh ta sẽ không chấp nhận bất cứ điều gì.

Câu trả lời này được lấy cảm hứng từ @TheNumberOne, người đã đề cập đến khỉ phi tiêu trong cuộc trò chuyện

import com.ppcg.stockexchange.Offer;
import com.ppcg.stockexchange.Player;
import com.ppcg.stockexchange.Stock;

import java.util.List;
import java.util.Random;

public class DartMonkey extends Player {
    private int basePrice = 100;
    private int numStocks;
    private int[] dartBoard;
    private boolean first = true;

    @Override
    public Offer acceptOffer(List<Offer> offers) {
        for(Offer offer : offers) {
            Stock stock = offer.getOffer();
            int type = stock.getType();
            int amount = stock.getAmount();
            int price = offer.getPayment();
            if(this.dartBoard[type] < 0 && amount <= -this.dartBoard[type] && price <= this.dartBoard[type + this.numStocks]) {
                this.dartBoard[type] = 0;
                return offer;
            }
        }
        return null;
    }

    @Override
    public Offer makeOffer(List<Stock> stocks) {
        if(this.first) {
            this.first = false;
            this.numStocks = stocks.size();
            this.dartBoard = new int[this.numStocks * 2];
            Random random = this.getRandom();
            for (int i = 0; i < 20; i++) {
                int index = random.nextInt(this.dartBoard.length / 2);
                this.dartBoard[index] = random.nextInt(1001);
                this.dartBoard[this.numStocks + index] = random.nextInt(1001);
            }

            for (int i = 0; i < 20; i++) {
                int index = random.nextInt(this.dartBoard.length / 2);
                this.dartBoard[index] = -random.nextInt(1001);
                this.dartBoard[this.numStocks + index] = random.nextInt(1001);                
            }
        }

        for (Stock stock : stocks) {
            int type = stock.getType();
            if(this.dartBoard[type] > 0) {
                Offer offer = new Offer(stock.setAmount(this.dartBoard[type]), this.basePrice + this.dartBoard[type + this.numStocks]);
                this.dartBoard[type] = 0;
                this.dartBoard[type + this.numStocks] = 0;
                return offer;
            }
        }

        return null;
    }

}

InsideTrader, Java

InsideTrader chỉ nhìn xung quanh và thấy rằng mọi người đang cố gắng sáng tạo. Nhưng anh ấy đã làm một điều sáng tạo: làm những gì được mong đợi.

Bot này mua khi nó "đáng giá" vì nó "mượn" một số "tài liệu nội bộ" để "hướng dẫn" "quyết định đầu tư".

Việc cần làm và cách thức hoạt động trong mã. ;)

Mật mã"

import java.util.List;

import com.ppcg.stockexchange.*;

public class InsideTrader extends Player {
    public String coverStory = "I can tell the good companies from the bad ones.";
    private String theTruth = "I'm cheating. (but so is everyone else)";
    private String ambitions = "Learn to \"follow the market\"";  // don't steal this idea
    private int secretStock = -1;
    private int secretStockValue = -1;

    private int appraiseOffer(Offer offer) {
        /* get how much the offer is worth, 0 if it's not the secret stock */
        if (offer.getOffer().getType() != secretStock ||offer.getOffer().getAmount() == 0) {
            return 0;
        }
        return (offer.getPayment()/offer.getOffer().getAmount())  // price per stock...
                - secretStockValue  // minus value of stock.
                ;
    }
    public Offer acceptOffer(List<Offer> offers) {
        Offer bestOffer = null;
        int bestOfferValue = -1;
        for (Offer offer :
                offers) {
            int value = appraiseOffer(offer);
            if (value > bestOfferValue && value > 0) {
                bestOfferValue = value;
                bestOffer = offer;
            }
        }
        return bestOffer;
    }

    public Offer makeOffer(List<Stock> currentStock) {
        return new Offer(new Stock(0,1), Integer.MAX_VALUE);
    }

    public void secretValue(int stockType, int value) {
        secretStock = stockType;
        secretStockValue = value;
    }

    public void acceptedOffers(List<Offer> acceptedOffers) {

    }
}

WallStreet, Kotlin

Bắt đầu bằng cách bán cao và mua thấp và dần dần chuyển sang những gì nó nghĩ rằng giá thực sự là. Ngoài ra, bạn có thể sử dụng điều này như một khuôn mẫu để tạo riêng của bạn trong kotlin.

Lưu ý: Có một lỗi ở đây mà tôi dường như không thể tái tạo một cách đáng tin cậy. Nếu chương trình của tôi gặp sự cố hoặc có vấn đề, vui lòng ping tôi trong trò chuyện và liên kết một nội dung của nội dung củasubmissions/other/WallStreet/log.txt

kotlinc WallStreet.kt
kotlin WallStreetKt

WallStreet.kt
import java.io.FileOutputStream
import java.io.PrintStream
import java.util.*

val LOGGER = PrintStream(FileOutputStream("log.txt", true))
const val DEBUG = false

const val LOG_GAME_HEADER = """
###############
#STARTING GAME#
###############"""

data class Stock(val type : Int, val amount : Int) {

    operator fun minus(amount : Int) = copy(amount = this.amount - amount)
    operator fun plus(amount: Int) = copy(amount = this.amount + amount)
    fun setAmount(amount: Int) = copy(amount = amount)

    operator fun minus(other : Stock) : Stock {
        assert(type == other.type)
        return copy(amount = this.amount - other.amount)
    }

    operator fun plus(other : Stock) : Stock {
        assert(type == other.type)
        return copy(amount = this.amount + other.amount)
    }

    override fun toString() = "$type:$amount"
}

data class Offer(val offer: Stock, val payment: Int) {
    override fun toString() = "$offer@$payment"
}

fun parseStock(repr : String) : Stock {
    val data = repr.split(":").map { it.toInt() }
    return Stock(data[0], data[1])
}

fun parseOffer(repr: String) : Offer {
    val data = repr.split("@")
    return Offer(parseStock(data[0]), data[1].toInt())
}

fun parseOffers(repr: String) = if (repr == "") emptyList<Offer>() else repr.split(";").map { parseOffer(it) }


interface Player {
    fun secretValue(stockType: Int, value: Int)
    fun makeOffer(currentStock: List<Stock>) : Offer?
    fun acceptOffer(offers: List<Offer>) : Offer?
    fun acceptedOffers(offers: List<Offer>)

    var random : Random
}

fun main(args : Array<String>) {

    try {

        if (DEBUG) {
            LOGGER.println(LOG_GAME_HEADER)
        }
        //Change bot name here
        val player = WallStreet()

        while (true) {
            val function = readLine()
            function ?: return
            val line = readLine()!!
            if (DEBUG) {
                LOGGER.println("\nInput:")
                LOGGER.println(function)
                LOGGER.println(line)
            }
            var result : Any
            try {
                result = when (function) {
                    "SecretValue" -> {
                        val data = line.split(":").map { it.toInt() }
                        player.secretValue(data[0], data[1])
                    }
                    "MakeOffer" -> player.makeOffer(line.split(";").map { parseStock(it) }) ?: ""
                    "AcceptOffer" -> player.acceptOffer(parseOffers(line)) ?: ""
                    "AcceptedOffers" -> player.acceptedOffers(parseOffers(line))
                    "RandomSeed" -> player.random = Random(line.toLong())
                    else -> return        //Exit program
                }
                if (function == "AcceptOffer" && result.toString() !in line) {
                    throw Exception("Offer not among available offers!!!!\nResult: $result\nParsed Available Offers: ${parseOffers(line)}")
                }
            } catch (e : Exception) {
                LOGGER.println("Turn #${player.turn}")
                LOGGER.println("\nInput:")
                LOGGER.println(function)
                LOGGER.println(line)
                throw e
            }

            if (result == Unit) {
                result = ""
            }
            if (DEBUG) {
                LOGGER.println("Output:")
                LOGGER.println(result)
            }

            println(if (result == Unit) "" else result)
        }
    } catch (e : Exception) {
        e.printStackTrace(LOGGER)
        throw e
    } finally {
        LOGGER.close()
    }
}


// ###################################################
// #          Put program logic below here.          #
// ###################################################


const val DEFAULT_STOCK_VALUE = 333
const val MAX_TURNS = 1000
const val MAX_STOCK_VALUE = 1000

class WallStreet : Player {

    var secretStockType = 0
    var secretStockValue = 0
    override var random = Random()


    var turn = 0
    val stockPriceStatistics = mutableMapOf<Int, DoubleSummaryStatistics>()

    override fun secretValue(stockType: Int, value: Int) {
        secretStockType = stockType
        secretStockValue = value
    }

    override fun makeOffer(currentStock: List<Stock>): Offer {
        val stock = currentStock[random.nextInt(currentStock.size)]
        val type = stock.type
        val amount = random.nextInt(stock.amount)
        val price = getSellPrice(type) * amount
        return Offer(Stock(type, amount), Math.ceil(price).toInt())
    }

    override fun acceptOffer(offers: List<Offer>): Offer? {
        var bestOffer : Offer? = null
        var mostProfit = 0.0
        for (offer in offers) {
            val offerProfit = profitOfOffer(offer)
            if (offerProfit > mostProfit) {
                bestOffer = offer
                mostProfit = offerProfit
            }
        }
        if (bestOffer != null && bestOffer !in offers) {
            throw IllegalStateException("Tried to accept non-existent offer.\nOffer:  $bestOffer\nAvailable Offers: ${offers.joinToString(";")}")
        }
        return bestOffer
    }

    override fun acceptedOffers(offers: List<Offer>) {
        turn++
        for ((stock, payment) in offers) {
            val stats = stockPriceStatistics.getOrPut(stock.type) { DoubleSummaryStatistics() }
            for (i in 1..stock.amount) {
                stats.accept(payment.toDouble() / stock.amount)
            }
        }
    }

    private fun getSellPrice(type: Int): Double {
        var price = getPrice(type)
        if (price < 1000) {
            price += (1000 - price) * (MAX_TURNS - turn) / MAX_TURNS
        }
        return if (type == secretStockType) Math.max(secretStockValue.toDouble(), price) else price
    }

    private fun getPrice(type: Int): Double {
        return stockPriceStatistics[type]?.average ?: DEFAULT_STOCK_VALUE.toDouble()
    }

    private fun profitOfOffer(offer: Offer): Double {
        return getBuyPrice(offer.offer.type) * offer.offer.amount - offer.payment
    }

    private fun getBuyPrice(type: Int): Double {
        var price = getPrice(type)
        price = price * turn / MAX_TURNS
        return if (type == secretStockType) Math.min(secretStockValue.toDouble(), price) else Math.min(price, MAX_STOCK_VALUE.toDouble())
    }

}

ChúScrooge, Java

import java.util.List;
import com.ppcg.stockexchange.*;

public class UncleScrooge extends Player {
    public Offer acceptOffer(List<Offer> offers) {
        Offer offer;
        try {
            offer = offers.get(0);
        } catch (Exception ex) {
            return null;
        }
        if (offer.getPayment() < 100)
            return offer;
        else
            return null;
    }
    public Offer makeOffer(List<Stock> currentStock){
        if (this.getRandom().nextDouble() < 0.6)
            return new Offer(currentStock.get(secretStockType).setAmount(1), Integer.MAX_VALUE);
        else
            return null;
    }
    public void secretValue(int stockType, int value) {
        super.secretValue(stockType, value);
    }
    public void acceptedOffers(List<Offer> acceptedOffers) { }
}

Bán cổ phiếu ở mức giá thực sự cao, và chỉ mua nếu giá dưới 100.

Người trục lợi, Java

Profiteer ở trong đó vì tiền, và anh ta luôn đếm tiền. Anh ta ước tính thận trọng về số tiền anh ta có. Sau đó, anh ta sẽ mua cổ phiếu bí mật, nếu nó thấp hơn giá trị, hoặc mua cổ phiếu giá rẻ. Anh ta cũng nhớ mình đã trả bao nhiêu cho mọi thứ và luôn đưa ra đề nghị cao hơn giá cổ phiếu. Hơn nữa, anh ta sẽ đưa ra đề nghị cao hơn nếu anh ta có ít tiền hơn.

Lưu ý: Tôi nghĩ rằng tôi đã thực hiện điều này một cách chính xác, nhưng nếu @NathanMerrill không ngại lướt qua mã của tôi để tìm lỗi, điều đó thật tuyệt

import com.ppcg.stockexchange.Offer;
import com.ppcg.stockexchange.Player;
import com.ppcg.stockexchange.Stock;

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

public class Profiteer extends Player {
    private List<StockInfo> onMarket;
    private List<StockInfo> stocks;
    private int money;
    private boolean first = true;

    @Override
    public Offer acceptOffer(List<Offer> offers) {
        Offer finalOffer;

        Optional<Offer> offer = offers.stream().filter(o -> o.getOffer().getType() == this.secretStockType && o.getPayment() < this.secretStockValue * o.getOffer().getAmount()).sorted((a, b) -> Integer.compare((this.secretStockValue * a.getOffer().getAmount()) - b.getPayment(), (this.secretStockValue * b.getOffer().getAmount()) - b.getPayment())).findFirst();
        if (offer.isPresent()) {
            finalOffer = offer.get();
        } else {
            finalOffer = offers.stream().sorted((a, b) -> Integer.compare(a.getPayment(), b.getPayment())).findFirst().orElse(null);
        }

        if (finalOffer == null || this.money <= finalOffer.getPayment()) {
            return null;
        } else {
            this.stocks.add(new StockInfo(finalOffer.getOffer(), finalOffer.getPayment()));
            this.refreshMoney();
            return finalOffer;
        }
    }

    @Override
    public Offer makeOffer(List<Stock> stocks) {
        if (this.first) {
            this.init(stocks);
        } else {
            this.refreshMarketList(stocks);
        }

        Optional<StockInfo> least = this.stocks.stream().sorted((a, b) -> Integer.compare(a.getBoughtPrice(), b.getBoughtPrice())).findFirst();
        Optional<StockInfo> secret = this.stocks.stream().filter(stockInfo -> stockInfo.getStock().getType() == this.secretStockType).sorted((a, b) -> Integer.compare(a.getBoughtPrice(), b.getBoughtPrice())).findFirst();

        StockInfo finalOffer;
        int price;
        if (secret.isPresent()) {
            finalOffer = secret.get();
        } else if (least.isPresent()) {
            finalOffer = least.get();
        } else {
            return null;
        }

        this.onMarket.add(finalOffer);
        this.stocks.remove(finalOffer);
        price = this.calculatePrice(finalOffer.boughtPrice);
        return new Offer(new Stock(finalOffer.getStock().getType(), finalOffer.getStock().getAmount()), price);
    }

    private int calculatePrice(int boughtPrice) {
        return (int) (boughtPrice + ((boughtPrice / (double) this.money) * this.money)) + 1;
    }

    private void refreshMarketList(List<Stock> stocks) {
        this.stocks.addAll(this.onMarket.stream().filter(stockInfo -> stocks.contains(stockInfo.getStock())).collect(Collectors.toList()));
        this.onMarket.clear();
    }

    private void refreshMoney() {
        this.money = this.stocks.stream().mapToInt(info -> this.secretStockType == info.getStock().getType() ? this.secretStockValue : 5).reduce((a, b) -> a + b).orElseGet(() -> 0) - this.stocks.stream().mapToInt(StockInfo::getBoughtPrice).reduce((a, b) -> a + b).orElseGet(() -> 0);
    }

    private void init(List<Stock> stocks) {
        this.stocks = stocks.stream().map(stock -> new StockInfo(stock, 0)).collect(Collectors.toList());
        this.onMarket = new ArrayList<>();
        this.money = 0;
        this.first = false;
        this.refreshMoney();
    }

    private static class StockInfo {
        private Stock stock;
        private int boughtPrice;

        public StockInfo(Stock stock, int boughtPrice) {
            this.stock = stock;
            this.boughtPrice = boughtPrice;
        }

        public Stock getStock() {
            return this.stock;
        }

        public int getBoughtPrice() {
            return this.boughtPrice;
        }

    }

}

MaxBot, Java

Bot này cố gắng kiếm lợi nhuận cao nhất từ ​​mỗi giao dịch. Trong khi bán, đặt giá của một cổ phiếu không xác định ở mức 300 đô la, khi mua 250 đô la.

import java.util.List;
import com.ppcg.stockexchange.*;
public class MaxBot extends Player {
    int toSell;
    int sellPrice;

    public void secretValue(int stockType, int value) {
        super.secretValue(stockType, value);
        toSell = stockType;
        sellPrice = (value + 1000)/2;
    }
    public Offer acceptOffer(List<Offer> offers) {
        Offer max = null;
        int maxDif = 0;
        for(Offer o: offers){
            int price = secretStockType == o.getOffer().getType()? secretStockValue: 250;
            int val = price * o.getOffer().getAmount();
            int dif = val - o.getPayment();
            if(maxDif < dif){
                max = o;
                maxDif = dif;
            }
        }
        return max;
    }
    public Offer makeOffer(List<Stock> currentStock){
        if(toSell == -1){
            return null;
        }
        int sum = 0;
        for (Stock s: currentStock){
            if(s.getType() == toSell){
                sum += s.getAmount;
            }
        }
        int n = sum - sum/2;
        return new Offer(new Stock(toSell, n), n * sellPrice);
    }
    public void acceptedOffers(List<Offer> acceptedOffers) {
        int highStock = -1;
        int highPrice = 0;
        int markup = 0;
        for(Offer o: offers){
            int trueVal = secretStockType == o.getOffer().getType()? secretStockValue: 250;
            int marketVal = o.getPayment()/o.getOffer().getAmount();
            if(marketVal - trueVal > markup){
                highStock = o.getOffer().getType();
                highPrice = marketVal;
                markup = marketVal - trueVal;
            }
        }
        toSell = highStock;
    }
}

BlackMarket, Java

Không có gì nhiều để nói về điều này, vì những giao dịch này sẽ ... tắt khỏi bảng xếp hạng, bạn có thể nói.

import java.util.List;
import com.ppcg.stockexchange.*;

public class BlackMarket extends Player {
    private boolean approvedBySEC = false;
    private int ammoLeft = 30;
    public String taxView = "We want higher tax rates";
    public String excuse = "I never saw that in my life";

    public void secretValue(int drugType, int warrantForMyArrest) {
        super.secretValue(drugType, warrantForMyArrest);
        if (warrantForMyArrest != 0 || drugType == 420) {
            ammoLeft += 10;
        }
    }

    public Offer acceptOffer(List<Offer> offers) {
        for (Offer offer : offers) {
            if (this.approvedBySEC || offer.getPayment() < 9)
                return offer;
        }
        return null;
    }


    public Offer makeOffer(List<Stock> currentStock) {
        return new Offer(new Stock(0,1),420);
    }
}

NotQuiteABanksBestFriend, Python 3

Command.txt:

python3 NotQuiteABanksBestFriend.py

NotQuiteABanksBestFriend.py
import random
from functools import total_ordering
from io import StringIO

log = StringIO()
log.write("\n\n~~~NEW GAME~~~\n\n")

LIST_DELIMITER = ';'
STOCK_DELIMITER = ':'
OFFER_DELIMITER = '@'

JAVA_MAX_INT = 2147483647

@total_ordering
class Stock:
    @staticmethod
    def parse(string: str):
        return Stock(*map(int, string.split(STOCK_DELIMITER)))

    def __init__(self, stock_type: int, amount: int):
        self.type = stock_type
        self.amount = max(amount, 0)

    def __str__(self):
        return "T%sx%s"%(self.type, self.amount)

    def __repr__(self):
        return str(self.type)+STOCK_DELIMITER+str(int(self.amount))

    def __bool__(self):
        return bool(self.amount)

    def __eq__(self, other):
        return self.amount == other.amount

    def __lt__(self, other):
        return self.amount < other.amount

    def update(self, amount) -> 'Stock':
        return Stock(self.type, amount)

    def __mul__(self, other: int) -> 'Stock':
        return self.update(self.amount*other)

    def __floordiv__(self, other: int) -> 'Stock':
        return self.update(self.amount//other)

    def __add__(self, other: int) -> 'Stock':
        return self.update(self.amount+other)

    def __sub__(self, other: int) -> 'Stock':
        return self.update(self.amount-other)


class Offer:
    @staticmethod
    def parse(string: str) -> 'Offer':
        try:
            stock, price = string.split(OFFER_DELIMITER)
        except ValueError:
            raise Exception("Cannot unpack "+string)
        return Offer(Stock.parse(stock), int(price.strip()))

    def __init__(self, stock: Stock, price: int):
        self.stock = stock
        self.price = price
        try:
            self.price_per_unit = self.price/self.stock.amount
        except ZeroDivisionError:
            self.price_per_unit = float('inf')

    def __str__(self):
        return "%s$%s"%(self.stock, self.price)

    def __repr__(self):
        return repr(self.stock)+OFFER_DELIMITER+str(int(self.price))


def read_stock_value(value: str):
    global hidden_price, hidden_stock
    stock, price = value.split(STOCK_DELIMITER)
    hidden_price = float(price)
    hidden_stock = int(stock)
    log.write("Hidden StockID: %s\nHidden Price: %s\n"%(hidden_stock, hidden_price))

def process_input():
    handlers = {
        "SecretValue": read_stock_value,
        "RandomSeed": read_seed,
        "MakeOffer": make_offer,
        "AcceptOffer": accept_offer,
        "AcceptedOffers": accepted_offers,
    }
    method = input().strip()
    data = input().strip()
    output = handlers[method](data)
    if output is not None:
        print(repr(output))
    else:
        print()

def read_seed(seed: str):
    random.seed(int(seed))

def start():
    while True:
        process_input()

hidden_stock = None
hidden_price = None

def filter_offers(offer):
    if offer.stock.amount == 0:
        return False
    if offer.price_per_unit > 1000:
        return False
    return True

def certain_profit(offer):
    stock = offer.stock
    if stock.type == hidden_stock and offer.price_per_unit < hidden_price:
        log.write("Offer, %s is certainly profitable.\n"%offer)
        return True
    return False

def make_offer(current_stock: str):
    current_stock = list(map(Stock.parse, current_stock.split(LIST_DELIMITER)))
    own_stock = [stock for stock in current_stock if stock.type == hidden_stock]
    if own_stock and own_stock[0]:
        own_stock = own_stock[0]
        amount_sold = min(random.randrange(1,50), own_stock.amount)
        price = hidden_price+random.randrange(10,50)
        return Offer(Stock(hidden_stock, amount_sold), price*amount_sold)
    sell_stock = random.choice(current_stock)
    amount_sold = min(random.randrange(1,50), sell_stock.amount)
    price = random.randrange(1000, JAVA_MAX_INT//(amount_sold or 1))
    return Offer(Stock(sell_stock.type, amount_sold), price*(amount_sold or 1))

def accept_offer(available_offers: str):
    available_offers = list(map(Offer.parse, available_offers.split(LIST_DELIMITER)))
    filtered_offers = list(filter(filter_offers, available_offers))
    profitable = list(filter(certain_profit, filtered_offers))
    rtn_list = filtered_offers
    if profitable:
        log.write("Profitable: %s\n"%profitable)
        rtn_list = profitable
    if not rtn_list:
        return None
    accepted_offer = min(rtn_list, key=lambda offer: offer.price_per_unit)
    log.write("Bidded for %s\n"%accepted_offer)
    return accepted_offer

def accepted_offers(offers: str):
    pass


if __name__ == "__main__":
    try:
        start()
    finally:
        log.close()

Luôn cố gắng bán cổ phiếu ẩn với giá trị cao hơn giá trị của nó.