Ở Hoàng gia Trung Quốc, các cấp bậc trong xã hội không được quyết định bởi sự sinh ra hay sự giàu có, mà bởi khả năng của một người vượt trội trong các kỳ thi Hoàng gia. Ngọc Hoàng, người cai trị thiêng liêng của thiên đàng, đã kêu gọi tất cả các đối tượng của mình được kiểm tra để xác định giá trị của họ, và ai sẽ là người ban cho Thần ủy cai trị Trung Quốc.

Các quy tắc của bộ máy quan liêu:

• Bộ máy quan liêu thiêng liêng bao gồm các cấp bậc không có giá trị nguyên âm, bắt đầu bằng 0. Mỗi thành viên (bot) của bộ máy quan liêu thuộc về một cấp bậc. Mỗi cấp bậc có thể chứa nhiều thành viên tùy ý, nhưng không thể để trống trừ khi tất cả các cấp trên đều trống
• Khi bắt đầu trò chơi, tất cả các thành viên có thứ hạng 0
• Mỗi lượt, mỗi thành viên của bộ máy quan liêu phải trả lời một bài kiểm tra. Bài kiểm tra bao gồm đoán chính xác các giá trị boolean của một danh sách. Độ dài của danh sách là số thứ hạng trên thành viên.
• Các đề thi được chuẩn bị bởi một thành viên ngẫu nhiên của thứ hạng trên. Thành viên của thứ hạng cao nhất nhận được câu hỏi của họ trực tiếp từ JadeEmperor(xem bên dưới)
• Một thành viên đạt ít nhất 50% trong bài kiểm tra của họ đủ điều kiện để được thăng hạng. Một thành viên đạt ít hơn 50% trong bài kiểm tra của họ đủ điều kiện cho Demotion.
• Một thành viên đủ điều kiện cho Demotion chỉ bị giảm một bậc nếu có thành viên đủ điều kiện cho Khuyến mãi ở thứ hạng dưới đây để thay thế họ.
• Tất cả các thành viên đủ điều kiện cho Khuyến mãi đều tăng thứ hạng của họ miễn là điều này không để lại thứ hạng trống.
• Nếu không phải tất cả các thành viên đủ điều kiện có thể bị hạ cấp hoặc được thăng cấp, thì ưu tiên sẽ thuộc về những người có mức độ thấp nhất (đối với việc hạ cấp). điểm cao nhất (cho khuyến mãi). Ties bị phá vỡ ngẫu nhiên.
• Thứ hạng của một thành viên chỉ có thể thay đổi tối đa 1 mỗi lượt.

Nội quy của trò chơi:

• Mỗi bot sẽ được gán ngẫu nhiên một ID khi bắt đầu trò chơi, điều này sẽ không thay đổi trong quá trình của nó. Có JadeEmperorID -1, tất cả những người khác có ID không âm liên tiếp, bắt đầu bằng 0.
• Tất cả các bot cạnh tranh cùng một lúc
• Trò chơi chạy trong 100 lượt, điểm số của bot là thứ hạng trung bình sở hữu trong thời gian đó.
• Tổng số điểm có được bằng cách chạy 1000 trò chơi và tính trung bình các kết quả.
• Mỗi Bot là một lớp Python 3 thực hiện bốn chức năng sau:
  • ask(self,n,ID), làm một bài kiểm tra bằng cách trả về một listBooleans có độ dài n. ID là ID của bot người phải đoán danh sách đó. ask()có thể được gọi nhiều lần trong một vòng cho bất kỳ bot nào, nhưng cũng không được.
  • answer(self,n,ID), đó là một nỗ lực để trả lời một bài kiểm tra bằng cách trả về một listBooleans có độ dài n. ID là ID của bot đã ask()tạo ra bài kiểm tra. answer()được gọi chính xác một lần mỗi vòng cho mỗi bot.
  • update(self,rankList,ownExam,otherExams)được gọi một khi Bộ điều khiển đã thực hiện tất cả các Ưu đãi và Giảm giá. Đối số của nó là: Một danh sách các số nguyên, liệt kê tất cả các thứ hạng theo ID của tất cả các bot; một tuple, bao gồm hai danh sách, đầu tiên là các câu hỏi thi, sau đó là các câu trả lời mà bot đưa ra (trong trường hợp nó quên); sau đó là một danh sách các bộ dữ liệu, tương tự bao gồm các cặp câu trả lời thi, lần này cho tất cả các bài kiểm tra mà bot đưa ra.
  • __init__(self, ID, n) vượt qua bot của chính ID của nó và số lượng bot cạnh tranh.
• Các lớp được phép thực hiện các chức năng khác để sử dụng riêng
• Xác định thêm các biến và sử dụng chúng để lưu trữ dữ liệu về các bài kiểm tra trước đây được cho phép rõ ràng.
• Hiệu ứng meta lập trình bị cấm, nghĩa là mọi nỗ lực truy cập trực tiếp vào mã của các bot khác, mã của Bộ điều khiển, gây ra Ngoại lệ hoặc tương tự. Đây là một cuộc thi về chiến lược cho các kỳ thi, không phải là hack mã.
• Các bot cố gắng giúp đỡ lẫn nhau được cho phép rõ ràng, miễn là họ không làm điều đó thông qua các hiệu ứng meta, mà hoàn toàn là thông tin được truyền qua update()
• Các ngôn ngữ khác chỉ được phép trong trường hợp chúng có thể dễ dàng chuyển đổi sang Python 3.
• Các thư viện numpy sẽ được nhập khẩu như np. Phiên bản là 1.6.5, có nghĩa là nó sử dụng thư viện ngẫu nhiên cũ. Nếu bạn có numpy 1.7, các chức năng cũ có sẵn numpy.random.mtrandđể thử nghiệm. Hãy nhớ để tước mtrand để nộp.
• Nếu một bot gây ra Ngoại lệ trong thời gian chạy, nó sẽ bị loại. Bất kỳ bot nào có mã bị xáo trộn đến mức không thể biết được liệu nó có tạo ra một danh sách có độ dài n khi ask()hay answer()được gọi hay không cũng sẽ bị loại. Một bot buộc tôi phải sao chép các kết quả đầu ra sâu được -1 trên điểm số.
• Tên lớp phải là duy nhất
• Nhiều bot cho mỗi người được cho phép, nhưng chỉ phiên bản mới nhất sẽ được lấy từ các bot được cập nhật lặp đi lặp lại.
• Vì dường như có một số nhầm lẫn về sự tương tự bot:
  • Bạn không được phép đăng một bản sao của bot khác. Đây là lỗ hổng tiêu chuẩn duy nhất thực sự áp dụng trong thử thách này.
  • Bạn được phép chia sẻ mã với các bot khác, bao gồm cả bot của người khác.
  • Bạn không được phép gửi bot khác với bot khác chỉ bằng một thay đổi nhỏ đối với chiến lược (như thay đổi hạt giống để tạo câu hỏi) trừ khi bạn có thể chứng minh rằng số bot sao chép carbon đó là mức tối thiểu cần thiết để thành công ban hành chiến lược của họ (Đó thường sẽ là hai bot cho sự hợp tác).

Ví dụ:

Đây JadeEmperorluôn là một phần của trò chơi, nhưng không cạnh tranh; ông phục vụ như là máy phát cho các kỳ thi của các bot cấp cao nhất. Các bài kiểm tra của ông là ngẫu nhiên, nhưng không thống nhất, để cho phép các bot thông minh một cách để tiến lên.

class JadeEmperor:
    def __init__(self):
        pass

    def ask(self,n,ID):
        num=min(np.random.exponential(scale=np.sqrt(np.power(2,n))),np.power(2,n)-1)
        bi=list(np.binary_repr(int(num),width=n))
        return [x=='0' for x in bi]

Các Người say sản xuất kỳ thi và câu trả lời hoàn toàn ngẫu nhiên. Anh ấy sẽ là một phần của trò chơi.

class Drunkard:
    def __init__(self,ID,n):
        pass

    def ask(self,n,ID):
        return list(np.random.choice([True,False],size=n,replace=True))

    def answer(self,n,ID):
        return list(np.random.choice([True,False],size=n,replace=True))

    def update(self,rankList,ownExam,otherExams):
        pass #out

Các ăn cắp chỉ là bản sao các kỳ thi trước. Anh ấy cũng sẽ là một phần của trò chơi.

class Plagiarist:
    def __init__(self,ID,n):
        self.exam=[True]

    def ask(self,n,ID):
        return (self.exam*n)[0:n]

    def answer(self,n,ID):
        return (self.exam*n)[0:n]

    def update(self,rankList,ownExam,otherExams):
        self.exam=ownExam[0]

Mã điều khiển có sẵn ở đây . Để kiểm tra, bạn có thể đặt lớp của riêng mình vào một tệp tin dự thi trong cùng một thư mục và chúng sẽ được nhập.

Chatroom có ​​thể được tìm thấy ở đây .

Kỳ thi bắt đầu!

Điểm hiện tại, với độ chính xác cao hơn (10000 lần chạy) cho ngày 20 tháng 10:

$$\begin{array}{|c|c|c|}\hline \textbf{Entrant}&\textbf{Author}&\textbf{Score}\\\hline % \text{Alpha}&\text{Sleafar}&9.669691\\ \hline \text{Gamma}&\text{Sleafar}&9.301362\\ \hline \text{Beta}&\text{Sleafar}&9.164597\\ \hline \text{WiQeLu}&\text{Purple P}&7.870821\\ \hline \text{StudiousBot}&\text{Dignissimus - Spammy}&7.538537\\ \hline \text{Santayana}&\text{Sara J}&7.095528\\ \hline \text{Plagiarist}&\text{}&6.522047\\ \hline \text{CountOracular}&\text{IFcoltransG}&5.881175\\ \hline \text{Thomas}&\text{Alien@System}&5.880041\\ \hline \text{Contrary}&\text{Draco18s}&5.529652\\ \hline \text{Marx}&\text{sugarfi}&5.433808\\ \hline \text{Drunkard}&\text{}&5.328178\\ \hline \text{YinYang}&\text{Purple P}&5.102519\\ \hline \text{Equalizer}&\text{Mnemonic}&4.820996\\ \hline \text{TitForTat}&\text{Anonymous}&3.35801\\ \hline \end{array}$$

Cuộc thi sẽ được tổ chức với mỗi mục mới trong tương lai gần.

Santayana

Những người không thể nhớ lại quá khứ bị kết án để lặp lại nó. Vì vậy, chúng tôi đưa ra quyết định dựa trên cách mà những người khác đã hành động trong quá khứ, trả lời dựa trên câu trả lời mà người hỏi thường mong đợi ở chúng tôi tại một chỉ số nhất định và hỏi câu trả lời mà họ đưa ra cho chúng tôi ít nhất ở một chỉ số nhất định .

import numpy as np

class Santayana:
    """
    Those who cannot remember the past are condemned to repeat it
    """
    def __init__(self, ID, num_competitors):
        self.ID = ID
        self.exams_taken = {}
        self.exams_issued = {}
        self.last_exam_asker = None
        self.recent_exam_takers = []

        for i in range(num_competitors):
            self.exams_taken[i] = []
            self.exams_issued[i] = []

    def ask(self, length, taker_ID):
        # Remember who asked
        self.recent_exam_takers.append(taker_ID)
        new_exam = []

        # At every index, expect the answer they've given the least often (default to False if equal)
        for i in range(length):
            trues = 0
            falses = 0
            for exam in self.exams_issued[taker_ID]:
                if len(exam) <= i: continue
                if exam[i]:
                    trues += 1
                else:
                    falses += 1
            new_exam.append(trues < falses)
        return new_exam

    def answer(self, num_answers, asker_ID):
        self.last_exam_asker = asker_ID
        if asker_ID == -1:
            # Copy emperor's process to hopefully get a similar exam
            num = min(np.random.exponential(scale=np.sqrt(np.power(2,num_answers))),np.power(2,num_answers)-1)
            as_bin = list(np.binary_repr(int(num),width=num_answers))
            return [x=='0' for x in as_bin]
        else:
            new_answer = []

            # At every index, give the answer that's been correct the greatest number of times (default to True if equal)
            for i in range(num_answers):
                trues = 0;
                falses = 0;
                for exam in self.exams_taken[asker_ID]:
                    if len(exam) <= i: continue
                    if exam[i]:
                        trues += 1
                    else:
                        falses += 1
                new_answer.append(trues >= falses)
            return new_answer

        return [True for i in range(num_answers)]

    def update(self, rank_list, own_exam, other_exams):
        if self.last_exam_asker > -1:
            # Save the exam we took, unless it was from the Emperor - we already know how he operates
            self.exams_taken[self.last_exam_asker].append(own_exam[0])
        for i in range(len(self.recent_exam_takers)):
            # Save the responses we got
            self.exams_issued[i].append(other_exams[i][1])

        self.recent_exam_takers = []

Bot học

Bot này nghiên cứu cho các bài kiểm tra! Nó cố gắng tìm các mẫu trong các thử nghiệm được đưa ra bởi các bot khác nhau và hành động một cách phù hợp.

Về phần tôi, cho đến nay, bot này vượt trội hơn tất cả các bot khác mà tôi có thể làm việc trên máy tính của mình ngoại trừ Alpha, Beta và Gamma (những người đã được lập trình để làm việc cùng nhau). Bot không sử dụng thực tế là cho phép lập nhóm vì tôi cảm thấy rằng nó hơi giống như gian lận và hơi bẩn. Nhìn qua nó, việc lập nhóm dường như khá hiệu quả.

Bot cố gắng nhận ra khi nào câu trả lời cho các bài kiểm tra là ngẫu nhiên và trong câu trả lời phù hợp với hy vọng trung bình 50% cho các bài kiểm tra.

Bot cũng cố gắng nhận ra khi bot chỉ đơn thuần đưa ra câu trả lời của mình để loại bỏ các bot khác đang buộc phải dự đoán hành vi của chúng, tuy nhiên tôi chưa lập trình để nó hành động cụ thể về điều này.

Tôi đã chú thích mã với một vài bình luận để dễ đọc hơn

import random
import numpy as np


class StudiousBot:
    GRAM_SIZE = 5
    def __init__(self, identifier, n):
        self.id = identifier
        self.ranks = {i: 0 for i in range(n)} # Stores ranks
        self.study_material = {i: [] for i in range(n)} # Stores previous exam data
        self.distribution = {i: [] for i in range(n)} # Stores the percentage of answers that were `True` on a Bot's tests over time
        self.last_examiner = None

    def ask(self, n, identifier):
        # This bot gives random tests, it doesn't bother making them difficult based on answers to them
        # The reason for this is that I can't personalise the tests for each bot
        return [random.choice([True, False]) for i in range(n)] 

    def answer(self, n, examiner_id):
        self.last_examiner = examiner_id
        if examiner_id == -1:
            return StudiousBot.answer_emperor(n) # Easy win, I know the distribution of answers for the Emperor's tests

        bother_predicting = True # Whether or not the Bot will attempt to predict the answers to the exam
        study_material = self.study_material[examiner_id]
        distribution = self.distribution[examiner_id]
        if len(distribution) > 0: # If there is actually data to analyse
            sd = StudiousBot.calculate_standard_deviation(distribution)
            normalised_sd = StudiousBot.calculate_normalised_standard_deviation(distribution)

            if abs(30 - sd) < 4: # 30 is the expected s.d for a random distribution
                bother_predicting = False # So I won't bother predicting the test 

            if abs(sd - normalised_sd * 2) > 4: # The bot is merely inverting answers to evade being predicted
                pass # However, at this time, I'm not certain how I should deal with this. I'll continue to attempt to predict the test 


        if bother_predicting and len(study_material) >= StudiousBot.GRAM_SIZE:
            return StudiousBot.predict(study_material, n)

        return [random.choice([True, False]) for i in range(n)]

    def predict(study_material, n): # Predicts the answers to tests with `n` questions
        grams = StudiousBot.generate_ngrams(study_material, StudiousBot.GRAM_SIZE) # Generate all n-grams for the study material
        last_few = study_material[-(StudiousBot.GRAM_SIZE - 1):] # Get the last 9 test answers
        prediction = None
        probability = -1
        for answer in [True, False]: # Finds the probabiility of the next answer being True or False, picks the one with the highest probability
            new_prediction = last_few + [answer]
            new_probability = grams.count(new_prediction)         

            if new_probability > probability:
                prediction = answer
                probability = new_probability

        if n == 1:
            return [prediction]

        return [prediction] + StudiousBot.predict(study_material + [prediction], n-1)          


    @staticmethod
    def calculate_standard_deviation(distribution):
        return np.std(distribution)

    def calculate_normalised_standard_deviation(distribution): # If the answers happen to be inverted at some point, this function will return the same value for answers that occured both before and after this point  
        distribution = list(map(lambda x: 50 + abs(50-x), distribution))
        return StudiousBot.calculate_standard_deviation(distribution)   

    @staticmethod
    def generate_ngrams(study_material, n):
        assert len(study_material) >= n
        ngrams = []
        for i in range(len(study_material) - n + 1):
            ngrams.append(study_material[i:i+n])

        return ngrams

    def update(self, ranks, own_exam, other_exams):
        self.ranks = dict(enumerate(ranks))
        if self.last_examiner != -1:
            self.study_material[self.last_examiner] += own_exam[0]
            self.distribution[self.last_examiner].append(own_exam[0].count(True) / len(own_exam[0]) * 100) # Stores the percentage of the answers which were True

    @staticmethod
    def answer_emperor(n): # Algorithm to reproduce Emperor's distribution of test answers  
        exp = np.random.exponential(scale=np.sqrt(np.power(2,n)))
        power = np.power(2,n) - 1        
        num = min(exp, power)
        bi = list(np.binary_repr(int(num), width=n))
        return [x == '0' for x in bi]

Bá tước

Bot này sử dụng một thuật toán tính trung bình các bài kiểm tra của tất cả các bot làm việc khác, (đưa ra số vòng và một số phép thuật khủng khiếp) để quyết định những gì bot khác sẽ đặt làm bài kiểm tra.
Bá tước yêu cầu bài kiểm tra của mình bằng cách sử dụng hàm băm md5. Do đó, cả câu hỏi và câu trả lời của nó đều mang tính quyết định. Nó bỏ qua hầu hết các yếu tố đầu vào, hỏi và trả lời chính xác các chuỗi booleans, mưa hoặc tỏa sáng, bao gồm cả chống lại Jade Emporer.

import numpy as np
import hashlib

class CountOracular:
    '''Uses very little external data to make heuristical statistical
    deterministic predictions about the average exam.
    (Assonance not intended.)
    To generate its own exams, uses a deterministic hash.'''
    def __init__(self, id, number_of_bots):
        self.last_round = []
        #functions for calculating what other bots will likely do.
        self.bots_calculators = [
            self._jad, #Jade Emporer
            self._alp, #Alpha
            self._bet, #Beta
            self._gam, #Gamma
            self._wiq, #Wi Qe Lu
            self._stu, #StudiousBot
            self._pla, #Plagiarist
            self._san, #Santayana
            self._tho, #Thomas
            self._dru, #Drunkard
            self._yin, #YinYang
            self._con, #Contrary
            self._tit, #TitForTat
            self._equ, #Equalizer
            self._mar, #Marx
        ]
        self.bot_types = len(self.bots_calculators)
    def ask(self, n, id):
        #if we can, show that hardcoding is no match for the power of heuristics:
        if n == 2:
            return [False, True]
        #otherwise, refer to the wisdom of Mayor Prentiss in order to command The Ask
        #i.e. hashes a quote, and uses that as the exam.
        salt = b"I AM THE CIRCLE AND THE CIRCLE IS ME " * n
        return self._md5_from(salt, n)
    def answer(self, n, id):
        #uses the power of heuristics to predict what the average bot will do
        #ignores all inputs except the length of the output
        #very approximate, and deterministic
        #i.e. every game, Count Oracular will send the same lists of answers, in the same order
        best_guess_totals = [0.5] * n #halfway between T and F
        for bot in self.bots_calculators:
            exam, confidence = bot(n)
            if not exam:
                continue
            while len(exam) < n:
                #ensure exam is long enough
                exam += exam[:1]
            exam = exam[:n] #ensure exam is short enough
            #map T and F to floats [0,1] based on confidence
            weighted_exam = [0.5+confidence*(0.5 if q else -0.5) for q in exam]
            best_guess_totals = [current+new for current,new in zip(best_guess_totals, weighted_exam)]
        best_guess_averages = [total/self.bot_types
            for total
            in best_guess_totals
        ]
        best_guess = [avg > 0.5 for avg in best_guess_averages]
        self.last_round = best_guess
        return best_guess
    def update(self, ranks, own, others):
        pass
    def _md5_from(self, data, n):
        md5 = hashlib.md5(data)
        for i in range(n):
            md5.update(data)
        exam = []
        while len(exam) < n:
            exam += [x == "0"
                for x
                in bin(int(md5.hexdigest(), 16))[2:].zfill(128)
            ]
            md5.update(data)
        return exam[:n]
    def _invert(self, exam):
        return [not val for val in exam]
    def _digits_to_bools(self, iterable):
        return [char=="1" for char in iterable]
    def _plagiarise(self, n):
        copy = (self.last_round * n)[:n]
        return copy

    '''functions to calculate expected exams for each other bot:
       (these values, weighted with corresponding confidence ratings,
       are summed to calculate the most likely exam.)'''
    def _jad(self, n):
        '''Calculate the mean of _jad's distribution, then
        use that as the guess'''
        mean = max(int(np.sqrt(np.power(2,n))), (2<<n)-1)
        string_mean = f"{mean}".zfill(n)
        exam = self._invert(self._digits_to_bools(string_mean))
        return exam, 0.5
    def _alp(self, n):
        '''Alpha uses a predictable hash,
        until it figures out we aren't Beta,
        modelled by the probability of giving or solving
        Alpha's exam'''
        #probability that Alpha thinks we're Beta
        #assuming we fail to pretend to be Beta if we meet Alpha
        chance_beta = ((1 - 1/self.bot_types) ** n) ** 2
        return self._md5_from(b"Beta", n), chance_beta
    def _gam(self, n):
        '''Gamma is like Beta, except after realising,
        switches to 50-50 random choice of inverse
        either Beta or Alpha's hash'''
        #probability that Gamma thinks we're Alpha still
        #(Unlikely that Gamma will think we're Beta;
        #we'd need to fail Alpha but pass Beta,
        #therefore, not accounted for)
        chance_unknown = ((1 - 1/self.bot_types) ** n) ** 2
        #default exam that assumes that Gamma thinks we're Alpha
        exam = self._md5_from(b"Beta", n)
        if chance_unknown > 0.5:#there exists a better heuristic here
            #assume Gamma will consider us Alpha
            confidence = chance_unknown
        else:
            #assume Gamma considers us neither Alpha nor Beta
            alpha = self._invert(self._md5_from(b"Beta", n))
            beta = self._invert(self._md5_from(b"Alpha", n))
            #check for bools where both possible exams match
            and_comp = [a and b for a, b in zip(alpha, beta)]
            nor_comp = [not (a or b) for a, b in zip(alpha, beta)]
            #count up matches vs times when fell back on default
            #to calculate ratio of default
            #to bools where hashes agree
            confidence_vs_default = (sum(and_comp)+sum(nor_comp)) / n
            confidence = confidence_vs_default * chance_unknown + (1 - confidence_vs_default) * (1 - chance_unknown)
            for i in range(n):
                if and_comp[i]:
                    exam[i] = True
                if nor_comp[i]:
                    exam[i] = False
        return exam, confidence
    def _bet(self, n):
        '''Beta is like Alpha, but with a different hash'''
        #probability we haven't matched with Beta yet
        #i.e. probability that Beta still thinks we're Alpha
        chance_alpha = ((1 - 1/self.bot_types) ** n) ** 2
        return self._md5_from(b"Alpha", n), chance_alpha
    def _wiq(self, n):
        '''Wi Qe Lu is hard to model, so we pretend
        that it mimicks Plagiarist for the most part'''
        if n == 1:
            #first round is random
            return [False], 0
        #other rounds are based on exams it met
        #leaning towards same as the previous exam
        return self._plagiarise(n), 0.1
    def _stu(self, n):
        '''StudiousBot is random'''
        return [False] * n, 0
    def _pla(self, n):
        '''Plagiarist copies the exams it received,
        which can be modelled with the standard prediction
        calculated for the previous round, padded with its first
        element.'''
        if n == 1:
            return [True], 1
        return self._plagiarise(n), 0.3
    def _san(self, n):
        '''Santayana is based on answers, which we don't predict.
        Modelled as random.'''
        #mostly random, slight leaning towards default False
        return [False] * n, 0.1
    def _tho(self, n):
        '''Thomas has an unpredictable threshold.'''
        #for all intents, random
        return [False] * n, 0
    def _dru(self, n):
        '''Drunkard is utterly random.'''
        return [False] * n, 0
    def _yin(self, n):
        '''YinYang inverts itself randomly, but not unpredictably.
        We can model it to find the probability. Also notably,
        one index is inverted, which factors into the confidence
        especially for lower n.'''
        if n == 1:
            #one element is inverted, so whole list must be False
            return [False], 1
        if n == 2:
            #split half and half randomly; can't predict
            return [True] * n, 0
        #cumulative chance of mostly ones or mostly zeros
        truthy = 1
        for _ in range(n):
            #simulate repeated flipping
            truthy = truthy * 0.44 + (1-truthy) * 0.56
        falsey = 1 - truthy
        if falsey > truthy:
            return [False] * n, falsey - 1/n
        return [True] * n, truthy - 1/n
    def _con(self, n):
        '''Contrary is like Jade Emporer, but inverts itself
        so much that modelling the probability of inversion
        is not worth the effort.'''
        #there are some clever ways you could do statistics on this,
        #but I'm content to call it uniform for now
        return [False] * n, 0
    def _tit(self, n):
        '''TitForTat is most likely to give us False
        but the confidence drops as the chance of having
        met TitForTat increases.
        The square root of the probability we calculate for
        Alpha, Beta and Gamma, because those also care about what
        we answer, whereas TitForTat only cares about what we ask'''
        #probability that we've not given TitForTat an exam
        chance_friends = (1 - 1/self.bot_types) ** n
        return [False] * n, chance_friends
    def _equ(self, n):
        '''Equalizer always asks True'''
        #certain that Equalizer's exam is all True
        return [True] * n, 1
    def _mar(self, n):
        '''Marx returns mostly True, randomised based on our rank.
        We don't predict our rank.
        There's ~50% chance an answer is random'''
        #75% chance we guess right (= 50% + 50%*50%)
        return [True] * n, 0.75

Âm dương

Trả lời tất cả True hoặc tất cả False, ngoại trừ một chỉ số được chọn ngẫu nhiên là ngược lại. Hỏi ngược lại những gì nó trả lời. Hoán đổi ngẫu nhiên để ném đối thủ.

import random

class YinYang:
    def __init__(self, ID, n):
        self.exam = True

    def update(self, rankList, ownExam, otherExams):
        if random.random() < 0.56:
            self.exam = not self.exam

    def answer(self, n, ID):
        a = [not self.exam] * n
        a[random.randint(0, n-1)] = self.exam
        return a

    def ask(self, n, ID):
        e = [self.exam] * n
        e[random.randint(0, n-1)] = not self.exam
        return e

Wi Qe Lu (Switcheroo)

Trả lời và hỏi ngẫu nhiên trong vòng đầu tiên. Sau đó, anh ta sử dụng các câu trả lời từ bài kiểm tra trước và thay đổi một câu hỏi nếu số lượng đối thủ cạnh tranh trên trung bình đạt được.

class WiQeLu:
    def __init__(self, ID, n):
        self.rounds = 1
        self.firstexam = True
        self.firstanswer = True
        self.lastexaminer = -1
        self.exam = []
        self.pastanswers = {}

    def update(self, rankList, ownExam, otherExams):
        questions, lastanswers = ownExam
        self.pastanswers[self.lastexaminer] = questions

        if len(otherExams) == 0:
            return
        correctCounts = [0 for i in otherExams[0][0]]
        for ourExam, response in otherExams:
            for i in range(len(response)):
                if ourExam[i] == response[i]:
                    correctCounts[i] += 1

        newExam = otherExams[0][0]
        meanWhoAnsweredCorrectly = sum(correctCounts) / len(correctCounts)
        for i in range(len(correctCounts)):
            if correctCounts[i] > meanWhoAnsweredCorrectly:
                newExam[i] = not newExam[i]
        self.exam = newExam

    def answer(self, n, ID):
        self.lastexaminer = ID
        if ID not in self.pastanswers:
            randomanswer = [random.randint(0, 1) == 1] * n
            self.pastanswers[ID] = randomanswer
            return randomanswer
        return (self.pastanswers[ID] * n)[:n]

    def ask(self, n, ID):
        if self.firstexam:
            self.firstexam = False
            self.exam = [random.randint(0, 1) == 1] * n
        return (self.exam * n)[:n]

Một bot của riêng tôi:

Thomas

Một du khách đến từ một vùng đất xa xôi, có một số ý tưởng nguy hiểm về kết quả trong quá khứ là biểu hiện của hiệu suất trong tương lai. Anh ta sử dụng chúng để giữ các bot khác, trừ khi điều đó kìm hãm sự tiến bộ của chính anh ta.

class Thomas:
    def __init__(self,ID,n):
        N=10
        self.ID=ID
        self.myrank=n
        self.lowerank=0
        #The highest number of questions is equal to the number of participants, so we can do this:
        self.probs=[{i:1.0/N for i in np.linspace(0,1,num=N)} for i in np.arange(n)]
        self.output=[0.5]*n

    def ask(self,n,ID):
        if self.myrank==1 and self.lowerrank > 1: #I can't advance without promoting somebody first
            return [self.output[i]>np.random.rand() for i in np.arange(n)]
        #Otherwise, try to step on their fingers by going against the expected probability
        return [self.output[i]<np.random.rand() for i in np.arange(n)]


    def answer(self,n,ID):
        return [self.output[i]>np.random.rand() for i in np.arange(n)]

    def update(self,rankList,ownExam,otherExams):
        #Update our ranks
        self.myrank=len([i for i in rankList if i==rankList[self.ID]])
        self.lowerrank=len([i for i in rankList if i==rankList[self.ID]-1])
        #Update our expectations for each input we've been given
        self.bayesianupdate(ownExam[0])
        for ex in otherExams:
            self.bayesianupdate(ex[1])
        #Compress into output variable
        self.output=[np.sum([l[entry]*entry for entry in l]) for l in self.probs]

    def bayesianupdate(self,data):
        for i in np.arange(len(data)):
            if data[i]: #Got a True
                self.probs[i].update({entry:self.probs[i][entry]*entry for entry in self.probs[i]})
            else: #Got a False
                self.probs[i].update({entry:self.probs[i][entry]*(1-entry) for entry in self.probs[i]})
            s=np.sum([self.probs[i][entry] for entry in self.probs[i]]) #Renormalize
            self.probs[i].update({entry:self.probs[i][entry]/s for entry in self.probs[i]})
```

Alpha

Đọc đoạn chat trước khi tải xuống. Những bot này không vi phạm bất kỳ quy tắc nào. OP thậm chí còn khuyến khích các bot hợp tác.

Alpha đang thành lập một nhóm cùng với Beta. Cả hai đang sử dụng một bộ bài kiểm tra được xác định trước để giúp nhau tăng thứ hạng. Cả hai đều tận dụng các bot sử dụng các bài kiểm tra giống nhau nhiều lần.

import numpy as np
import hashlib

class Alpha:
    def __init__(self, ID, n):
        self.alpha = hashlib.md5(b"Alpha")
        self.beta = hashlib.md5(b"Beta")
        self.asker = -1
        self.betas = set(range(n)).difference([ID])
        self.fixed = set(range(n)).difference([ID])
        self.fixedExams = [[]] * n

    def ask(self,n,ID):
        if ID in self.betas:
            return self.md5ToExam(self.alpha, n)
        else:
            return list(np.random.choice([True, False], n))

    def answer(self,n,ID):
        self.asker = ID
        if self.asker == -1:
            return [True] * n
        elif self.asker in self.fixed and len(self.fixedExams[self.asker]) > 0:
            return (self.fixedExams[self.asker] * n)[:n]
        elif self.asker in self.betas:
            return self.md5ToExam(self.beta, n)
        else:
            return list(np.random.choice([True, False], n))

    def update(self,rankList,ownExam,otherExams):
        if self.asker >= 0:
            if self.asker in self.betas and ownExam[0] != self.md5ToExam(self.beta, len(ownExam[0])):
                    self.betas.remove(self.asker)
            if self.asker in self.fixed:
                l = min(len(ownExam[0]), len(self.fixedExams[self.asker]))
                if ownExam[0][:l] != self.fixedExams[self.asker][:l]:
                    self.fixed.remove(self.asker)
                    self.fixedExams[self.asker] = []
                elif len(ownExam[0]) > len(self.fixedExams[self.asker]):
                    self.fixedExams[self.asker] = ownExam[0]
        self.alpha.update(b"Alpha")
        self.beta.update(b"Beta")

    def md5ToExam(self, md5, n):
        return [x == "0" for x in bin(int(md5.hexdigest(), 16))[2:].zfill(128)][:n]

Bộ cân bằng

Mọi người nên bình đẳng (không có ai trong số hoàng đế ngớ ngẩn này), vì vậy hãy cung cấp càng nhiều sự di chuyển xã hội càng tốt. Làm cho các câu hỏi thực sự dễ dàng (câu trả lời luôn luôn đúng) để mọi người có thể thành công.

class Equalizer:
    def __init__(self, ID, n):
        self.previousAnswers = [[0, 0] for _ in range(n)]
        self.previousAsker = -1

    def ask(self, n, ID):
        return [True] * n

    def answer(self, n, ID):
        if ID == -1:
            return [True] * n

        # Assume that questions from the same bot will usually have the same answer.
        t, f = self.previousAnswers[ID]
        return [t >= f] * n

    def update(self, rankList, ownExam, otherExams):
        if self.previousAsker == -1:
            return

        # Keep track of what answer each bot prefers.
        counts = self.previousAnswers[self.previousAsker]
        counts[0] += ownExam[0].count(True)
        counts[1] += ownExam[0].count(False)

Beta

Đọc đoạn chat trước khi tải xuống. Những bot này không vi phạm bất kỳ quy tắc nào. OP thậm chí còn khuyến khích các bot hợp tác.

Beta đang thành lập một nhóm cùng với Alpha. Cả hai đang sử dụng một bộ bài kiểm tra được xác định trước để giúp nhau tăng thứ hạng. Cả hai đều tận dụng các bot sử dụng các bài kiểm tra giống nhau nhiều lần.

import numpy as np
import hashlib

class Beta:
    def __init__(self,ID,n):
        self.alpha = hashlib.md5(b"Alpha")
        self.beta = hashlib.md5(b"Beta")
        self.asker = -1
        self.alphas = set(range(n)).difference([ID])
        self.fixed = set(range(n)).difference([ID])
        self.fixedExams = [[]] * n

    def ask(self,n,ID):
        if ID in self.alphas:
            return self.md5ToExam(self.beta, n)
        else:
            return list(np.random.choice([True, False], n))

    def answer(self,n,ID):
        self.asker = ID
        if self.asker == -1:
            return [True] * n
        elif self.asker in self.fixed and len(self.fixedExams[self.asker]) > 0:
            return (self.fixedExams[self.asker] * n)[:n]
        elif self.asker in self.alphas:
            return self.md5ToExam(self.alpha, n)
        else:
            return list(np.random.choice([True, False], n))

    def update(self,rankList,ownExam,otherExams):
        if self.asker >= 0:
            if self.asker in self.alphas and ownExam[0] != self.md5ToExam(self.alpha, len(ownExam[0])):
                    self.alphas.remove(self.asker)
            if self.asker in self.fixed:
                l = min(len(ownExam[0]), len(self.fixedExams[self.asker]))
                if ownExam[0][:l] != self.fixedExams[self.asker][:l]:
                    self.fixed.remove(self.asker)
                    self.fixedExams[self.asker] = []
                elif len(ownExam[0]) > len(self.fixedExams[self.asker]):
                    self.fixedExams[self.asker] = ownExam[0]
        self.alpha.update(b"Alpha")
        self.beta.update(b"Beta")

    def md5ToExam(self, md5, n):
        return [x == "0" for x in bin(int(md5.hexdigest(), 16))[2:].zfill(128)][:n]

Gamma

Đọc đoạn chat trước khi tải xuống. Những bot này không vi phạm bất kỳ quy tắc nào. OP thậm chí còn khuyến khích các bot hợp tác.

Gamma đã phát hiện ra kế hoạch của Alpha và Beta và đang cố gắng tận dụng lợi thế của cả hai bằng cách ngụy trang thành một trong số họ.

import numpy as np
import hashlib

class Gamma:
    def __init__(self, ID, n):
        self.alpha = hashlib.md5(b"Alpha")
        self.beta = hashlib.md5(b"Beta")
        self.asker = -1
        self.alphas = set(range(n)).difference([ID])
        self.betas = set(range(n)).difference([ID])
        self.fixed = set(range(n)).difference([ID])
        self.fixedExams = [[]] * n

    def ask(self,n,ID):
        if ID in self.alphas:
            return self.md5ToExam(self.beta, n)
        elif ID in self.betas:
            return self.md5ToExam(self.alpha, n)
        else:
            return self.md5ToWrongExam(np.random.choice([self.alpha, self.beta], 1)[0], n)

    def answer(self,n,ID):
        self.asker = ID
        if self.asker == -1:
            return [True] * n
        elif self.asker in self.fixed and len(self.fixedExams[self.asker]) > 0:
            return (self.fixedExams[self.asker] * n)[:n]
        elif self.asker in self.alphas:
            return self.md5ToExam(self.alpha, n)
        elif self.asker in self.betas:
            return self.md5ToExam(self.beta, n)
        else:
            return list(np.random.choice([True, False], n))

    def update(self,rankList,ownExam,otherExams):
        if self.asker >= 0:
            if self.asker in self.alphas and ownExam[0] != self.md5ToExam(self.alpha, len(ownExam[0])):
                    self.alphas.remove(self.asker)
            if self.asker in self.betas and ownExam[0] != self.md5ToExam(self.beta, len(ownExam[0])):
                    self.betas.remove(self.asker)
            if self.asker in self.fixed:
                l = min(len(ownExam[0]), len(self.fixedExams[self.asker]))
                if ownExam[0][:l] != self.fixedExams[self.asker][:l]:
                    self.fixed.remove(self.asker)
                    self.fixedExams[self.asker] = []
                elif len(ownExam[0]) > len(self.fixedExams[self.asker]):
                    self.fixedExams[self.asker] = ownExam[0]
        self.alpha.update(b"Alpha")
        self.beta.update(b"Beta")

    def md5ToExam(self, md5, n):
        return [x == "0" for x in bin(int(md5.hexdigest(), 16))[2:].zfill(128)][:n]

    def md5ToWrongExam(self, md5, n):
        return [x == "1" for x in bin(int(md5.hexdigest(), 16))[2:].zfill(128)][:n]

TitForTat

Hỏi bạn những câu hỏi dễ nếu bạn hỏi nó những câu hỏi dễ trong quá khứ. Nếu bạn chưa bao giờ cho nó một bài kiểm tra, nó mặc định cho các câu hỏi dễ.

Ngoài ra, không tin tưởng bất cứ ai hỏi những câu hỏi khó và sẽ cung cấp cho họ những câu trả lời không thể đoán trước.

import numpy as np

class TitForTat:
    def __init__(self, ID, n):
        self.friendly = [True] * n
        self.asker = -1

    def make_answers(self, n, ID):
        if ID == -1 or self.friendly[ID]:
            return [False] * n
        else:
            return list(np.random.choice([True, False], n))

    def ask(self, n, ID):
        return self.make_answers(n, ID)

    def answer(self, n, ID):
        self.asker = ID
        return self.make_answers(n, ID)

    def update(self, rankList, ownExam, otherExams):
        if self.asker != -1:
            # You are friendly if and only if you gave me a simple exam
            self.friendly[self.asker] = all(ownExam[0])

Bot này hoạt động tốt nếu các bot khác hợp tác với nó. Hiện tại chỉ có Equalizer hợp tác, nhưng điều này hy vọng là đủ.

Trái ngược

Ngọc Hoàng luôn luôn đúng, vì vậy, nó thực hiện chức năng hỏi của Ngọc Hoàng là chức năng trả lời riêng của mình khi cần nhiều hơn 2 câu trả lời. Chỉ có 1 câu trả lời, nó trả lời true(tỷ lệ chính xác là đúng) và cho 2 câu trả lờitrue,false ( này vượt qua "ít nhất một nửa" câu hỏi trong số bốn câu hỏi có thể, tốt hơn là chọn ngẫu nhiên).

Sử dụng logic tương tự trong Cập nhật của nó liên quan đến cách nó thay đổi kiểu hỏi của nó, nhưng logic hỏi của nó tương tự như Ngọc Hoàng, chỉ với một trọng lượng khác. Biến động giữa các giá trị cao hơn truevới giá trị cao hơn falsekhi có quá nhiều thí sinh đạt điểm cao đủ để vượt qua.

class Contrary:
    def __init__(self,ID,n):
        self.rank = 0
        self.ID = ID
        self.competitors = {}
        self.weight = -2
        pass

    def ask(self,n,ID):
        if self.weight > 0:
            num=min(np.random.exponential(scale=np.sqrt(np.power(self.weight,n))),np.power(2,n)-1)
            bi=list(np.binary_repr(int(num),width=n))
            return [x=='0' for x in bi]
        else:
            num=min(np.random.exponential(scale=np.sqrt(np.power(-self.weight,n))),np.power(2,n)-1)
            bi=list(np.binary_repr(int(num),width=n))
            return [x=='1' for x in bi]

    def answer(self,n,ID):
        if n == 1:
            return [True]
        if n == 2:
            return [True,False]
        num=min(np.random.exponential(scale=np.sqrt(np.power(2,n))),np.power(2,n)-1)
        bi=list(np.binary_repr(int(num),width=n))
        return [x=='0' for x in bi]

    def update(self,rankList,ownExam,otherExams):
        self.rank = rankList[self.ID];
        if len(otherExams) == 0:
            return
        correctCounts = [0 for i in otherExams[0][0]]
        for ourExam, response in otherExams:
            for i in range(len(response)):
                if ourExam[i] == response[i]:
                    correctCounts[i] += 1

        meanWhoAnsweredCorrectly = sum(correctCounts) / len(correctCounts)
        for i in range(len(correctCounts)):
            if correctCounts[i]+1 > meanWhoAnsweredCorrectly:
                self.weight = np.copysign(np.random.uniform(1,3),-self.weight)

Marx

Đây là bot Marx. Ông tin rằng, thay vì một bộ máy quan liêu, chúng ta nên có một hệ thống cộng sản. Để giúp đạt được mục tiêu này, nó đưa ra các câu đố khó hơn cho các bot xếp hạng cao hơn. Nó cũng đưa ra nhiều câu trả lời ngẫu nhiên hơn cho các câu đố từ các bot cao hơn, bởi vì chúng có thể thông minh hơn, bởi vì chúng cao hơn.

import numpy as np

class Marx():
    def __init__(self, ID, n):
        self.ID = ID
        self.n = n
        self.ranks = [] # The bot rankings
        self.e = [] # Our quiz
        self.rank = 0 # Our rank
    def ask(self, n, ID):
        test = [True] * n
        # Get the rank of the bot being quizzed
        if self.ranks:
            rank = self.ranks[ID]
        else:
            rank = 0
        for i in range(len(test)):
            item = test[i]
            if np.random.uniform(0, rank / self.n) > 0.5:
                # If the bot is higher ranking, make the quiz harder
                item = np.random.choice([True, False], 1)[0]
            test[i] = item
        # IF the test is not long enough, add Falses to the end
        while len(test) < n - 1:
            test.append(False)
        return test
    def answer(self, n, ID):
        # Get the rank of the asking bot
        if self.ranks:
            rank = self.ranks[ID]
        else:
            rank = 0
        if self.e:
            # Pad our quiz with Falses so it will not throw IndexError
            while len(self.e) < n:
                self.e.append(False)
            for i in range(len(self.e)):
                item = self.e[i]
                if np.random.uniform(0, rank / self.n) > 0.5:
                    # Assume that higher ranking bots are cleverer, so add more random answers
                    item = np.random.choice([True, False], 1)[0]
                self.e[i] = item
            if len(self.e) > self.rank + 1:
                self.e = self.e[:self.rank + 1]
            return self.e
        else:
            # If it is the first round, return all Trues
            return [True] * n
    def update(self, rankList, ownExam, otherExams):
        # Update our list of ranks
        self.ranks = rankList
        # Store the quiz we were given, to give to the next bot
        self.e = ownExam[0]
        # Store our rank
        self.rank = rankList[self.ID]