Bế mạc 4 người

Sự miêu tả

Bạn bằng cách nào đó đã tìm thấy chính mình trong một bế tắc bốn chiều. Một khẩu súng nạp nằm trong tay bạn, và một số lựu đạn được móc vào thắt lưng của bạn.

Mục tiêu là có sức khỏe tốt nhất khi kết thúc cuộc chiến. Bế tắc đã kết thúc khi nhiều nhất một người có sức khỏe tích cực.

Mỗi người chơi có 5sức khỏe và chết khi sức khỏe giảm xuống / xuống dưới 0. Lượt người chơi chết là lượt cuối cùng mà người chơi có thể nhận sát thương.

Nếu có một người chơi trực tiếp ở cuối bế tắc, người chơi đó sẽ thắng. Nếu không, người chơi có ít sức khỏe tiêu cực nhất sẽ chiến thắng.

Hành động

• Bắn : Chụp một ai đó.

  • 2 sát thương nếu bắn kẻ thù còn sống
  • 0 sát thương nếu bắn chết kẻ thù
  • health_at_start_of_turn+2thiệt hại nếu tự bắn. (Lưu ý rằng điều này sẽ giúp bạn có -2sức khỏe NHẤT .)
  • Nếu một kẻ thù bắn vào bạn trong cùng một lượt bạn tự bắn, bạn sẽ kết thúc cuộc chiến với -4 máu (bạn vẫn nhận sát thương từ những người chơi khác trong lượt bạn tự sát).
  • Hành động của bạn lần lượt sau sẽ bị bỏ qua (và được giả định là Nothing).

• Dodge : Cố gắng né một phát bắn của đối thủ.

• Chuẩn bị : Bỏ lựu đạn của bạn và chuẩn bị ném nó.

  • Bạn chỉ có ba lượt để ném nó, trước khi bạn bị nổ tung ( 6gây sát thương cho bản thân, 3gây sát thương cho tất cả kẻ thù còn sống)
  • Chết với một quả lựu đạn chưa từng thấy tương đương với việc không ném lựu đạn trong ba lượt.

• Ném : Lựu đạn về phía ai đó và hy vọng điều tốt nhất.

  • Mục tiêu nhận 8sát thương nếu còn sống
  • Mọi người khác (bao gồm cả chính bạn) nhận 3sát thương nếu còn sống

• Không có gì : Đứng yên trong một lượt và xem tất cả mọi người chết.

Đầu vào

Chương trình của bạn sẽ được thông qua các thông tin sau:

• Sức khỏe của mỗi người chơi

• Danh sách các hành động được thực hiện bởi người chơi đó kể từ khi bắt đầu bế tắc Dưới đây là định dạng cho thông tin được truyền cho mỗi người chơi:

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

Các hành động sẽ được đưa ra ở định dạng được chỉ định trong phần Đầu ra .

Bạn sẽ nhận được 4 chuỗi như vậy, cách nhau bởi một khoảng trắng và được truyền dưới dạng một đối số. Thứ tự của các chuỗi này là:

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

Các chuỗi được thông qua như là đối số thứ hai. Đối số đầu tiên chứa một số nguyên xác định duy nhất trạng thái chờ được ban hành. Bế tắc giữa cùng một nhóm người chơi được đảm bảo không đồng thời. Tuy nhiên, nhiều lần bế tắc sẽ xảy ra cùng một lúc.

Ví dụ:

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

Hiện tại, người chơi và đối thủ thứ hai có 3 máu, đối thủ thứ nhất có 5 máu và đối thủ thứ ba có -2 máu và đã chết.

Ở lượt đầu tiên:

• Người chơi 1 bắn kẻ thù 2
• Kẻ thù 1 đã chuẩn bị một quả lựu đạn
• Kẻ thù bắn 2 phát
• Kẻ thù 3 tự bắn mình

Ở lượt thứ hai:

• Tất cả người chơi không làm gì cả. (Người chơi và kẻ thù 2 không thể làm bất cứ điều gì kể từ khi họ bắn vào lượt trước. Kẻ thù 3 đã chết: anh ta sẽ làm Nothingtrong phần còn lại của bế tắc.)

Đối số thứ hai khi bắt đầu bế tắc là : 5 5 5 5.

Đầu ra

Một lệnh nên được xuất ra ở định dạng được liệt kê dưới đây. Một đầu ra không hợp lệ được hiểu là "Không có gì". Một lệnh yêu cầu một mục tiêu phải được theo sau bởi một số nguyên ( 0-3, 0đại diện cho người chơi và 1-3đại diện cho kẻ thù 1-3).

• S[target]: Bắn [mục tiêu].
• D[target]: Cố gắng né tránh [mục tiêu].
• P: Chuẩn bị một quả lựu đạn.
• T[target]: Ném lựu đạn vào [mục tiêu].
• N: Không làm gì cả.

Một lệnh cần một mục tiêu, nhưng được cung cấp một mục tiêu không nằm giữa 0và 3không được cung cấp hoàn toàn một mục tiêu sẽ được giả định để nhắm mục tiêu 0(người chơi).

Chấm điểm

Vào cuối mỗi lần chờ, người chơi nhận được một số điểm được tính theo công thức sau:

35 + health at end of standoff 

Trong trường hợp người chơi kết thúc cuộc chiến với sức khỏe tiêu cực, họ sẽ nhận được điểm dưới 35 . Các điểm sau đây cũng được thưởng như một phần thưởng:

• Sức khỏe nhiều nhất: +4 điểm
• Sức khỏe thứ hai: +2 điểm
• Sức khỏe thứ ba: +1 điểm.

Trong trường hợp hòa, phần thưởng thấp hơn được cấp (nếu hai người có nhiều sức khỏe nhất, cả hai đều được cấp +2; nếu có 3 người có nhiều sức khỏe nhất, +1 và nếu mọi người kết thúc như nhau, +0).

Điểm cuối cùng được xác định bằng cách tính giá trị trung bình của tất cả các điểm riêng lẻ.

Quy tắc / Chi tiết

• Thứ tự các sự kiện trong một lượt như sau:
  • Tất cả người chơi làm hành động của họ.
  • Người chơi có 0 hoặc ít sức khỏe sẽ chết.
  • Lựu đạn Unthrown cần nổ, sẽ phát nổ (người chơi vừa chết vẫn bị tổn thương, vì đây vẫn là lượt họ chết).
• Không có sự hợp tác giữa các mục.
• Ba * bế tắc sẽ xảy ra giữa mỗi bộ 4 người chơi. (Thứ tự của người chơi có thể thay đổi theo từng bế tắc).
• Các mục tiêu thụ quá nhiều bộ nhớ của dung lượng đĩa sẽ bị loại.
• Đọc từ hoặc sửa đổi các tệp khác với mục nhập của bạn sẽ không đủ điều kiện cho mục nhập của bạn.
• Một chiếc xe tải, được điều khiển bởi một người say rượu, sẽ chạy qua tất cả những người chơi còn sống sau khi 50thrẽ, nếu cuộc đình công vẫn chưa kết thúc vào cuối 50thlượt.
  • Chiếc xe tải này gây 20 sát thương cho tất cả người chơi trực tiếp.
• Bế tắc xảy ra nhanh chóng. Các chương trình bị cắt sau 1 giây.
• Chương trình của bạn sẽ được gọi mỗi lượt, ngay cả sau khi bạn đã chết.
• Bạn chỉ có thể đọc hoặc ghi tệp vào thư mục của mình (nếu mục nhập của bạn có tên JohnDoe, bạn có thể lưu tệp trong thư mục người chơi / JohnDoe /); tuy nhiên, đây sẽ KHÔNG phải là thư mục hiện tại trong khi tập lệnh của bạn đang chạy.
• Cuộc đình công sẽ diễn ra trên một máy chạy Arch Linux (Phiên bản 2014 / 08.01).

Bộ điều khiển có sẵn trên GitHub .

Vui lòng bao gồm những điều sau đây trong bài viết của bạn:

• Tên cho bot của bạn
• Một lệnh shell để chạy bot (ví dụ java Doe.java) Đầu vào sẽ được chuyển qua dòng lệnh dưới dạng một đối số ( java Doe.java 5 "-2,S0 -2,S1 -2,S2 5,N")
• Mã bot của bạn
• Làm thế nào bot nên được biên dịch (nếu có)
• Ngôn ngữ (và phiên bản nếu có, đặc biệt là đối với python)

* Bộ điều khiển đang diễn ra quá lâu trong sáu.

Bảng điểm

                      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

Nhật ký: trên GitHub

Người quan sát

Anh chàng này phân tích kẻ thù của mình. Mục tiêu là để tồn tại cho đến khi chỉ còn lại một đối thủ "hung hăng", và sau đó giết chết kẻ đó trong một tình huống tuyệt vời.

Biên dịch: javac Observer.javaChạy: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);
    }
}

Grenadier

Súng được đánh giá quá cao. Một sự thật bế tắc Scotsman của đi như thế này:

• Chuẩn bị
• Ném vào kẻ thù với nhiều sức khỏe nhất
• Lặp lại (nếu bằng một phép lạ nào đó bạn vẫn còn sống)

Trong khi điều này có vẻ tầm thường, nó có thể không phải là một chiến lược khủng khiếp . Kể từ súng và lựu đạn cả hai đều có một chu kỳ hai lượt, điều này đến nay là hiệu quả hơn ¹ cách để giải quyết thiệt hại.

Tất nhiên, nếu cả ba đối thủ bắn tôi vào vòng đầu tiên thì không tốt. Nhưng cũng không nhiều.

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

Biên dịch / chạy theo cách Java tiêu chuẩn:

> javac Grenadier.java
> java Grenadier arg0 arg1

¹ chú thích vô nghĩa

Quy tắc số 0 Bot của Asimov - Python

Robot có thể không gây hại cho nhân loại, hoặc, bằng cách không hành động, cho phép loài người đến gây hại.

Khá thẳng về phía trước, anh ta sẽ tấn công người chơi đầu tiên mà anh ta thấy đang cầm lựu đạn để bảo vệ phần lớn con người. Nếu không ai là mối đe dọa cho phần lớn con người, anh ta sẽ không làm gì cả.

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

Chạy nó như:

python rule0bot.py

Han Solo - Con trăn

Hân bắn trước. Trong trường hợp này, anh ta sẽ bắn đầu tiên bằng cách chọn mục tiêu gần nhất còn sống.

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

Chạy nó như:

python hansolo.py

_{Lưu ý : Đây là điều đầu tiên tôi từng viết bằng Python, vì vậy nếu bạn thấy bất kỳ thực hành xấu cụ thể nào về trăn, vui lòng cho tôi biết.}

EmoCowboy

Tại sao phải chờ chết? Hãy tự sát ngay bây giờ. Hy vọng rằng những kẻ ngốc còn lại sẽ thổi mỗi cái ít hơn -2.

Điểm thường sẽ là -2. Đôi khi -4 nếu mọi người quyết định bắn tôi ra khỏi con dơi. Hiếm khi hơn thế, điều đó có nghĩa là điều này sẽ đánh bại một số bài nộp hiện tại.

Con trăn

print('S0')

python EmoCowboy.py

EDIT: Đây không phải là một trò đùa, mà nói chung là lý do tại sao những bài nộp emo này được tán thành. Đây là một chiến lược hợp pháp. Sống là chết người!

Hòa bình

Anh ấy là một chàng trai thực sự, vừa bị bắt kịp với đám đông sai trái.

main = putStr "N"

Chạy dưới dạng runghc pacifist.hs, nhưng bạn có thể muốn biên dịch nó với -O3 nếu hiệu quả là một vấn đề.

Monkey - Python (Lần đầu tiên nhập cảnh!)

Khỉ thấy, khỉ làm. Sẽ lặp lại chính xác hành động cuối cùng được thực hiện bởi một người chơi ngẫu nhiên.

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

Có thể chạy như thế này: "python khỉ.py args" Không cần thêm bước.

Bắn súng đơn giản - Perl (lỗi cố định)

Bot này bắn vào đối thủ với nhiều sức khỏe nhất. Đó là một chiến lược rất đơn giản, nhưng tôi nghĩ nó có cơ hội tốt để thực sự làm tốt.

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

Đây là cách chạy nó bằng cách sử dụng một số ví dụ đầu vào:

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

Spock, trong Python 3.x

Mã này giống như một thử nghiệm mặc dù (do đó được đặt tên theo Spock bởi vì ... anh ta là một người thô tục và họ khá giỏi trong những thứ này) nhưng dù sao cũng rất vui khi xây dựng nó. Lý do chính đằng sau tất cả các mã này là các giả định, một thực thể logic, tốt, như Spock, sẽ làm, nếu được đưa ra các quy tắc của trò chơi:

Mục tiêu của trò chơi này là tối đa hóa điểm số, điều này sẽ được thực hiện bởi tất cả mọi người chỉ đứng yên, điều không thể, do xe tải.

• Một trong những chỉ thị mà Spock phải tuân theo là ngăn chặn chiếc xe tải xuất hiện, đảm bảo rằng tất cả mọi người trừ một người đã chết trước khi chiếc xe tải xuất hiện.

Cách Spock chơi trong phần còn lại của trò chơi có thể được tóm tắt bằng câu nói nổi tiếng của ông: " Nhu cầu của nhiều người vượt xa nhu cầu của số ít ". Nói cách khác, Spock phải đảm bảo rằng thiệt hại ít nhất phải chịu, bằng cách giết những người làm điều đó. Làm thế nào anh ấy làm điều đó:

• Nếu không có người chơi nào chuẩn bị lựu đạn, hãy nhắm vào người chơi kém sức khỏe nhất vẫn đang chơi.
• Nếu có những người chơi chuẩn bị lựu đạn, từ những mục tiêu kém lành mạnh nhất.

Lý do là, bằng cách nhắm vào những người chơi yếu nhất, chúng tôi đang chấm dứt các nguồn thiệt hại. Lý do đằng sau những quả lựu đạn là chúng sẽ tắt bất kể và chúng ít gây sát thương hơn nếu chúng không bị ném.

Và vì vậy bot này hoạt động. Tôi đã không kiểm tra rộng rãi cho các lỗi đầu vào (vì vậy xin vui lòng cảnh báo tôi nếu có gì đó không ổn) nhưng tôi tự tin rằng tôi đã giải quyết được hầu hết các nút thắt. Tôi đã dựa vào một phần nhỏ mã từ bot HanSolo nhưng phần lớn đó là một mớ hỗn độn của mã. Thưởng thức.

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)

Chạy nó như:

python spock.py

2014 / 08-12 - Lỗi nhỏ về phát hiện lựu đạn
2014-08-14 - Lỗi nhỏ liên quan đến trò chơi cuối, nhờ isaacg đã chỉ ra trước đó

Tay súng chính trị

Rất đúng về mặt chính trị, vì nó không phân biệt đối xử với bất cứ điều gì. Do đó, nó không thông minh lắm.

import random

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

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

Nó ... không thực sự quan trọng những tranh luận được truyền cho nó như thế nào. python politicallycorrectgunman.py

Cú sút thẳng

Anh ta là một phần được huấn luyện của kỵ binh và nói chuyện bằng nhiều ngôn ngữ, nhưng trong nháy mắt, Straight Shooter chỉ có thể nhìn thấy một kẻ thù trước mặt anh ta. Là một con ngựa, anh ta không hiểu rằng bạn phải đợi giữa các lần bắn.

print('S2')

Perl, Python 2/3, Ruby: con ngựa này thực sự là một mục nhập đa giác.

Dù sao tôi cũng đang thắng. Tôi không thể thua. Bạn có thể bắn tôi nhưng bạn không thể giết tôi. Ông Ed không nói xấu tôi!

Để biết câu trả lời có thêm một chút suy nghĩ (và một số mô hình chức năng) được đưa vào, hãy xem Hai mươi bốn và một nửa thế kỷ .

Chống lựu đạn

Lựu đạn là xấu. Rất tệ. Vì vậy, nếu bất cứ ai đang chuẩn bị một, điều tốt nhất để làm là bắn chúng. Nếu không, chúng tôi sẽ đi chơi.

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

Các chiến lược đơn giản dường như làm rất tốt trong thử thách này, vì vậy đây là một chiến lược khác. Nó bắn một người chơi sống ngẫu nhiên. Nó có thêm tính năng tự tử vào cuối để tránh xe tải.

@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";

Chạy như vậy:

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

Kẻ xâm lược

Kéo vào vòng một, ném vào đối thủ có sức khỏe cao nhất ở vòng 2, bắn vào đối thủ có sức khỏe cao nhất sau đó.

#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;
}

Chạy như thế này ./agg ID "5 5 5 5".

nhẫn giả

Chỉ cần tránh ngẫu nhiên cố gắng để tránh bị tấn công.

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

chạy như

lua ninja.lua

Các đối số là không cần thiết, nhưng có thể được thêm vào vấn đề w / o.

Tên : Mục tiêu ưu tiên

Lệnh Shell : ruby ​​PriorityTarget.rb 5 [game_state]

Ngôn ngữ : Ruby V2.1.2

Mô tả : PriorityTarget cố gắng tìm các kiểu chơi phổ biến. Sau đó, nó quyết định, dựa trên những kiểu chơi đó, người mà nó muốn tấn công và sử dụng vũ khí gì.

Lưu ý : đệ trình Golf Code đầu tiên! Lớn hơn nhiều so với các bài nộp khác vì tôi đã phát điên một chút.

#!/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

Hèn nhát - Perl

Hành vi rất hèn. Khi anh ta cảm thấy khỏe mạnh, anh ta chọn một kẻ thù không cảm thấy như vậy và bắn anh ta. Điểm thưởng cho những kẻ thù đã bắn vào lượt cuối (vì chúng được biết là đang thực hiện Nothinglượt này và do đó hoàn toàn không phòng bị). Khi cảm thấy không ổn, anh chạy ra che để cứu anh ta, thỉnh thoảng bắn ai đó.

#!/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);
}

Mã Perl khá chuẩn; lưu nó trong một số tập tin và sau đó chạy perl file argument argument [...]. Tôi đã kiểm tra cú pháp và nó vẫn ổn, vì vậy tôi hy vọng không có vấn đề gì với việc này.

E: loại bỏ khả năng chia cho 0 lỗi.

Máy bay ném bom

Bot viết bằng R, dòng lệnh nên là: Rscript Bomberman.R arg0 arg1
Tôi nhận ra sau khi bắt đầu viết bot này rằng Geobits đã tạo ra một quả lựu đạn nhưng tôi nghĩ rằng tôi khác biệt đáng kể, trong đó nó kiểm tra sức khỏe của nó là trên 3 trước khi chuẩn bị lựu đạn, ném nó vào người bắn cuối cùng trước, và người thứ hai khỏe mạnh nhất, và nếu sức khỏe của nó dưới 3, nó sẽ tránh được người chơi nguy hiểm (không chết cũng không bắn trong vòng cuối) hoặc bắn một trong những người chơi còn lại.

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)

Biên tập

Dường như có một số vấn đề giao tiếp giữa bot này và bộ điều khiển của bạn vì tất cả các bản ghi mà tôi nhìn thấy cho thấy bot của tôi chỉ xuất ra N. Vì vậy, đây là cùng một bot nhưng được viết lại bằng Python, với hy vọng rằng nếu cái này cũng có vấn đề về giao tiếp, sẽ có người nhìn thấy nó.
Để được gọi với 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 một người chơi sống không bắn lần cuối. Nếu mọi người còn sống bắn lần cuối, hãy bắn một người chơi sống ngẫu nhiên. Tự tử khi nhìn thấy đèn pha.

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

Tôi không mong đợi nhiều từ anh chàng này chống lại những kẻ cười lựu đạn, nhưng với những kẻ bắn súng thì nó có thể hoạt động khá tốt. Chúng ta sẽ thấy.

Hai mươi bốn và một nửa thế kỷ

Mục Python này vịt và né tránh cho đến khi chỉ còn những người chơi thụ động hoặc một người chơi hung hăng duy nhất, sau đó bắt đầu bắn. Nó hy vọng một martian đi qua chăm sóc lựu đạn và lái xe tải say rượu.

Trừ khi tôi đã làm gì đó sai, đây là Python chức năng. Nó chắc chắn không giống với loại Python mà tôi đã viết trước khi Haskell và bạn bè tìm thấy tôi, và tôi không nghĩ rằng tôi đã thay đổi bất cứ thứ gì tại chỗ. Nhưng nếu bạn biết rõ hơn, xin vui lòng cho tôi biết.

#!/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))

Chạy như:

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

Sợ hãi

Trình này là sợ của tất cả mọi người. Nhưng nó đặc biệt sợ một số người. Vì vậy, nó chỉ ra ai là người nguy hiểm nhất và bắn họ. Nếu nhiều kẻ thù trông nguy hiểm nhất, nó sẽ bắn một phát ngẫu nhiên.

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

Đây là python (2 hoặc 3, kết quả tương tự trong cả hai.) Lưu dưới dạng scared.py, chạy vớipython3 scared.py

Thao tác khốn - Python

Chuẩn bị và ném lựu đạn. Nếu anh ta nghĩ rằng không có thời gian hoặc có quá ít kẻ thù, anh ta sẽ bắn. Nếu anh ta một mình, anh ta cố gắng vượt qua anh chàng kia.

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

Osama

Tôi đã thử điều này trong một ngày hoặc lâu hơn, bây giờ là lúc để đăng và xem những người khác đã phát triển như thế nào trong thời gian đó.

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

Biên dịch với ghc -O2 osama.hs, sau đó chạy bằng cách sử dụng ./players/Osama/osama.

Bắn tỉa - Lua

Ở lượt đầu tiên, nó sẽ bắn một người ngẫu nhiên, sau đó nó sẽ bắn bất kỳ người chơi nào mà nó có thể giết (2 hoặc 1 máu). Nếu cả hai không hoạt động, nó sẽ cố bắn người chơi bắn cuối cùng, nếu không nó sẽ bắn một người chơi ngẫu nhiên. Chạy vớilua 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)))

Darwin

Sống sót mạnh nhất có nghĩa là người khỏe mạnh nhất phải chết.

Cơ sở lý luận

Nhìn vào loạt kết quả từ thứ ba (12), dường như có ba nhóm riêng biệt: những người sống sót; tự tử hiệu quả; và tệ hơn là vô dụng. Những người sống sót chia sẻ các chiến lược dựa trên bắn súng đơn giản. Trong khi một vài bot khác ( Spock , Coward ) sẽ nhắm vào kẻ thù kém lành mạnh nhất, chúng cũng làm phức tạp chiến lược của chúng bằng các hành động khác. Cái này thì không. Giống như Simple Shooter , nó có một định nghĩa rõ ràng về mục tiêu và gắn bó với nó không ngừng. Sẽ rất thú vị khi xem nó phù hợp với kết quả nào.

#!/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))

Đây là phiên bản rút gọn, được sửa đổi đôi chút của Twenty-Fourth and Halfth Century trước đây của tôi và chia sẻ lời mời của nó:

python darwin.py 3 "5 5 5 5"

Zaenille - C

Ưu tiên:

1. Chụp nếu đó là 1 trên 1 trái
2. Bắn lựu đạn
3. Dodge
4. Không có gì (chỉ để nhầm lẫn một số)

Biên dịch với gcc <filename.c> .

Chạy với ./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

Chìa khóa của một trò chơi như thế này là phân tích cách tất cả các đối thủ của bạn đang chơi để phản ứng phù hợp. Bot của tôi sẽ làm điều đó bằng cách sử dụng các thuật toán phức tạp sẽ dẫn đến việc sử dụng các đối thủ của tôi biến thành lợi thế của tôi mang lại chiến thắng quyết định!

Chỉnh sửa: Tôi bây giờ

1. né bất kỳ người chơi nào có lựu đạn sống
2. sẽ không còn cố gắng để shoow / ném / né tránh bản thân mình.

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

Biên dịch bot bằng lệnh sau (Cần phải có ghc)

ghc - thực hiện InputAnalyzer.hs

Lệnh Shell để chạy phải như sau

./InputAnalyzer

Lưu ý: Tôi đã thử nghiệm trên windows vì vậy nếu bạn gặp bất kỳ rắc rối nào về việc biên dịch / chạy, vui lòng nói như vậy trong phần bình luận và tôi sẽ cố hết sức để tìm ra lệnh chính xác.

Chú chó tên là Can đảm

Điều đầu tiên - bắn kẻ xấu vào tầm nhìn. Sau đó né ngẫu nhiên cho đến khi có người chuẩn bị lựu đạn. Sau đó, khi mọi người bắn vào anh ta, chuẩn bị lựu đạn của riêng tôi và ném nó vào bất cứ ai. Nhưng người đàn ông mất tập trung.

Chỉnh sửa: Bây giờ thực hiện như tôi nghĩ Nó nên được. Trước đó, điểm số là: 35,9

Cập nhật: Đôi khi bắn thay vì né tránh

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

Chạy như

python couragethedog.py

MAD - Java

Bot MAD tin tưởng vào sức mạnh của sự đe dọa thông qua sự hủy diệt được đảm bảo lẫn nhau . Bất cứ khi nào anh ta không có lựu đạn sẵn sàng, anh ta chuẩn bị một quả. Sau đó anh ta tránh được các xạ thủ có thể cho đến khi ai đó cố gắng gây sát thương cho anh ta hoặc lựu đạn của anh ta sắp nổ tung. Từ lúc anh ta bị tấn công, anh ta ném lựu đạn vào bất cứ ai đã cố gắng gây thêm sát thương cho anh ta trong trận đấu này cho đến nay. Nếu lựu đạn của anh ta sắp nổ tung, anh ta ném bom người chơi hàng đầu. MAD không chống lại việc bắn ai đó khi không có gì để né hoặc trực tiếp tặc một quả lựu đạn và lựu đạn của anh ta vẫn tốt trong ít nhất một lượt.

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

Bot này có thể sẽ hoạt động kém, nhưng dù sao thì tôi cũng thích ý tưởng đó. MAD có thể sẽ làm tốt hơn trong một lĩnh vực với các bot thông minh hơn ghi lại hành vi của các bot khác và với nhiều trận đấu hơn chạy giữa 4 bot.

Tàn bạo

trăn

Ưu tiên của anh là gây đau và lựu đạn. Anh kéo lượt đầu tiên. Anh ta thích giết khi bạn không thể tấn công. Anh ta chơi đồ chơi với SSS (game bắn súng đơn giản) bằng cách né và kéo để kéo dài sự thống trị. Anh ta thậm chí còn chọn tấn công những người đầu tiên không làm gì với ai.

Bởi vì anh ta sử dụng lựu đạn, anh ta (và mọi người khác) sẽ không thể sống sót trong vòng thứ hai hoặc thứ ba. Nếu anh ta được ghép đôi với một quả lựu đạn khác, mọi người sẽ chết. Điều này có nghĩa là tôi không mong đợi chiến thắng nhưng tôi đã viết nó để học python (chưa bao giờ sử dụng nó trước đây và tôi đang cố gắng giới thiệu về một loạt các ngôn ngữ mới). Có một số khác, "kéo đầu tiên" vì vậy nếu bạn cảm thấy nó quá mô phỏng hãy cho tôi biết. Tuy nhiên, những người khác dường như không sẵn sàng kéo và sau đó né tránh.

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