ความขัดแย้ง 4-Man

ลักษณะ

คุณพบว่าตัวเองขัดแย้งกันสี่ทาง ปืนที่บรรจุอยู่ในมือของคุณและมีระเบิดติดอยู่บนเข็มขัดของคุณ

จุดประสงค์คือการมีสุขภาพที่ดีที่สุดในตอนท้ายของความขัดแย้ง ความขัดแย้งสิ้นสุดลงเมื่อคนส่วนใหญ่มีสุขภาพที่ดี

ผู้เล่นแต่ละคนมีสุขภาพและตายเมื่อสุขภาพของพวกเขาลดลงไป5 / ด้านล่าง 0เทิร์นที่ผู้เล่นเสียชีวิตเป็นเทิร์นสุดท้ายที่ผู้เล่นสามารถรับความเสียหายได้

หากมีผู้เล่นสดเมื่อสิ้นสุดการขัดแย้งผู้เล่นนั้นจะชนะ มิฉะนั้นผู้เล่นที่มีค่าลบน้อยที่สุดจะเป็นผู้ชนะ

การปฏิบัติ

• ยิง : ยิงใส่ใครซักคน

  • 2 สร้างความเสียหายหากยิงศัตรูที่มีชีวิต
  • 0 สร้างความเสียหายหากยิงศัตรูที่ตายแล้ว
  • health_at_start_of_turn+2ความเสียหายถ้ายิงตัวเอง (โปรดทราบว่าสิ่งนี้จะทำให้คุณมี-2สุขภาพที่ดีที่สุด)
  • หากศัตรูคนหนึ่งยิงคุณในเทิร์นเดียวกันกับที่คุณยิงตัวเองคุณจะจบการต่อสู้ด้วยสุขภาพ -4 (คุณยังคงได้รับความเสียหายจากผู้เล่นอื่นเมื่อคุณฆ่าตัวเอง)
  • การกระทำของคุณในเทิร์นต่อไปนี้จะถูกละเว้น (และสันนิษฐานว่าเป็นNothing)

• Dodge : พยายามหลบการยิงของฝ่ายตรงข้ามเพียงคนเดียว

• เตรียม : ปลดลูกระเบิดมือของคุณและเตรียมโยนมัน

  • คุณมีเพียงสามรอบที่จะโยนมันก่อนที่คุณจะได้รับการเป่าขึ้น ( 6ความเสียหายให้กับตัวเอง3ความเสียหายให้กับศัตรูที่มีชีวิตทั้งหมด)
  • การตายด้วยระเบิดมือที่ไม่มีผู้โยนนั้นเทียบเท่ากับการไม่ทิ้งระเบิดไว้สามรอบ

• โยน : โยนระเบิดใส่คนและหวังว่าจะดีที่สุด

  • เป้าหมายจะได้รับ8ความเสียหายหากมีชีวิตอยู่
  • คนอื่น ๆ (รวมถึงตัวคุณเอง) จะได้รับ3ความเสียหายหากยังมีชีวิตอยู่

• ไม่มีอะไร : ยืนเฉยๆเพื่อดูและทุกคนตาย

อินพุต

โปรแกรมของคุณจะถูกส่งผ่านข้อมูลต่อไปนี้:

• สุขภาพของผู้เล่นแต่ละคน

• รายการของการกระทำที่ดำเนินการโดยผู้เล่นตั้งแต่จุดเริ่มต้นของความขัดแย้งด้านล่างเป็นรูปแบบสำหรับข้อมูลที่ส่งผ่านต่อผู้เล่น:

  [Health],[Action 1],[Action 2],[Action 3],...
  

การดำเนินการจะได้รับในรูปแบบที่ระบุในส่วนผลลัพธ์

คุณจะได้รับ 4 สตริงดังกล่าวคั่นด้วยช่องว่างและส่งผ่านเป็นอาร์กิวเมนต์เดียว ลำดับของสตริงเหล่านี้คือ:

[Player Info] [Opponent 1 Info] [Opponent 2 Info] [Opponent 3 Info]

สตริงจะถูกส่งเป็นอาร์กิวเมนต์ที่สอง อาร์กิวเมนต์แรกมีจำนวนเต็มที่ระบุการขัดแย้งที่ถูกตราขึ้นมา การแสตนด์บายระหว่างผู้เล่นชุดเดียวกันนั้นรับประกันว่าจะไม่พร้อมกัน อย่างไรก็ตามการสแตนด์บายหลายครั้งจะเกิดขึ้นในเวลาเดียวกัน

ตัวอย่างเช่น:

$./Player.bash 5 "3,S2,N 5,P,N 3,S0,N -2,S3,N"

ปัจจุบันผู้เล่นและคู่ต่อสู้ที่สองมี 3 สุขภาพคู่ต่อสู้คนแรกมี 5 สุขภาพและคู่ที่สามมีสุขภาพ -2 และตาย

ในเทิร์นแรก:

• ผู้เล่น 1 ยิงศัตรู 2
• ศัตรู 1 เตรียมระเบิดมือ
• Enemy 2 shot player
• ศัตรู 3 ยิงตัวเอง

ในเทิร์นที่สอง:

• ผู้เล่นทุกคนไม่ได้ทำอะไรเลย (ผู้เล่นและศัตรู 2 ไม่สามารถทำอะไรได้ตั้งแต่ที่พวกเขายิงในเทิร์นก่อนหน้าศัตรู 3 นั้นตายแล้ว: เขาจะทำNothingเพื่อการต่อสู้ที่เหลือ)

อาร์กิวเมนต์ที่สองที่จุดเริ่มต้นของการขัดแย้งคือ: 5 5 5 5.

เอาท์พุต

คำสั่งควรแสดงผลในรูปแบบที่แสดงด้านล่าง ผลลัพธ์ที่ไม่ถูกต้องถูกตีความว่า 'ไม่มีอะไร' คำสั่งที่ต้องการเป้าหมายควรตามด้วยจำนวนเต็ม ( 0-3พร้อม0ตัวแทนผู้เล่นและ1-3เป็นตัวแทนศัตรู 1-3)

• S[target]: ถ่ายภาพ [เป้าหมาย]
• D[target]: พยายามหลบ [เป้าหมาย]
• P: เตรียมระเบิดมือ
• T[target]: ขว้างระเบิดไปที่ [เป้าหมาย]
• N: ไม่ทำอะไร.

คำสั่งที่ต้องการเป้าหมาย แต่ถูกป้อนเป้าหมายไม่ใช่ระหว่าง0และ3หรือไม่ป้อนเป้าหมายทั้งหมดจะถือว่าเป็นเป้าหมาย0(ผู้เล่น)

เกณฑ์การให้คะแนน

เมื่อสิ้นสุดการขัดแย้งแต่ละครั้งผู้เล่นจะได้รับคะแนนคำนวณตามสูตรต่อไปนี้:

35 + health at end of standoff 

ในกรณีที่ผู้เล่นที่จบลงด้วยความขัดแย้งด้านลบต่อสุขภาพที่พวกเขาจะได้รับคะแนนต่ำกว่า 35 คะแนนต่อไปนี้จะได้รับเป็นโบนัสด้วย:

• สุขภาพส่วนใหญ่: +4 คะแนน
• สุขภาพอันดับสอง: +2 คะแนน
• สุขภาพอันดับสาม: +1 จุด

ในกรณีที่เสมอกันโบนัสที่ต่ำกว่าจะได้รับ (หากคนสองคนเสมอกันที่มีสุขภาพส่วนใหญ่ทั้งคู่จะได้รับ +2 หากมี 3 คนที่มีสุขภาพดีที่สุด +1 และหากทุกคนจบลงอย่างเท่าเทียมกัน +0)

คะแนนสุดท้ายจะถูกกำหนดโดยการคำนวณค่าเฉลี่ยของคะแนนแต่ละบุคคล

กฎ / รายละเอียด

• ลำดับเหตุการณ์ภายในรอบดังนี้:
  • ผู้เล่นทุกคนลงมือทำ
  • ผู้เล่นที่มีค่าพลังชีวิต 0 หรือน้อยกว่าจะตาย
  • ระเบิดที่ไม่ต้องโยนซึ่งจะต้องระเบิดจะระเบิด (ผู้เล่นที่เพิ่งเสียชีวิตจะยังคงได้รับบาดเจ็บ
• ไม่มีการทำงานร่วมกันระหว่างรายการ
• สาม standoffs จะเกิดขึ้นระหว่างผู้เล่นชุดละ 4 คน (คำสั่งของผู้เล่นอาจแตกต่างกันไปในแต่ละข้อขัดแย้ง)
• รายการที่ใช้หน่วยความจำมากเกินไปของพื้นที่ดิสก์จะถูกตัดสิทธิ์
• การอ่านหรือแก้ไขไฟล์นอกเหนือจากรายการของคุณจะทำให้รายการของคุณไม่มีคุณสมบัติ
• รถบรรทุกที่ขับเคลื่อนด้วยคนขี้เมาจะวิ่งไปหาผู้เล่นที่ยังมีชีวิตอยู่ทั้งหมดหลังจาก50thเทิร์นหากยังไม่จบในตอนท้ายของ50thเทิร์น
  • รถบรรทุกคันนี้สร้างความเสียหาย20 ดาเมจให้กับผู้เล่นสดทุกคน
• Standoffs เกิดขึ้นอย่างรวดเร็ว โปรแกรมจะถูกตัดออกหลังจาก 1 วินาที
• โปรแกรมของคุณจะถูกเรียกทุกครั้งแม้หลังจากที่คุณเสียชีวิต
• คุณสามารถอ่านหรือเขียนไฟล์ไปยังไดเรกทอรีของคุณเท่านั้น (หากรายการของคุณชื่อ JohnDoe คุณสามารถบันทึกไฟล์ในไดเรคทอรีผู้เล่น / JohnDoe /); อย่างไรก็ตามนี่จะไม่ใช่ไดเรกทอรีปัจจุบันขณะที่สคริปต์ของคุณทำงานอยู่
• การหยุดทำงานจะเกิดขึ้นบนเครื่องที่ใช้ Arch Linux (Release 2014.08.01)

ตัวควบคุมที่มีอยู่บนGitHub

โปรดระบุสิ่งต่อไปนี้ในโพสต์ของคุณ:

• ชื่อบอทของคุณ
• คำสั่งเชลล์เพื่อเรียกใช้ bot (เช่นjava Doe.java) อินพุตจะถูกส่งผ่านบรรทัดคำสั่งเป็นอาร์กิวเมนต์เดียว ( java Doe.java 5 "-2,S0 -2,S1 -2,S2 5,N")
• รหัสของบอทของคุณ
• วิธีรวบรวมบอท (ถ้ามี)
• ภาษา (และรุ่นถ้ามีโดยเฉพาะอย่างยิ่งสำหรับงูใหญ่)

* คอนโทรลเลอร์ใช้เวลานานเกินไปสำหรับหกคน

ป้ายบอกคะแนน

                      Observer 43.280570409982
                   MuhammadAli 43.134861217214
                         Osama 43.031983702572
                    LateBoomer 42.560275019099
                 SimpleShooter 42.412885154062
             LessSimpleShooter 42.3772
                           Neo 42.3738
                        Scared 42.3678
                     Richochet 42.3263
                   Equivocator 42.2833
  TwentyFourthsAndAHalfCentury 42.2640
                        Darwin 42.1584
                       HanSolo 42.1025
                        Coward 42.0458
           ManipulativeBastard 41.8948
                        Sadist 41.7232
                     Aggressor 41.7058
                 CourageTheDog 41.5629
                     Grenadier 40.9889
                     Bomberman 40.8840
                         Spock 40.8713
                        Sniper 40.6346
                 DONTNUKEMEBRO 39.8151
               PriorityTargets 39.6126
                     Hippolyta 39.2480
                     EmoCowboy 39.2069
                      Zaenille 39.1971
                 AntiGrenadier 39.1919
      PoliticallyCorrectGunman 39.1689
                 InputAnalyzer 39.1517
                      Rule0Bot 39.1000
                     BiasedOne 39.0664
                      Pacifist 39.0481
               StraightShooter 39.0292
                         Ninja 38.7801
                           MAD 38.2543
                        Monkey 37.7089
                   Label1Goto1 36.2131
Generated: 2014/08/22 03:56:13.470264860 UTC

บันทึก: บน GitHub

ผู้สังเกตการณ์

ผู้ชายคนนี้วิเคราะห์ศัตรูของเขา เป้าหมายคือการเอาชีวิตรอดจนกว่าฝ่ายตรงข้ามจะเหลือเพียง "ก้าวร้าว" เท่านั้นและจากนั้นก็ฆ่าคนนั้นด้วยการเผชิญหน้าอันยิ่งใหญ่

รวบรวม: javac Observer.javaเรียกใช้:java Observer arg0 arg1

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

class Observer {
    private static List<Integer> aggressiveEnemies = new ArrayList<>();
    private static List<Integer> enemyGrenadiers = new ArrayList<>();
    private static List<Integer> aliveEnemies = new ArrayList<>();

    public static void main(String[] args) {
        if (args[1].length() <= 7) { //first round
            Random rand = new Random();
            printResult("D" + (rand.nextInt(3) + 1));
        }
        String players[] = args[1].split(" ");

        if (truckIsOnWay(players[0])) {
            printResult("P");
        }       

        calcEnemyInfo(players);

        // end this standoff now
        if (truckWillHit(players[0])) {
            if (isGrenadier(players[0]))
                printResult("T" + aliveEnemies.get(0));
            else
                printResult("S0");
        }

        // shoot enemy who is not aggressive
        if (aggressiveEnemies.size() == 0) {
            printResult("S" + aliveEnemies.get(0));
        }

        // only one enemy to handle
        if (aggressiveEnemies.size() == 1) {
            String player = players[aggressiveEnemies.get(0)];
            if (isGrenadier(player)) {
                printResult("S" + aggressiveEnemies.get(0));
            } else if (shotLastTurn(player, aggressiveEnemies.get(0))) {
                //safe to shoot him without receiving damage
                printResult("S" + aggressiveEnemies.get(0));
            } else {
                printResult("D" + aggressiveEnemies.get(0));
            }
        }

        // multiple aggressive enemies
        if (enemyGrenadiers.size() > 0) {
            printResult("S" + enemyGrenadiers.get(0));
        } else {
            int id = aggressiveEnemies.get(0);
            for (int playerId : aggressiveEnemies) {
                if (!shotLastTurn(players[playerId], playerId)) {
                    id = playerId;
                }
            }
            printResult("D" + id);
        }
    }

    private static void printResult(String result) {
        System.out.print(result);
        System.exit(0);
    }

    private static boolean isAlive(String player) {
        return !(player.charAt(0) == '-' || player.charAt(0) == '0');
    }

    private static void calcEnemyInfo(String[] players) {
        for (int i = 1; i < players.length; i++) {
            if (isAlive(players[i])) {
                aliveEnemies.add(i);
                if (isAggressive(players[i], i)) {
                    aggressiveEnemies.add(i);
                }
                if (isGrenadier(players[i])) {
                    enemyGrenadiers.add(i);
                }
            }
        }
    }

    private static boolean truckIsOnWay(String player) {
        return player.length() - player.replace(",", "").length() == 48;
    }

    private static boolean truckWillHit(String player) {
        return player.length() - player.replace(",", "").length() == 49;
    }

    private static boolean isAggressive(String player, int id) {
        return (player.contains("S") || player.contains("P")) && !player.contains("S" + id);
    }

    private static boolean isGrenadier(String player) {
        return player.contains("P");
    }

    private static boolean shotLastTurn(String player, int id) {
        return player.charAt(player.length() - 2) == 'S' && !player.contains("S" + id);
    }
}

ทหารราบรักษาพระองค์

ปืนถูก overrated จริงขัดแย้งของสกอตไปเช่นนี้

• เตรียมการ
• โยนศัตรูให้มีสุขภาพดีที่สุด
• ทำซ้ำ (ถ้าปาฏิหาริย์บางอย่างคุณยังมีชีวิตอยู่)

ขณะนี้ดูเหมือนเล็กน้อยมันอาจไม่ใช่กลยุทธ์ที่แย่มาก ตั้งแต่ปืนและระเบิดทั้งสองมีรอบสองกลับกันนี้คือโดยไกลที่มีประสิทธิภาพมากขึ้น¹วิธีที่จะจัดการความเสียหาย

แน่นอนถ้าทั้งสามคนยิงข้าในรอบแรกมันไม่ดี แต่ก็ไม่มากเท่าไหร่

public class Grenadier {
    public static void main(String[] args) {
        if(args.length < 2)
            return;
        String[] list = args[1].split(" ");
        if(list.length < 4)
            return;

        if(list[0].charAt(list[0].length()-1) != 'P'){
            System.out.print("P");
            return;
        }

        int target = 1;
        for(int i=2;i<4;i++)
            if(list[i].charAt(0)>list[target].charAt(0))
                target = i;

        System.out.print("T"+target);
    }
}

คอมไพล์ / รันด้วยวิธี Java มาตรฐาน:

> javac Grenadier.java
> java Grenadier arg0 arg1

¹เชิงอรรถที่ไม่มีจุดหมาย

Asimov's Rule Number 0 Bot - Python

หุ่นยนต์อาจไม่เป็นอันตรายต่อมนุษยชาติหรือโดยไม่ได้รับอนุญาตจะทำให้มนุษยชาติเกิดอันตราย

ค่อนข้างตรงไปตรงมาเขาจะโจมตีผู้เล่นคนแรกที่เขาเห็นว่าถือระเบิดเพื่อปกป้องมนุษย์ส่วนใหญ่ หากไม่มีใครเป็นภัยคุกคามต่อมนุษย์ส่วนใหญ่เขาจะไม่ทำอะไรเลย

import sys

def total_humans_alive(humans):
  return sum([is_alive(human) for human in humans])

def is_alive(x):
  return int(x.split(",")[0]) > 0  

def is_threat_to_humanity(lastAction):
  return lastAction == "P"

action = "N"
threat_id = 1
humans = sys.argv[2].split()[1:];

if total_humans_alive(humans) == 3:
  for human in humans:
    if is_threat_to_humanity(human[-1]):
      action = "S" + str(threat_id)
      break
    threat_id= threat_id+ 1

print action

เรียกใช้เช่น:

python rule0bot.py

ฮันโซโล - งูหลาม

ฮันช็อตแรก ในกรณีนี้เขาจะยิงก่อนโดยเลือกเป้าหมายที่อยู่ใกล้ที่สุด

import sys

def is_alive(player):
  return int(player.split(",")[0]) > 0

closest_living_target = 1;

for player in sys.argv[2].split()[1:]:
  if is_alive(player):
    action = "S" + str(closest_living_target)
    break

  closest_living_target = closest_living_target + 1

print action

เรียกใช้เช่น:

python hansolo.py

_{หมายเหตุ : นี่เป็นสิ่งแรกที่ฉันเคยเขียนไว้ใน Python ดังนั้นหากคุณเห็นวิธีปฏิบัติที่ไม่เหมาะสมสำหรับงูหลามใด ๆ โปรดแจ้งให้เราทราบ}

EmoCowboy

รอตายทำไม เพิ่งฆ่าตัวตายตอนนี้ หวังว่าคนโง่ที่เหลือจะทำให้แต่ละคนเหลือน้อยกว่า -2

โดยปกติคะแนนจะเป็น -2 บางครั้ง -4 ถ้ามีคนตัดสินใจที่จะยิงฉันออกจากค้างคาว ยิ่งไปกว่านั้นซึ่งหมายความว่าควรเอาชนะผลงานที่ส่งเข้ามาหลายครั้ง

หลาม

print('S0')

python EmoCowboy.py

แก้ไข: นี่ไม่ใช่เรื่องตลกซึ่งโดยทั่วไปเป็นสาเหตุว่าทำไมการส่งเพลงถึงเหล่านี้จึงทำให้ขมวดคิ้ว นี่เป็นกลยุทธ์ที่ถูกต้องตามกฎหมาย การมีชีวิตอยู่นั้นเป็นอันตรายถึงตาย!

ผู้รักความสงบ

เขาเป็นคนที่บวมจริง ๆ เพิ่งติดกับฝูงชนที่ผิด

main = putStr "N"

เรียกใช้runghc pacifist.hsแต่คุณอาจต้องการคอมไพล์ด้วย -O3 หากประสิทธิภาพเป็นปัญหา

Monkey - Python (รายการแรก!)

ลิงเห็นลิงทำ. จะทำซ้ำการกระทำล่าสุดโดยผู้เล่นสุ่ม

import sys, random
targetData = sys.argv[2].split()[random.randint(0,3)]
print(targetData.split(',')[len(targetData.split(','))-1])

สามารถเรียกใช้ดังนี้: "python monkey.py args" ไม่จำเป็นต้องมีขั้นตอนเพิ่มเติม

Simple Shooter - Perl (แก้ไขข้อผิดพลาด)

บอทนี้ยิงใส่คู่ต่อสู้ด้วยพลังชีวิตสูงสุด มันเป็นกลยุทธ์ที่ง่ายมาก แต่ฉันคิดว่ามันมีโอกาสดีที่จะทำได้ดี

@history = map([split(",",$_)],split(" ",$ARGV[1]));
$target = 1;
for(2..3){
 if($history[$_][0] >= $history[$target][0]){$target = $_}
}
print "S$target"

นี่คือวิธีการรันโดยใช้ตัวอย่างอินพุต:

perl simpleshooter.plx 7 "3,S2,N 5,P,N 3,S0,N -2,S3,N"

สป็อคใน Python 3.x

รหัสนี้เป็นมากกว่าการทดลอง (ซึ่งตั้งชื่อตามสป็อคเพราะ ... เขาเป็นคนหยาบคายและพวกเขาค่อนข้างเก่งในเรื่องเหล่านี้) แต่ก็สนุกที่ได้สร้างมันขึ้นมา เหตุผลหลักที่อยู่เบื้องหลังรหัสนี้เป็นข้อสันนิษฐานที่ดีตรรกะเหมือน Spock ถ้าทำตามกฎของเกม:

วัตถุประสงค์ของเกมนี้คือการเพิ่มคะแนนซึ่งทุกคนจะต้องยืนนิ่งซึ่งเป็นไปไม่ได้เนื่องจากรถบรรทุก

• หนึ่งในแนวทางที่ต้องปฏิบัติตามคือเพื่อป้องกันไม่ให้รถบรรทุกปรากฏสป็อคตรวจสอบให้แน่ใจว่าทุกคน แต่ตายก่อนที่รถบรรทุกจะปรากฏขึ้น

วิธีที่สป็อคเล่นในส่วนที่เหลือของเกมสามารถสรุปได้จากคำพูดที่โด่งดังของเขา: " ความต้องการของคนจำนวนมากเกินความต้องการของคนไม่กี่คน " กล่าวอีกนัยหนึ่งสป็อคต้องตรวจสอบให้แน่ใจว่าความเสียหายน้อยที่สุดได้รับความเดือดร้อนโดยการฆ่าคนที่ทำมัน เขาทำได้อย่างไร:

• หากไม่มีผู้เล่นเตรียมระเบิดมือให้ตั้งเป้าหมายผู้เล่นที่แข็งแรงที่สุดที่ยังคงเล่นอยู่
• หากมีผู้เล่นที่เตรียมระเบิดมือจากเป้าหมายที่แข็งแรงที่สุด

เหตุผลก็คือการกำหนดเป้าหมายไปยังผู้เล่นที่อ่อนแอที่สุดนั้นเรากำลังยกเลิกแหล่งที่มาของความเสียหาย เหตุผลที่อยู่เบื้องหลังการระเบิดก็คือพวกเขาจะออกไปโดยไม่คำนึงถึงและพวกเขาจะสร้างความเสียหายน้อยลงหากพวกเขาไม่ได้ถูกโยน

บอทนี้จึงใช้งานได้ ฉันยังไม่ได้ทดสอบอย่างกว้างขวางสำหรับความล้มเหลวในการป้อนข้อมูล (ดังนั้นโปรดเตือนฉันว่ามีบางอย่างผิดปกติ) แต่ฉันมั่นใจว่าฉันทำงานได้ดีที่สุด ฉันใช้โค้ดเล็ก ๆ น้อย ๆ จาก HanSolo bot แต่ส่วนใหญ่มันเป็นรหัสยุ่งเหยิง สนุก.

def IsAlive(player):
  return int(player[1].split(",")[0]) > 0
def IsTarget(player, target_health):
  return int(player[1].split(",")[0]) < target_health
def HasGrenade(player):
  max_range = max(-4,-current_turn)
  for foo in range(-1,max_range,-1):
    if "P" in player[1].split(",")[foo]:
      for bar in range(-1,foo-1,-1):
        if player[1].split(",")[bar] not in ["T0", "T1", "T2", "T3"]:
          return True
  return False

import sys
info_list = sys.argv[2].split()
current_turn = len(info_list[0].split(","))
action = "N"

def Startgame():
  global action

  target = 1
  target_health = 5
  grenade_list=[]

  for player in zip(range(1,4),info_list[1:]):
    if HasGrenade(player):
      grenade_list.append(player)

  if not grenade_list:
    foo_list = []
    for player in zip(range(1,4),info_list[1:]):
      foo_list.append(player)
    target_list = foo_list
  else:
    target_list = grenade_list

  # Choose the least healthy player
  for player in target_list:
    if IsAlive(player) and IsTarget(player, target_health):
      target = player[0]
      target_health = int(player[1][0])

  action = "S" + str(target)

def Endgame(turn):
  global action

  if turn in [47, 49]:
    # Check if in 2 moves he can do enough damage
    rem_health = 0
    for player in zip(range(1,4),info_list[1:]):
      if IsAlive(player): rem_health += player[0]

    if rem_health < 5:
      Startgame() # It's lazy, but it should work
      return
    else:
      action = "P"
      return

  if turn in [48, 50]:
    # If Spock shot someone before, it needs to shoot again
    if info_list[0].split(",")[-1] in ["S0", "S1", "S2", "S3"]:
      Startgame()
      return
    else:
    # There's no rule against throwing grenades to dead bodies, so if
    # possible it will be thrown there.    
      target = 1
      target_health = 5

      foo_list = []
      for player in zip(range(1,4),info_list[1:]):
        foo_list.append(player)
      target_list = foo_list

      for player in target_list:
        if IsTarget(player, target_health):
          target = player[0]
          target_health = int(player[1][1])

      action = "T" + str(target)
      return

if current_turn > 46:
  Endgame(current_turn)
else:
  Startgame()

print(action)

เรียกใช้เช่น:

python spock.py

2014-08-12 - แก้ไขข้อผิดพลาดเล็กน้อยเกี่ยวกับการตรวจจับระเบิดมือ
2014-08-14 - แก้ไขข้อผิดพลาดเล็กน้อยเกี่ยวกับ endgame ขอขอบคุณ isaacg สำหรับการชี้ให้เห็นก่อน

มือปืนแก้ไขทางการเมือง

ถูกต้องทางการเมืองมากเพราะมันไม่แยกแยะกับสิ่งใด ดังนั้นมันไม่ได้ฉลาดมาก

import random

array = ["P", "N", "S0", "S1", "S2", "S3", "D1", "D2", "D3", "T1", "T2", "T3"]

print(array[random.randrange(0,11)])

มัน ... ไม่สำคัญว่าการโต้เถียงจะผ่านไปอย่างไรกันแน่ python politicallycorrectgunman.py

ยิงตรง

เขาเป็นทหารม้าที่ได้รับการฝึกฝนและพูดคุยในหลายภาษา แต่เมื่อถูกกระพริบตา Straight Shooter สามารถมองเห็นศัตรูเพียงคนเดียวที่อยู่ตรงหน้าเขา เป็นม้าเขาไม่เข้าใจว่าคุณต้องรอระหว่างนัด

print('S2')

Perl, Python 2/3, Ruby: ม้าตัวนี้เป็นรูปหลายเหลี่ยมจริงๆ

ฉันชนะต่อไป ฉันไม่สามารถสูญเสีย คุณสามารถยิงฉัน แต่คุณไม่สามารถฆ่าฉัน มิสเตอร์เอ็ดไม่ได้โกรธฉัน

คำตอบที่มีความคิดเล็ก ๆ น้อย ๆ (และบางกระบวนทัศน์การทำงาน) ใส่ลงในนั้นให้ดูที่ยี่สิบสี่และศตวรรษ Halfth

ต่อต้านกองทัพบก

ระเบิดเป็นสิ่งที่ไม่ดี ที่เลวร้ายมาก. ดังนั้นหากใครกำลังเตรียมตัวอยู่สิ่งที่ดีที่สุดที่ควรทำคือยิงพวกเขา มิฉะนั้นเราจะออกไปเที่ยวกัน

-- Antigrenadier
local args = {...}  -- command line arguments

match = args[2]     -- store the set of matches

-- why this isn't standard in Lua....
function string:split( inSplitPattern, outResults )
  if not outResults then
    outResults = { }
  end
  local theStart = 1
  local theSplitStart, theSplitEnd = string.find( self, inSplitPattern, theStart )
  while theSplitStart do
    table.insert( outResults, string.sub( self, theStart, theSplitStart-1 ) )
    theStart = theSplitEnd + 1
    theSplitStart, theSplitEnd = string.find( self, inSplitPattern, theStart )
  end
  table.insert( outResults, string.sub( self, theStart ) )
  return outResults
end

-- set up the players
players = match:split(" ")

-- search other players for someone who pulled a grenade
for i=2,#players do
   moves = players[i]
   -- test if person is alive
   if moves:sub(1,1) ~= "-" then
      -- cycle through all elements of the string
      for j=#moves,2,-1 do
         -- if found, shoot!
         if moves:sub(j,j) == "P" then
            print("S"..i-1)
            os.exit()
         end
      end
   end
end

-- otherwise we just relax
print("N")

Ricochet - Perl

กลยุทธ์ง่ายๆดูเหมือนจะเหมาะสมในความท้าทายนี้ดังนั้นจึงเป็นอีกกลยุทธ์หนึ่ง มันยิงผู้เล่นที่มีชีวิตแบบสุ่ม มันมีคุณสมบัติเพิ่มเติมในการฆ่าตัวตายในตอนท้ายเพื่อหลีกเลี่ยงรถบรรทุก

@history = map([split(",",$_)],split(" ",$ARGV[1]));
$health = $history[0][0];
@options = ();
for(1..3){
 if($history[$_][0] > 0){
  push(@options,$_);
 }
}
$target = @options[int(rand(~~@options))];
if(~~@{$history[0]} == 50){
 $target = 0;
}
print"S$target";

ทำงานอย่างนั้น:

perl ricochet.plx 5 "-2,S0 -2,S1 -2,S2 5,N" 

ผู้รุกราน

ดึงหนึ่งรอบขว้างไปที่คู่ต่อสู้สุขภาพสูงสุดในรอบ 2 ยิงที่คู่ต่อสู้สุขภาพสูงสุดหลังจากนั้น

#include <cstdio>
#include <cstring>

int main(int argc, char** argv){
   char* t;
   t = strtok(argv[2]," ");
   int len = strlen(t);
   int max = -50, maxP;
   for(int i=1;i<4;i++){
      int cur;
      t = strtok(NULL," ");
      if(t[0]=='-'){cur = -1*(t[1]-'0');}
      else{cur = t[0]-'0';}
      if(cur>max){
         max = cur;
         maxP = i;
      }
   }
   if(len == 1){printf("P\n"); return 0;}
   if(len == 3){printf("T%d\n",maxP); return 0;}
   printf("S%d\n",maxP);
   return 0;
}

เรียกใช้เช่น. /agg ID "5 5 5 5"

นินจา

เพียงหลบอย่างสุ่มพยายามหลีกเลี่ยงการโดน

math.randomseed(os.time())
print("D"..tostring(math.random(4)-1))

ทำงานเป็น

lua ninja.lua

Args นั้นไม่จำเป็น แต่สามารถเพิ่มได้โดยไม่มีปัญหา

ชื่อ : PriorityTargets

คำสั่งเชลล์ : ruby ​​PriorityTargets.rb 5 [game_state]

ภาษา : Ruby V2.1.2

คำอธิบาย : PriorityTargets พยายามค้นหา playstyles ทั่วไป จากนั้นจะตัดสินใจตาม playstyles ที่ต้องการโจมตีและอาวุธที่จะใช้

หมายเหตุ : การส่งรหัสกอล์ฟครั้งแรก! ใหญ่กว่าผลงานอื่น ๆ เพราะฉันคลั่งไปนิดหน่อย

#!/usr/bin/env ruby

class PriorityTargets
  class PlayerAction
    SHOOT = 'S'
    DODGE = 'D'
    PREPARE_GRENADE = 'P'
    THROW_GRENADE = 'T'
    NOTHING = 'N'
    attr_accessor :action, :target

    def initialize(action_string)
        @action = action_string[0, 1]
        @target = self.has_target? ? action_string[1, 1].to_i : false
    end

    def to_s
      string = @action
      string << @target.to_s if self.has_target?
      string
    end

    def has_cooldown?
      [SHOOT].include? @action
    end

    def is_aggressive?
      [SHOOT, PREPARE_GRENADE, THROW_GRENADE].include? @action
    end

    def has_target?
      [SHOOT, DODGE, THROW_GRENADE].include? @action
    end
  end


  class Player
    attr_reader :identifier, :health, :history
    attr_accessor :playstyles

    def initialize(player_identifier, player_string)
      @identifier = player_identifier
      @playstyles = []

      player_info = player_string.split(',')
      @health = player_info.shift.to_i
      @history = parse_history(player_info)
    end


    def has_attacked?(player, round = nil)
      round ||= self.history.length - 1
      player.history[0, round].each do |turn|
        did_attack = true and break if turn.is_aggressive? && turn.has_target? && turn.target == player.identifier
      end
      did_attack ||= false
    end

    def is_holding_grenade?(round = nil)
      round ||= self.history.length
      turn_history = self.history[0, round]
      is_holding = false

      turn_history.each_with_index do |turn, curr_round|
        if turn.action == PlayerAction::PREPARE_GRENADE && curr_round >= round - 3
          is_holding = true if turn_history.drop(curr_round).select{|turn| turn.action == PlayerAction::THROW_GRENADE }.length == 0
        end
      end

      is_holding
    end

    def is_dead?; self.health <= 0; end
    def is_on_cooldown?
      return false if self.history.length == 0
      self.history.last.has_cooldown?
    end

    def turn_at_round(round); self.history[round-1]; end

    private

      def parse_history(history_array)
        parsed = []
        history_array.each {|action_string| parsed << PlayerAction.new(action_string) }
        parsed
      end
  end

  class PlayerList
    include Enumerable

    def initialize(player_list = [], filter_list = false)
      @list = player_list
      @filter = filter_list if filter_list
    end

    #Enumerable Methods
    def each
      list = @list.select{|player| @filter.include?(player.identifier) } if @filter
      list = @list unless @filter
      list.each {|player| yield(player) }
    end

    def <<(player); @list << player; end
    def [](key)
      player = @list.select{|player| @filter.include?(player.identifier) }[key] if @filter
      player = @list[key] unless @filter
      player
    end

    def length
      list = @list.select{|player| @filter.include?(player.identifier) } if @filter
      list = @list unless @filter
      list.length
    end

    def empty?; self.length == 0; end
    def not_empty?; self.length > 0; end

    def create_filtered_list(player_ids)
      new_player_list = PlayerList.new(@list, player_ids)
      new_player_list
    end

    #PlayerList Methods
    def includes_playstyle?(playstyle)
      (self.with_playstyle(playstyle).length > 0)
    end

    def have_executed_action?(action)
      action_found = false
      self.each {|player| action_found = true and break if player.history.select {|turn| turn.action == action}.length > 0 }
      action_found
    end

    def direct_damages(round = nil)
      round ||= self.first.history.length

      damage_list = {}
      @list.each {|player| damage_list[player.identifier] = 0 }

      if round >= 1
        @list.each do |player|
          player.history[0, round].each_with_index do |turn, curr_round|

            if turn.has_target?
              target_player = @list.select{|curr_player| curr_player.identifier == turn.target }.first
              target_turn = target_player.turn_at_round(curr_round)

              damage_list[turn.target] += 8 if turn.action == PlayerAction::THROW_GRENADE

              if turn.action == PlayerAction::SHOOT
                damage_list[turn.target] += 2 unless target_turn.action == PlayerAction::DODGE && target_turn.target == player.identifier
              end
            end
          end
        end
      end

      damage_list.select! {|key| @filter.include? key } if @filter
      damage_list
    end


    def filtered_with_condition(&condition_block)
      player_ids = []
      self.each {|player| player_ids << player.identifier if condition_block.call(player) }
      create_filtered_list(player_ids)
    end

    def on_cooldown; filtered_with_condition {|player| player.is_on_cooldown?} end
    def not_on_cooldown; filtered_with_condition {|player| !player.is_on_cooldown?} end

    def dead; filtered_with_condition {|player| player.is_dead?} end
    def not_dead; filtered_with_condition {|player| !player.is_dead?} end

    def with_playstyle(playstyle); filtered_with_condition {|player| player.playstyles.include?(playstyle)} end
    def not_with_playstyle(playstyle); filtered_with_condition {|player| !player.playstyles.include?(playstyle)} end

    def with_max_health(round = nil)
      round ||= self.first.history.length
      player_damages = direct_damages(round)
      filtered_with_condition {|player| player_damages[player.identifier] == player_damages.values.min }
    end

    def with_identifier(identifier)
      matches = self.with_identifiers([ identifier ])
      return nil if matches.empty?
      matches.first
    end

    def with_identifiers(identifiers)
      create_filtered_list(identifiers)
    end
  end

  class PlayerTypes
    GRENADIER = :GRENADIER
    COWBOY = :COWBOY
    SKIDDISH = :SKIDDISH
    AGGRESSOR = :AGGRESSOR
    DEFENSIVE = :DEFENSIVE
    ANTI_GRENADIER = :ANTI_GRENADIER
    PLAYSTYLE_ORDER = [GRENADIER, COWBOY, SKIDDISH, AGGRESSOR, DEFENSIVE, ANTI_GRENADIER]

    def initialize(player_list)
      @players = player_list
    end

    def analyze_playstyles
      return if @players.first.history.length == 0

      PLAYSTYLE_ORDER.each do |playstyle|
        check_fnc = "is_"+playstyle.to_s+'?'
        @players.each {|player| player.playstyles << playstyle if self.send(check_fnc, player) }
      end
    end

    def is_GRENADIER?(player)
      #Grenade on first turn
      #Used more than one grenade
      #Never used gun, only grenade
      shoot_count = player.history.count {|turn| turn.action == PlayerAction::SHOOT }
      grenade_count = player.history.count {|turn| turn.action == PlayerAction::PREPARE_GRENADE }

      profiled ||= true if player.history.first.action == PlayerAction::PREPARE_GRENADE
      profiled ||= true if grenade_count > 1
      profiled ||= true if shoot_count == 0 && grenade_count > 0
      profiled ||= false
    end

    def is_COWBOY?(player)
      #Never used grenade, only gun
      shoot_count = player.history.count {|turn| turn.action == PlayerAction::SHOOT }
      grenade_count = player.history.count {|turn| turn.action == PlayerAction::PREPARE_GRENADE }

      profiled ||= true if grenade_count == 0 && shoot_count > 0
      profiled ||= false
    end

    def is_SKIDDISH?(player)
      #Dodged more than once
      #Never hurts anybody
      dodge_count = player.history.count {|turn| turn.action == PlayerAction::DODGE }
      attack_count = player.history.count {|turn| turn.is_aggressive? }

      profiled ||= true if dodge_count > 1
      profiled ||= true if attack_count == 0 && player.history.length > 1
      profiled ||= false
    end

    def is_AGGRESSOR?(player)
      #Only shoots person >= most health
      profiled = false
      player.history.each {|turn| profiled = true if turn.is_aggressive? && turn.has_target? }

      player.history.each_with_index do |turn, round|
        if turn.is_aggressive? && turn.has_target?
          profiled = false if !@players.with_max_health(round).include? @players.with_identifier(turn.target)
        end
      end
      profiled
    end

    def is_DEFENSIVE?(player)
      #Only hurts people who hurt them first
      player.history.each {|turn| profiled = true if turn.is_aggressive? && turn.has_target? }

      player.history.each_with_index do |turn, round|
        if turn.is_aggressive? && turn.has_target?
          target_player = @players.with_identifier(turn.target)
          profiled = false unless target_player.has_attacked?(player, round)
        end
      end
      profiled ||= false
    end

    def is_ANTI_GRENADIER?(player)
      #After a Grenadier has been shown, only shoots grenadier
      shots_fired = 0
      shots_fired_while_holding = 0

      player.history.each_with_index do |turn, round|
        if turn.is_aggressive? && turn.has_target?
          target_player = @players.with_identifier(turn.target)
          shots_fired += 1
          shots_fired_while_holding += 1 if target_player.is_holding_grenade?(round)
        end
      end

      (shots_fired > 0 && shots_fired/2.0 <= shots_fired_while_holding)
    end
  end




  def initialize(game_state)
    players_info = game_state.split(' ')
    @player = Player.new(0, players_info.shift)
    @players = PlayerList.new
    @players << @player
    enemy_identifiers = []

    players_info.each_with_index {|info, index| @players << Player.new(index+1, info); enemy_identifiers << index+1; }

    @enemies = @players.with_identifiers(enemy_identifiers  )
  end

  def analyze_playstyles
    types = PlayerTypes.new(@players)
    types.analyze_playstyles
  end

  def find_dodge_target
    armed_aggressors = @enemies.with_playstyle(PlayerTypes::AGGRESSOR).not_on_cooldown().not_dead()

    if armed_aggressors.not_empty?
      return armed_aggressors.with_max_health().first if @players.with_max_health().include?(@player) && @players.with_max_health().length == 1
    end

    return @enemies[Random.rand(3)] if @player.history.length == 0
    nil
  end

  def find_target
    unarmed_aggressors = @enemies.with_playstyle(PlayerTypes::AGGRESSOR).on_cooldown().not_dead()
    anti_grenadiers = @enemies.with_playstyle(PlayerTypes::ANTI_GRENADIER).not_dead()
    grenadiers = @enemies.with_playstyle(PlayerTypes::GRENADIER).not_dead()
    cowboys = @enemies.with_playstyle(PlayerTypes::COWBOY).not_dead()
    skiddish = @enemies.with_playstyle(PlayerTypes::SKIDDISH).not_dead()
    defensive = @enemies.with_playstyle(PlayerTypes::DEFENSIVE).not_dead()

    if unarmed_aggressors.not_empty?
      return unarmed_aggressors.with_max_health().first if @players.with_max_health().include?(@player) && @players.with_max_health().length == 1
    end

    return anti_grenadiers.with_max_health().first if anti_grenadiers.not_empty?
    return grenadiers.with_max_health().first if grenadiers.not_empty?
    return cowboys.with_max_health().first if cowboys.not_empty?
    return skiddish.with_max_health().first if skiddish.not_empty?
    return defensive.with_max_health().first if defensive.not_empty?
    return @enemies.with_max_health().not_dead().first if @enemies.with_max_health().not_dead().length > 0
    nil
  end

  def find_weapon
    return PlayerAction::THROW_GRENADE if @player.is_holding_grenade?

    anti_grenadiers = @enemies.with_playstyle(PlayerTypes::ANTI_GRENADIER).not_dead()

    return PlayerAction::PREPARE_GRENADE if anti_grenadiers.empty? && @enemies.have_executed_action?(PlayerAction::PREPARE_GRENADE)
    PlayerAction::SHOOT
  end

  def make_decision
    dodge_target = self.find_dodge_target
    target = self.find_target
    weapon = self.find_weapon

    decision ||= PlayerAction.new(PlayerAction::NOTHING) if @player.is_on_cooldown? || @enemies.with_max_health().not_dead().length == 0
    decision ||= PlayerAction.new(PlayerAction::DODGE + dodge_target.identifier.to_s) if dodge_target
    decision ||= PlayerAction.new(weapon + target.identifier.to_s)
    STDOUT.write decision.to_s
  end
end

priority_targets = PriorityTargets.new(ARGV[1])
priority_targets.analyze_playstyles
priority_targets.make_decision

คนขี้ขลาด - Perl

ทำหน้าที่ขี้ขลาดมาก เมื่อเขารู้สึกแข็งแรงเขาเลือกศัตรูที่ไม่รู้สึกเช่นนั้นและยิงเขา คะแนนโบนัสสำหรับศัตรูที่ถูกยิงในเทิร์นสุดท้าย (เพราะรู้กันว่ากำลังทำNothingเทิร์นนี้และป้องกันตัวเองไม่ได้) เมื่อเขารู้สึกไม่ดีเขาก็วิ่งหาที่กำบังเพื่อช่วยซ่อนตัวของเขาไว้บางครั้งก็ยิงใครซักคน

#!/usr/bin/perl

@allinfo = map { [split/,/] } split / /, $ARGV[1];
@life = map { $_->[0] } @allinfo;
@action = map { @$_>1 ? $_->[-1] : () } @allinfo;

if($life[0] < 3 && rand() < .5 )
{
    printf "D%d", +(sort { ($life[$a]>0)*($action[$a] eq "N") <=> ($life[$b]>0)*($action[$b] eq "N") } 1..3)[2]
}
else
{
    @score = map { $life[$_]>0 ? (5/$life[$_] + 2*($action[$_] =~ /S./)) : 0 } 1..3;
    printf "S%d", +(sort { $score[$a] <=> $score[$b] } 1..3);
}

รหัส Perl มาตรฐานที่ค่อนข้างดี; perl file argument argument [...]บันทึกไว้ในแฟ้มบางส่วนและเรียกใช้ ฉันตรวจสอบไวยากรณ์แล้วและก็ใช้ได้ดังนั้นฉันหวังว่าจะไม่มีปัญหากับมัน

E: กำจัดโอกาสในการหารด้วย 0 ข้อผิดพลาด

Bomberman

บอทที่เขียนใน R บรรทัดคำสั่งควรเป็น: Rscript Bomberman.R arg0 arg1
ฉันรู้ว่าหลังจากเริ่มเขียนบอทนี้ที่ Geobits สร้างทหารราบอยู่แล้วแต่ฉันคิดว่าของฉันแตกต่างกันมากในการตรวจสอบสุขภาพของมันนั้นสูงกว่า 3 ก่อนเตรียมระเบิดทิ้ง นักกีฬาคนสุดท้ายคนแรกและคนที่แข็งแรงที่สุดและถ้าสุขภาพต่ำกว่า 3 มันจะหลบผู้เล่นที่อันตราย (ไม่ตายหรือไม่ยิงในรอบสุดท้าย) หรือยิงผู้เล่นคนใดคนหนึ่งที่เหลือ

input <- commandArgs(TRUE)
history <- do.call(rbind,strsplit(scan(textConnection(input[2]),"",quiet=TRUE),","))
health <- as.integer(history[,1])
last_shooter <- which(grepl("S",history[-1,ncol(history)]))
last_prepare <- which(history[1,]=="P")
if(!length(last_prepare)) last_prepare <- -1
last_throw <- which(grepl("T",history[1,]))
if(!length(last_throw)) last_throw <- 0
most_healthy <- which.max(health[-1])
dead <- which(health[-1]<=0)
inoffensive <- c(last_shooter,dead)
danger <- which(!(1:3)%in%inoffensive)
alive <- which(!(1:3)%in%dead)
if(health[1]>3 & last_throw > last_prepare) out <- "P"
if(last_throw < last_prepare) out <- ifelse(length(last_shooter),paste("T",last_shooter[1],sep=""),paste("T",most_healthy[1],sep=""))
if(health[1]<=3 & last_throw > last_prepare){
    if(length(danger)){
        out <- paste("D",sample(danger,1),sep="")
    }else{
        out <- paste("S",sample(alive,1),sep="")
    }
}
cat(out)

แก้ไข

ดูเหมือนจะมีบางปัญหาการสื่อสารระหว่าง ธ ปทนี้และการควบคุมของคุณตั้งแต่บันทึกทุกสิ่งที่ผมมองแสดงให้เห็นว่า ธ Nปทเอาท์พุทของฉันเท่านั้น ดังนั้นนี่คือบอทเดียวกัน แต่เขียนใหม่ใน Python ด้วยหวังว่าถ้าอันนี้มีปัญหาการสื่อสารใครบางคนจะเห็นมัน ที่จะเรียกว่ามี
python Bomberman.py arg0 arg1

import sys,re,random

history = sys.argv[2]
history = [k.split(",") for k in history.split()]
health = [k[0] for k in history]
last_turn = [k[-1] for k in history]
last_shooter = [i for i,x in enumerate(last_turn) if re.search(r'S[0-3]',x)]
last_prepare = [i for i,x in enumerate(history[0]) if x=='P']
if not len(last_prepare):
    last_prepare = [-1]

last_throw = [i for i,x in enumerate(history[0]) if re.search(r'T[0-3]',x)]
if not len(last_throw):
    last_throw = [0]

most_healthy = [i for i,x in enumerate(health) if x==max(health)]
dead = [i for i,x in enumerate(health) if x<=0]
inoffensive = last_shooter+dead
danger = [k for k in range(1,4) if k not in inoffensive]
alive = [k for k in range(1,4) if k not in dead]
if health[0]>3 and last_throw[-1] > last_prepare[-1]:
    out = 'P'

if last_throw[-1] < last_prepare[-1]:
    if len(last_shooter):
        out = 'T'+random.choice(last_shooter)
    else:
        out = 'T'+random.choice(most_healthy)

if health[0]<=3 and last_throw[-1] > last_prepare[-1]:
    if len(danger):
        out = 'D'+random.choice(danger)
    else:
        out = 'S'+random.choice(alive)

print(out)

Neo

Dodge ผู้เล่นที่ยังมีชีวิตอยู่ซึ่งไม่ได้ยิงเทิร์นสุดท้าย หากทุกคนยังมีชีวิตอยู่ในเทิร์นสุดท้ายให้ยิงผู้เล่นแบบสุ่ม การฆ่าตัวตายเมื่อคุณเห็นไฟหน้า

import java.util.Random;
public class Neo {
    public static void main(String[] args) {
        if(args.length < 2)
            return;
        String[] list = args[1].split(" ");
        if(list.length < 4)
            return;
        Random rand = new Random();
        int turn = list[0].split(",").length;
        if(turn == 49){
            System.out.print("S0");
            return;
        }
        int target=0;
        for(int i=1;i<4;i++)
            if(list[i].length()<2 || (list[i].charAt(0)!='-' && list[i].charAt(list[i].length()-2)!='S'))
                target=i;
        if(target>0){
            System.out.print("D"+target);
            return;
        }
        while(target<1){
            int i=rand.nextInt(3)+1;
            if(list[i].charAt(0)!='-')
                target=i;
        }
        System.out.print("S"+target);
    }
}

ฉันไม่ได้คาดหวังอะไรมากนักจากผู้ชายคนนี้กับลูกระเบิดมือ แต่มันอาจจะทำงานได้ดี เราจะเห็น

ยี่สิบสี่และครึ่งศตวรรษที่

งูหลามรายการนี้หลบและหลบจนกว่าจะมีผู้เล่นเพียงคนเดียวหรือผู้เล่นก้าวร้าวเพียงคนเดียวจากนั้นก็เริ่มถ่ายทำ หวังว่าดาวอังคารที่ผ่านจะดูแลทหารราบและทหารราบที่ขี้เมา

นี่เป็น Python ที่ใช้งานได้เว้นแต่ว่าฉันทำอะไรผิดไป แน่นอนว่ามันไม่เหมือนกับ Python ที่ฉันเขียนก่อนที่ Haskell และเพื่อน ๆ จะพบฉันและฉันไม่คิดว่าฉันจะกลายพันธุ์อะไร แต่ถ้าคุณรู้ดีกว่าโปรดบอกฉันที

#!/usr/bin/env python
import sys
import random

## ==== Move Types ================================================== ##
def move_type (move):
    if "" == move:
        return "N"
    return move[0]

def is_passive_move (move):
    if "N" == move:
        return True
    if "D" == move_type (move):
        return True
    return False

def is_aggressive_move (move):
    return not is_passive_move (move)

def passive_moves (moves):
    return [m for m in moves if is_passive_move (m)]

def aggressive_moves (moves):
    return [m for m in moves if is_aggressive_move (m)]
## ================================================== Move Types ==== ##

## ==== Player Model ================================================ ##
class Player:
    def __init__ (self, number, health, moves):
        self.number = number
        self.health = health
        self.moves  = moves

    def last_move (self):
        if 0 == len (self.moves):
            return ""
        return self.moves[-1]

def player_from (number, player_string):
    x = player_string.split (",")
    health = int (x[0].strip ())
    moves = [move.strip () for move in x[1:]]

    return Player (number, health, moves)

def players_from (game_state):
    return [player_from (n, p) for (n, p) in
                                   zip (range(4), game_state.split ())]

def is_alive (player):
    return 0 < player.health

def i_am_dead (me):
    return not is_alive (me)

def can_shoot (player):
    return "S" != move_type (player.last_move ())

def is_passive (player):
    passive_move_count = len (passive_moves (player.moves))
    aggressive_move_count = len (aggressive_moves (player.moves))

    return passive_move_count > (aggressive_move_count + 1)

def players_who_can_breathe (players):
    return [p for p in players if is_alive (p)]

def players_who_can_shoot (players):
    return [p for p in players if can_shoot (p)]

def players_who_stand_around (players):
    return [p for p in players if is_passive (p)]
## ================================================ Player Model ==== ##

## ==== Actions ===================================================== ##
def shoot_randomly_at (possible_targets):
    chosen_target = random.choice (possible_targets)
    return "S{0}".format (chosen_target.number)

def dodge_one_of_the (potential_shooters):
    chosen_shooter = random.choice (potential_shooters)
    return "D{0}".format (chosen_shooter.number)

def do_nothing ():
    return "N"

def pick_move (game_state):

    players = players_from (game_state)
    me = players[0]
    enemies = players[1:]

    if i_am_dead (me):
        return do_nothing ()

    living_enemies = players_who_can_breathe (enemies)
    if 1 == len (living_enemies):
        return shoot_randomly_at (living_enemies)

    passive_enemies = players_who_stand_around (living_enemies)
    if len (living_enemies) == len (passive_enemies):
        return shoot_randomly_at (passive_enemies)

    potential_shooters = players_who_can_shoot (living_enemies)
    if 0 < len (potential_shooters):
        return dodge_one_of_the (potential_shooters)

    return do_nothing ()
## ===================================================== Actions ==== ##

if "__main__" == __name__:

    game_state = sys.argv[2]
    print (pick_move (game_state))

ทำงานเป็น:

python twenty-fourth-and-a-halfth-century.py 0 "5 5 5 5"

กลัว

การส่งนี้กลัวของทุกคน แต่บางคนก็กลัวเป็นพิเศษ ดังนั้นจึงเป็นตัวระบุว่าใครเป็นผู้ที่อันตรายที่สุดและยิงพวกเขา หากศัตรูหลาย ๆ ตัวดูอันตรายที่สุดมันจะสุ่มยิงแบบสุ่ม

import sys
import random


def is_alive(player):
    return int(player.split(",")[0]) > 0


# Anyone with a live grenade who is alive is dangerous
def is_dangerous(player):
    return player.count("P") > player.count("T") and \
        int(player.split(",")[0]) > 0


def health(player):
    return int(player.split(",")[0])


# Failing that, healthy people are dangerous
def danger_rating(player):
    return 6 if is_dangerous(player) else health(player)

enemies = sys.argv[2].split()[1:]

highest_danger = max(danger_rating(enemy) for enemy in enemies)
most_dangerous_enemy = random.choice(
    [enemy_num+1 for enemy_num in range(len(enemies))
     if danger_rating(enemies[enemy_num]) == highest_danger])

print("S"+str(most_dangerous_enemy))

นี่คืองูหลาม (2 หรือ 3 ผลลัพธ์เดียวกันใน) บันทึกเป็นscared.pyเรียกใช้ด้วยpython3 scared.py

ไอ้แบบบิดเบือน - Python

เตรียมและขว้างระเบิด หากเขาคิดว่าไม่มีเวลาหรือมีศัตรูน้อยเกินไปเขาก็จะยิง ถ้าเขาอยู่คนเดียวเขาพยายามที่จะเอาชนะคนอื่น

import sys

def health(p):
    return int(p[0])

def is_alive(p):
    return health(p) > 0

def can_act(p):
    return is_alive(p) and p[-1][0] != 'S'

def can_throw(p):
    return is_alive(p) and p[-1][0] == 'P'

def shot_first(p):
    if len(p) == 1:
        return False
    return p[1][0] == 'S'

def act(a):
    print a
    sys.exit(0)

player = sys.argv[2].split()[0].split(',')
enemies = [e.split(',') for e in sys.argv[2].split()[1:]]
healthiest = sorted(enumerate(enemies, 1), key=lambda e:health(e[1]))[-1]
alive = sum(is_alive(e) for e in enemies)

if alive == 1:
    i, e = healthiest
    if health(e) <= 2 and not can_act(e):
        act('S%d' % i)
    if can_throw(player):
        act('T%d' % i)
    if can_throw(e):
        act('S%d' % i)
    if can_act(e) and shot_first(e) and len(player) < 40:
        act('D%d' % i)
    if len(player) > 45:
        act('P')
    act('S%d' % i)

if can_throw(player):
    i, e = healthiest
    act('T%d' % i)

if len(player) > 45:
    act('P')

if health(player) <= 2 or any(can_throw(e) for e in enemies) or alive == 2:
    i, e = healthiest
    act('S%d' % i)

act('P')

อุซามะห์

ฉันได้ลองทำสิ่งนี้มาซักวันแล้วตอนนี้ถึงเวลาโพสต์และดูว่าคนอื่น ๆ มีการพัฒนาอย่างไรในระหว่างนี้

module Main where

import Data.List
import Data.Ord
import System.Environment

words' "" = []
words' s = s' : words' (tail' s'')
  where
    (s', s'') = break (==',') s
    tail' (',':r) = r
    tail' r = r

nRound = length . words'

lastAction = last . words'

health :: String -> Int
health = read . head . words'

alive = (>0) . health

grenadeAge :: String -> Int
grenadeAge p | not (alive p) = 0
             | otherwise = g 0 $ tail $ words' p
  where
    g n (a:b:r) | head a == 'S' = g (if n>0 then n+2 else 0) r
    g 0 ("P":r) = g 1 r
    g n (('T':_):r) | n>0 = g 0 r
    g n (_:r) | n>0 = g (n+1) r
    g n (_:r) = g n r
    g n [] = n

prepared :: String -> Bool
prepared p = alive p && head (lastAction p) /= 'S'

nShotMe = length . filter (=="S0") . words'

getPlayer = (!!)

action players@(me:them) | not (prepared me) = "S2" -- bogus
                         | nRound me >= 49 = "S0"
                         | grenadeAge me >= 1 = 'T':(show $ maximumBy (comparing (nShotMe . getPlayer players)) l)
                         | any prepared them && nRound me > 0 = 'D':(show $ maximumBy (comparing (nShotMe . getPlayer players)) l)
                         | otherwise = 'S':(show $ maximumBy (comparing (health . getPlayer players)) l)
  where l = filter (alive . (getPlayer players)) [1..3]



main = do
  players <- fmap (words . head . tail) getArgs
  putStrLn $ action players

รวบรวมแล้วเรียกใช้ghc -O2 osama.hs./players/Osama/osama

Sniper - Lua

ในเทิร์นแรกมันจะยิงคนที่สุ่มแล้วมันจะยิงผู้เล่นคนใดก็ได้ที่มันสามารถฆ่าได้ (2 หรือ 1 พลังชีวิต) หากไม่มีงานเหล่านั้นมันจะพยายามยิงผู้เล่นที่ยิงครั้งสุดท้ายไม่เช่นนั้นจะยิงผู้เล่นแบบสุ่ม ทำงานด้วยlua Sniper.lua

turns = arg[2]
health = string.sub(turns, 1, 1)
--make random numbers random
math.randomseed(io.popen("date +%s%N"):read("*all"))
math.random(); math.random(); math.random()
function Split(str, delim, maxNb)
    -- Eliminate bad cases...
    if string.find(str, delim) == nil then
        return { str }
    end
    if maxNb == nil or maxNb < 1 then
        maxNb = 0    -- No limit
    end
    local result = {}
    local pat = "(.-)" .. delim .. "()"
    local nb = 0
    local lastPos
    for part, pos in string.gmatch(str, pat) do
        nb = nb + 1
        result[nb] = part
        lastPos = pos
        if nb == maxNb then break end
    end
    -- Handle the last field
    if nb ~= maxNb then
        result[nb + 1] = string.sub(str, lastPos)
    end
    return result
end
enemies = Split(turns, " ")
--first turn
if #enemies[1] == 1 then
  print(string.format("S%i",math.random(1,3)))
  os.exit()
end
--kills if possible
for enemy=1,3 do
  if (tonumber(string.sub(enemies[enemy + 1],1,1)) or 0) < 3 and string.sub(enemies[enemy + 1],1,1) ~= "-" then
    print(string.format("S%i",enemy))
    os.exit()
  end
end
--shoots the last person that shot at it
for enemy=1,3 do
  if string.sub(enemies[enemy + 1],#enemies[enemy + 1]-1) == "S0" and tonumber(string.sub(enemies[enemy + 1],1,1)) > 0 then
    print(string.format("S%i",enemy))
    os.exit()
  end
end
--otherwise shoot a random alive person
local aliveEnemies = {}
for enemy=1,3 do
  if string.sub(enemies[enemy + 1],1,1) ~= "-" then
    aliveEnemies[#aliveEnemies+1]=enemy
  end
end
print(string.format("S%i",math.random(1,#aliveEnemies)))

ดาร์วิน

การอยู่รอดของผู้ที่เหมาะสมที่สุดหมายถึงผู้ที่มีสุขภาพแข็งแรงที่สุดต้องตาย

หลักการและเหตุผล

เมื่อดูชุดผลลัพธ์ตั้งแต่วันอังคารที่ 12 ดูเหมือนจะมีกลุ่มที่แตกต่างกันสามกลุ่ม: ผู้รอดชีวิต การฆ่าตัวตายอย่างมีประสิทธิภาพ และสิ่งที่เลวร้ายยิ่งกว่าไร้ประโยชน์ ผู้รอดชีวิตแบ่งปันกลยุทธ์การยิงที่ง่าย ในขณะที่บอทอื่นสองสามตัว ( Spock , Coward ) จะกำหนดเป้าหมายไปยังศัตรูที่มีสุขภาพดีน้อยที่สุด อันนี้ไม่ได้ เช่นเดียวกับSimple Shooterมันมีคำจำกัดความที่ชัดเจนของเป้าหมายและเกาะติดมันอย่างไม่ลดละ มันจะน่าสนใจที่จะดูว่ามันเหมาะกับผลลัพธ์อย่างไร

#!/usr/bin/env python

import sys
import random

## ==== Player Model ================================================ ##
class Player:
    def __init__ (self, number, health):
        self.number = number
        self.health = health

def player_from (number, player_string):
    x = player_string.split (",")
    health = int (x[0].strip ())

    return Player (number, health)

def players_from (game_state):
    return [player_from (n, p) for (n, p) in
                                   zip (range(4), game_state.split ())]

def is_alive (player):
    return 0 < player.health

def i_am_dead (me):
    return not is_alive (me)

def players_who_can_breathe (players):
    return [p for p in players if is_alive (p)]

def players_by_health (players):
    return sorted (players, key=lambda p: p.health)

def least_healthy_players (players):
    sorted_living_players = \
        players_by_health (players_who_can_breathe (players))
    lowest_living_health = sorted_living_players[0].health
    return [p for p in players if lowest_living_health == p.health]
## ================================================ Player Model ==== ##

## ==== Actions ===================================================== ##
def shoot_randomly_at (possible_targets):
    chosen_target = random.choice (possible_targets)
    return "S{0}".format (chosen_target.number)

def do_nothing ():
    return "N"

def pick_move (game_state):
    players = players_from (game_state)
    me = players[0]
    enemies = players[1:]

    if i_am_dead (me):
        return do_nothing ()

    least_healthy_enemies = least_healthy_players (enemies)
    return shoot_randomly_at (least_healthy_enemies)
## ===================================================== Actions ==== ##

if "__main__" == __name__:

    game_state = sys.argv[2]
    print (pick_move (game_state))

นี่เป็นเวอร์ชั่นที่ถูกถอดเปลี่ยนลงเล็กน้อยจากยี่สิบสี่และศตวรรษที่สิบห้าก่อนหน้านี้ของฉันและแบ่งปันการร้องขอ:

python darwin.py 3 "5 5 5 5"

ซาแนล - ซี

ลำดับความสำคัญ:

1. ยิงถ้ามันเหลือ 1 ต่อ 1
2. ยิงทหารราบรักษาพระองค์
3. หลบ
4. ไม่มีอะไร (แค่ทำให้สับสน)

gcc <filename.c>คอมไพล์ด้วย

./a.out <parameters>ทำงานด้วย

#include <stdio.h>
#include <string.h>

int main(int argc, char *argv[]){
    char* input = argv[2];
    int enemyCount=1;
    int aliveCount=0;
    int aliveEnemy=0;

    //default
    char action = 'N';
    int target = NULL;

    const char delim[1] = " ";
    char *token;

    //first turn
    if(strcmp(input,"5 5 5 5")==0){
        printf("D1");
        return 0;
    }

    token = strtok(input, delim);
    token = strtok(NULL, delim); //skip to the first enemy

    while(token != NULL){
        //if someone is alive :
        if(strstr(token,"-")==NULL && token[0]!='0'){
            aliveCount++;
            aliveEnemy=enemyCount;
            //if that person did nothing this turn, take it as a tip that he will shoot next turn, and dodge
            if(strstr(token, "N")!=NULL){
                action = 'D';
                target=enemyCount;
            }

            //if that person prepared a grenade, shoot him down
            if(strstr(token, "P")!=NULL){
                action = 'S';
                target=enemyCount;
            }
        }

        token = strtok(NULL, delim);
        enemyCount++;
    }

    //if there is 1 enemy left, shoot him down
    if(aliveCount==1){
        action='S';
        target=aliveEnemy;
    }

    printf(action=='N'?"N":"%c%d",action,target);

    return 0;
}

InputAnalyzer

กุญแจสำคัญของเกมเช่นนี้คือการวิเคราะห์ว่าฝ่ายตรงข้ามทั้งหมดของคุณกำลังเล่นเพื่อตอบสนองอย่างไร บอทของฉันจะทำเช่นนั้นโดยใช้อัลกอริธึมที่ซับซ้อนซึ่งจะส่งผลให้การใช้คู่ต่อสู้ของฉันเปลี่ยนเป็นข้อได้เปรียบของฉันซึ่งทำให้ได้ชัยชนะอย่างเด็ดขาด!

แก้ไข: ฉันตอนนี้

1. หลบผู้เล่นคนใดที่มีลูกระเบิดมือสด
2. จะไม่พยายาม shoow / throw / dodge ตัวเองอีกต่อไป

import System.Environment   
import Data.Char (ord)
import Data.List.Split

main = do 
    args <- getArgs
    let secondArg = (last args)
    let opt = (argCount secondArg 0)
    let list = (splitOn " " secondArg)
    let enemysToCheck = [1,2,3]
    let target = (avoidShootingSelf (findTarget (last args) 0 0 0 0))
    putStrLn (decide list enemysToCheck opt target)

argCount :: String -> Int -> Int
argCount (s:str) i
    |(length str) == 0 = i `mod` 4
    | otherwise = (argCount str (i + (ord s)))

--myPseudo takes number 0-3, and a possible target and translates it to a command 
myPseudo :: Int -> Int -> String
myPseudo 0 b = "S" ++ (show b)
myPseudo 1 b = "D" ++ (show b)
myPseudo 2 b = "P"
myPseudo 3 b = "T" ++ (show b)

decide :: [String] -> [Int] -> Int -> Int -> String
decide [] [] a b = (myPseudo a b)
decide (x:xs) [] a b = (myPseudo a b)
decide xs (y:ys) a b
    | (liveGrenade z 0) == True = "D" ++ (show y)
    | otherwise = (decide xs ys a b)
    where z = xs!!y

--checks if a player has a live grenade
liveGrenade :: String -> Int -> Bool
liveGrenade [] a = a > 0
liveGrenade (s:str) a
    | s == 'T' = (liveGrenade str (a - 1))
    | s == 'P' = (liveGrenade str (a + 1))
    | otherwise = (liveGrenade str a)

--findTarget picks a target by doing some irrelevant string processing on the 2nd argument
findTarget :: String -> Int -> Int -> Int -> Int -> Int
findTarget [] a b c d = ((maximum [a,b,c,d]) `mod` 4)
findTarget (s:str) a b c d
    | s == 'S' = (findTarget str (a + 1) b c d)
    | s == 'D' = (findTarget str a (b + 1) c d)
    | s == 'P' = (findTarget str a b (c + 1) d)
    | s == 'T' = (findTarget str a b c (d + 1))
    | s == 'N' = (findTarget str a b c (d + 1))
    | otherwise = (findTarget str a b c d)

--Makes sure I do target myself takes int 0-3
avoidShootingSelf :: Int -> Int
avoidShootingSelf 0 = 1
avoidShootingSelf a = a

รวบรวม bot ด้วยคำสั่งต่อไปนี้ (ต้องมี ghc)

ghc - สร้าง InputAnalyzer.hs

คำสั่งเชลล์ที่จะรันควรเป็นดังนี้

./InputAnalyzer

หมายเหตุ: ฉันทดสอบบน windows ดังนั้นหากคุณมีปัญหาใด ๆ เกี่ยวกับการคอมไพล์ / รันโปรดพูดอย่างนั้นในคอมเม้นท์และฉันจะพยายามอย่างเต็มที่เพื่อหาคำสั่งที่ถูกต้อง

สุนัขชื่อกล้าหาญ

สิ่งแรก - ยิงคนเลวที่เห็น จากนั้นหลบแบบสุ่มจนกว่าจะมีคนเตรียมระเบิดมือ จากนั้นเมื่อทุกคนยิงใส่เขาให้เตรียมระเบิดมือของฉันและโยนมันใส่ใคร แต่ความว้าวุ่นใจของมนุษย์

แก้ไข: ดำเนินการตามที่ฉันคิดว่าควรจะเป็น ก่อนหน้านี้คะแนนเป็น: 35.9

อัปเดต: บางครั้งยิงแทนการหลบ

couragethedog.py

import sys
from collections import defaultdict as ddict
from random import choice
args = sys.argv
info = " ".join(args[2:]).strip('"').split(" ")
players = ddict(dict)
for i,s in enumerate(info):
    parts = s.split(",")
    players[i]["health"]=int(parts[0])
    players[i]["last"]=parts[-1]
    players[i]["history"]=parts[1:]
    players[i]["turn"]=len(parts)
me=0
others=[1,2,3]
turn=players[me]["turn"]
alive = filter(lambda p:players[p]["health"]>0,others)
def act():
    if turn is 1:
        return "S%d" % choice(alive)
    if "P" == players[me]["history"][-1]:
        targets = set(alive)
        for i in alive:
            if "P" == players[i]["history"][-2]:
                targets.remove(i)
        return "T%d" % choice(list(targets))
    for i in others:
        if players[i]["history"][-1] is "P":
            return "P"
    if choice([True,False,False]):
        return "S%d" % choice(alive)
    return "D%d" % choice(alive)
print act()

ทำงานเป็น

python couragethedog.py

MAD - Java

ความไว้วางใจ MAD บอทในพลังของการข่มขู่ผ่านมั่นร่วมกันทำลาย เมื่อใดก็ตามที่เขาไม่มีลูกระเบิดมือเขาก็เตรียมอันหนึ่งไว้ จากนั้นเขาก็หลบมือปืนที่เป็นไปได้จนกว่าจะมีใครพยายามทำความเสียหายให้กับเขา นับตั้งแต่วินาทีที่เขาถูกโจมตีเขาจะระเบิดใส่ใครก็ตามที่พยายามจะสร้างความเสียหายให้กับเขาในนัดนี้ หากระเบิดมือของเขากำลังจะระเบิดเขาจะระเบิดผู้เล่นชั้นนำ MAD ไม่ได้เป็นการยิงที่ใครบางคนเมื่อไม่มีสิ่งใดที่จะหลบหรือโยนระเบิดใส่ได้โดยตรงและลูกระเบิดของเขาก็ยังดีอยู่อย่างน้อยหนึ่งรอบ

    import java.util.ArrayList;
import java.util.Random;

public class MAD 
{
    public static void main(String[] args) 
    {
        if(args.length < 2)
        {
            return; // nothing to do here
        }
        String[] players = args[1].split(" ");
        if(players.length < 4 || !isAlive(players[0]))
        {
            return; // nothing to do here
        }
        Random rand = new Random();

        int grenadeExplodes = grenadeExplodes(players[0]);        
        if(grenadeExplodes==-1)
        {
            System.out.print("P"); // I don't feel safe without a prepared grenade in my hand
            return;
        }

        int highestDamage = -1;
        int playerToShoot = -1;        
        for(int i=1; i<4; i++) // did anyone try to hit me?
        {
            int damage = damageAttempted(players[i], 0);
            if(isAlive(players[i]) && (damage>highestDamage || (damage==highestDamage && rand.nextDouble()>0.5)))
            {
                highestDamage = damage;
                playerToShoot = i;
            }           
        }

        if(highestDamage > 0)
        {
            System.out.print("T" + Integer.toString(playerToShoot)); // don't tell me I didn't warn you
            return;
        }

        int highestHealth = -1;
        int healthiestPlayer = -1;      
        for(int i=1; i<4; i++) // who is doing too well for their own good?
        {
            int health = getHealth(players[i]);
            if(health>highestHealth || (health==highestHealth && rand.nextDouble()>0.5))
            {
                highestHealth = health;
                healthiestPlayer = i;
            }
        }

        if(grenadeExplodes==0)
        {
            System.out.print("T" + Integer.toString(healthiestPlayer).charAt(0)); // get this hot head outta here!!
            return;
        }

        // I've got time to flaunt my grenade around

        ArrayList<Integer> playersToDodge = new ArrayList<Integer>();       
        for(int i=1; i<4; i++) // lets see who could shoot me
        {
            if(canMove(players[i]) && grenadeExplodes(players[i])!=0)
            {
                playersToDodge.add(i);
                if(grenadeExplodes(players[i])==-1) // players who have no grenade are more likely to shoot
                {
                    playersToDodge.add(i);
                }
            }
        }

        if(playersToDodge.size()>0)
        {
            System.out.print("D" + Integer.toString(playersToDodge.get(rand.nextInt(playersToDodge.size() - 1))).charAt(0)); // what do we say to would-be gunners?
            return;
        }

        if(grenadeExplodes!=1)
        {
            System.out.print("S" + Integer.toString(healthiestPlayer).charAt(0)); // seems like I can take a free shot at someone
        }
        else
        {
            System.out.print("N"); // wouldn't want to end up with an exploding grenade in my hand while being unable to throw it.
        }

    }

    public static boolean isAlive(String player) 
    {
        return player.charAt(0)!='-'; 
    }

    public static boolean canMove(String player)
    {
        return isAlive(player) && player.charAt(player.length()-2)!='S';
    }

    public static int grenadeExplodes(String player)
    {
        String[] actions = player.split(",");

        if(actions.length>3 && actions[actions.length - 3].charAt(0)=='P' 
            && actions[actions.length - 2].charAt(0)=='T' 
            && actions[actions.length - 1].charAt(0)=='P')
        {
            return 0;
        } 
        else if(actions.length>2 && actions[actions.length - 2].charAt(0)=='P' 
            && actions[actions.length - 1].charAt(0)=='T')
        {
            return 1;
        } 
        else if(actions.length>1 && actions[actions.length - 1].charAt(0)=='P')
        {
            return 2;
        }
        else
        {
            return -1;
        }
    }

    public static int damageAttempted(String player, int target)
    {
        String[] actions = player.split(",");
        int damage = 0;
        char targetChar = Integer.toString(target).charAt(0);
        for(int i=0; i<actions.length; i++)
        {
            if(actions[i].charAt(0)=='S' && actions[i].charAt(1)==targetChar)
            {
                damage += 2;
            } 
            else if (actions[i].charAt(0)=='T')
            {
                if(actions[i].charAt(1)==targetChar)
                {
                    damage += 8;
                }
                else
                {
                    damage += 3;
                }
            }
        }

        return damage;
    }

    public static int getHealth(String player)
    {
        return Integer.parseInt(player.split(",")[0]);
    }
}

บอทนี้มีแนวโน้มที่จะทำงานได้ไม่ดี แต่ฉันก็ชอบไอเดียนี้อยู่ดี MAD น่าจะทำได้ดีกว่าในสนามที่มีบอทที่ฉลาดกว่าซึ่งจะบันทึกพฤติกรรมของบอทอื่น ๆ

ซาดิสม์

หลาม

ลำดับความสำคัญของเขาคือการทำให้เกิดความเจ็บปวดและระเบิดมือเจ็บ เขาดึงเทิร์นแรก เขาชอบฆ่าเมื่อคุณไม่สามารถโจมตีได้ เขาเล่นกับ SSS (มือปืนธรรมดาคนเดียว) โดยหลบและดึงเพื่อยืดเวลาการครอบครอง เขายังเลือกที่จะโจมตีคนแรกที่ไม่ได้ทำอะไรกับใครเลย

เพราะเขาใช้ลูกระเบิดเขา (และคนอื่น ๆ ) จะไม่รอดชีวิตในรอบที่สองหรือสาม หากเขาถูกจับคู่กับระเบิดมืออีกคนทุกคนจะตาย นี่หมายความว่าฉันไม่ได้คาดหวังว่าจะชนะ แต่ฉันเขียนสิ่งนี้เพื่อเรียนรู้ภาษาไพ ธ อน มีอีกหลายอย่างที่ "ดึงลำดับที่หนึ่ง" ดังนั้นถ้าคุณรู้สึกว่ามันเป็นเรื่องง่ายเกินไปให้ฉันรู้ คนอื่นดูเหมือนจะไม่เต็มใจที่จะดึงแล้วหลบไป

import sys    

def ident(thatguy):

    return int(thatguy.split(",")[0])

def health(thatguy):
    return int(thatguy.split(",")[1])

def shooter(thatguy):
    if(len(thatguy.split(","))<3):
        return 1==1
    else: return thatguy.split(",")[2][0]=="S"

def mosthealth(group):
    bigbad=group[0]
    for foe in group:
        if (health(foe)>health(bigbad)): bigbad=foe
    return bigbad

def igotanuke(mine):
    return mine.count("P")-mine.count("T")>0

def guytonuke(allguys,fighters):
    backup=allguys[:]
    for Aguy in backup:
        if(health(Aguy)<4):
            allguys.remove(Aguy)
            if (shooter(Aguy)): fighters.remove(Aguy)

    if(len(allguys)==0): return mosthealth(backup)
    if (len(allguys)==len(fighters)):
        return mosthealth(allguys)
    else:
        for fighter in fighters: allguys.remove(fighter)
        return mosthealth(allguys)

raw = sys.argv[2]
player = raw.split(" ")
thisisme=player.pop(0)
turn = len(player[0].split(","))-1

guys=[]
gunners=[]
c=1
for dude in player:
    dude=str(c)+","+dude
    c+=1
    if (health(dude)>0): 
        guys.append(dude)
        if (shooter(dude)):
            gunners.append(dude)

if (turn==0): print "P"
elif(turn==49): print"S0"
elif(igotanuke(thisisme))&( turn % 2 == 1): print "T"+str(ident(guytonuke(guys,gunners)))
elif(len(guys)<2)&(len(gunners)>0) & (turn % 2 == 1): print P
elif(turn % 2 == 0) & (len(gunners)>0): print "D"+str(ident(mosthealth(gunners)))
elif(turn % 2 == 1) & (len(gunners)>0): print "S"+str(ident(mosthealth(gunners)))
else: print "S"+str(ident(mosthealth(guys)))