Đây vua-of-the-đồi thách thức là dựa tắt của các chương trình trò chơi, liên kết yếu nhất . Đối với những người không quen thuộc với chương trình, mấu chốt của thử thách này liên quan đến người bạn bỏ phiếu :

• Nếu những người chơi khác thông minh hơn bạn, thì bạn sẽ ít có cơ hội nhận được tiền cược.
• Nếu những người chơi khác ngu hơn bạn, thì bạn sẽ có ít tiền hơn.

Vào đầu mỗi vòng, Pot bắt đầu với $ 0. Một nhóm 9 người chơi được hình thành, và mỗi người chơi được đưa ra một độc đáo smartness 1-9.

Khi bắt đầu mỗi lượt, Pot += Smartnesscho mỗi người chơi vẫn vào vòng trong. Sau đó, người chơi bỏ phiếu cho người chơi mà họ muốn xóa. Người chơi có nhiều phiếu nhất sẽ bị xóa. Trong trường hợp hòa, người chơi thông minh hơn được giữ.

Khi chỉ còn 2 người chơi vào vòng trong, họ phải đối mặt trong một trận chiến trí tuệ. Cơ hội của người chơi chiến thắng là Smartness/(Smartness+OpponentSmartness). Người chơi chiến thắng sau đó nhận được toàn bộ tiền cược.

Người chơi nào nhận được nhiều tiền nhất vào cuối trò chơi sẽ thắng.

Đầu ra đầu vào

Mỗi lượt, bạn sẽ nhận được danh sách đối thủ hiện tại. Bạn sẽ có quyền truy cập vào sự thông minh của mình và toàn bộ lịch sử bầu chọn của người chơi cho vòng đấu thông qua các chức năng trong lớp Người chơi.

Là đầu ra, bạn phải trả về một số nguyên duy nhất, đại diện cho người chơi bạn muốn bỏ phiếu (đại diện cho sự thông minh của họ). Bỏ phiếu cho chính mình được cho phép (nhưng không được khuyến khích).

Vòng 9 sẽ lặp lại cho đến khi tất cả người chơi đã chơi ít nhất 1000 10000 vòng và tất cả người chơi đã chơi trong cùng một số vòng.

Bạn có thể tìm thấy bộ điều khiển ở đây: https://github.com/nathanmerrill/WeakestLink

Để tạo trình phát, bạn cần mở rộng lớp Trình phát và thêm trình phát của mình vào lớp PlayerFactory. Lớp học của bạn phải tuân theo các quy tắc sau:

1. Liên lạc hoặc can thiệp với bất kỳ người chơi nào khác (bao gồm những người chơi khác cùng loại của bạn) đều bị nghiêm cấm.

2. Các biến phản xạ và tĩnh (trừ các hằng số) không được phép.

3. Nếu bạn muốn sử dụng tính ngẫu nhiên, tôi đã cung cấp một getRandom()hàm trong lớp Player. Sử dụng nó, vì vậy mô phỏng có thể được xác định.

Tôi đã cung cấp nhiều chức năng trong lớp Player để dễ dàng truy cập dữ liệu. Bạn có thể tìm thấy chúng trực tuyến trên Github . Người chơi của bạn sẽ được khởi tạo mỗi vòng mới. Người chơi "ngu ngốc / tự tử" được phép (nhưng không phải người chơi có cùng chiến lược).

Điểm số

377195  WeakestLink.Players.PrudentSniper
362413  WeakestLink.Players.Sniper
353082  WeakestLink.Players.VengefulSniper
347574  WeakestLink.Players.AntiExtremist
298006  WeakestLink.Players.BobPlayer
273867  WeakestLink.Players.MedianPlayer
247881  WeakestLink.Players.TheCult
240425  WeakestLink.Players.Leech
235480  WeakestLink.Players.SniperAide
223128  WeakestLink.Players.Guard
220760  WeakestLink.Players.Anarchist
216839  WeakestLink.Players.RevengePlayer
215099  WeakestLink.Players.IndependentVoter
213883  WeakestLink.Players.SniperKiller
210653  WeakestLink.Players.MaxPlayer
210262  WeakestLink.Players.Bandwagon
209956  WeakestLink.Players.MeanPlayer
208799  WeakestLink.Players.Coward
207686  WeakestLink.Players.Spy
204335  WeakestLink.Players.Hero
203957  WeakestLink.Players.MiddleMan
198535  WeakestLink.Players.MinPlayer
197589  WeakestLink.Players.FixatedPlayer
197478  WeakestLink.Players.HighOrLowNotSelf
181484  WeakestLink.Players.RandomPlayer
165160  WeakestLink.Players.BridgeBurner

Kẻ bắn tỉa

Ý tưởng chung là giữ xung quanh một trong những người chơi ngu ngốc (tức là những người mà chúng ta có nhiều khả năng đánh bại khi đối mặt) để bắn tỉa cho các điểm. Sau đó, chúng tôi cố gắng loại bỏ những người chơi có giá trị thấp khác để nâng cao số tiền. Nhưng khi chúng tôi đến với những người chơi thông minh, chúng tôi sẽ chọn loại bỏ những người nguy hiểm nhất trong trường hợp người chơi ngu ngốc của chúng tôi bị xóa. Theo cách đó, nếu chúng ta không có ai đó để bắn tỉa, chúng ta nên có một người mà chúng ta ít nhất có cơ hội chống lại. Ngoài ra, vì chúng tôi luôn bỏ phiếu với một người chơi tối thiểu hoặc tối đa, tôi hy vọng chúng tôi khá hiệu quả trong việc tìm đường.

package WeakestLink.Players;
import java.util.Collections;
import java.util.Iterator;
import java.util.Set;
public class Sniper extends Player {
    @Override
    public int vote(Set<Integer> currentOpponents) {
        int smrt = getSmartness();

        //count number of players smarter/stupider than me
        Iterator<Integer> opps = currentOpponents.iterator();
        int cnt_smrt=0, cnt_stpd=0, opp_smrt, min_stpd=10, max_smrt=0;

        while(opps.hasNext()){
            opp_smrt = opps.next().intValue();
            if(opp_smrt > smrt){
                cnt_smrt++;
                if(opp_smrt > max_smrt) max_smrt = opp_smrt;
            }
            else if(opp_smrt < smrt){
                cnt_stpd++;
                if(opp_smrt < min_stpd) min_stpd = opp_smrt;
            }
        }

        //remove low-value, then dangerous players
        if(cnt_stpd>1)
            return min_stpd;
        else
            return max_smrt;
    }
}

PrudentSniper

Sniper , nhưng với hai hành vi trường hợp đặc biệt. Một là nếu có ba bot còn lại và PrudentSniper là thông minh nhất, nó sẽ bỏ phiếu cho bot giữa thay vì kém thông minh nhất. Điều này cho phép nó giành chiến thắng thêm một vài trận đấu. Hành vi khác là nếu bot thông minh nhất đang bắn súng cho nó (đã bình chọn cho nó hoặc bot tương tự lần trước) và kém thông minh nhất thì không, nó sẽ bầu cho người thông minh nhất để tự vệ.

package WeakestLink.Players;
import WeakestLink.Game.Vote;
import java.util.Collections;
import java.util.Iterator;
import java.util.Set;
public class PrudentSniper extends Player {
    @Override
    public int vote(Set<Integer> currentOpponents) {
        int smrt = getSmartness();

        //count number of players smarter/stupider than me, find max/min
        Iterator<Integer> opps = currentOpponents.iterator();
        int cnt_smrt=0, cnt_stpd=0, opp_smrt, min_stpd=10, max_smrt=0;

        while(opps.hasNext()){
            opp_smrt = opps.next().intValue();
            if(opp_smrt > max_smrt) max_smrt = opp_smrt;
            if(opp_smrt < min_stpd) min_stpd = opp_smrt;
            if(opp_smrt > smrt){
                cnt_smrt++;
            }
            else if(opp_smrt < smrt){
                cnt_stpd++;
            }
        }

        //identify enemies
        Iterator<Vote> votes = getRecentVotes().iterator();
        boolean[] voted_for_me = new boolean[9];

        while(votes.hasNext()) {
          Vote opp_vote = votes.next();
          voted_for_me[opp_vote.getVoter()] = (opp_vote.getVoted() == getSmartness() ||
                                              (opp_vote.getVoted() < getSmartness() && cnt_stpd < 1) ||
                                              (opp_vote.getVoted() > getSmartness() && cnt_smrt < 1));
        }

        if (currentOpponents.size() < 3 || cnt_stpd < 2 || (voted_for_me[max_smrt] && !voted_for_me[min_stpd] && cnt_smrt > 0) )
          return max_smrt;
        else
          return min_stpd;
    }
}

TheCult

Những người chơi sùng bái có một kế hoạch bỏ phiếu bí truyền nhẹ, qua đó họ cố gắng xác định lẫn nhau và bỏ phiếu như một nhóm, chỉ sử dụng hồ sơ bỏ phiếu. Vì mỗi thành viên của giáo phái đều biết cách bỏ phiếu, bất cứ ai bầu khác nhau đều được tiết lộ là người không phải là thành viên và cuối cùng bị nhắm mục tiêu để loại bỏ.

Sơ đồ bỏ phiếu trong nháy mắt:

• trong lần bỏ phiếu đầu tiên cho thí sinh yếu nhất, làm việc trong buổi hòa nhạc với min & sniper giúp giáo phái có được sức mạnh
• trong các lượt tiếp theo bỏ phiếu cho những người không phải là thành viên đã biết cho đến khi chỉ còn giáo phái (chúng tôi bỏ phiếu cho những người không phải là thành viên có giá trị thấp nhất để đạt được điểm miễn là chúng tôi nghĩ rằng mình đang kiểm soát).
• khi chỉ còn các thành viên, bỏ phiếu cho các thành viên có giá trị thấp để lấy điểm (thực sự hy sinh bản thân vì lợi ích của giáo phái).

Mật mã:

package WeakestLink.Players;
import WeakestLink.Game.Vote;
import java.util.Iterator;
import java.util.Set;
public class TheCult extends Player {
    private int cult_vote;
    private boolean[] isMember = null;
    @Override
    public int vote(Set<Integer> currentOpponents) {
        //on first turn, vote the code
        if(isMember == null){
            isMember = new boolean[10];
            for(int i=10; --i!=0;) isMember[i]=true; //runs 9-1
            return cult_vote = 1;
        }
        //on all other turn, assess who is not voting with the cult
        Vote opp_vote;
        int cult_cnt=0;
        Iterator<Vote> votes = getRecentVotes().iterator();
        while(votes.hasNext()){
            opp_vote = votes.next();
            if(opp_vote.getVoted() != cult_vote)
                isMember[opp_vote.getVoter()] = false;
            else
                cult_cnt++;
        }
        //find weakest and stongest non-members, and weakest members
        Iterator<Integer> opps = currentOpponents.iterator();
        int opp_smrt, min_mem=10, min_non=10, max_non=0;
        while(opps.hasNext()){
            opp_smrt = opps.next().intValue();
            if(isMember[opp_smrt]){
                if(opp_smrt < min_mem) min_mem = opp_smrt;
            }else{
                if(opp_smrt < min_non) min_non = opp_smrt;
                if(opp_smrt > max_non) max_non = opp_smrt;
            }
        }
        if(cult_cnt>2 && min_non!=10) cult_vote = min_non;
        else if(max_non!=0)           cult_vote = max_non;
        else                          cult_vote = min_mem;
        return cult_vote;
    }
}

Suy nghĩ cuối cùng:

Giáo phái bây giờ chuyển sang bỏ phiếu cho những người chơi nguy hiểm nhất khi chỉ còn hai hoặc ít hơn các thành viên giáo phái để đối mặt. Tôi đã thử nghiệm nó nhiều lần với cult_cnt>1và cult_cnt>2điều kiện và sau đó chiến thắng thường xuyên hơn.

Tuy nhiên, đây là một biện pháp phòng ngừa và giáo phái thực sự không được thiết kế để hoạt động như một người chơi đơn độc, vì vậy khi số lượng người chơi mới tăng giáo phái vẫn sẽ mất dần.

Cầu quay

Không phải nơi nào tôi có thể kiểm tra điều này ngay bây giờ, và điều này xuất hiện cảm giác như mã thực sự xấu xí / ngu ngốc, nhưng nó sẽ hoạt động.

Bot này chỉ muốn bị ghét. Nó bỏ phiếu cho bất cứ ai đã bỏ phiếu chống lại nó ít nhất . Trong trường hợp hòa, nó chọn bất cứ ai đã đi lâu nhất mà không bỏ phiếu cho nó. Trong trường hợp có một chiếc cà vạt khác, nó chọn người thông minh nhất trong số đó (có lẽ vì họ sẽ tạo ra kẻ thù tồi tệ nhất). Nó sẽ không bỏ phiếu cho chính nó, bởi vì không ai sẽ thực sự ghét nó khi nó không ở gần.

package WeakestLink.Players;

import WeakestLink.Game.Vote;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class BridgeBurner extends Player{
    @Override
    public int vote(Set<Integer> currentOpponents) {
        List<Integer> votes_against = Stream.generate(() -> 0).limit(9).collect(Collectors.toList());
        List<Integer> last_voted_against = Stream.generate(() -> 0).limit(9).collect(Collectors.toList());
        Iterator<Vote> votes_against_me = getVotesForSelf().iterator();

        for (int c = 0; c < 9; c++){
            if (!currentOpponents.contains(c)){
                votes_against.set(c,-1);
                last_voted_against.set(c,-1);
            }
        }

        while(votes_against_me.hasNext()){
            Vote vote = votes_against_me.next();

            int voter = vote.getVoter();
            int round = vote.getRound();

            if (currentOpponents.contains(voter)){
                votes_against.set(voter, votes_against.get(voter)+1);
                last_voted_against.set(voter, Math.max(round, last_voted_against.get(voter)));
            } else {
                votes_against.set(voter, -1);
                last_voted_against.set(voter, -1);
            }
        }

        int min_tally = Collections.max(votes_against);
        for (int c = 0; c < 9; c++){
            int current_tally = votes_against.get(c);
            if (current_tally != -1 && current_tally < min_tally){
                min_tally = current_tally;
            }
        }

        if (Collections.frequency(votes_against, min_tally) == 1){
            return votes_against.indexOf(min_tally);
        } else {
            List<Integer> temp_last_against = new ArrayList<>();
            for (int c = 0; c < 9; c++){
                if (votes_against.get(c) == min_tally){
                    temp_last_against.add(last_voted_against.get(c));
                }
            }
            return last_voted_against.lastIndexOf(Collections.min(temp_last_against));
        }
    }
}

Phong trào

Theo dõi đám đông bỏ phiếu, trừ khi anh ta là người được nhắm đến.

package WeakestLink.Players;

import WeakestLink.Game.Vote;
import java.util.Map;
import java.util.Set;

/**
 * Votes for the currently most voted bot in the game. Or the lowest one.
 */
public class Bandwagon
        extends Player {

    @Override
    public int vote(Set<Integer> currentOpponents) {
        int self = getSmartness(), vote = -1;
        java.util.Map<Integer, Integer> votes = new java.util.TreeMap<>();
        getVotingHistory().stream().map((Vote v)-> v.getVoted()).filter((Integer i)-> !i.equals(self)).forEach((Integer tgt)-> {
            if(!votes.containsKey(tgt)) {
                votes.put(tgt, 1);
            } else {
                votes.put(tgt, votes.get(tgt) + 1);
            }
        });

        do {
            if(votes.entrySet().isEmpty()) {
                vote = currentOpponents.stream().filter((Integer i)-> !i.equals(self)).sorted().findFirst().get();
            } else {
                if(votes.containsKey(vote)) {
                    votes.remove(vote);
                    vote = -1;
                }

                for(Map.Entry<Integer, Integer> vv: votes.entrySet()) {
                    Integer key = vv.getKey();
                    Integer value = vv.getValue();

                    if((vote == -1) || (value > votes.get(vote))) {
                        vote = key;
                    }
                }
            }
        } while(!currentOpponents.contains(vote));

        return vote;
    }
}

Tôi đoán điều này sẽ giúp lính bắn tỉa mạnh hơn bằng cách theo dõi họ, nhưng cũng tránh bị nhắm vào giáo phái và xạ thủ bắn tỉa một cách hiệu quả. Nó cũng có thể là một meatshield cho những kẻ giết người bắn tỉa hoặc hỗ trợ họ nếu có thêm họ. (Cần kiểm tra với các bản cập nhật mới nhất).

Sử dụng các tính năng java 8 vì trò chơi cần điều đó để chạy.

Trả thù

Bot này sẽ bình chọn cho bất cứ ai bầu chọn cho anh ta nhiều lần nhất, tiebreaker là người chơi thông minh nhất. Lý thuyết là một người chơi đã bình chọn cho bạn trong quá khứ có thể sẽ bỏ phiếu cho bạn một lần nữa.

package WeakestLink.Players;
import java.util.Collections;
import java.util.Set;
import java.util.Iterator;
import WeakestLink.Game.Vote;
public class RevengePlayer extends Player{

    @Override
    public int vote(Set<Integer> opponents) {
        int[] A;
        A = new int[10];
        for(int i = 1;i < 10;i++)
            A[i] = opponents.contains(i)? i+1 : 0;
        Set<Vote> H = getVotingHistory();
        Iterator<Vote> I = H.iterator();
        while(I.hasNext()){
            Vote v = I.next();
            if(v.getVoted() == getSmartness())
                A[v.getVoter()] += A[v.getVoter()] != 0?10:0;
        }
        int maxI = 0;
        for(int i = 1;i < 10;i++)
            if(A[i] > A[maxI])
                maxI = i;
        return maxI;
    }
}

Nghĩa là

Bầu chọn những người ngu ngốc nhất cũng không phải là người chơi thông minh nhất và anh ta mang theo một khẩu súng (lén lút bảo mật)

public class MeanPlayer extends Player{

    @Override
    public int vote(Set<Integer> currentOpponents) {
        int mid = currentOpponents.size() / 2;
        Object[] sortedOpponents = currentOpponents.toArray();
        Arrays.sort(sortedOpponents);
        return (int) sortedOpponents[mid];
    }
}

Chống ngoại lệ

Chủ nghĩa xã hội cực đoan này tin rằng tất cả mọi người nên có sự thông minh như nhau. Anh ta cố gắng giết những người thông minh hơn hoặc ngu ngốc hơn anh ta. Anh ta xem xét cả hai nhưng anh ta nói chung là ngu ngốc. Anh ấy ủng hộ những người câm ngay từ đầu và cuối cùng thông minh, nhưng điều đó có trọng số dựa trên mức độ cực đoan của những người đó.

package WeakestLink.Players;
import java.util.Arrays;
import java.util.Set;

public class AntiExtremist extends Player {

    Object[] currentPlayers;

    @Override
    public int vote(Set<Integer> currentOpponents) {

        currentPlayers = (Object[]) currentOpponents.toArray();
        Arrays.sort(currentPlayers);

        int smartness = getSmartness();
        int turns = getTurnNumber();

        //// Lets get an idea of who's smart and who's dumb ////

        int smarter = 0, dumber = 0;

        int max_smart = 0, min_smart = 10;

        currentOpponents.toArray();

        for (int i = 0; i < currentPlayers.length; i++) {
            int osmart = (int)currentPlayers[i];

            if (osmart == smartness)
                continue;

            if (osmart > smartness) {
                smarter++;

                if (osmart > max_smart)
                    max_smart = osmart;
            }
            else if (osmart < smartness) {
                dumber++;

                if (osmart < min_smart)
                    min_smart = osmart;
            }

        }

        // int total = smarter+dumber;

        double smarter_ratio = smarter > 0 ? (max_smart-smartness)/4.5 : 0; 
        double dumber_ratio = dumber > 0 ? (smartness-min_smart)/3.0 : 0;//Favor dumber

        smarter_ratio*=.25+(turns/9.0*.75);
        dumber_ratio*=1-(turns/8.0*.75);

        return smarter_ratio > dumber_ratio ? max_smart : min_smart;

    }

}

LƯU Ý: Theo Linus, điều này sẽ bỏ phiếu giống như bắn tỉa trong phần lớn thời gian (525602: 1228).

Gián điệp

Gián điệp được bảo lưu. Anh ta không thích dùng súng cho những người thông minh nhất. Tương tự như vậy, anh không làm như chọn trên quartata idiots khả năng tự vệ. Vì vậy, anh ấy thích loại bỏ những người gần gũi nhất với anh ấy bằng sự thông minh.

package WeakestLink.Players;

import java.util.Iterator;
import java.util.Set;

public class Spy extends Player{
  @Override
  public int vote(Set<Integer> currentOpponents) {
    int selfIntel = getSmartness();
    int closestIntel = 100; // default
    // get closest player
    Iterator<Integer> enemies = currentOpponents.iterator();
    while(enemies.hasNext()){
      int enemyIntel = enemies.next().intValue();
      if(Math.abs(enemyIntel - selfIntel) < closestIntel) closestIntel = enemyIntel;
    }
    return closestIntel;
  }
}

Bạn vừa bị đánh đập, mes amis . Anh ta không quan tâm nếu anh ta thắng. Anh ta chỉ thích tiếng dao đâm vào lưng bạn khi anh ta bỏ phiếu cho bạn thành công.

MedianPlayer

Người chơi này cố gắng trở thành người trung bình nhất (tốt, trung bình) một bên trái.

Nó bỏ phiếu để loại bỏ những đối thủ thông minh nhất và ngu ngốc nhất (với một chút thiên vị đối với việc bỏ phiếu thông minh nhất), tùy thuộc vào việc có nhiều hay ít thông minh hơn / ngu ngốc hơn chính họ.

package WeakestLink.Players;
import java.util.Collections;
import java.util.Iterator;
import java.util.Set;
public class MedianPlayer extends Player {
  @Override
  public int vote(Set<Integer> currentOpponents) {
    int smrt = getSmartness();

    //count number of players smarter/stupider than me
    Iterator<Integer> opps = currentOpponents.iterator();
    int cnt_smrt=0, cnt_stpd=0, min_stpd=10, max_smrt=0;

    while(opps.hasNext()){
      int opp_smrt = opps.next().intValue();
      if(opp_smrt > smrt){
        cnt_smrt++;
        if(opp_smrt > max_smrt)
          max_smrt = opp_smrt;
      } else if(opp_smrt < smrt){
        cnt_stpd++;
        if(opp_smrt < min_stpd)
          min_stpd = opp_smrt;
      }
    }

    // the middle must hold
    if(cnt_stpd>cnt_smrt)
      return min_stpd;
    else
      return max_smrt;
  }
}

khung bị đánh cắp trắng trợn từ @Linus ở trên.

nhát gan

package WeakestLink.Players;
import WeakestLink.Game.Vote;
import java.util.Collections;
import java.util.Iterator;
import java.util.Set;
public class Coward extends Player {
  @Override
  public int vote(Set<Integer> currentOpponents) {

    boolean[] currentOpponent = new boolean[10];

    Iterator<Integer> opps = currentOpponents.iterator();
    while(opps.hasNext()){
      currentOpponent[opps.next().intValue()] = true;
    }

    int[] voteCounts = new int[9];
    for(int i=0; i<9; i++) {
        voteCounts[i] = 0;
    }

    Iterator<Vote> votes = getRecentVotes().iterator();

    while(votes.hasNext()){
      Vote opp_vote = votes.next();
      if(currentOpponent[opp_vote.getVoter()])
        voteCounts[opp_vote.getVoted()] += 1;
      else
        voteCounts[opp_vote.getVoter()] += 100;
    }

    int previous_weakest = -1;
    int max_votes_gotten = 0;
    for(int i=0;i<9;i++){
      if (voteCounts[i] > max_votes_gotten) {
        max_votes_gotten = voteCounts[i];
        previous_weakest = i;
      }
    }
    int min_closeness = 10;
    int to_vote = -1;
    int opp;
    int closeness;
    opps = currentOpponents.iterator();
    while(opps.hasNext()){
      opp = opps.next();
      closeness = Math.abs(opp - previous_weakest);
      if(closeness <= min_closeness) {
        to_vote = opp;
        min_closeness = closeness;
      }
    }

    return to_vote;

  }
}

Chỉ không muốn bỏ phiếu, vì vậy, phiếu bầu cho đối thủ giống với người chơi đã bỏ phiếu vòng trước để tối đa hóa cơ hội được vào đội chiến thắng.

Không làm đặc biệt tốt ngay bây giờ, nhưng cũng có thể ném nó vào hỗn hợp.

Anh hùng

Bỏ phiếu những người yếu đuối ... hoặc làm phiền anh ta.

package WeakestLink.Players;

import WeakestLink.Game.Game;
import WeakestLink.Game.Vote;

import java.util.*;

/**
 * Created by thenumberone on 12/2/15.
 * @author thenumberone
 */
public class Hero extends Player{

    @Override
    public int vote(Set<Integer> currentOpponents) {
        int me = getSmartness();
        Set<Vote> history = getVotingHistory();
        history.removeIf(vote -> !currentOpponents.contains(vote.getVoter()) || vote.getVoter() == me);
        int[] evilnessLevel = new int[Game.NUMBER_PLAYERS_PER_ROUND];
        for (Vote vote : history){
            evilnessLevel[vote.getVoter()] += vote.getVoted() == me ? 1_000_000 : Game.NUMBER_PLAYERS_PER_ROUND - vote.getVoted();
        }
        int mostEvilOpponent = -1;
        for (int opponent : currentOpponents){
            if (mostEvilOpponent == -1 || evilnessLevel[opponent] > evilnessLevel[mostEvilOpponent]){
                mostEvilOpponent = opponent;
            }
        }
        return mostEvilOpponent;
    }
}

Bob

Bob chỉ là người bình thường nghĩ rằng anh ta thông minh hơn anh ta thực sự. Không thể chiến thắng gia đình bắn tỉa nhưng có được top 5 trong các mô phỏng của tôi hầu hết thời gian.

package WeakestLink.Players;

import java.util.Collections;
import java.util.Set;

import WeakestLink.Game.Vote;

public class BobPlayer extends Player {


    @Override
    public int vote(Set<Integer> currentOpponents) {
        int smartness;

        // Bob sometimes thinks he is smarter than he really is
        if (getRandom().nextInt(10) == 0) {
            smartness = 10;
        } else {
            smartness = getSmartness();
        }

        // If there is still some competition
        if (currentOpponents.size() > 3) {
            // And Bob is the dumbest
            if (smartness < Collections.min(currentOpponents)) {
                // Go for the smartest one
                return Collections.max(currentOpponents);
                // But if he is the smartest
            } else if (smartness > Collections.max(currentOpponents)) {
                // Go for the weak link
                return Collections.min(currentOpponents);
            } else {
                // Else revenge!
                for (Vote v : getRecentVotes()) {
                    if (v.getVoted() == smartness && currentOpponents.contains(v.getVoter())) {
                        return v.getVoter();
                    }
                }
            }
            return Collections.min(currentOpponents);
        } else {
            //If there are few opponents just revenge!
            for (Vote v : getRecentVotes()) {
                if (v.getVoted() == smartness && currentOpponents.contains(v.getVoter())) {
                    return v.getVoter();
                }
            }
            return Collections.max(currentOpponents);
        }
    }



}

FixatedPlayer

Chọn một mục tiêu ngẫu nhiên, sau đó bỏ phiếu cho chúng cho đến khi chúng biến mất. Không bỏ phiếu cho chính mình mặc dù.

package WeakestLink.Players;

import WeakestLink.Game.Vote;

import java.util.*;

public class FixatedPlayer extends Player{
    @Override
    public int vote(Set<Integer> currentOpponents) {
        int self = getSmartness();
        Vote previous_vote = getLastVote();
        if (previous_vote == null || !currentOpponents.contains(previous_vote.getVoted())){
            return (int) currentOpponents.toArray()[getRandom().nextInt(currentOpponents.size())];
        }
        else {
            return previous_vote.getVoted();
        }
    }
}

Số liệu thống kê

Đây không phải là một mục để tham gia cuộc thi. Đây chỉ là một cách để có được số liệu thống kê hữu ích của một trò chơi. Các thống kê này in ra khả năng phần trăm mà một người chơi cụ thể sẽ được bỏ phiếu trong một vòng.

Để thực hiện việc này, hãy thêm các dòng sau vào Round.javađể phần trên cùng của tệp trông như thế này:

package WeakestLink.Game;

import WeakestLink.Players.Player;

import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class Round {

    private static int[][] statistics = new int[Game.NUMBER_PLAYERS_PER_ROUND - 2][Game.NUMBER_PLAYERS_PER_ROUND + 1];
    private static int[] counts = new int[Game.NUMBER_PLAYERS_PER_ROUND - 2];

    static {
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            for (int i = 0; i < Game.NUMBER_PLAYERS_PER_ROUND - 2; i++){
                System.out.println();
                System.out.println("For " + (i+1) + "th round:");
                for (int j = 1; j <= Game.NUMBER_PLAYERS_PER_ROUND; j++){
                    System.out.println(String.format("%f%% voted for %d", 100.0*statistics[i][j]/counts[i], j));
                }
            }
        }));
    }

...

Sau đó sửa đổi phương thức bỏ phiếu để trông như thế này:

private Vote vote(Player player){
    player.setVotingHistory(new HashSet<>(votes));
    player.setTurnNumber(currentTurn);
    player.setPot(pot);
    Set<Integer> players = currentPlayers.stream()
            .filter(p -> p != player)
            .map(playerToSmartness::get)
            .collect(Collectors.toSet());
    int vote = player.vote(players);
    if (!currentPlayers.contains(smartnessToPlayer.get(vote))){
        throw new RuntimeException(player.getClass().getSimpleName()+" voted off non-existent player");
    }
    Vote v = new Vote(playerToSmartness.get(player), vote, currentTurn);
    counts[v.getRound()]++;
    statistics[v.getRound()][v.getVoted()]++;
    return v;
}

Kết quả ví dụ:

For 1th round:
55.554756% voted for 1
4.279166% voted for 2
1.355189% voted for 3
1.778786% voted for 4
3.592771% voted for 5
3.952368% voted for 6
1.779186% voted for 7
6.427149% voted for 8
21.280630% voted for 9

For 2th round:
2.889877% voted for 1
34.080927% voted for 2
6.826895% voted for 3
4.990010% voted for 4
5.914753% voted for 5
4.985510% voted for 6
3.302524% voted for 7
11.304360% voted for 8
25.705144% voted for 9

For 3th round:
2.152783% voted for 1
13.005153% voted for 2
21.399772% voted for 3
7.122286% voted for 4
6.122008% voted for 5
6.761774% voted for 6
11.687049% voted for 7
19.607500% voted for 8
12.141674% voted for 9

For 4th round:
2.122183% voted for 1
10.105719% voted for 2
11.917105% voted for 3
17.547460% voted for 4
8.626131% voted for 5
12.079103% voted for 6
18.819449% voted for 7
11.065111% voted for 8
7.717738% voted for 9

For 5th round:
1.689826% voted for 1
7.364821% voted for 2
9.681763% voted for 3
11.704946% voted for 4
20.336237% voted for 5
20.691914% voted for 6
13.062855% voted for 7
9.332565% voted for 8
6.135071% voted for 9

For 6th round:
1.456188% voted for 1
6.726546% voted for 2
10.154619% voted for 3
16.355569% voted for 4
22.985816% voted for 5
17.777558% voted for 6
11.580207% voted for 7
7.757938% voted for 8
5.205558% voted for 9

For 7th round:
1.037992% voted for 1
6.514748% voted for 2
15.437876% voted for 3
22.151823% voted for 4
17.015864% voted for 5
14.029088% voted for 6
11.907505% voted for 7
7.957136% voted for 8
3.947968% voted for 9

MaxPlayer

Một bí quyết Thích loại bỏ bất cứ ai có trí thông minh cao (do đó có thể thách thức trí tuệ chưa từng có của anh ta)

public class MaxPlayer extends Player{

    @Override
    public int vote(Set<Integer> currentOpponents) {
        return Collections.max(currentOpponents);
    }
}

Bảo vệ

Bỏ phiếu những người chọn kẻ mạnh ... hoặc những người làm phiền anh ta.

package WeakestLink.Players;

import WeakestLink.Game.Game;
import WeakestLink.Game.Vote;

import java.util.Set;

/**
 * Created by thenumberone on 12/2/15.
 * @author thenumberone
 */
public class Guard extends Player{

    @Override
    public int vote(Set<Integer> currentOpponents) {
        int me = getSmartness();
        Set<Vote> history = getVotingHistory();
        history.removeIf(vote -> !currentOpponents.contains(vote.getVoter()) || vote.getVoter() == me);
        int[] evilnessLevel = new int[Game.NUMBER_PLAYERS_PER_ROUND];
        for (Vote vote : history){
            evilnessLevel[vote.getVoter()] += vote.getVoted() == me ? 1_000_000 : vote.getVoted();
        }
        int mostEvilOpponent = -1;
        for (int opponent : currentOpponents){
            if (mostEvilOpponent == -1 || evilnessLevel[opponent] > evilnessLevel[mostEvilOpponent]){
                mostEvilOpponent = opponent;
            }
        }
        return mostEvilOpponent;
    }
}

Đỉa

Dựa vào các bot khác để bầu chọn những kẻ thông minh và ngu ngốc nhất .. loại.

Anh ta hài lòng với việc bật lên ở đâu đó ở giữa và cuối cùng chia nồi với người chiến thắng (vì anh ta thực sự là một anh chàng bot thực sự đàng hoàng ).

package WeakestLink.Players;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Set;

public class Leech extends Player {
    /**
     * Copyrighted (not really, use this however you want friends) by Sweerpotato :~)!
     */
    @Override
    public int vote(Set<Integer> currentOpponents) {
        int mySmartness = getSmartness();

        ArrayList<Integer> opponentSmartness = new ArrayList<Integer>();
        opponentSmartness.addAll(currentOpponents);
        opponentSmartness.add(mySmartness);
        Collections.sort(opponentSmartness);

        if(mySmartness > 4 && mySmartness > Collections.min(opponentSmartness)) {
            //There's somebody dumber than me, vote that dude off
            return opponentSmartness.get(opponentSmartness.indexOf(mySmartness) - 1);
        }
        else {
            //Vote off the smartest guy, so we have a better chance to win
            if(mySmartness == Collections.max(opponentSmartness)) {
                //Apparently, we're the smartest guy
                return opponentSmartness.get(opponentSmartness.indexOf(mySmartness) - 1);
            }
            else {
                return Collections.max(opponentSmartness);
            }
        }
    }
}

Súng bắn tỉa

Một câu trả lời khác bị đánh cắp một cách đáng xấu hổ từ mã của Linus . Cái này trong sẽ giết tất cả lính bắn tỉa, không bảo vệ họ. Nếu nó biết rằng không còn lính bắn tỉa nào nữa, nó sẽ hoạt động giống như một tay bắn tỉa.

package WeakestLink.Players;
import WeakestLink.Game.Vote;
import java.util.Collections;
import java.util.Iterator;
import java.util.Set;

public class SniperKiller extends Player {
    boolean[] sniperish;
    int[] sniperwouldvote;

    @Override
    public int vote(Set<Integer> currentOpponents) {
        int smrt = getSmartness();
        currentOpponents.add(smrt);
        if(sniperish==null){
            sniperish = new boolean[10];
            sniperwouldvote = new int[10];
            for(int i=10;--i!=0;){
                sniperish[i] = true;
                sniperwouldvote[i] = 1;
            }
            sniperish[smrt]=false; //knows we are not the sniper
            return 1;
        }
        //figure out who isn't a sniper
        Vote opp_vote;
        int opp_smrt;
        Iterator<Vote> votes = getRecentVotes().iterator();
        while(votes.hasNext()){
            opp_vote = votes.next();
            opp_smrt = opp_vote.getVoter();
            if(opp_vote.getVoted() != sniperwouldvote[opp_smrt])
                sniperish[opp_smrt] = false;
        }
        //figure out how snipers would vote this round
        Iterator<Integer> opps = currentOpponents.iterator();
        int cnt_opp=0, min_opp=10, max_opp=0;
        int[] snpr_votes = new int[10];
        while(opps.hasNext()){
            opp_smrt = opps.next().intValue();
            if(smrt == opp_smrt) continue;
            sniperwouldvote[opp_smrt] = hypothetically(opp_smrt, currentOpponents);
            cnt_opp++;
            if(sniperish[opp_smrt]){
                snpr_votes[sniperwouldvote[opp_smrt]]++;
            }
            if(opp_smrt<min_opp) min_opp=opp_smrt;
            if(opp_smrt>max_opp) max_opp=opp_smrt;
        }
        for(int i = 1;i<10;i++){//hit the weakest sniper.
            if(sniperish[i] && currentOpponents.contains(i))
                return i;
        }
        return hypothetically(smrt, currentOpponents);
    }

    private int hypothetically(int smrt, Set<Integer> currentOpponents) {
        Iterator<Integer> opps = currentOpponents.iterator();
        int cnt_smrt=0, cnt_stpd=0, opp_smrt, min_stpd=10, max_smrt=0;
        while(opps.hasNext()){
            opp_smrt = opps.next().intValue();
            if(opp_smrt > smrt){
                cnt_smrt++;
                if(opp_smrt > max_smrt) max_smrt = opp_smrt;
            }
            else if(opp_smrt < smrt){
                cnt_stpd++;
                if(opp_smrt < min_stpd) min_stpd = opp_smrt;
            }
        }
        if(cnt_stpd>1) return min_stpd;
        return max_smrt;
    }
}

Ngẫu nhiên

public class RandomPlayer extends Player{

    @Override
    public int vote(Set<Integer> currentOpponents) {
        return (int) currentOpponents.toArray()[getRandom().nextInt(currentOpponents.size())];
    }
}

MinPlayer

Một Elitist. Thích loại bỏ bất cứ ai có trí thông minh thấp.

public class MinPlayer extends Player {

    @Override
    public int vote(Set<Integer> currentOpponents) {
        return Collections.min(currentOpponents);
    }
}

Báo thù

Điều này bắt đầu như một thứ mà tôi nghĩ là ban đầu được gọi StupidBuffering(một cái tên mà tôi ghét phải từ bỏ), sau đó cuối cùng chỉ là một PrudentSniper, người không quan tâm nếu anh ta bị nhắm đến. Đây dường như cũng là lý do duy nhất anh ta không thể đánh bại PrudentSniper, vì vậy tôi đã điều chỉnh mọi thứ xung quanh một chút để làm cho anh ta tập trung.

Bây giờ, đây về cơ bản là một tay bắn tỉa, nhưng nếu bot thông minh nhất hoặc ngu ngốc nhất nhắm vào anh ta, anh ta sẽ nhắm mục tiêu bất cứ ai có nhiều phiếu bầu nhất vòng trước. Nếu cả hai đều có cùng số phiếu và cả hai đều nhắm vào anh ta, anh ta sẽ quay lại hành vi bắn tỉa bình thường. Trong các thử nghiệm của tôi, đôi khi thực tế đánh bại PrudentSniper.

package WeakestLink.Players;

import java.util.*;

import WeakestLink.Game.Vote;

public class VengefulSniper extends Player{
    @Override
    public int vote(Set<Integer> currentOpponents) {
        int me = getSmartness();
        int smartOpp = Collections.max(currentOpponents);
        int dumbOpp = Collections.min(currentOpponents);
        int votesAgainstSmart=0, votesAgainstDumb=0;
        Boolean targetedBySmart = false, targetedByDumb = false;

        Set<Vote> votesForMe = getRecentVotes();
        Iterator<Vote> votes = votesForMe.iterator();
        while(votes.hasNext()){
            Vote vote = votes.next();
            int voter = vote.getVoter();
            int voted = vote.getVoted();

            if(voted == me){
                if(voter == smartOpp){
                    targetedBySmart = true;
                }
                if(voter == dumbOpp){
                    targetedByDumb = true;
                }
            } else if (voted == smartOpp){
                votesAgainstSmart++;
            } else if (voted == dumbOpp){
                votesAgainstDumb++;
            }
        }

        // If being targeted by smartest or dumbest, take them out
        // Try to go with the rest of the crowd if they both targeted me
        if(targetedBySmart ^ targetedByDumb){
            return targetedBySmart ? smartOpp : dumbOpp;
        } else if (targetedBySmart && targetedByDumb){
            if (votesAgainstSmart > votesAgainstDumb){
                return smartOpp;
            } else if (votesAgainstDumb > votesAgainstSmart){
                return dumbOpp;
            }
        }

        Iterator<Integer> opps = currentOpponents.iterator();
        int cnt_stpd=0;
        while(opps.hasNext()){
            int opp_smrt = opps.next().intValue();
            if(opp_smrt < me){
                cnt_stpd++;
            }
        }

        if (cnt_stpd < 2 || (currentOpponents.size() < 4)){ //buffer is small, protect myself
            return smartOpp;
        } else {
            return dumbOpp;
        }
    }
}

Trung sĩ

MiddleMan cố gắng hết sức để tối đa hóa lợi nhuận trong khi vẫn cảnh giác rằng anh ta không bị cắt khỏi trò chơi. Anh ấy giữ các thí sinh ít hơn để cải thiện cơ hội lọt vào vòng tiếp theo (và để lại một kết thúc dễ dàng). Anh ta sẽ bỏ phiếu cho ai đó thông minh hơn anh ta nếu có nhiều thí sinh thông minh hơn so với những thí sinh kém hơn. Bất cứ ai trong hai nhóm, anh ta luôn bỏ phiếu cho nhóm thấp nhất trong nhóm để giữ cho nồi trèo.

package WeakestLink.Players;
import java.util.Collections;
import java.util.Iterator;
import java.util.Set;
public class MiddleMan extends Player {
    @Override
    public int vote(Set<Integer> currentOpponents) {
        int smrt = getSmartness();

        //count number of players smarter/stupider than me
        Iterator<Integer> opps = currentOpponents.iterator();
        int cnt_smrt=0, cnt_stpd=0, opp_smrt, min_stpd=9, min_smrt=9;

        while(opps.hasNext()){
            opp_smrt = opps.next().intValue();
            if(opp_smrt > smrt){
                cnt_smrt++;
                if(opp_smrt < min_smrt) min_smrt = opp_smrt;
            }
            else if(opp_smrt < smrt){
                cnt_stpd++;
                if(opp_smrt < min_stpd) min_stpd = opp_smrt;
            }
        }

        //Keep myself in the middle of the pack, favoring the point earners
        if(cnt_stpd>cnt_smrt)
            return min_stpd;
        else
            return min_smrt;
    }
}

PS hy vọng nó biên dịch, tôi không phải là một người Java.

Có kế hoạch này trong tâm trí trước khi đọc các mục khác. Sau đó, tôi đã rất ngạc nhiên khi Sniper gần (nhưng cực kỳ khác biệt) nên tôi đã tiếp tục và sử dụng nó như một điểm xuất phát kể từ khi tôi không biết cú pháp Java. Cảm ơn @Linus

Xấp xỉ

Bot này đang cố gắng bắn khoảng các giá trị thông minh bị thiếu, giả sử rằng nhóm sẽ tiếp tục với cùng một mẫu, nghĩa là nó sẽ nhắm mục tiêu cùng loại mục tiêu. Nó luôn bầu chọn cho người chơi thông minh nhất trong hai người chơi khi có sự lựa chọn.

Lâu rồi tôi không sử dụng Java và hiện đang làm việc nên ... Không thể kiểm tra được, hy vọng nó không quá lỗi, vui lòng nhẹ nhàng :).

Nhân tiện, nó chỉ sử dụng awt.point vì tôi quá lười để thực hiện một tuple n_n.

package WeakestLink.Players;
import WeakestLink.Game.Vote;

import java.util.*;
import java.awt.Point;

public class ApproximatePosition extends Player
{

    @Override
    public int vote(Set<Integer> currentOpponent)
    {
        List<Integer> present = new ArrayList<>(currentOpponent);
        List<Integer> emptyPosition = new ArrayList<Integer>();
        Collections.sort(present);

        //If it is the first round, vote for the smartest buddy
        if(present.size()==8)
            return present.get(present.size()-1);


        int lastCheck=present.get(0);
        if(lastCheck>0)
            for(int i=0;i<lastCheck;i++)
                if(i!=getSmartness()&&!emptyPosition.contains(i))
                    emptyPosition.add(i);
        for(int i=1;i<present.size();i++)
        {
            if(present.get(i)-lastCheck>1)
                for (int j=lastCheck+1;j<present.get(i);j++)
                    if(j!=getSmartness()&&!emptyPosition.contains(j))
                        emptyPosition.add(j);
            lastCheck=present.get(i);
        }
        //untill there's at least 3 excluded members, we continue with this behaviour
        if(emptyPosition.size()<=2)
        {
            if(emptyPosition.isEmpty()) return present.get(present.size()-1);
            return decide(emptyPosition.get(0),present.get(present.size()-1),present.get(0),present);
        }

        Point maxRangeOfBlank=new Point(present.get(present.size()-1),present.get(present.size()-1));
        for (int i=0;i<emptyPosition.size()-1;i++)
            if(emptyPosition.get(i+1)-emptyPosition.get(i)==1)
            {
                int size=0;
                while(i+size+1<emptyPosition.size() && emptyPosition.get(i+size+1)-emptyPosition.get(i+size)==1)
                    size++;
                if(size>=sizeOfRange(maxRangeOfBlank))
                    maxRangeOfBlank=new Point(emptyPosition.get(i),emptyPosition.get(size));
                i+=size;
            }

        return decide(maxRangeOfBlank,present.get(present.size()-1),present.get(0),present);
    }

    private int decide(int blankSeat, int smartest,int dumbest,List<Integer> present)
    {
        return decide(new Point(blankSeat,blankSeat),smartest,dumbest,present);
    }

    private int decide(Point rangeBlankSeat, int smartest,int dumbest,List<Integer> present)
    {
        int target= smartest;
        if (rangeBlankSeat.getY()==smartest||((int)rangeBlankSeat.getY()+1)==getSmartness()){
            if ((rangeBlankSeat.getX()==dumbest||(int)rangeBlankSeat.getX()-1==getSmartness())){
                target= smartest; //should not happen
            } else {
                target= (int) rangeBlankSeat.getX()-1; //Vote for dumber than the missing
            }
        } else {
            target= (int) rangeBlankSeat.getY() +1; //Vote for smarter than the missing, default comportment
        }
        if(present.contains(target))
            return target;
        return smartest;
    }
    //Return the number of consecutive values between X and Y (included)
    private int sizeOfRange(Point range)
    {
        return (int)(range.getY()-range.getX())+1;
    }

}

Bắn tỉa

Trước khi thêm PrudentSniper, tôi đã viết một bot để giúp Sniper đánh bại AntiExtremist và các gian lận khác (tôi sử dụng từ này với tình yêu). Bot, SniperAide, tìm kiếm những người chơi bỏ phiếu như lính bắn tỉa và bỏ phiếu vì họ nghĩ họ sẽ làm thế khi có sự đồng ý. Nếu tất cả người chơi trông giống như những tay súng bắn tỉa mà anh ta bầu cho tối đa, bảo vệ những xạ thủ thấp hơn (người cũng sẽ chuyển sang tối đa tại thời điểm này), ngay cả khi đó là chính anh ta.

Mã :

package WeakestLink.Players;
import WeakestLink.Game.Vote;
import java.util.Collections;
import java.util.Iterator;
import java.util.Set;

public class SniperAide extends Player {
    boolean[] sniperish;
    int[] sniperwouldvote;

    @Override
    public int vote(Set<Integer> currentOpponents) {
        int smrt = getSmartness();
        if(sniperish==null){
            sniperish = new boolean[10];
            sniperwouldvote = new int[10];
            for(int i=10;--i!=0;){
                sniperish[i] = true;
                sniperwouldvote[i] = 1;
            }
            sniperish[smrt]=false; //knows we are not the sniper
            return 1;
        }
        //figure out who might isn't a sniper
        Vote opp_vote;
        int opp_smrt;
        Iterator<Vote> votes = getRecentVotes().iterator();
        while(votes.hasNext()){
            opp_vote = votes.next();
            opp_smrt = opp_vote.getVoter();
            if(opp_vote.getVoted() != sniperwouldvote[opp_smrt])
                sniperish[opp_smrt] = false;
        }
        //include ourself in the simulation of other snipers.
        currentOpponents.add(smrt);
        //figure out how snipers would vote this round
        Iterator<Integer> opps = currentOpponents.iterator();
        int cnt_snpr=0, cnt_opp=0, min_opp=10, max_opp=0;
        int[] snpr_votes = new int[10];
        while(opps.hasNext()){
            opp_smrt = opps.next().intValue();
            if(smrt == opp_smrt) continue;
            sniperwouldvote[opp_smrt] = hypothetically(opp_smrt, currentOpponents);
            cnt_opp++;
            if(sniperish[opp_smrt]){
                cnt_snpr++;
                snpr_votes[sniperwouldvote[opp_smrt]]++;
            }
            if(opp_smrt<min_opp) min_opp=opp_smrt;
            if(opp_smrt>max_opp) max_opp=opp_smrt;
        }
        //figure out how to vote in sniper's intrest when not identified
        if(cnt_snpr == cnt_opp)
            return max_opp;
        if(cnt_snpr == 0)
            return hypothetically(smrt, currentOpponents);
        //if multiple hypothetical snipers only vote how they agree
        int onlyvote = -1;
        for(int i=10; --i!=0;){
            if(onlyvote>0 && snpr_votes[i]!=0) onlyvote=-2;
            if(onlyvote==-1 && snpr_votes[i]!=0) onlyvote=i;
        }
        if(onlyvote>0) return onlyvote;
        return max_opp;
    }

    private int hypothetically(int smrt, Set<Integer> currentOpponents) {
        Iterator<Integer> opps = currentOpponents.iterator();
        int cnt_smrt=0, cnt_stpd=0, opp_smrt, min_stpd=10, max_smrt=0;
        while(opps.hasNext()){
            opp_smrt = opps.next().intValue();
            if(opp_smrt > smrt){
                cnt_smrt++;
                if(opp_smrt > max_smrt) max_smrt = opp_smrt;
            }
            else if(opp_smrt < smrt){
                cnt_stpd++;
                if(opp_smrt < min_stpd) min_stpd = opp_smrt;
            }
        }
        if(cnt_stpd>1) return min_stpd;
        return max_smrt;
    }
}

Anh ta hiện không giúp được gì nhiều cho PrudentSniper.

HighOrLowNotSelf

Loại bỏ ngẫu nhiên người chơi thông minh thấp nhất hoặc cao nhất (nhưng không tự).

public class HighOrLowNotSelf extends Player{
    @Override
    public int vote(Set<Integer> ops) {
        int b=Math.round(Math.random()*1);
        int p;
        if(b==1) p=Collections.max(ops) else p=Collections.min(ops);
        if(p==getSmartness()) {
            return vote(ops);
        }
        return p;
    }
}

Người vô chính phủ

Người vô chính phủ không thích chế độ.
Người vô chính phủ sẽ cố gắng giết tổng thống hiện tại.
Nếu người vô chính phủ là tổng thống, anh ta quyết định lạm dụng quyền lực của mình và giết những viên thuốc vô dụng. Trừ khi anh ta bị nhắm đến bởi một trong những người thấp kém của mình, vì họ nên đốt cháy thay thế.

package WeakestLink.Players;

import WeakestLink.Game.Vote;

import java.util.LinkedList;
import java.util.Set;

public class Anarchist extends Player {

    LinkedList<Integer> opponents;

    @Override
    public int vote(Set<Integer> currentOpponents) {
        opponents = new LinkedList();
        opponents.addAll(currentOpponents);
        opponents.sort(Integer::compare);

        int me = getSmartness();

        if (getPresident() != me) {
            return getPresident();
        } else {
            // treason ?
            Vote voteForMe = getRecentVotes().stream().filter(v -> v.getVoted() == me).findAny().orElse(null);
            if (voteForMe == null) {
                // No treason ! Hurray. Kill the peagants.
                return getPeagant();
            } else {
                // TREASON!
                return opponents.get(opponents.indexOf(voteForMe.getVoter()));
            }
        }
    }

    private int getPresident() {
        return opponents.getLast();
    }

    private int getPeagant() {
        return opponents.getFirst();
    }

}

Độc lậpVoter

Bot này biết rằng dân số nói chung luôn luôn sai! Vì vậy, nó bỏ phiếu cho bất cứ ai nhận được ít phiếu nhất.

Mã gần giống với "Bandwagon" của SolarAaron, nhưng logic cuối được lật.

package WeakestLink.Players;

import WeakestLink.Game.Vote;
import java.util.Map;
import java.util.Set;

/**
 * Votes for the currently lest voted bot in the game.
 * Or the lowest one.
 */
public class IndependentVoter
        extends Player {

    @Override
    public int vote(Set<Integer> currentOpponents) {
        int self = getSmartness(), vote = -1;
        java.util.Map<Integer, Integer> votes = new java.util.TreeMap<>();
        getVotingHistory().stream().map((Vote v)-> v.getVoted()).filter((Integer i)-> !i.equals(self)).forEach((Integer tgt)-> {
            if(!votes.containsKey(tgt)) {
                votes.put(tgt, 1);
            } else {
                votes.put(tgt, votes.get(tgt) + 1);
            }
        });

        do {
            if(votes.entrySet().isEmpty()) {
                vote = currentOpponents.stream().filter((Integer i)-> !i.equals(self)).sorted().findFirst().get();
            } else {
                if(votes.containsKey(vote)) {
                    votes.remove(vote);
                    vote = -1;
                }

                for(Map.Entry<Integer, Integer> vv: votes.entrySet()) {
                    Integer key = vv.getKey();
                    Integer value = vv.getValue();

                    if((vote == -1) || (value < votes.get(vote))) {
                        vote = key;
                    }
                }
            }
        } while(!currentOpponents.contains(vote));

        return vote;
    }
}