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

@ সিএসᵠ সঠিক আপনার স্মার্টনেসটি রাউন্ড থেকে রাউন্ডে পরিবর্তিত হয় (এটি অন্যথায় অন্যায় হবে)।

— নাথান মেরিল

2

মানসিক চাপ এবং আনন্দ হতে হবে

— CSᵠ

1

আমার কি পিপড়া বিল্ড কনফিগার বা এরকম কিছু আশা করা উচিত? আমি জাভাতে নতুন মাত্রা, এবং আমি নিশ্চিত না যে লোকেরা সাধারণত এই জাতীয় প্রকল্পগুলি কীভাবে সেটআপ করে।

— ডেল জনসন

4

ভিতরে থেকে src\WeakestLinkআমি javac Game\*.java Players\*.java Main.javaসংকলন এবং java -cp .. WeakestLink.Mainচালানোর জন্য ব্যবহৃত ।

— লিনাস

22

স্নাইপার

পয়েন্টগুলি স্নাইপ করার জন্য সাধারণ ধারণাটি হ'ল মূ .় খেলোয়াড়দের মধ্যে একজনকে (অর্থাৎ আমরা মুখোমুখি হতে পারি beat এরপরে আমরা পাত্র বাড়ানোর জন্য অন্যান্য নিম্ন-মানের খেলোয়াড়কে সরিয়ে দেওয়ার চেষ্টা করি। তবে আমরা যখন বুদ্ধিমান খেলোয়াড়দের কাছে পৌঁছে যাই তখন আমাদের বোকা খেলোয়াড় অপসারণের ক্ষেত্রে আমরা সবচেয়ে বিপজ্জনক খেলোয়াড়দের অপসারণের বিকল্পটি বেছে নিয়েছি । সেভাবে যদি আমাদের কাছে স্নাইপ করার কেউ না থাকে তবে আমাদের কমপক্ষে কাউকে সুযোগ দেওয়া উচিত least এছাড়াও, যেহেতু আমরা সর্বদা একটি ন্যূনতম বা সর্বোচ্চ প্লেয়ারের সাথে ভোট দিয়ে থাকি, আমি আশা করি আমরা আমাদের উপায় অর্জনে মোটামুটি কার্যকর।

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
সূত্র

আমি নিশ্চিত না যে উভয় অগ্রগতি সমান মূল্যবান। আপনি কি তাদের প্রত্যেককে আলাদাভাবে চেষ্টা করেছেন?

— লিনাস

আমি করেছি, এবং তিনটি বটের ক্ষেত্রে একটি দ্ব্যর্থহীন উন্নতি হয়েছে (কমপক্ষে বর্তমানে রেপোতে মাস্টার থাকা বটদের বিরুদ্ধে), প্রতিশোধ নেটেটি নেট সম্পর্কে। আমি এটিকে এক ধরণের অস্পষ্ট প্রতিরোধকারী, ঘাতকদের বিরুদ্ধে সতর্কতা হিসাবে রেখে এসেছি।

— হিস্টোক্র্যাট

প্রাসঙ্গিক;)

— কনার ও'ব্রায়েন

আমি সম্প্রতি একটি বাগ ঠিক করেছি যেখানে স্মার্টনেস 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

আমি কন্ট্রোলার কোডটি আপডেট করেছি যাতে এলোমেলো পরিবর্তনশীল স্থির থাকে (এবং গেম.র্যান্ডমের মাধ্যমে অ্যাক্সেস করা যায়)। আমি গিথুবে

— নাথান মেরিল

1

@ নাথানম্যারিল ধন্যবাদ, তবে আমি যদি এই আগ্রহের পক্ষে ভোট দেয় এমন অজ্ঞাত-সদস্যদের জন্য আমি যদি ধর্মীয় সম্প্রদায়টিকে আরও সহিষ্ণুতার (চিত্রের দিকে) যেতে দিই তবে আমি আরও ভাল ফলাফল পাব বলে মনে হচ্ছে।

— লিনাস

@ অ্যাগবার, পরামর্শের জন্য ধন্যবাদ। এটি সম্ভবত ক্ল্যাক্টকে আরও ভাল একমাত্র খেলোয়াড় হিসাবে পরিণত করবে, তবে যতক্ষণ না এর সংখ্যা রয়েছে ততক্ষণ পাত্রটি চালানোর চেষ্টা করা উচিত। আমি মনে করি আমার নতুন সংস্করণ উভয় বিশ্বের সেরা।

— লিনাস

2

দ্য কাল্ট আমাকে অনুরোধ করার জন্য অনুরোধ জানিয়েছিল যে unusedPlayers.addAll(allPlayers);গেম.জভাতে প্রায় নয় বার নকল করা উচিত, যাতে সমস্ত খেলোয়াড় বিভিন্ন ধরণের (যেমন একাধিক ডেকে কার্ড একসাথে বদলে ফেলার মতো) ঘটতে পারে ... অবশ্যই তা নয়, এটি সম্পূর্ণ পক্ষপাতদুষ্ট অনুরোধ কিন্তু টিম ভিত্তিক কৌশলটি কীভাবে শক্তিশালী হতে পারে তা দেখতে আকর্ষণীয় এটি যদি তাদের একসাথে থাকার খুব সামান্য সুযোগও থাকে।

— লিনাস

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
সূত্র

আমি এই বোটটি কাজে লাগাতে পারিনি। আমি বেশ কয়েকটি বাগ স্থির করেছি এবং এটি এখন অস্তিত্বহীন খেলোয়াড়ের পক্ষে ভোট দিচ্ছে। যে পরিবর্তনটি আমি নিশ্চিত ছিলাম তা সঠিক ছিল কিনা তা ছিল "সর্বশেষ_মোহিত_ভোট" সংজ্ঞায়িত করা হয়নি, তাই আমি এটিকে "সর্বশেষ_ভোট_ইগেইনস্ট" হিসাবে পরিবর্তন করেছি। আপনি আমার পরিবর্তনগুলি এখানে পেতে পারেন: github.com/nathanmerrill/WeakestLink/blob/master/src/…

— নাথন মেরিল

@ নাথানমারিল এই কোডটি আমার ধারণা থেকে আরও খারাপ ছিল। এখন যেহেতু আমি এটি পরীক্ষা করতে পারি, আমি উভয় সংস্করণটি দেখব এবং এটি কাজ করার চেষ্টা করব।

— স্নোরিংফ্রোগ

@ নাথানমারিল একটি দু'টি বিষয় খুঁজে পেয়েছেন। যথা, আমি এমন খেলোয়াড়দের উপেক্ষা করিনি যাঁরা খুঁজে পাননি যে কখনও বটের পক্ষে ভোট দেয়নি, এ কারণেই তারা সর্বদা তাদের পক্ষে ভোট দেওয়ার চেষ্টা করেছিল। এক পর্যায়ে সূচক পেতে ভুল তালিকাও ব্যবহার করা হয়েছিল, ফলস্বরূপ প্লেয়ারকে -1ভোট দেওয়া হয়। তবে এটি এখনই ঠিক করা উচিত।

— স্নোরিংফ্রোগ

1

ঠিক আছে, এটি কাজ করে তবে ভয়ানক কাজ করে। র্যান্ডম খেলোয়াড়কে মারধর করার জন্য অভিনন্দন!

— নাথান মেরিল

1

@ নাথানমারিল কখনও কখনও

— স্নোরিংফ্রোগ

6

জনপ্রি়তার গাড়ি

ভোটিংয়ে জনসমাগম অনুসরণ করে, যদি না তাকে লক্ষ্য করা হয় being

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 ছিল। এটি আপনার কোডটি ভেঙে ফেলেছে

— নাথান মেরিল

আমার কোডের জন্য আপনার নাটকে @ নাথানমিরিল একটি ছোট বাগ দিয়েছে। আমি আমার কোডটি আরও ভাল করার জন্য সম্পাদনা করেছি।

— মেগাটম

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ᵠ
সূত্র

আমি বুঝতে পারছি না কেন এই প্লেয়ারটি বিশ্রাম / বিদ্রূপের চেয়ে কেন মাঝারি

— নাথান মেরিল

নাথনমিরিল দেখুন, সে বন্দুক পেয়েছে! আমি যদি আপনি থাকতাম তবে আমি আমার শব্দগুলি সাবধানে বেছে নেব ...

— CSᵠ

10

@ সিএসᵠ আমি উদ্বিগ্ন নই যখন তিনি গড় খেলোয়াড় হন, তখন সে নিজের উপর বন্দুকটি ব্যবহার করে।

— কুইন্টোপিয়া

14

এই প্লেয়ারটি তার চেয়ে কম গড়পড়তা। তিনি গড় থেকে বেশি মধ্যম বলে মনে হয়।

— ইয়াক

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
সূত্র

আমি এখনকার (দ্রুত পরীক্ষার জন্য) বর্তমান রান 10 কে রাখছি। আমি যখন চূড়ান্তভাবে দৌড়াদৌড়ি করি তখন আমি সম্ভবত এটি আরও বড় করব make

— নাথান মেরিল

আমি আপনাকে কোনওরকম অভিযোগ করার চেষ্টা করছি না, তবে স্নাইপার যেভাবে সময়টি 99.7% ডলার করে দেবে, এটি মূলত কে জিতবে সে সম্পর্কে মূলত এটি একটি মুদ্রার ফ্লিপ হতে চলেছে, যেহেতু তারা একই কৌশলটির এত নিকটবর্তী।

— লিনাস

কোথা থেকে আপনি এই পরিসংখ্যান পেয়েছেন? আমি স্বীকার করি যে এটির একটি অর্ধ-অনুরূপ কৌশল রয়েছে তবে আমার লক্ষ্য ছিল আপনার মতো সহজ কিছুকে উন্নত করার চেষ্টা করা যাদের পক্ষে আমার চেয়ে উল্লেখযোগ্য বুদ্ধিমান তারা যদি খুব স্মার্ট হয় তাদের পক্ষে ভোট দেওয়ার মাধ্যমে (ওরফে আমি জয়ের সম্ভাবনা নই) পট যদি তারা বেঁচে থাকে)

— csga5000

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

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

— অ্যাডিসন ক্রম্প

আমি মনে করি এটি একটি বাগ আছে। Math.abs(enemyIntel - selfIntel) < closestIntelহওয়া উচিত Math.abs(enemyIntel - selfIntel) < Math.abs(closestIntel - selfIntel)।

— মেগাটম

@ মেগা টম আমি মনে করি আপনি ঠিক বলেছেন। আমার জাভা পাওয়া গেলে আমি এটি আরও পরীক্ষা করে দেখব। সম্ভাব্য ধরার জন্য ধন্যবাদ!

— কনর ওব্রায়েন

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
সূত্র

আপনি আমার আইডিই নকল কোড সম্পর্কে অভিযোগ করেছেন!

— নাথান মেরিল

@ নাথানমিরিল কপি-পাস্তা আক্রমণ! নোট আমি পোস্ট করার পর থেকে ক্লাসের নাম পরিবর্তন করেছি। যেহেতু আমি মনে করি যে আপনি কারওর বিরুদ্ধে যেতে পারবেন না তা নিশ্চিত করার জন্য অন্য কারও শ্রেণির নাম নকল করা নিয়মের চেতনাবিরোধী।

— ইয়াক

2

আমার কাজ নির্মমভাবে চুরি করার জন্য, বা কমপক্ষে স্বীকার করার জন্য ধন্যবাদ।

— লিনাস

2

@ লিনাস আপনাকে স্বাগতম! অনুকরণটি সেরা চাটুকারিতা, আমি আশা করি।

— ইয়াক

2

@ csga5000 স্পষ্টতই চুরি করা ছিল তার রসিকতা, এবং আমি কেবল খেলছিলাম। যে কোনও অর্ধ-সক্ষম কোডার (যেমন আমি নিজে) লুপটি একইভাবে লিখতাম, তাই তিনি যা করেছিলেন তা সবই আমার পরিবর্তনশীল নামগুলি চুরি করছিল। আমি যদি তাদের কপিরাইট করতে ভেবে থাকতাম তবে আমি রয়্যালটি নিতে পারি; )

— লিনাস

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

— নাথান মেরিল

@ নাথনম্যারিল আপনাকে ধন্যবাদ :)

— 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/…

— নাথান মেরিল

@ নাথানম্যারিল আমি আমার উত্তরে সংশোধিত কোডটি সম্পাদনা করেছি যাতে যে কেউ এখানে এটি দেখছে তা আসলে কী চলছে তা দেখুন

— স্নোরিংফ্রোগ

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" ইত্যাদি মুদ্রণের জন্য এটি পরিবর্তন করার পরামর্শ দেব

— স্কাইলার

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

জোঁক

সবচেয়ে বুদ্ধিমান ও বোবা ছেলেদের ভোট দেওয়ার জন্য অন্যান্য বটগুলির উপর নির্ভর করে .. সাজানো of

তিনি মাঝখানে কোথাও ঘুরে এসে অবশেষে বিজয়ীর সাথে পাত্রটি বিভক্ত করে সন্তুষ্ট (যেহেতু তিনি আসলেই সত্যই একটি শালীন ~~ছেলে~~ বট)।

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

লিনাসের কোড থেকে নির্লজ্জভাবে চুরি হয়ে গেছে আরও একটি উত্তর । এটি একজন সমস্ত স্নাইপারকে হত্যা করবে, তাদের রক্ষা করবে না। যদি এটি জেনে থাকে যে কোনও স্নিপার নেই it তবে এটি নিজেই একজন স্নিপারের মতো কাজ করবে।

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

আমি ধারণাটি পছন্দ করি তবে এখানে ন্যূনতম বা সর্বাধিক প্লেয়ারের পক্ষে ভোট দেওয়ার সংস্কৃতি রয়েছে বলে মনে হয়। অন্য কাউকে ভোট দেওয়া আপনার ভোট দূরে ফেলতে পারে । অন্যের পক্ষে ভোট দেওয়ার আগে আপনি যদি সর্বাধিক স্নাইপারিশ হন কিনা তা পরীক্ষা করে দেখেন আপনি কিছুটা ধরতে পারবেন ... (আমি ফোনে চেক করতে পারছি না)

— লিনাস

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 যারা যদি তিনি লক্ষ্যবস্তু হচ্ছে গ্রাহ্য করা হয়নি হচ্ছে শেষ পর্যন্ত। এটি প্রুডেন্টস্নিপারকে পরাজিত করতে না পারার একমাত্র কারণ বলে মনে হয়েছিল, তাই আমি তার ফোকাসটি তৈরি করার জন্য কিছুটা জিনিস টুইকে করেছি।

এখন, এটি মূলত একটি স্নিপার, তবে যদি সবচেয়ে স্মার্ট বা বোকা বট তাকে টার্গেট করে তবে তিনি সর্বশেষ রাউন্ডে সবচেয়ে বেশি ভোট পেয়ে যাকেই লক্ষ্যবস্তু করবেন। যদি তারা উভয়ই সমান সংখ্যক ভোট পেয়ে এবং উভয়ই তাকে লক্ষ্যবস্তু করে তোলে, তবে তিনি স্বাভাবিক স্নিপার-ওয়াই আচরণে ফিরে যান। আমার পরীক্ষাগুলিতে, এই প্রকৃত প্রুডেন্টস্নিপারকে উপলক্ষে ats

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

আপনার কোড পরীক্ষা করুন। আপনি জানেন না এমন ভাষাগুলিতে উত্তর লেখার চেষ্টা করবেন না

— তানমাথ

@ ট্যানম্যাথ - আপনার ইনপুটটির জন্য ধন্যবাদ। সি / জাভা-জাতীয় ভাষায় আমার অনেক অভিজ্ঞতা রয়েছে, তবে জাভা নির্দিষ্টভাবে নয়, তাই আমি যথেষ্ট আত্মবিশ্বাসী যে আমার কোডটি আসলে সঠিক এবং কার্যকর হবে will বলা হচ্ছে, যদি এতে কোনও ত্রুটি থাকে এবং এটি চালিত না হয় তবে গেম মাস্টার যদি প্রবেশকে অযোগ্য ঘোষণা করে তবে আমি ক্ষুব্ধ হব না।

— tbernard

তুমি ঠিক বলছো. ধন্যবাদ লিনাস সম্পাদনা করা হয়েছে।

— tbernard

1

@ টিবারনার্ড আমি বাগগুলি ঠিক করতে পেরে আনন্দিত, তবে আপনার কোডটিতে কোনও কিছুই নেই :)

— নাথান মেরিল

সেকি। আমি যেমন আশা করছিলাম তেমনি করিনি। আমি যদিও স্নিপারকে সাহায্য করতে দেখেছি বলে মনে হয়েছিল, তাই এটি আমার ধারণা হাহা।

— tbernard

2

ApproximatePosition

এই বটটি প্রায় অনুপস্থিত স্মার্টনেস মানগুলির আশেপাশে শ্যুটিং করার চেষ্টা করছে, ধরে নিচ্ছে যে গ্রুপটি একই ধাঁচের সাথে চলবে, যার অর্থ এটি একই ধরণের লক্ষ্যকে লক্ষ্য করবে target যখন কোনও বিকল্প থাকে তখন সর্বদা দু'জন প্লেয়ারের মধ্যে সবচেয়ে স্মার্টকে ভোট দেয়।

অনেক দিন আমি জাভা ব্যবহার করিনি, এবং বর্তমানে কর্মক্ষেত্রে তাই ... এটি পরীক্ষা করতে পারছি না, আশা করি এটি খুব বগি নয়, দয়া করে সৌম্য হোন :)।

যাইহোক, এটি কেবল ডাব্লু পয়েন্ট ব্যবহার করে কারণ আমি একটি টিপল এন_এন বাস্তবায়নে খুব অলস।

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
সূত্র

সুতরাং, কিছু বাগ ছিল। :) প্রথমত, দুর্ভাগ্যক্রমে, পূর্ণসংখ্যা [] কাস্ট কাজ করে না, এটি একটি অবজেক্ট [] কাস্ট হতে হবে (যা আমি পছন্দ করি না)। সুতরাং আমি এগুলিকে অ্যারের পরিবর্তে একটি অ্যারেলিস্টে আবৃত করেছি। দ্বিতীয়ত, এই লাইন: emptyPosition[emptyPosition.length]=j;সর্বদা আপনাকে সীমা ছাড়িয়ে অ্যারে দেবে। অবশেষে, কেন তা নিশ্চিত নয় তবে আপনি রাউন্ডে নেই এমন খেলোয়াড়দের ভোট দেবেন।

— নাথান মেরিল

ওহ, এছাড়াও, আপনার টেরিনারি ব্লকটি int এর পরিবর্তে দ্বিগুণ ফিরছিল, এবং দুর্দান্ত সংশ্লেষিত হয়েছিল, আমি / অন্যথায় এটি মানকে পরিণত করেছি। আপনি আমার সমস্ত পরিবর্তন গিথুব এ

— নাথান মেরিল

@ নাথানমারিল ওয়াও, অনেক ধন্যবাদ এর জন্য emptyPosition[emptyPosition.length], এটি বোবা ভুল কারণ দৈর্ঘ্য সর্বদা সর্বশেষ সূচকের চেয়ে এক over পরিবর্তনের জন্য ধন্যবাদ, আমি এটি সংশোধন করতে এই নতুন সংস্করণটি ব্যবহার করব। টেরিনারি ব্লক সম্পর্কে ... হ্যাঁ, এটি ব্যবহার করার মতো অনুভূত হয়েছিল এবং সম্ভবত নিজের পক্ষে লেখার অভ্যাসও আমার অনুমানের মতো পড়ার পক্ষে সহজ ছিল না। সংশোধনগুলি করা এবং এটি আপডেট করা।

— কাটেনকিও

2

SniperAide

যোগে আগে PrudentSniper আমি একটি বট লিখেছিলেন সাহায্য করার জন্য স্নাইপার বীট AntiExtremist এবং অন্যান্য জালিয়াতি (আমি ভালবাসা দিয়ে শব্দ ব্যবহার করুন)। বট, স্নিপারএইড এমন খেলোয়াড়দের সন্ধান করে যারা স্নিপার এবং ভোটের মতো ভোট দেয় বলে মনে করে যে তারা যখন sensক্যমত্য হয় তখন তারা তা করবে। যদি সমস্ত খেলোয়াড় স্নাইপারগুলির মতো দেখায় তবে তিনি সর্বাধিক পক্ষে ভোট দেন, নিম্ন স্নিপারগুলিকে রক্ষা করেন (যারা এই সময়ে সর্বোচ্চটিতে স্যুইচও করবেন), এমনকি যদি তা নিজেই হয়।

কোড :

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

@ সিএসগা ৫০০০, যেহেতু আপনি ভোটাধিকার রেকর্ডের মাধ্যমে স্নাইপারকে খুব কমই সনাক্ত করতে পারেন এটি এখন তাদের সমস্ত কিছুটা রক্ষা করে। তবে কোনও পার্থক্য পরিষ্কার হয়ে গেলে এটি সর্বদা স্নিপারগুলির আগ্রহে কাজ করে, তাই এটি বেশিরভাগ ক্ষেত্রে টাই-ব্রেকার er জয়ের উপর ফোকাস হ'ল ম্যাক্রোস্কোপিক গেমস, স্বতন্ত্র রাউন্ড নয়, বেশিরভাগ রাউন্ডে এটি মুদ্রা-উল্টাপাল্টা পরিস্থিতি বজায় রাখার চেয়ে আরও কিছু করতে পারে না।

— লিনাস

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
সূত্র

সুতরাং, এই জমা দেওয়ার সাথে বেশ কয়েকটি বাগ রয়েছে। প্রথমত, ম্যাথ.াউন্ড () ফেরত দেয় long, না int। দ্বিতীয়ত, opsনিজেকে ধারণ করে না। (আপনি যদি নিজের পক্ষে ভোট দিতে চান তবে আপনাকে এটি স্পষ্টভাবে অন্তর্ভুক্ত করতে হবে)। অবশেষে, যদি / অন্য আপনি অন্তর্ভুক্ত করেন তবে তা জাভা নয়। আমি আপনার কোডটি ঠিক করে রেখেছি এবং এটি গিথুবে

— নাথান মেরিল

1

নৈরাজ্যবাদী

নৈরাজ্যবাদীরা সরকারকে পছন্দ করে না like
নৈরাজ্যবাদী বর্তমান রাষ্ট্রপতিকে হত্যা করার চেষ্টা করবে।
যদি নৈরাজ্যবাদী রাষ্ট্রপতি হন, তবে তিনি তার ক্ষমতার অপব্যবহার এবং অকেজো পেজেন্টকে মেরে ফেলার সিদ্ধান্ত নেন। যদি না তাকে তাঁর নিকৃষ্টতর একজনের দ্বারা নিশানা করা হয় তবে তাদের পরিবর্তে তাদের জ্বলতে হবে।

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