अवलोकन
यह देखने के लिए लड़ाई है कि कौन सबसे लंबे समय तक जीवित रह सकता है। इन बॉट्स पर हमला होने से उनकी शक्ति बढ़ती है, हालांकि, आपको गोली मारने से पहले सावधानी से सोचने की आवश्यकता है।
प्रत्येक मोड़ पर, आप हमला करने या बचाव करने के लिए एक बॉट चुन सकते हैं। हमला करने से इसका जीवन कम हो जाएगा और इसकी शक्ति बढ़ जाएगी। अंतिम बॉट स्थायी जीत।
बॉट
प्रत्येक बॉट 1000 जीवन और 10 शक्ति से शुरू होता है।
जब हमला हुआ:
- आपके हमलावर की शक्ति आपके जीवन से घटा दी जाती है
- आपकी शक्ति 1 से बढ़ जाती है।
तो, अगर पहली बारी पर, आप दो बॉट्स द्वारा हमला करते हैं, तो आपके पास 980 जीवन और 12 शक्ति होगी।
यदि आप बचाव करना चुनते हैं:
- आपकी शक्ति 1 से कम हो जाएगी
- आपके खिलाफ सभी हमले इस मोड़ को आधे से कम कर देंगे
- यदि आप पर हमला किया जाता है, तो आप 1 के बजाय प्रत्येक हमलावर के लिए 2 शक्ति प्राप्त करेंगे
इसलिए, यदि आप पहली बारी का बचाव करते हैं और दो बॉट्स द्वारा हमला किया जाता है, तो आपके पास 990 जीवन और 13 शक्ति होगी। यदि आप बचाव करते हैं और हमला नहीं किया जाता है, तो आपके पास 1000 जीवन होंगे, लेकिन 9 शक्ति।
यदि एक मोड़ के अंत में आपकी शक्ति एक से नीचे है, तो इसे एक पर सेट किया जाएगा। यदि आपका जीवन 1 से कम है, तो आप मर जाते हैं।
इनपुट आउटपुट
बॉट्स को प्रति बार एक बार बुलाया जाता है। प्रत्येक मोड़ के लिए एक सेकंड की समय सीमा है।
प्रारंभिक
पहली बार जब आपके बॉट को बुलाया जाता है, तो उसे कोई तर्क नहीं दिया जाएगा। के साथ प्रतिक्रिया दें ok। यह केवल यह सुनिश्चित करने के लिए किया जाता है कि आपका बॉट प्रतिक्रिया करता है। यदि ऐसा नहीं होता है, तो इसे खिलाड़ी सूची में नहीं जोड़ा जाएगा।
प्रत्येक मोड़
प्रत्येक मोड़ पर, आपके बॉट को गेम के सभी बॉट्स के बारे में कमांड लाइन के तर्क के रूप में जानकारी दी जाती है। इन तर्कों का एक उदाहरण है:
1 0,1000,10,1 1,995,11,D
पहला तर्क आपके बॉट की यूनिक आईडी है। फिर, बॉट्स की एक अलग-अलग सूची दिखाई देती है। प्रत्येक बॉट को स्वरूपित किया गया है:
id,life,power,lastAction
lastActionएक पूर्णांक हो सकता है कि वे किस बॉट पर हमला करते हैं, Dअगर उन्होंने बचाव किया है, और Xअगर यह पहली बारी है। अन्य सभी पूर्णांक हैं।
तो ऊपर दिए गए उदाहरण में, आप 1अपने अंतिम मोड़ पर बॉट और बचाव कर रहे हैं। बॉट 0ने आप पर हमला किया और अभी भी स्वास्थ्य / शक्ति शुरू करने में है।
प्रत्येक मोड़ के लिए आउटपुट बहुत सरल है। सीधे शब्दों में उत्पादन बॉट आप एक पूर्णांक (जैसे के रूप में हमला करने के लिए चाहते हैं 0या 3), या Dकी रक्षा के लिए। मृत या गैर-मौजूद बॉट्स पर हमला न करें, क्योंकि यह एक अवैध कमांड के रूप में गिना जाता है। कोई भी अमान्य आदेश आपको 1 शक्ति खो देगा।
टूर्नामेंट संरचना
प्रत्येक खेल में 1000 स्वास्थ्य और 10 शक्ति से शुरू होने वाले सभी बॉट शामिल हैं। सभी बॉट द्वारा कार्रवाई एक साथ की जाती है। एक गेम के लिए मोड़ों की अधिकतम संख्या 1000 है।
यदि मोड़ के अंत में एक बॉट जीवित है (जीवन> 0), तो यह एक अंक स्कोर करता है और दूसरा गेम शुरू होता है। यदि टर्न सीमा समाप्त हो जाती है और कई बॉट जीवित हैं, तो किसी को भी बात नहीं मिलती है। यदि सभी शेष बॉट एक ही मोड़ पर मर जाते हैं, तो किसी को भी एक बिंदु नहीं मिलता है।
एक टूर्नामेंट में 15 खेल होते हैं। अंत जीत में सबसे अधिक अंक जो कोई भी हो! प्रत्येक जीते हुए खेल में शेष जीवन के योग से संबंध टूट जाते हैं।
राज्य
बॉट्स केवल एक ही फाइल को पढ़ सकते हैं या उसके नाम से लिख सकते हैं, एक सीधे सबफ़ोल्डर में जिसका नाम state("हीरो" लिख सकता है state/hero.whatever)। इस फ़ाइल में 1024 अधिक नहीं होनी चाहिए 2 आकार में बाइट्स। ध्यान रखें कि समय सीमा का पालन करें। आपके कार्यक्रम को गिनने के लिए एक सेकंड के भीतर समाप्त होना चाहिए , न कि केवल एक प्रतिक्रिया दें।
इन फ़ाइलों को प्रत्येक टूर्नामेंट से पहले मिटा दिया जाएगा, लेकिन गेम के लिए गेम जारी रहेगा। idगेम्स के बीच सभी बॉट आइडेंटिफ़ायर ( ) भी समान रहेंगे।
नियंत्रक
नीचे टूर्नामेंट नियंत्रक ( Stronger.java) है। डिफ़ॉल्ट रूप से , यह केवल अंतिम परिणाम (खिलाड़ियों की छंटनी सूची, शीर्ष पर विजेता) को आउटपुट करता है, जिसमें काफी समय लग सकता है। यह जमी नहीं है, बस चुप है। यदि आप अधिक विस्तृत टर्न-बाय टर्न आउटपुट चाहते हैं, -logतो दौड़ते समय तर्क जोड़ें ।
बॉट्स जोड़ने के लिए, आपके पास दो विकल्प हैं:
कमांड को तर्क के रूप में जोड़ें (
java Stronger -log "python bot.py")defaultPlayers[]स्रोत में कमांड जोड़ें ("python bot.py")
बॉट्स हीरो , बुली और कायर को इस उत्तर में पाया जा सकता है , और इसका उपयोग स्कोरिंग उद्देश्यों के लिए किया जाएगा।
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
public class Stronger {
static final String[] defaultPlayers = {
"java Hero",
"java Bully",
"java Coward"
};
final int timeout = 1000;
final int startLife = 1000;
final int startPower = 10;
final int numRounds = 15;
boolean log = false;
List<Player> players;
public static void main(String[] args){
new Stronger().run(args);
}
void run(String[] args){
init(args);
for(int i=0;i<numRounds;i++){
Collections.shuffle(players);
runGame();
}
Collections.sort(players);
for(Player player : players)
System.out.println(player.toString());
}
void runGame(){
log("Player Count: " + players.size());
for(Player player : players)
player.reset();
int turn = 0;
while(turn++ < startLife){
if(aliveCount() < 2)
break;
log("Turn " + turn);
List<Player> clones = new ArrayList<Player>();
for(Player player : players)
clones.add(player.copy());
for(Player player : players){
if(player.life < 1 || player.timedOut)
continue;
String[] args = new String[players.size()+1];
args[0] = "" + player.id;
for(int i=1;i<args.length;i++)
args[i] = players.get(i-1).toArgument();
String reply = getReply(player, args);
Player clone = player.findCopyOrMe(clones);
if(reply.equals("T")){
clone.timedOut = true;
clone.life = 0;
}
clone.lastAction = reply.trim();
}
for(Player player : players){
if(player.life < 1 || player.timedOut)
continue;
Player clone = player.findCopyOrMe(clones);
if(clone.lastAction.equals("D")){
clone.power--;
}else{
try{
int target = Integer.parseInt(clone.lastAction);
for(Player t : players)
if(t.id == target && t.life < 1)
throw new Exception();
for(Player tclone : clones){
if(tclone.id == target){
int atk = player.power;
if(tclone.lastAction.equals("D")){
atk -= player.power / 2;
tclone.power++;
}
tclone.life -= atk;
tclone.power++;
}
}
} catch (Exception e){
log(player.cmd + " returned an invalid command: (" + clone.lastAction + ")");
clone.power--;
}
}
}
players = clones;
for(Player player : players){
if(player.power < 1)
player.power = 1;
log(player.life + "\t\t" + player.power + "\t\t(" + player.id + ")\t" + player.cmd);
}
log("\n");
}
if(aliveCount() == 1)
for(Player player : players)
if(player.life > 0){
player.scoreRounds++;
player.scoreLife += player.life;
}
}
void log(String msg){if(log)System.out.println(msg);}
String getReply(Player player, String[] args){
try{
List<String> cmd = new ArrayList<String>();
String[] tokens = player.cmd.split(" ");
for(String token : tokens)
cmd.add(token);
for(String arg : args)
cmd.add(arg);
ProcessBuilder builder = new ProcessBuilder(cmd);
builder.redirectErrorStream();
long start = System.currentTimeMillis();
Process process = builder.start();
Scanner scanner = new Scanner(process.getInputStream());
process.waitFor();
String reply = scanner.nextLine();
scanner.close();
process.destroy();
if(System.currentTimeMillis() - start > timeout)
return "T";
return reply;
}catch(Exception e){
e.printStackTrace();
return "Exception: " + e.getMessage();
}
}
void init(String[] args){
players = new ArrayList<Player>();
for(String arg : args){
if(arg.toLowerCase().startsWith("-log")){
log = true;
}else{
Player player = createPlayer(arg);
if(player != null)
players.add(player);
}
}
for(String cmd : defaultPlayers){
Player player = createPlayer(cmd);
if(player != null)
players.add(player);
}
}
Player createPlayer(String cmd){
Player player = new Player(cmd);
String reply = getReply(player, new String[]{});
log(player.cmd + " " + reply);
if(reply != null && reply.equals("ok"))
return player;
return null;
}
int aliveCount(){
int alive = 0;;
for(Player player : players)
if(player.life > 0)
alive++;
return alive;
}
static int nextId = 0;
class Player implements Comparable<Player>{
int id, life, power, scoreRounds, scoreLife;
boolean timedOut;
String cmd, lastAction;
Player(String cmd){
this.cmd = cmd;
id = nextId++;
scoreRounds = 0;
scoreLife = 0;
reset();
}
public Player copy(){
Player copy = new Player(cmd);
copy.id = id;
copy.life = life;
copy.power = power;
copy.scoreRounds = scoreRounds;
copy.scoreLife = scoreLife;
copy.lastAction = lastAction;
return copy;
}
void reset(){
life = startLife;
power = startPower;
lastAction = "X";
timedOut = false;
}
Player findCopyOrMe(List<Player> copies){
for(Player copy : copies)
if(copy.id == id)
return copy;
return this;
}
public int compareTo(Player other){
if(scoreRounds == other.scoreRounds)
return other.scoreLife - scoreLife;
return other.scoreRounds - scoreRounds;
}
public String toArgument(){
return id + "," + life + "," + power + "," + lastAction;
}
public String toString(){
String out = "" + scoreRounds + "\t" + scoreLife;
while(out.length() < 20)
out += " ";
return out + "(" + id + ")\t" + cmd;
}
}
}
नियम
आप दो बॉट में प्रवेश कर सकते हैं । यदि आप तीसरे में प्रवेश करने के लिए किसी एक को हटाना चाहते हैं, तो कृपया इसकी पोस्ट हटा दें।
आप मेटा-विश्लेषण द्वारा किसी बॉट को लक्षित या अन्यथा एकल नहीं कर सकते। अपने बॉट को दी गई जानकारी का ही उपयोग करें। इसमें आपके अपने बॉट्स शामिल हैं, इसलिए आप दो बॉट्स को नहीं जोड़ सकते हैं जो आपस में टकराते हैं।
किसी भी तरह से नियंत्रक या अन्य बॉट के चलने में हस्तक्षेप करने का प्रयास न करें।
आपका बॉट तुरंत या अन्यथा नियंत्रक या अन्य बॉट नहीं चला सकता है।
परिणाम
(2015-05-22 00: 00: 00Z के अनुसार प्रस्तुत बॉट्स)
खेल का यह दौर थोड़ा बेहतर रहा, जिसमें केवल दो गेम 1000 टर्न पर आउट हुए। कुडोस को राल्फ मार्शल के संतायण में , जिसने पहले स्थान पर रखा, एकमात्र बॉट था जिसने तीन जीत हासिल की। वह पर्याप्त नहीं था, इसलिए वह भी साथ तीसरे स्थान पर ले लिया रणनीतिज्ञ । स्टॉर्मक्रॉ ने फैंटम मेंस के साथ दूसरा स्थान हासिल किया , जो यहां पहली बार ठीक पोस्ट था। सभी में हम नए सदस्यों द्वारा एक बहुत अच्छा दिखा रहे थे, शीर्ष छह स्थानों में पांच से कम पदों वाले लोगों के लिए जा रहे थे। बधाई, और साइट पर आपका स्वागत है!
स्थान बचाने के लिए शून्य जीत हासिल करने वाले बॉट सूचीबद्ध नहीं हैं। ऊपर दिए गए टाइमस्टैम्प से पहले पोस्ट किए गए सभी बॉट चलाए गए थे, इसलिए यदि आप अपना नहीं देखते हैं, तो यह कुछ भी नहीं जीता।
Wins Life(tiebreaker) Name
3 561 perl Santayana.pl
2 850 java PhantomMenace
2 692 perl Tactician.pl
2 524 java Wiisniper
1 227 java Tank
1 184 java Velociraptor
1 7 java Coward
1 3 java IKnowYou
Sorta स्केची समानांतर नियंत्रक ( दूसरों के द्वारा ):
import java.lang.ProcessBuilder.Redirect;
import java.nio.file.FileSystems;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
import java.util.concurrent.atomic.AtomicInteger;
public class Stronger {
static final String[] defaultPlayers = {
"java Hero",
"java Bully",
"java Coward",
"java Psycho",
"./monte.out",
"java Analyst",
"java Guardian",
"java Revenger",
"python precog.py",
//"python snappingTurtle.py",
"python beserker.py",
"./suprise.out",
//"python boxer.py",
"python defense.py",
"java Tank",
"java IKnowYou",
//"java BroBot",
"java Equaliser",
"java Velociraptor",
//"java AboveAverage",
"java PhantomMenace",
"java Wiisniper",
//"python semiRandom.py",
"/usr/bin/perl tactition.pl",
"/usr/bin/perl santayana.pl",
//"java GlitchUser"
"/usr/local/bin/Rscript opportunity.R",
"/usr/local/bin/scala Bandwagoner",
};
final int timeout = 5000;
final int startLife = 1000;
final int startPower = 10;
final int numRounds = 20;
boolean log = true;
List<Player> players;
public static void main(String[] args){
new Stronger().run(args);
}
void run(String[] args){
init(args);
for(int i=1;i<=numRounds;i++){
if(log) System.out.println("Begining round "+ i);
Collections.shuffle(players);
runGame();
}
Collections.sort(players);
for(Player player : players)
System.out.println(player.toString());
}
void runGame(){
log("Player Count: " + players.size());
for(Player player : players)
player.reset();
int turn = 0;
while(turn++ < startLife){
if(aliveCount() < 2)
break;
log("Turn " + turn);
List<Player> clones = new ArrayList<Player>();
for(Player player : players)
clones.add(player.copy());
AtomicInteger count=new AtomicInteger(players.size());
for(Player player : players){
new Thread(() -> {
if(player.life >= 1 && !player.timedOut){
String[] args = new String[players.size()+1];
args[0] = "" + player.id;
for(int i=1;i<args.length;i++)
args[i] = players.get(i-1).toArgument();
String reply = getReply(player, args);
Player clone = player.findCopyOrMe(clones);
if(reply.equals("T")){
clone.timedOut = true;
clone.life = 0;
}
clone.lastAction = reply.trim();
}
synchronized(count){
count.decrementAndGet();
count.notify();
}
}).start();
}
synchronized(count){
while(count.get() > 0){
//System.out.println(count);
try{
count.wait();
}catch(InterruptedException e){
}
}
}
for(Player player : players){
if(player.life < 1 || player.timedOut)
continue;
Player clone = player.findCopyOrMe(clones);
if(clone.lastAction.equals("D")){
clone.power--;
}else{
try{
int target = Integer.parseInt(clone.lastAction);
for(Player t : players)
if(t.id == target && t.life < 1)
throw new Exception();
for(Player tclone : clones){
if(tclone.id == target){
int atk = player.power;
if(tclone.lastAction.equals("D")){
atk -= player.power / 2;
tclone.power++;
}
tclone.life -= atk;
tclone.power++;
}
}
} catch (Exception e){
log(player.cmd + " returned an invalid command: (" + clone.lastAction + ")");
clone.power--;
}
}
}
players = clones;
for(Player player : players){
if(player.power < 1)
player.power = 1;
log(player.life + "\t\t" + player.power + "\t\t" + player.lastAction + "\t\t(" + player.id + ")\t" + player.cmd);
}
log("\n");
}
if(aliveCount() == 1)
for(Player player : players)
if(player.life > 0){
player.scoreRounds++;
player.scoreLife += player.life;
}
}
void log(String msg){if(log)System.out.println(msg);}
String getReply(Player player, String[] args){
try{
List<String> cmd = new ArrayList<String>();
String[] tokens = player.cmd.split(" ");
for(String token : tokens)
cmd.add(token);
for(String arg : args)
cmd.add(arg);
ProcessBuilder builder = new ProcessBuilder(cmd);
builder.directory(FileSystems.getDefault().getPath(".", "bin").toFile());
//builder.redirectError(Redirect.PIPE);
long start = System.currentTimeMillis();
Process process = builder.start();
Scanner scanner = new Scanner(process.getInputStream());
process.waitFor();
String reply = scanner.nextLine();
scanner.close();
process.destroy();
if(System.currentTimeMillis() - start > timeout)
return "T";
return reply;
}catch(Exception e){
//e.printStackTrace();
return "Exception: " + e.getMessage();
}
}
void init(String[] args){
players = new ArrayList<Player>();
for(String arg : args){
if(arg.toLowerCase().startsWith("-log")){
log = true;
}else{
Player player = createPlayer(arg);
if(player != null)
players.add(player);
}
}
for(String cmd : defaultPlayers){
Player player = createPlayer(cmd);
if(player != null)
players.add(player);
}
}
Player createPlayer(String cmd){
Player player = new Player(cmd);
String reply = getReply(player, new String[]{});
log(player.cmd + " " + reply);
if(reply != null && reply.equals("ok"))
return player;
return null;
}
int aliveCount(){
int alive = 0;;
for(Player player : players)
if(player.life > 0)
alive++;
return alive;
}
static int nextId = 0;
class Player implements Comparable<Player>{
int id, life, power, scoreRounds, scoreLife;
boolean timedOut;
String cmd, lastAction;
Player(String cmd){
this.cmd = cmd;
id = nextId++;
scoreRounds = 0;
scoreLife = 0;
reset();
}
public Player copy(){
Player copy = new Player(cmd);
copy.id = id;
copy.life = life;
copy.power = power;
copy.scoreRounds = scoreRounds;
copy.scoreLife = scoreLife;
copy.lastAction = lastAction;
return copy;
}
void reset(){
life = startLife;
power = startPower;
lastAction = "X";
timedOut = false;
}
Player findCopyOrMe(List<Player> copies){
for(Player copy : copies)
if(copy.id == id)
return copy;
return this;
}
public int compareTo(Player other){
if(scoreRounds == other.scoreRounds)
return other.scoreLife - scoreLife;
return other.scoreRounds - scoreRounds;
}
public String toArgument(){
return id + "," + life + "," + power + "," + lastAction;
}
public String toString(){
String out = "" + scoreRounds + "\t" + scoreLife;
while(out.length() < 20)
out += " ";
return out + "(" + id + ")\t" + cmd;
}
}
}