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

• หากผู้เล่นคนอื่นฉลาดกว่าคุณแสดงว่าคุณมีโอกาสน้อยที่จะได้เงินกองกลาง
• หากผู้เล่นคนอื่นงี่เง่ากว่าคุณแล้วคุณมีหม้อน้อยกว่าที่จะได้รับ

ในตอนเริ่มต้นของแต่ละรอบพ็อตจะเริ่มต้นด้วย $ 0 กลุ่มผู้เล่น 9 คนถูกสร้างขึ้นและผู้เล่นแต่ละคนจะได้รับความเก่งกาจไม่ซ้ำใครจาก 1 ถึง 9

ในช่วงเริ่มต้นของการหมุนแต่ละรอบPot += Smartnessสำหรับผู้เล่นแต่ละคนยังอยู่ในรอบ จากนั้นผู้เล่นลงคะแนนให้ผู้เล่นที่ต้องการลบ ผู้เล่นที่โหวตมากที่สุดจะถูกลบ ในกรณีที่เสมอกันผู้เล่นที่ฉลาดขึ้นจะถูกเก็บไว้

เมื่อมีผู้เล่นเหลือเพียง 2 คนในรอบพวกเขาจะเผชิญหน้ากับการต่อสู้ด้วยปัญญา Smartness/(Smartness+OpponentSmartness)โอกาสของผู้เล่นที่ชนะคือ ผู้เล่นที่ชนะจะได้รับเงินกองกลางทั้งหมด

ผู้เล่นที่ได้รับเงินมากที่สุดเมื่อจบเกมชนะ

อินพุต / เอาต์พุต

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

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

รอบ 9 จะทำซ้ำจนกว่าผู้เล่นทุกคนจะเล่นอย่างน้อย1,000 10,000 รอบและผู้เล่นทุกคนจะเล่นในจำนวนรอบเดียวกัน

คุณสามารถค้นหาคอนโทรลเลอร์ได้ที่นี่: https://github.com/nathanmerrill/WeakestLink

ในการสร้างผู้เล่นคุณจะต้องขยายคลาสผู้เล่นและเพิ่มผู้เล่นของคุณในคลาส PlayerFactory ชั้นเรียนของคุณจะต้องปฏิบัติตามกฎต่อไปนี้:

1. การสื่อสารหรือการรบกวนกับผู้เล่นคนอื่น ๆ (รวมถึงผู้เล่นอื่นของคุณประเภทเดียวกัน) เป็นสิ่งต้องห้ามอย่างเคร่งครัด

2. ไม่อนุญาตให้ใช้การสะท้อนและตัวแปรแบบคงที่ (ยกเว้นค่าคงที่)

3. หากคุณต้องการใช้การสุ่มฉันได้จัดเตรียมgetRandom()ฟังก์ชั่นในคลาสผู้เล่น ใช้มันดังนั้นการจำลองสามารถกำหนดได้

ฉันมีฟังก์ชั่นมากมายในคลาสผู้เล่นเพื่อให้เข้าถึงข้อมูลได้ง่าย คุณสามารถค้นหาได้ออนไลน์บน Github ผู้เล่นของคุณจะถูกยกตัวอย่างแต่ละรอบใหม่ อนุญาตผู้เล่น "ใบ้ / ฆ่าตัวตาย" (แต่ไม่ใช่ผู้เล่นที่ใช้กลยุทธ์เดียวกัน)

คะแนน

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

นกปากซ่อม

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

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แต่มีสองกรณีพฤติกรรมพิเศษ หนึ่งคือว่าถ้ามีบอทสามตัวที่เหลือและ PrudentSniper นั้นฉลาดที่สุดมันจะลงคะแนนให้บอทกลางแทนสมาร์ทตัวน้อยที่สุด วิธีนี้ช่วยให้ชนะการประลองอีกสองสามครั้ง พฤติกรรมอื่น ๆ ก็คือถ้าบอทที่ฉลาดที่สุดกำลังยิงมัน (โหวตให้มันหรือบอทที่คล้ายคลึงกันในครั้งที่แล้ว) และสมาร์ทตัวที่น้อยที่สุดก็ไม่ได้

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

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

รูปแบบการลงคะแนนอย่างรวดเร็ว:

• ในการลงคะแนนเสียงรอบแรกสำหรับผู้แข่งขันที่อ่อนแอที่สุดการทำงานร่วมกับ min & sniper ช่วยให้ลัทธิได้รับอำนาจ
• ในการเปลี่ยนครั้งต่อไปจะลงคะแนนจากผู้ที่ไม่ได้เป็นสมาชิกจนกว่าจะมีเพียงลัทธิเท่านั้น
• เมื่อมีสมาชิกเหลืออยู่เท่านั้นให้ลงคะแนนจากสมาชิกที่มีค่าต่ำสำหรับคะแนน (เสียสละตัวเองเพื่อประโยชน์ของลัทธิ)

รหัส:

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

ความคิดสุดท้าย:

ตอนนี้ลัทธิเปลี่ยนไปเป็นการลงคะแนนให้กับผู้เล่นที่อันตรายที่สุดเมื่อมีสมาชิกลัทธิเหลืออยู่เพียงสองคนหรือน้อยกว่าสำหรับการเผชิญหน้า ผมทดสอบหลายครั้งด้วยcult_cnt>1และcult_cnt>2เงื่อนไขและชนะต่อมาบ่อยขึ้น

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

BridgeBurner

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

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

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

bandwagon

ติดตามฝูงชนในการลงคะแนนเว้นแต่เขาจะเป็นเป้าหมาย

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

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

การใช้คุณสมบัติ java 8 เพราะเกมต้องการให้ทำงานต่อไป

RevengePlayer

บอทนี้จะลงคะแนนให้ใครก็ตามที่โหวตให้เขาบ่อยครั้งที่สุด tiebreaker เป็นผู้เล่นที่ฉลาดที่สุด ทฤษฎีคือผู้เล่นที่โหวตให้คุณในอดีตมีแนวโน้มที่จะลงคะแนนให้คุณอีกครั้ง

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

MeanPlayer

โหวตทั้งผู้โง่และผู้เล่นที่ฉลาดที่สุดและเขาก็ถือปืน

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

AntiExtremist

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

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;

    }

}

หมายเหตุ:ตาม Linus สิ่งนี้จะลงคะแนนเสียงเหมือนกับ sniper โดยส่วนใหญ่ (525602: 1228)

สอดแนม

สงวนไว้ซึ่ง Spy เขาไม่ชอบที่จะยิงเพื่อคนที่ฉลาดที่สุด ในทำนองเดียวกันเขาไม่ชอบการเลือกในquartataโง่ที่พึ่ง ดังนั้นเขาชอบที่จะกำจัดคนที่ใกล้ชิดกับเขาด้วยความฉลาด

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

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

MedianPlayer

ผู้เล่นคนนี้พยายามที่จะเป็นคนที่ต่ำต้อยที่สุด

มันออกเสียงลงคะแนนเพื่อกำจัดฝ่ายตรงข้ามที่ฉลาดและโง่เง่า (มีอคติเล็กน้อยต่อการลงคะแนนที่ฉลาดที่สุด) ขึ้นอยู่กับว่ามีมากขึ้นหรือน้อยลง / ฉลาดกว่าพวกเขาเอง

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

เฟรมเวิร์กที่ถูกขโมยโจ๋งครึ่มจาก @Linus ด้านบน

คนขี้ขลาดตาขาว

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;

  }
}

เพียงแค่ไม่ต้องการลงคะแนนดังนั้นคะแนนสำหรับคู่ต่อสู้ที่คล้ายกันกับผู้เล่นที่ลงคะแนนในรอบสุดท้ายเพื่อเพิ่มโอกาสในการอยู่ในทีมที่ชนะ

ไม่ได้ทำอย่างดีตอนนี้ แต่อาจรวมไว้ในการผสม

พระเอก

โหวตคนที่เลือกผู้อ่อนแอ ... หรือทำให้เขารำคาญ

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

ผมบ๊อบ

บ๊อบเป็นคนธรรมดาที่คิดว่าเขาฉลาดกว่าเขาก็จริง ๆ ไม่สามารถชนะตระกูลสไนเปอร์ได้ แต่ติด 5 อันดับแรกในการจำลองของฉันเกือบตลอดเวลา

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

เลือกเป้าหมายแบบสุ่มจากนั้นลงคะแนนให้พวกเขาจนกว่าพวกเขาจะไป จะไม่ลงคะแนนให้ตัวเอง

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

สถิติ

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

เมื่อต้องการทำสิ่งนี้ให้เพิ่มบรรทัดต่อไปนี้เพื่อRound.javaให้ด้านบนของไฟล์มีลักษณะดังนี้:

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

...

จากนั้นแก้ไขวิธีการลงคะแนนให้มีลักษณะดังนี้:

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

ตัวอย่างผลลัพธ์:

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

ความรู้ทั้งหมด ชอบที่จะลบใครด้วยสติปัญญาสูง (ซึ่งสามารถท้าทายสติปัญญาที่ไม่มีใครเทียบของเขา)

public class MaxPlayer extends Player{

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

ยาม

โหวตคนที่เลือกความแข็งแกร่ง ... หรือคนที่ทำให้เขารำคาญ

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

ปลิง

อาศัยบอทคนอื่น ๆ เพื่อโหวตคนที่ฉลาดและโง่ที่สุดออกมา ..

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

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

SniperKiller

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

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

RandomPlayer

public class RandomPlayer extends Player{

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

MinPlayer

คนชั้นนำ ชอบลบใครที่มีสติปัญญาต่ำ

public class MinPlayer extends Player {

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

VengefulSniper

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

ทีนี้นี่เป็นสไนเปอร์ แต่ถ้าบอทที่ฉลาดหรือโง่เขลาเป็นเป้าหมายเขาจะกำหนดเป้าหมายใดก็ตามที่ได้รับคะแนนมากที่สุดในรอบสุดท้าย หากพวกเขาทั้งสองได้รับคะแนนเสียงเท่ากันและทั้งคู่กำหนดเป้าหมายเขาเขาก็กลับไปที่พฤติกรรมการซุ่มยิงตามปกติ ในการทดสอบของฉัน 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;
        }
    }
}

คนกลาง

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

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 หวังว่ามันจะรวบรวมฉันไม่ใช่คนชวา

มีแผนการนี้ในใจก่อนที่จะอ่านรายการอื่น ๆ จากนั้นฉันก็ประหลาดใจว่าSniper (แต่แตกต่างกันอย่างมาก) ฉันจึงไปข้างหน้าและใช้มันเป็นจุดกระโดดเพราะฉันไม่รู้ไวยากรณ์ของจาวา ขอบคุณ @Linus

ApproximatePosition

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

นานมาแล้วที่ฉันไม่ได้ใช้ Java และตอนนี้ทำงานอยู่ ... ไม่สามารถทดสอบได้หวังว่ามันจะไม่เป็นรถเกินไปโปรดอ่อนโยน :)

โดยวิธีการใช้ awt.Point เพียงเพราะฉันขี้เกียจเกินกว่าที่จะใช้ 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;
    }

}

SniperAide

ก่อนที่จะเพิ่มPrudentSniperฉันได้เขียนบอทเพื่อช่วยSniperเอาชนะAntiExtremistและการหลอกลวงอื่น ๆ(ฉันใช้คำด้วยความรัก) บอท SniperAide ค้นหาผู้เล่นที่ลงคะแนนเหมือนพลซุ่มยิงและลงคะแนนเพราะคิดว่าพวกเขาจะทำเมื่อมีการยินยอม หากผู้เล่นทุกคนดูเหมือนสไนเปอร์เขาลงคะแนนให้สูงสุดปกป้องสไนเปอร์ที่ต่ำกว่า (ใครจะสลับไปสูงสุดในตอนนี้) แม้ว่ามันจะเป็นตัวเขาเองก็ตาม

รหัส :

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

ปัจจุบันเขาไม่ได้ช่วย PrudentSniper มากนัก

HighOrLowNotSelf

ลบผู้เล่นข่าวกรองขั้นต่ำหรือสูงสุดแบบสุ่ม (แต่ไม่ใช่ตัวเอง)

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

ผู้นิยมอนาธิปไตย

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

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

}

IndependentVoter

บอทนี้รู้ว่าประชากรทั่วไปผิดเสมอ! ดังนั้นคะแนนสำหรับผู้ที่ได้รับคะแนนน้อยที่สุด

โค้ดใกล้เคียงกับ "Bandwagon" ของ SolarAaron แต่ตรรกะสิ้นสุดถูกพลิก

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