पृष्ठभूमि
आप सभी व्यापारी प्रतिष्ठित स्टॉक फर्म से थोड़े कम के लिए हैं। आप सभी व्यापारियों के एक समूह का हिस्सा हैं जो केवल एक विशिष्ट स्टॉक पर ध्यान केंद्रित करते हैं।
प्रत्येक घंटे प्रत्येक व्यापारी के पास एक्स स्टॉक खरीदने या एक्स स्टॉक बेचने का मौका होता है। प्रति राउंड 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
| +-- BotNameFolder
| +-- BotProgram
कृपया अपने कोड को 'खिलाड़ियों की निर्देशिका' के अंदर से चलाने के लिए कमांड लाइन तर्क के साथ प्रदान करें। उदाहरण के लिए Test1 व्यापारी के साथ चलाया जा सकता हैjava -cp "Test1" Test1
अतिरिक्त नियम
आगे बढ़ो, अपने आप को इमोवुल्फ, ईदक शूट करें।
अपने 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
पहला नंबर राउंड की संख्या है, दूसरा नंबर राउंड प्रति है, इसके बाद कमांड प्रत्येक खिलाड़ी को चलाने के लिए है।
Ampersands के साथ रिक्त स्थान बदलें! ( 'और')
~ मुझे बताएं कि क्या मैं इस पोस्ट के शब्दों में सुधार कर सकता हूं, और खुश ट्रेडिंग!