50

इस राजा की पहाड़ी चुनौती, गेम शो, कमजोर कड़ी पर आधारित है । इस शो से अपरिचित लोगों के लिए, इस चुनौती का क्रेज यह है कि आप किसे वोट देते हैं :

यदि अन्य खिलाड़ी आपसे अधिक स्मार्ट हैं, तो आपके पास पॉट होने की संभावना कम है।
यदि अन्य खिलाड़ी आपसे कमतर हैं, तो आपके पास पाने के लिए एक बर्तन कम है।

प्रत्येक दौर की शुरुआत में, पॉट $ 0 से शुरू होता है। 9 खिलाड़ियों का एक समूह बनता है, और प्रत्येक खिलाड़ी को 1 से 9 तक एक अद्वितीय स्मार्टनेस दी जाती है ।

Pot += Smartnessप्रत्येक दौर की शुरुआत में, प्रत्येक खिलाड़ी अभी भी दौर में। फिर, खिलाड़ी उस खिलाड़ी पर वोट देते हैं जिसे वे हटाना चाहते हैं। सबसे अधिक वोट वाले खिलाड़ी को हटा दिया जाता है। एक टाई के मामले में, होशियार खिलाड़ी को रखा जाता है।

जब राउंड में केवल 2 खिलाड़ी बचे होते हैं, तो वे एक युद्ध में हार का सामना करते हैं। जीतने वाले खिलाड़ी का मौका होता है Smartness/(Smartness+OpponentSmartness)। विजेता खिलाड़ी फिर पूरे बर्तन प्राप्त करता है।

खेल के अंत में सबसे अधिक पैसा पाने वाले खिलाड़ी की जीत होती है।

इनपुट आउटपुट

प्रत्येक मोड़ पर, आपको विरोधियों की वर्तमान सूची प्राप्त होगी। आप खिलाड़ी वर्ग में कार्यों के माध्यम से राउंड के लिए अपने स्मार्टनेस और सभी खिलाड़ियों के संपूर्ण मतदान इतिहास तक पहुंच पाएंगे ।

आउटपुट के रूप में, आपको एक पूर्णांक वापस करना होगा, जिस खिलाड़ी को आप वोट देना चाहते हैं उसका प्रतिनिधित्व करना (उनकी स्मार्टनेस का प्रतिनिधित्व करना)। अपने लिए मतदान करने की अनुमति है (लेकिन अनुशंसित नहीं)।

9 के राउंड तब तक दोहराए जाएंगे जब तक सभी खिलाड़ी कम से कम ~~1000~~ 10000 राउंड नहीं खेल चुके हों, और सभी खिलाड़ी एक ही राउंड में खेले हों।

आप यहां नियंत्रक पा सकते हैं: https://github.com/nathanmerrill/WeakestLink

एक खिलाड़ी बनाने के लिए, आपको प्लेयर वर्ग का विस्तार करने की आवश्यकता है, और अपने खिलाड़ी को प्लेयरफैक्टरी वर्ग में जोड़ें। आपकी कक्षा को निम्नलिखित नियमों का पालन करना चाहिए:

किसी अन्य खिलाड़ी के साथ संचार या हस्तक्षेप (उसी प्रकार के अपने अन्य खिलाड़ियों को शामिल करना) सख्त वर्जित है।
प्रतिबिंब और स्थिर चर (स्थिरांक को छोड़कर) की अनुमति नहीं है।
यदि आप यादृच्छिकता का उपयोग करना चाहते हैं, तो मैंने getRandom()प्लेयर वर्ग में एक फ़ंक्शन प्रदान किया है । इसका उपयोग करें, इसलिए सिमुलेशन निर्धारक हो सकते हैं।

मैंने डेटा की आसान पहुंच के लिए प्लेयर वर्ग में कई कार्य प्रदान किए हैं। आप उन्हें जीथब पर ऑनलाइन पा सकते हैं । आपके खिलाड़ी को प्रत्येक नए दौर में त्वरित किया जाएगा। "गूंगा / आत्मघाती" खिलाड़ियों को अनुमति दी जाती है (लेकिन एक ही रणनीति वाले खिलाड़ी नहीं)।

स्कोर

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

king-of-the-hill java

— नाथन मेरिल
स्रोत

1

इसे प्राप्त न करें: "प्रत्येक दौर की शुरुआत में ... 9 खिलाड़ियों का एक समूह बनता है, और प्रत्येक खिलाड़ी को एक अद्वितीय स्मार्टनेस दी जाती है" खेल शुरू होने के समय नहीं?

— सीएस

1

@ CS @ सही है। आपकी स्मार्टनेस राउंड से राउंड में बदल जाती है (यह अनुचित होगा अन्यथा)।

— नाथन मेरिल

2

तनाव और आनंद होना चाहिए

— CSᵠ

1

क्या मुझे चींटी बिल्ड कॉन्फिग या कुछ ऐसे की उम्मीद करनी चाहिए? मैं जावा में नया हूं, और मुझे यकीन नहीं है कि लोग आमतौर पर इस तरह की छोटी परियोजनाएं कैसे स्थापित करते हैं।

— डेल जॉनसन

4

भीतर से src\WeakestLinkमैं javac Game\*.java Players\*.java Main.javaसंकलन करता था और java -cp .. WeakestLink.Mainचलाता था।

— लाइनस

22

निशानची

सामान्य विचार यह है कि बेवकूफ खिलाड़ियों में से एक के आसपास रखना है (यानी हम चेहरे में हरा करने की अधिक संभावना है) अंक के लिए स्निप करने के लिए। उसके बाद हम बर्तन को उठाने के लिए अन्य कम-मूल्य वाले खिलाड़ियों को निकालने का प्रयास करते हैं। लेकिन जब हम बुद्धिमान खिलाड़ियों को प्राप्त करते हैं तो हम सबसे खतरनाक लोगों को हटाने का विकल्प चुनते हैं, जब हमारा बेवकूफ खिलाड़ी हटा दिया जाता है। इस तरह से अगर हमारे पास कोई नहीं है तो हमें उस व्यक्ति को हासिल करना चाहिए जिसे हम कम से कम एक मौका देना चाहते हैं। इसके अलावा, चूंकि हम हमेशा किसी ना किसी मंत्री या अधिकतम खिलाड़ी के साथ मतदान करते हैं, मुझे उम्मीद है कि हम अपना रास्ता पाने में काफी प्रभावी हैं।

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

— लीनुस
स्रोत

तो जाहिरा तौर पर रोलबैक संपादन को नहीं हटाता है। यदि संभव हो तो मैं किसी भी संपादन को हटा देना चाहता हूं ताकि यह स्पष्ट रूप से स्पष्ट हो सके कि यह मूल संस्करण है।

— लीनुस

12

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

— histocrat
स्रोत

मुझे यकीन नहीं है कि दोनों उन्नति समान मूल्य की हैं। क्या आपने उन्हें अलग से आज़माया है?

— लिनस

मैंने किया था, और जबकि तीन बॉट का मामला एक अस्पष्ट सुधार है (कम से कम रेपो पर वर्तमान में मास्टर के बॉट के खिलाफ), प्रतिशोध नेट पर, तटस्थ के बारे में है। मैंने इसे एक तरह के अस्पष्ट निवारक, हत्यारों के खिलाफ एहतियात के रूप में छोड़ दिया।

— हिस्टोक्रेट 22

प्रासंगिक;)

— कॉनर ओ'ब्रायन

मैंने हाल ही में एक बग तय किया था, जहां 1-9 के बजाय स्मार्टनेस 0-8 थी। इससे आपका कोड टूट गया, इसलिए मैंने इसे ठीक कर दिया (आप रिपॉजिटरी पर अपडेटेड कोड पा सकते हैं): github.com/nathanmerrill/WeakestLink/blob/master/src/…

— नाथन मेरिल

12

धारा

पंथ के खिलाड़ियों के पास एक मामूली गूढ़ मतदान योजना है जिसके द्वारा वे एक दूसरे की पहचान करने और समूह के रूप में मतदान करने का प्रयास करते हैं, केवल मतदान रिकॉर्ड का उपयोग करते हुए। चूंकि पंथ के प्रत्येक सदस्य को पता है कि मतदान कैसे करना है, जो कोई भी अलग-अलग वोट देता है वह एक गैर-सदस्य के रूप में प्रकट होता है और अंततः उन्मूलन के लिए लक्षित होता है।

एक नज़र में मतदान योजना:

सबसे कमजोर प्रतियोगी के लिए पहली बारी वोट पर, न्यूनतम और स्नाइपर के साथ संगीत कार्यक्रम में काम करने से पंथ हासिल करने में मदद मिलती है
जब तक केवल ज्ञात रहता है तब तक ज्ञात गैर-सदस्यों को वोट देना बंद कर देता है (जब तक हम सोचते हैं कि हम नियंत्रण में हैं, तब तक अंक कम करने के लिए सबसे कम मूल्य वाले गैर-सदस्य को वोट देते हैं)।
जब केवल सदस्य बने रहें, तो कम-मूल्य वाले सदस्यों को अंकों के लिए वोट दें (वास्तव में पंथ की भलाई के लिए अपने आप को बलिदान कर रहे हैं)।

कोड:

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स्थितियों के साथ परीक्षण किया और बाद में अधिक बार जीता।

फिर भी, यह एक एहतियात है और पंथ वास्तव में अकेले खिलाड़ी के रूप में काम करने के लिए डिज़ाइन नहीं किया गया है, इसलिए नए खिलाड़ियों की संख्या बढ़ने के बाद भी पंथ को अंततः खोना चाहिए।

— लीनुस
स्रोत

क्या पहले सबसे स्मार्ट गैर-सदस्यों को वोट देना बेहतर नहीं होगा?

— agweber

मैंने कंट्रोलर कोड अपडेट किया है ताकि रैंडम वैरिएबल स्टैटिक हो (और Game.random के जरिए एक्सेस किया जा सके)। मैंने github पर कोड अपडेट करने की स्वतंत्रता भी ले ली है: github.com/nathanmerrill/WeakestLink/blob/master/src/…

— Nathan Merrill

1

@NathanMerrill धन्यवाद, लेकिन मैं बेहतर परिणाम प्राप्त करने के लिए लग रहा हूं अगर मैं पंथ को अधिक सहिष्णु (जाने का आंकड़ा) देता हूं, तो अज्ञात गैर-सदस्यों को जो ब्याज में वोट देते हैं।

— लाइनस

@agweber, सुझाव के लिए धन्यवाद। यह शायद thecult को एक बेहतर एकमात्र खिलाड़ी बनाता है, लेकिन जब तक इसके पास संख्याएँ होती हैं, इसे बर्तन को चलाने की कोशिश करनी चाहिए। मुझे लगता है कि मेरा नया संस्करण दोनों दुनिया के लिए सबसे अच्छा है।

— लाइनस

2

TheCult ने मुझसे यह अनुरोध करने के लिए कहा कि unusedPlayers.addAll(allPlayers);Game.java में लगभग नौ बार नकल की जाए, ताकि सभी खिलाड़ी विभिन्न बहुलता में हो सकें (जैसे कार्ड के कई डेक को एक साथ फेरबदल करना) ... नहीं, बिल्कुल नहीं, यह पूरी तरह से एक पक्षपाती अनुरोध है लेकिन यह देखना दिलचस्प है कि टीम आधारित रणनीति अभी भी कितनी शक्तिशाली हो सकती है अगर उनके पास एक साथ रखने का एक छोटा मौका है।

— लिनस

7

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

— SnoringFrog
स्रोत

मुझे यह बॉट काम करने में असमर्थ था। मैंने कई बगों को ठीक किया, और यह अब एक गैर-मौजूद खिलाड़ी के लिए मतदान कर रहा है। एक बदलाव मुझे यकीन नहीं था अगर यह सही था कि "last_round_vott" परिभाषित नहीं है, इसलिए मैंने इसे "last_voted_against" में बदल दिया। आप यहां मेरे परिवर्तन पा सकते हैं: github.com/nathanmerrill/WeakestLink/blob/master/src/…

— नाथन मेरिल

@NathanMerrill यह कोड स्पष्ट रूप से मेरे विचार से भी बदतर था। अब जब मैं इसका परीक्षण कर सकता हूं, तो मैं दोनों संस्करणों को देखूंगा और इस कार्य को प्राप्त करने का प्रयास करूंगा।

— SnoringFrog

@NathanMerrill कुछ मुद्दों को मिला। अर्थात्, मैंने उन खिलाड़ियों को अनदेखा नहीं किया, जो इस बात में नहीं थे कि उन्होंने कभी भी बॉट के लिए मतदान नहीं किया, यही वजह है कि उन्होंने हमेशा उनके लिए वोट करने की कोशिश की। इसके अलावा एक सूची से एक सूचकांक प्राप्त करने के लिए गलत सूची का उपयोग किया जाता है, जिसके परिणामस्वरूप खिलाड़ी -1को वोट दिया जाता है। लेकिन इसे अब तय किया जाना चाहिए।

— SnoringFrog

1

ठीक है, यह काम करता है, लेकिन भयानक है। बेतरतीब खिलाड़ी की पिटाई पर बधाई!

— नाथन मेरिल

1

@NathanMerrill कभी

— SnoringFrog

6

गाड़ी में सवार

मतदान में भीड़ का अनुसरण करता है, जब तक कि वह लक्षित न हो।

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

मैं यह अनुमान लगा रहा हूं कि केवल स्निपर्स का पालन करके उन्हें मजबूत बनाया जाएगा, लेकिन पंथ और स्नाइपर-सहयोगियों द्वारा थोड़े प्रभावी तरीके से लक्षित होने से भी बचा जाता है। यह स्नाइपर हत्यारों के लिए एक मीटशील्ड हो सकता है या उनमें से अधिक होने पर उनकी सहायता कर सकता है। (नवीनतम अपडेट के साथ परीक्षण करने की आवश्यकता है)।

जावा 8 सुविधाओं का उपयोग करना क्योंकि खेल को वैसे भी चलाने की आवश्यकता है।

— SolarAaron
स्रोत

1

यह कुछ अच्छी तरह से लिखा कोड देखने के लिए अच्छा है :)

— नाथन मेरिल

6

RevengePlayer

यह बॉट उसे वोट देगा जिसने उसे सबसे अधिक बार वोट दिया, टाईब्रेकर सबसे चतुर खिलाड़ी है। सिद्धांत यह है कि एक खिलाड़ी जिसने आपको अतीत में वोट दिया था, वह आपको फिर से वोट देगा।

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

— MegaTom
स्रोत

मैंने हाल ही में एक बग तय किया था, जहां 1-9 के बजाय स्मार्टनेस 0-8 थी। इससे आपका कोड टूट गया, इसलिए मैंने इसे ठीक कर दिया (आप रिपॉजिटरी पर अपडेटेड कोड पा सकते हैं): github.com/nathanmerrill/WeakestLink/blob/master/src/…

— Nathan Merrill

मेरे कोड के लिए @NathanMerrill के पास एक छोटा सा बग था। मैंने इसे बेहतर बनाने के लिए अपना कोड संपादित किया।

— मेगाटॉम

5

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

— CSᵠ
स्रोत

मुझे समझ में नहीं आता है कि यह खिलाड़ी बाकी के मुकाबले किसी भी तरह का मतलबी क्यों है / व्यंग्य

— नाथन मेरिल

देखो @NathanMerrill, वह एक बंदूक है! मैं अपने शब्दों को ध्यान से चुनता अगर मैं तुम थे ...

— CS

10

@ CS @ मैं चिंतित नहीं हूं। जब वह औसत खिलाड़ी होता है, तो वह खुद पर बंदूक का इस्तेमाल करता है।

— क्विंटोपिया

14

यह खिलाड़ी जितना हो सकता है उससे कम का मतलब है। वह मतलबी से ज्यादा मंझली नजर आती है।

— Yakk

7

हाह .... मुझे एक मिनट लगा

— मोनिका

5

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;

    }

}

नोट: लीनस के अनुसार यह स्नाइपर समय के विशाल बहुमत (525602: 1228) के समान होगा।

— csga5000
स्रोत

मैं वर्तमान रन को 10K के लिए रखने जा रहा हूं (अब जल्दी परीक्षण के लिए)। जब मैं फाइनल रन करूंगा, तो मैं इसे बड़ा बनाऊंगा।

— नाथन मेरिल

मैं आप पर कुछ भी आरोप लगाने की कोशिश नहीं कर रहा हूँ, लेकिन इस तरह से स्निपर ~ 99.7% वोट देता है, यह मूल रूप से एक सिक्का फ्लिप होने वाला है जो जीतता है, क्योंकि वे एक ही रणनीति के बहुत करीब हैं।

— लीनुस

आपको वह आँकड़ा कहाँ से मिला? मैं मानता हूं कि यह एक अर्ध-समान रणनीति है, लेकिन मेरा लक्ष्य उन लोगों के लिए मतदान करने के लिए चुनने के रूप में कुछ के रूप में सरल रूप से बेहतर बनाने की कोशिश करना था, जो बहुत स्मार्ट हैं अगर वे मुझसे काफी चालाक हैं (उर्फ मैं जीतने की संभावना नहीं हूं। पॉट अगर वे जीवित रहते हैं)

— सीएसगा 5000

1

मैं अपनी कक्षा एक दिया static Sniper S = new Sniper()और static long agrees=0, disagrees=0;। आपकी वोटिंग पद्धति में मैं यह जोड़ता हूं S.setSmartness(getSmartness()); int sniper_answer=S.vote(currentOpponents);कि एक स्नाइपर आपकी स्थिति में कैसे मतदान करेगा, फिर अपना उत्तर एक चर में रखें ताकि यह गिना जाए कि वह सहमत है या उसका जवाब देने से पहले असहमत है। एक बार खेल खत्म होने के बाद आप सहमत हो सकते हैं: असहमत जो 525602: 1228 था।

— लिनस

1

@ लिनुस जो समझ में आता है, वह वैध लगता है। मैं उस बारे में एक नोट जोड़ूंगा।

— csga5000 21

5

जासूस

जासूसी आरक्षित है। वह सबसे चतुर लोगों के लिए बंदूक चलाना पसंद नहीं करता है। इसी तरह, वह ~~चौकड़ी~~ रक्षाहीन बेवकूफों को चुनना पसंद नहीं करता है । इसलिए, वह स्मार्टनेस में अपने सबसे करीबी लोगों को खत्म करना पसंद करता है।

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

आप सिर्फ बैकस्टैब, मेस एमिस रहे हैं । अगर वह जीत जाता है तो उसे कोई परवाह नहीं है। वह आपकी पीठ में चाकू की आवाज़ पसंद करता है क्योंकि वह आपको सफलतापूर्वक वोट देता है।

— कोनोर ओ ब्रायन
स्रोत

4

वह छवि, हालांकि। +1

— Addison Crump

मुझे लगता है कि यह एक बग है। Math.abs(enemyIntel - selfIntel) < closestIntelहोना चाहिए Math.abs(enemyIntel - selfIntel) < Math.abs(closestIntel - selfIntel)।

— मेगाटॉम

@MegaTom मुझे लगता है कि आप सही हैं। मैं इस पर आगे की जाँच करूंगा जब मेरे पास जावा उपलब्ध होगा। संभव पकड़ के लिए धन्यवाद!

— कोनोर ओ'ब्रायन

4

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

फ्रेमवर्क ऊपर से @ लिनुस से स्पष्ट रूप से चुराया गया।

— Yakk
स्रोत

आपने डुप्लिकेट कोड के बारे में मेरी आईडीई शिकायत की!

— नाथन मेरिल

@NathanMerrill कॉपी-पास्ता हमला! नोट मैंने पोस्ट करने के बाद से कक्षा का नाम बदल दिया है। जैसा कि मुझे लगता है कि यह सुनिश्चित करने के लिए कि आप उनके खिलाफ नहीं जा सकते, किसी और के वर्ग के नाम की नकल करना नियमों की भावना के खिलाफ होगा।

— यमक

2

कम से कम मेरा काम चुराने के लिए धन्यवाद, या कम से कम इतना स्वीकार करने के लिए।

— लाइनस

2

@Linus आपका स्वागत है! नकल सबसे अच्छी चापलूसी है, मुझे उम्मीद है।

— यक्ष

2

@ csga5000 blatantly चुराया गया उसका मज़ाक था, और मैं बस साथ खेल रहा था। कोई भी आधा सक्षम कोडर (जैसे खुद) लूप को उसी तरह लिखता है, इसलिए उसने वास्तव में मेरे चर नामों को चुरा लिया था। अगर मैंने उन्हें कॉपीराइट देने के बारे में सोचा होता तो शायद मैं रॉयल्टी वसूल सकता; )

— लिनस

4

डरपोक

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;

  }
}

सिर्फ विजेता को वोट देने की इच्छा नहीं है, इसलिए प्रतिद्वंद्वी के लिए सबसे अधिक वोट उसी खिलाड़ी को मिलते हैं जिसने विजेता टीम पर होने का मौका अधिकतम करने के लिए अंतिम दौर में वोट दिया।

अभी विशेष रूप से अच्छी तरह से नहीं करता है, लेकिन मिश्रण में फेंक सकता है।

— histocrat
स्रोत

मैंने हाल ही में एक बग तय किया था, जहां 1-9 के बजाय स्मार्टनेस 0-8 थी। इससे आपका कोड टूट गया, इसलिए मैंने इसे ठीक कर दिया (आप रिपॉजिटरी पर अपडेटेड कोड पा सकते हैं): github.com/nathanmerrill/WeakestLink/blob/master/src/…

— नाथन मेरिल

4

नायक

जो कमजोर पर उठाते हैं उन्हें वोट देते हैं ... या उसे गुस्सा दिलाते हैं।

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

— नंबर एक
स्रोत

मैंने हाल ही में एक बग तय किया था, जहां 1-9 के बजाय स्मार्टनेस 0-8 थी। इससे आपका कोड टूट गया, इसलिए मैंने इसे ठीक कर दिया (आप रिपॉजिटरी पर अपडेटेड कोड पा सकते हैं): github.com/nathanmerrill/WeakestLink/blob/master/src/…

— नाथन मेरिल

@NathanMerrill धन्यवाद :)

— TheNumberOne

4

बॉब

बॉब सिर्फ औसत आदमी है जो सोचता है कि वह होशियार है तो वह वास्तव में है। स्नाइपर परिवार को जीत नहीं सकते लेकिन मेरे सिमुलेशन में शीर्ष 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);
        }
    }



}

— Averroes
स्रोत

4

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

— SnoringFrog
स्रोत

यह कोड या तो काम नहीं करता था, लेकिन एक आसान फिक्स था। आपका ऐसा करते समय वास्तव में आवश्यक नहीं है, क्योंकि मैं आपको अपने स्मार्टनेस नहीं देता हूं जब मैं आपको अपने वर्तमान साथियों से गुजरता हूं। निश्चित कोड यहां पाया जा सकता है: github.com/nathanmerrill/WeakestLink/blob/master/src/…

— नाथन मेरिल

@NathanMerrill मैंने अपने उत्तर में सही कोड को संपादित किया, इसलिए किसी ने भी इसे यहाँ देख कर देखा कि वास्तव में क्या चल रहा है

— SnoringFrog

4

आंकड़े

यह प्रतियोगिता में प्रवेश नहीं है। यह एक खेल के उपयोगी आंकड़े प्राप्त करने का एक तरीका है। ये आंकड़े प्रतिशत की संभावना को प्रिंट करते हैं कि एक विशेष खिलाड़ी को एक दौर में वोट दिया जाएगा।

ऐसा करने के लिए निम्न पंक्तियों को जोड़ें 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

— नंबर एक
स्रोत

1

1 वें, 2 वें, 3 वें? मैं इसे "1 राउंड के लिए" आदि प्रिंट करने के लिए बदलने का सुझाव देता हूं

— Skyler

3

MaxPlayer

एक पता-यह सब। उच्च-बुद्धि वाले किसी को भी निकालना पसंद करता है (जो अपनी बेजोड़ बुद्धि को चुनौती दे सकता है)

public class MaxPlayer extends Player{

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

— नाथन मेरिल
स्रोत

3

रक्षक

उन लोगों को वोट दें जो मजबूत पर उठाते हैं ... या जो उन्हें परेशान करते हैं।

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

— नंबर एक
स्रोत

मैंने हाल ही में एक बग तय किया था, जहां 1-9 के बजाय स्मार्टनेस 0-8 थी। इससे आपका कोड टूट गया, इसलिए मैंने इसे ठीक कर दिया (आप रिपॉजिटरी पर अपडेटेड कोड पा सकते हैं): github.com/nathanmerrill/WeakestLink/blob/master/src/…

— नाथन मेरिल

3

जोंक

अन्य बॉट पर निर्भर होशियार और विनम्र लोगों को वोट देने के लिए।

वह बीच-बीच में कहीं पलट कर संतुष्ट हो जाता है और अंत में विजेता के साथ बर्तन का बंटवारा कर लेता है (क्योंकि वह वास्तव में एक सभ्य ~~लड़का है~~ )।

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

— sweerpotato
स्रोत

2

मुझे पसंद है। मुझे चिंता है कि यह अच्छा नहीं करेगा, क्योंकि बहुत से लोग आपको वोट नहीं देंगे। इस प्रतियोगिता के साथ एक दोष यह है कि यह मुझे लगता है कि अन्य बॉट आपको एक निश्चित प्रकार की रणनीति के अनुरूप होने के लिए मजबूर करते हैं।

— csga5000

3

हालांकि अभी भी मज़ा! जीतना सब कुछ नहीं है: ~)!

— स्वेरापॉटो

3

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

— MegaTom
स्रोत

1

मुझे यह विचार पसंद है, लेकिन इसमें न्यूनतम या अधिकतम खिलाड़ी को वोट देने की संस्कृति प्रतीत होती है। हो सकता है कि किसी और को वोट देने से आपका वोट दूर हो जाए । हो सकता है कि अगर आप जांच करें कि किसी और को वोट देने से पहले अधिकतम स्निपर है या नहीं, तो आप थोड़ा सा पकड़ लेंगे ... (मैं फोन पर जांच नहीं कर सकता)

— Linus

2

RandomPlayer

public class RandomPlayer extends Player{

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

— नाथन मेरिल
स्रोत

2

MinPlayer

एक एलीटिस्ट। कम बुद्धि वाले किसी को भी निकालना पसंद करता है।

public class MinPlayer extends Player {

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

— नाथन मेरिल
स्रोत

2

VengefulSniper

यह तब शुरू हुआ जब मैंने सोचा था कि मूल कहा जाता है StupidBuffering(एक नाम जिसे मुझे देने से नफरत है), फिर अंत में सिर्फ एक प्रुडेंटसपाइपर रहा जिसने ध्यान नहीं दिया कि वह लक्षित हो रहा है। यह भी एकमात्र कारण प्रतीत होता है कि वह प्रुडेंटस्नाइपर को हरा नहीं सकता था, इसलिए मैंने अपना ध्यान केंद्रित करने के लिए चीजों को थोड़ा घुमाया।

अब, यह मूल रूप से एक स्नाइपर है, लेकिन अगर सबसे चतुर या डंबल बॉट उसे निशाना बनाता है, तो वह अंतिम दौर में सबसे ज्यादा वोट पाने वाले को भी निशाना बनाएगा। यदि उन दोनों को समान संख्या में वोट मिले और दोनों ने उसे निशाना बनाया, तो वह सामान्य स्नाइपर-वाई व्यवहार पर वापस चला जाता है। मेरे परीक्षणों में, यह वास्तविक अवसर पर 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;
        }
    }
}

— SnoringFrog
स्रोत

2

बिचौलिया

मिडिलमैन की पूरी कोशिश रहती है कि वह खेल से कटे हुए न हो जाए। वह अगले दौर में (और एक आसान खत्म करने के लिए) बनाने के अपने मौके को बेहतर बनाने के लिए कम प्रतियोगियों के आसपास रहता है। वह अपने से ज्यादा स्मार्ट किसी को तभी वोट देगा जब उससे कम प्रतियोगी हों उससे ज्यादा होशियार प्रतियोगी हों। दो समूहों में से जो भी हो, वह पॉट पर चढ़ने के लिए हमेशा सबसे कम समूह को वोट देता है।

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 उम्मीद है कि यह संकलित है, मैं एक जावा लड़का नहीं हूं।

अन्य प्रविष्टियों को पढ़ने से पहले इस योजना को ध्यान में रखें। तब मैं आश्चर्यचकित था कि कैसे (लेकिन गंभीर रूप से अलग) स्निपर इतना था कि मैं आगे बढ़ गया और इसका इस्तेमाल एक कूदने वाले बिंदु के रूप में किया क्योंकि मुझे जावा सिंटैक्स पता नहीं है। धन्यवाद @ लिनुस

— tbernard
स्रोत

1

कृपया अपने कोड का परीक्षण करें। उन भाषाओं में उत्तर लिखने की कोशिश न करें जिन्हें आप नहीं जानते हैं

— TanMath

@ तन्माथ - आपके इनपुट के लिए धन्यवाद। मुझे सी / जावा जैसी भाषाओं में बहुत अनुभव है, हालांकि विशेष रूप से जावा नहीं है, इसलिए मुझे पूरा विश्वास है कि मेरा कोड वास्तव में सही है और काम करेगा। यह कहा जा रहा है, अगर इसमें कोई त्रुटि है और यह नहीं चलेगा तो मैं नाराज नहीं होऊंगा यदि गेम मास्टर प्रविष्टि को अयोग्य घोषित करता है।

— tbernard

आप सही हे। धन्यवाद @ लिनुस संपादित।

— tbernard 8

1

@tbernard बग को ठीक करने में मुझे खुशी हो रही है, लेकिन आपके कोड में कोई भी :) नहीं है

— नाथन मेरिल

आउच। के रूप में के रूप में अच्छी तरह से मैं उम्मीद नहीं किया था मैं हालांकि मदद करने के लिए बाहर निशानची लग रहा था, तो यह है कि मुझे लगता है कि कुछ है।

— tbernard 22

2

ApproximatePosition

यह बॉट लापता स्मार्टनेस मूल्यों के आसपास लगभग शूटिंग करने की कोशिश कर रहा है, यह मानते हुए कि समूह एक ही पैटर्न के साथ जारी रहेगा, अर्थात यह एक ही प्रकार के लक्ष्य को लक्षित करेगा। यह हमेशा दो खिलाड़ियों में से सबसे अच्छे खिलाड़ी के लिए मतदान करता है जब कोई विकल्प होता है।

लंबे समय तक मैंने जावा का उपयोग नहीं किया था, और वर्तमान में काम पर है ... इसका परीक्षण नहीं कर सकता, आशा है कि यह बहुत छोटी नहीं है, कृपया कोमल बनें :)।

वैसे, यह केवल ttle n_n को लागू करने के लिए बहुत आलसी होने के कारण awt.Point का उपयोग करता है।

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

}

— Katenkyo
स्रोत

तो, कुछ कीड़े थे। :) पहले, दुर्भाग्य से, Integer [] कास्ट काम नहीं करता है, यह एक ऑब्जेक्ट [] कास्ट (जो मुझे पसंद नहीं है) होना चाहिए। इसलिए मैंने इसे एक सरणी के बजाय एक ArrayList में लपेट दिया। दूसरे, यह पंक्ति: emptyPosition[emptyPosition.length]=j;हमेशा आपको सीमा से बाहर की ओर ले जाएगी। अंत में, निश्चित नहीं कि क्यों, लेकिन आप उन खिलाड़ियों को वोट देंगे जो गोल में नहीं हैं।

— नाथन मेरिल 13

ओह, इसके अलावा, आपका टर्नरी ब्लॉक इंट के बजाय एक डबल लौट रहा था, और सुपर दृढ़ था, मैंने इसे एक मानक में बदल दिया अगर और। आप Github पर मेरे सभी परिवर्तन पा सकते हैं: github.com/nathanmerrill/WeakestLink/blob/master/src/…

— नाथन मेरिल

@NathanMerrill वाह, बहुत बहुत धन्यवाद। इसके लिए emptyPosition[emptyPosition.length], यह एक गंभीर गलती है क्योंकि लंबाई हमेशा एक अंतिम इंडेक्स ^ ^ से अधिक होती है। परिवर्तनों के लिए धन्यवाद, मैं इसे सही करने के लिए इस नए संस्करण का उपयोग करूंगा। टेनरी ब्लॉक के बारे में ... हाँ, इसे इस्तेमाल करने का मन किया, और शायद इस तरह से अपने लिए लिखने का भी इस्तेमाल किया, मुझे लगता है कि पढ़ना आसान नहीं था। सुधार करना और उसे अपडेट करना।

— काटेन्केओ डिक 2'15

2

SniperAide

PrudentSniper के जुड़ने से पहले मैंने एक बॉट को लिखा था कि निशानची को AntiExtremist और अन्य धोखाधड़ी (मैं प्यार से शब्द का उपयोग करता हूं) को हरा सकता हूं। बॉट, स्नाइपरएड, ऐसे खिलाड़ियों की तलाश करता है जो स्नाइपर्स की तरह वोट देते हैं और वोट देते हैं क्योंकि उन्हें लगता है कि जब वे एक कंसेंटस होंगे। यदि सभी खिलाड़ी स्निपर्स की तरह दिखते हैं तो वे अधिकतम के लिए वोट करते हैं, निचले स्नाइपर्स की रक्षा करते हैं (जो इस बिंदु पर अधिकतम पर भी स्विच करेंगे), भले ही वह खुद हो।

कोड :

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

वर्तमान में वह प्रुडेंटसेंपर के खिलाफ ज्यादा मददगार नहीं है।

— लीनुस
स्रोत

आपके विवरण और सिद्धांत के आधार पर मैं नहीं देखता कि यह कैसे किसी स्नाइपर की मदद करेगा जैसे कि बॉट किसी भी अन्य स्नाइपर को हरा देता है .. अगर कुछ भी नहीं होगा तो यह सभी स्निपर्स की रक्षा करेगा? क्षमा करें, आपके पास आपके कोड को खोदने के लिए अधिक समय नहीं है और वास्तव में इसे अपने लिए समझें।

— csga5000 21

@ csga5000, चूंकि आप शायद ही रिकॉर्ड रिकॉर्ड करके स्निपर की पहचान कर सकते हैं, इसलिए यह उन सभी की थोड़ी बहुत रक्षा करता है। लेकिन जब एक अंतर स्पष्ट होता है तो यह हमेशा स्नाइपर्स के हित में काम करता है, इसलिए यह ज्यादातर एक प्रकार का टाई-ब्रेकर होता है। जीतने पर ध्यान केंद्रित मैक्रोस्कोपिक गेम है, न कि व्यक्तिगत राउंड, अधिकांश राउंड में यह वास्तव में सिक्का-फ्लिप स्थिति को बनाए रखने से ज्यादा कुछ नहीं कर सकता है।

— लाइनस

1

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

— username.ak
स्रोत

तो, इस सबमिशन के साथ कुछ बग हैं। सबसे पहले, Math.round () रिटर्न a long, नहीं int। दूसरे, opsअपने आप को सम्‍मिलित नहीं करता है। (यदि आप अपने लिए मतदान करना चाहते हैं, तो आपको स्पष्ट रूप से इसे शामिल करना होगा)। अंत में, यदि आपने शामिल किया है तो मान्य जावा नहीं है। मैंने आपका कोड तय कर दिया है, और इसे

— नाथन मेरिल

1

अराजकतावादी

अराजकतावादी शासनों को पसंद नहीं करता है।
अराजकतावादी वर्तमान राष्ट्रपति को मारने की कोशिश करेगा।
यदि अराजकतावादी राष्ट्रपति है, तो वह अपनी शक्ति का दुरुपयोग करने और बेकार मोरों को मारने का फैसला करता है। जब तक कि वह अपने एक अवर द्वारा लक्षित नहीं किया गया था, क्योंकि उन्हें इसके बजाय जलना चाहिए।

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

}

— बैसड्रॉब कंबरवुबवबब
स्रोत

1

IndependentVoter

यह बॉट जानता है कि सामान्य आबादी हमेशा गलत होती है! तो यह वोट के लिए जो कोई भी कम से कम वोट मिल रहा है।

कोड सोलरएरॉन के "बैंडवागन" के लिए लगभग समान है, लेकिन अंतिम तर्क फ़्लिप है।

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

— MegaTom
स्रोत

आप कमजोर कड़ी हैं, अलविदा

इनपुट आउटपुट

स्कोर

निशानची

PrudentSniper

धारा

BridgeBurner

गाड़ी में सवार

RevengePlayer

MeanPlayer

AntiExtremist

जासूस

MedianPlayer

डरपोक

नायक

बॉब

FixatedPlayer

आंकड़े

MaxPlayer

रक्षक

जोंक

SniperKiller

RandomPlayer

MinPlayer

VengefulSniper

बिचौलिया

ApproximatePosition

SniperAide

HighOrLowNotSelf

अराजकतावादी

IndependentVoter