Pokerface

บทนำ

เลโอสนุกกับการเล่นโป๊กเกอร์ แต่งานของเขาที่ Tech Inc. นั้นเรียกร้องเกินกว่าที่เขาจะเรียนรู้วิธีเล่นได้ดี เลโอเป็นนักวิทยาศาสตร์คอมพิวเตอร์ไม่ท้อถอย เขาตัดสินใจที่จะใช้เวลามากกว่าที่จะเรียนรู้โป๊กเกอร์และใช้มันเพื่อเขียนบอทโป๊กเกอร์เพื่อช่วยให้เขาเล่นได้ดีขึ้น แต่ตอนนี้ลีโอมีปัญหา: เพื่อที่จะเข้าใจวิธีการเล่นให้ดีขึ้นเลโอต้องสังเกตหลาย ๆ เกมของ "คน" หลายคน แต่ "คน" ต้องการสไตล์การเล่นที่แตกต่างกันเพื่อปรับปรุงคุณภาพและความเป็นจริงของเกม

ความท้าทาย

ลีโอเล่าว่ามีเว็บไซต์ที่ทุ่มเทให้กับการเขียนโปรแกรมท้าทายและขอความช่วยเหลือจากคุณ! งานของคุณคือการเขียนโปรแกรมที่เล่น "Pokerface" เป็นไพ่โป๊กเกอร์แบบ 5 ใบที่ปรับเปลี่ยนแล้ว โปรแกรมจะรับอินพุตเป็นไพ่ 5 ใบในรูปแบบที่คุณต้องการหลังจากนั้นโปรแกรมจะแสดงผล:

• แน่นอน (ตรงตามตัวพิมพ์ใหญ่ - เล็ก) "จริง" "1" หรือ "t" หากผู้เล่นต้องการแลกเปลี่ยนไพ่อื่น ๆ ที่ไม่ว่างเปล่าเป็นอย่างอื่น
• หากเป็นจริงรายการของดัชนีของการ์ดและ / หรือชื่อการ์ดที่ผู้เล่นต้องการแลกเปลี่ยน
• ตัวเลขเดี่ยวระหว่าง 0 และ 3 ซึ่งระบุจำนวนบัตรเพิ่มเติมที่ผู้เล่นต้องการ
• พิมพ์มือที่ผู้เล่นต้องการใช้

(ดูรูปแบบด้านล่าง)

กฎ Pokerface

• เนื่องจาก pokerface เป็นเกมผจญภัยแบบข้อความคุณต้องแสดงการ์ดในลักษณะที่สอดคล้องกัน ไพ่จะถูกแทนด้วยรหัสตัวละครสองตัวตัวแรกคือชุดสูทและตัวที่สองคือชื่อของการ์ด
  • การ์ด:
    • 2-9 = 2-9
    • 10 = T
    • แจ็ค = เจ
    • ราชินี = Q
    • King = K
    • Ace = A
  • ชุด:
    • Spades = S
    • สโมสร = C
    • หัวใจ = H
    • เพชร = D

เอซโพดำก็คือ SA, 10 ดวงคือ HT, อันดับ 4 ของเพชรคือ D4, เป็นต้น

• Pokerface รอบเดียวประกอบด้วยสี่ขั้นตอน:
  • สำรับได้รับการปรับโฉมใหม่และไพ่ห้าใบแจกให้ผู้เล่นแต่ละคน
  • ผู้เล่นแต่ละคนจะได้รับโอกาสในการแลกเปลี่ยนการ์ดได้มากเท่าที่พวกเขาต้องการ
  • ผู้เล่นแต่ละคนจะได้รับโอกาสในการได้รับไพ่เพิ่มอีกสามใบ
  • ผู้เล่นแต่ละคนจะต้องเปิดเผยมือที่ดีที่สุดของพวกเขา
• มือที่ดีที่สุดชนะและได้รับคะแนนผู้เล่นคนนั้น ในกรณีที่เสมอกันผู้เล่นทั้งสองจะได้รับแต้ม
• ในเกมเดียวจะมีการเล่นสิบรอบและผู้เล่นที่มีคะแนนมากที่สุดจะเป็นผู้ชนะและได้รับ "win point" เพียงหนึ่งเดียว ในกรณีที่เสมอกันผู้เล่นทั้งสองจะได้รับคะแนนชนะ
• ลีโอไม่มีเงินจำนวนมากจริงๆดังนั้น ธ ปท. ของคุณสามารถสันนิษฐานได้ว่านี่เป็นโลกที่สมบูรณ์แบบโดยไม่มีการเดิมพัน

มือ

• มือมีความยาวไพ่ 5 ใบอย่างแน่นอน (อินพุตเริ่มต้นและเอาต์พุตสุดท้าย)
• มือมีการจัดอันดับความสอดคล้องกับกฎที่อธิบายไว้ที่นี่

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

• Leo รู้เฉพาะ Java เท่านั้นดังนั้นโปรแกรมของคุณจะต้องสามารถเรียกใช้งานได้ผ่านProcess API (บรรทัดคำสั่ง) และใช้ STDIN และ STDOUT สำหรับอินพุตและเอาต์พุตตามลำดับ
• สำหรับแต่ละขั้นตอนของอินพุตและเอาต์พุตที่มีรายละเอียดด้านบนแต่ละอินพุตและเอาต์พุตต้องมีอยู่ในหนึ่งบรรทัด
• ต้องมีบรรทัดใหม่ต่อท้ายอย่างน้อยหนึ่งบรรทัดหลังจากเอาต์พุตสุดท้าย (นี่เป็นเพราะวิธีการอ่านอินพุตจาก STDIN)
• ไม่อนุญาตอินพุต / เอาท์พุตภายนอกนอกเหนือจากช่องว่างต่อท้ายและช่องว่างนำหน้า ตัวแยกวิเคราะห์เพียงแค่ไม่เข้าใจสิ่งที่ต้องการหรือfinal_hand=...draw 0
• เมื่อการวาดภาพเอาต์พุตเป็นจำนวนเต็มเดียวเมื่อการแลกเปลี่ยนเอาต์พุตเป็นรายการจำนวนเต็มและ / หรือการ์ดที่กำหนดไว้ด้านล่างและเมื่อมีการแจกไพ่ดั้งเดิมมือเอาท์พุทคือรายการของการ์ดที่กำหนดไว้ด้านล่าง
• หมายเลขอินพุต / เอาต์พุตทั้งหมดต้องเป็นจำนวนเต็มบวกในฐาน 10
• คุณสามารถกำหนดรูปแบบสำหรับอินพุตของการ์ด (ดูรูปแบบโพสต์ด้านล่าง)
• True ถูกกำหนดเป็น "true," "1" หรือ "t" อย่างแน่นอนและ false เป็นค่าอื่น ๆ ที่ไม่ว่างเปล่า
• ระหว่างขั้นตอนการแลกเปลี่ยน:
  • ดัชนีของการ์ดจะต้องส่งออกอย่างน้อยหนึ่งช่องว่างระหว่างพวกเขา (เช่น3 4 0)
  • ชื่อบัตรจะต้องถูกส่งออกอย่างน้อยหนึ่งช่องว่างระหว่างพวกเขา (เช่นH4 S8)
  • ชื่อและดัชนีของการ์ดอาจผสมกันในเอาท์พุท (เช่น0 H7 3 D3)
  • อนุญาตให้ใช้ช่องว่างส่วนท้ายและส่วนหน้า
  • อินพุตที่เป็นผลมาจากผู้เล่นที่เอาท์พุทข้างต้นจะถูกฟอร์แมทตามที่ระบุโดยbot.jlscไฟล์ตามลำดับที่ร้องขอ
• จำนวนไพ่ที่ผู้เล่นต้องการเพิ่มในมือสามารถมีช่องว่างนำหน้าและต่อท้ายได้
• มือจะต้องถูกส่งออกอย่างน้อยหนึ่งช่องว่างระหว่างพวกเขา (เช่นH4 D5 CA) ช่องว่างต่อท้ายและช่องว่างนำ
• มือไม่จำเป็นต้องส่งออกในลำดับที่เหมาะสม (เช่นH4 D4 C4 DA SAและH4 DA D4 SA C4ทั้งสองเป็นตัวแทน 4, 4, 4, Ace, Ace ซึ่งเป็นบ้านเต็มรูปแบบ)
• หากคุณต้องการสร้างกลยุทธ์โดยการวิเคราะห์ฝ่ายตรงข้ามคุณอาจเก็บข้อมูลไว้ใน<botname>/dataไดเรกทอรี
  • หลังจากบอทที่แข่งขันแสดงมือของพวกเขาแล้วพวกเขาจะถูกเขียนไปยังทุกไดเรกทอรีข้อมูลบอทใน hands.txt โดยแต่ละมือในบรรทัดใหม่ (คั่นด้วย \ n) ไฟล์จะถูกเข้ารหัสใน US_ASCII
• หลังจากบอทของคุณร้องขอการ์ดใหม่หรือการ์ดแลกเปลี่ยนการ์ดจะถูกป้อนขึ้นอยู่กับรูปแบบที่คุณระบุในbot.jlscไฟล์

รูปแบบโพสต์

• โพสต์ทุกคนจะต้องมีสองสิ่ง:
  • ซอร์สโค้ดของบ็อตของคุณหรือลิงก์ไปยังที่เก็บข้อมูลสาธารณะ
  • ไฟล์ zip ที่มี:
    • บอทของคุณที่คอมไพล์หรือรันได้ (หากไฟล์นั้นเป็นไฟล์. exe หรือไฟล์ที่ไม่สามารถคอมไพล์ได้โปรดใส่คำแนะนำในการคอมไพล์ในโพสต์ของคุณ)
    • bot.jlscไฟล์ดูด้านล่าง (หมายเหตุด้าน: ขยาย .jlsc เป็นเพียงเพราะด้านหนึ่งของโครงการเหมือง, รูปแบบการตั้งค่าไฟล์ด้านล่างที่ตรงกันไวยากรณ์ที่เหมาะสมดังนั้นไม่ต้องกังวล.)
  • ไฟล์. zip ต้องตั้งชื่อเหมือนกับ bot ของคุณ
• หากคุณไม่สามารถเข้าถึง windows หรือยูทิลิตี้การซิปอื่น ๆ หรือไม่สามารถทำการ. zip ด้วยเหตุผลใดก็ตามเพียงแค่ใส่ข้อความของไฟล์ bot.jlsc ในโพสต์ของคุณ

ไฟล์ bot.jlsc:

name= "Botty"
link= "example.com"
cmd= "java -jar Botty.jar"
input_hand= "${0} ${1} ${2} ${3} ${4}"
input_1= "${0}"
input_2= "${0} ${1}"
input_3= "${0} ${1} ${2}"
input_4= "${0} ${1} ${2} ${3}"

ที่ไหน:

• "cmd" เป็นคำสั่งwindows command line เพื่อเรียกใช้ bot ของคุณ โปรดทราบว่าบอทของคุณจะอยู่ในไดเรกทอรี<botname>ดังนั้นปรับคำสั่งให้เหมาะสม
• "name" คือชื่อบอทของคุณ
• "link" เป็นลิงค์ไปยังคำตอบของคุณคุณจะต้องแก้ไขในหลังจากโพสต์
  • "input_hand" เป็นวิธีที่คุณต้องการให้รูปแบบการทำธุรกรรมดั้งเดิม (มี $ {#} แสดงถึงบัตร 0-4)
• "input_1" เป็นวิธีที่คุณต้องการให้อินพุตการ์ดเพิ่มเติมหนึ่งแผ่นถูกจัดรูปแบบ
• "input_2" เป็นวิธีที่คุณต้องการให้ฟอร์แมตการ์ดเพิ่มเติมสองใบ
• "input_3" เป็นวิธีที่คุณต้องการให้ฟอร์แมตการ์ดเพิ่มเติมสามใบ
• "input_4" เป็นวิธีที่คุณต้องการให้ฟอร์แมตการ์ดเพิ่มเติมอีกสี่การ์ด

ข้อมูลจำเพาะ

• ช่องโหว่เหล่านี้ไม่ได้รับอนุญาต (ดู 'ข้อผิดพลาดทั่วไป')
• คุณไม่สามารถเขียนบอทที่จะส่งออกมือที่ดีที่สุดที่เป็นไปได้ทุกครั้งภายในชุดกฎ (เช่นไม่มีบ็อตเดรัจฉานที่ใช้กำลังนานไม่ควรมีอะไรที่ 'ดี' เท่า LeoBot มากนัก)
• บอทของคุณควรทำงานใน ~ 100 ms หรือน้อยกว่า (ผ่อน ณ จุดนี้สูงสุด ~ 1 วินาที)
• ผลลัพธ์ของบอทหลังจากมือที่เลือกจะถูกละเว้น
• ช่องโหว่มาตรฐานไม่ได้รับอนุญาต
• ใช่ฉันรู้ว่า linux นั้นดีกว่า แต่ฉันมี windows PC ดังนั้นโปรดตรวจสอบให้แน่ใจว่าโปรแกรมของคุณสามารถคอมไพล์ / รันได้จากคอมไพล์บรรทัดคำสั่ง windows
  • ฉันได้ติดตั้งไพ ธ อนและ Java ไว้ในคอมพิวเตอร์แล้ว แต่ฉันยินดีที่จะอัปเดตเป็นเวอร์ชันใหม่และติดตั้งสภาพแวดล้อมอื่น ๆ ดังนั้นโปรดระบุประเภทของสภาพแวดล้อมที่โปรแกรมของคุณต้องการ
• คุณไม่สามารถเขียนบอทที่ทำสิ่งเดียวกันกับบอทอื่นในทุกกรณี อนุญาตบอทสแปม แต่ไม่สนับสนุน
• บอทของคุณอาจใช้การ์ดที่มีเท่านั้น ไพ่ที่หายไปจากการแลกเปลี่ยนหรือไม่ได้รับการจัดการเพื่อเริ่มต้นนั้นเป็นเอาท์พุทที่ไม่ถูกต้องในมือสุดท้าย
• อินพุตและเอาต์พุตอาจมีอักขระ ASCII ได้เท่านั้น

ทัวร์นาเมนต์

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

เกณฑ์การให้คะแนน

กฎ KoTH ปกติ บอทที่ชนะการแข่งขันมากที่สุดชนะการท้าทาย

LeoBot

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

package com.gmail.socraticphoenix.pokerface.leobot;

import com.gmail.socraticphoenix.pokerface.lib.card.Card;
import com.gmail.socraticphoenix.pokerface.lib.card.Deck;
import com.gmail.socraticphoenix.pokerface.lib.rule.HandRegistry;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class LeoBot {

    public static void main(String[] args) {
        List<Card> hand = new ArrayList<>();

        Scanner scanner = new Scanner(System.in);
        hand.addAll(Card.parseHand(scanner.nextLine()));
        System.out.println(false);

        System.out.println(3);
        hand.addAll(Card.parseHand(scanner.nextLine()));

        List<List<Card>> possibleHands = LeoBot.getSubsets(hand, 5);
        System.out.println(Deck.toString(possibleHands.stream().sorted((a, b) -> HandRegistry.determineWinner(b, a).comparable()).findFirst().get()));
    }

    private static <T> void getSubsets(List<T> superSet, int k, int idx, List<T> current, List<List<T>> solution) {
        if (current.size() == k) {
            solution.add(new ArrayList<>(current));
            return;
        }
        if (idx == superSet.size()) return;
        T x = superSet.get(idx);
        if (!current.contains(x)) {
            current.add(x);
        }
        getSubsets(superSet, k, idx + 1, current, solution);
        current.remove(x);
        getSubsets(superSet, k, idx + 1, current, solution);
    }

    public static <T> List<List<T>> getSubsets(List<T> superSet, int k) {
        List<List<T>> res = new ArrayList<>();
        getSubsets(superSet, k, 0, new ArrayList<T>(), res);
        return res;
    }

}

โปรดทราบว่าหาก LeoBot ชนะการแข่งขันอย่างต่อเนื่องและมีจำนวนรายการที่ดีฉันจะหยุดรวมถึงเขาในการวิ่ง

ลิงค์สำคัญ

• บอททัวร์นาเมนต์และห้องสมุด
• บอทของลีโอ

คำปฏิเสธ

Leo และ Tech Inc. เป็นองค์ประกอบเรื่องราวและมีความคล้ายคลึงกับ บริษัท หรือคนในชีวิตจริงโดยไม่ได้ตั้งใจ (อย่างไรก็ตามเมื่อ 'สถานการณ์' ของลีโอเพิ่มหรือลบเงื่อนไขออกจากคำถามเหล่านั้นจะเป็นส่วนหนึ่งของคำถาม ... )

(Python), Pairbot, ไม่ใช่การแข่งขันค่อนข้างมาก (ฉันไม่ทราบวิธีการสร้างคำสั่งและสิ่งต่างๆ)

Pairbot จะแข่งขันทันทีที่มีคนช่วยเหลือด้วยไฟล์ bot.jlsc และไฟล์ zip เป็นต้น

Pairbot รู้ว่าคุณไม่ได้รับสิ่งที่ดีเสมอไป เขารู้ว่ามือที่ดีนั้นหายาก Pairbot รู้ว่าการจับคู่และการทำซ้ำอื่น ๆ เป็นมือที่ดีที่สุด Pairbot รู้ว่ามือที่ต่ำที่สุดที่คุณจะได้รับคือเจ็ดสูงดังนั้นเขารู้ว่าถ้าเขามี 6 สูงจริง ๆ แล้วมันตรง (pairbot ไม่รู้ว่าทำไมเขาถึงรู้) เขารู้ด้วยว่าไพ่ต่ำสุดของเขาคือ 10 (ไม่มีคู่) นั่นเป็นเส้นตรง (pairbot รู้ว่าเขาจะได้รับฟัจด์แบบนี้) Pairbot จะทำการตรวจสอบหมายเลขที่ซ้ำกันส่วนใหญ่ แต่ยังตรวจสอบ straights สองประเภทในกรณีพิเศษ

card_values={"2":2, "3":3, "4":4, "5":5, "6":6, "7":7, "8":8,
             "9":9, "T":10, "J":11, "Q":12, "K":13, "A":14,}
straight=False
def card_valuing(item):
    return card_values[item[1]]

input_list=input().split()
pairs_to_keep=[]
for item in input_list:
    if sum(item[1]==card[1] for card in input_list)>1:
        pairs_to_keep+=[item]
cards_to_remove=input_list
for item in pairs_to_keep:cards_to_remove.remove(item)#we want to remove all non pairs
hand=pairs_to_keep
if pairs_to_keep==[]:
    input_list.sort(key=card_valuing, reverse=True)
    if card_values[input_list[0][1]]==6:
        straight=True
        hand=input_list
    elif card_values[input_list[-1][1]]==10:
        straight=True
        hand=input_list
    else:
        print("true\n"+" ".join(input_list[1:]))
        hand+=input_list[0]+input().split()
elif input_list!=[]:
    print("true\n"+" ".join(input_list))
    hand+=input().split()
else:print(0, end=', ')
if straight:print("0\n0\n"+" ".join(hand))
else:
    print("3")
    hand+=input().split()
    same_number_dict={} #holds the amount of each type (A, 2, 3, etc.)

    def dict_value(item):
        return int(same_number_dict[item[1]])*100+card_values[item[1]]

    for card in hand:
        same_number_dict[card[1]]=sum(card[1] == item[1] for item in hand)

    hand=list(sorted(hand, key=dict_value, reverse=True))
    final_hand =[]
    last_number=hand[0][1]
    hand_taken=0
    while hand_taken < 5:
        if last_number==hand[0][1]:
            final_hand+=[hand[0]]
            hand=hand[1:]
            hand_taken+=1
        else:
            for card in hand:
                if same_number_dict[card[1]]>5-hand_taken:
                    same_number_dict[card[1]]=5-hand_taken
            hand=list(sorted(hand, key=dict_value, reverse=True))
            last_number=hand[0][1]
    print(" ".join(final_hand))

รูปแบบสำหรับอินพุตเหมือนกับในตัวอย่าง: คั่นด้วยช่องว่าง

ถ้าโสคราฟีฟินิกซ์สามารถช่วยเหลือเรื่องไฟล์ได้ก็คงจะดี

ช่างประปา Python

ช่างประปาเป็นเรื่องเกี่ยวกับวูบวาบ ช่างประปายังให้ความสำคัญกับบัตรที่มีมูลค่าสูงกว่า (ซึ่งหมายความว่าบางครั้งเขาสามารถรับฟลัชโดยตรงโดยเฉพาะอย่างยิ่งรอยัล (ควรเกิดขึ้น)) ช่างประปาสับสนมากหากเขาไม่ได้รับฟลัชยกเว้นว่าเขาอาจโชคดีพอ ช่างประปาจะได้รับฟลัชประมาณ 20% ของเวลาถ้าการคำนวณโดยSherlock9ถูกต้อง

hand=input().split()
suit_in_hand={"S":0,"C":0,"D":0,"H":0}
card_values={"2":2, "3":3, "4":4, "5":5, "6":6, "7":7, "8":8,
             "9":9, "T":10, "J":11, "Q":12, "K":13, "A":14,}
def value_sort(x):
    return card_values[x[1]]
def suit_sort(x):
    return suit_in_hand[x[0]]

for card in hand:
    suit_in_hand[card[0]]+=1

hand.sort(key=suit_sort, reverse=True)

print(" ".join(hand[suit_in_hand[hand[0][0]]:]))
hand=hand[:suit_in_hand[hand[0][0]]]

for new_card in input().split():
    hand+=[new_card]
    suit_in_hand[new_card[0]]+=1

print(3)

for new_card in input().split():
    hand+=[new_card]
    suit_in_hand[new_card[0]]+=1
hand.sort(key=value_sort, reverse=True)
hand.sort(key=suit_sort, reverse=True)
print(" ".join(hand[:5]))

รับอินพุตโดยคั่นด้วยช่องว่างเช่นเดียวกับบอทสองตัวของฉัน

LadyGaga, Python 3

• ค่อนข้างจะตาบอด
• มีชุดที่เต็มไปด้วยแมลง

• และชอบเล่น Poker Face นาน ๆ ครั้ง

  from math import ceil as f
  M=lambda A:max(set(A),key=A.count)
  K=lambda A:A.count(M(A))
  O=lambda A:range(len(A))
  J=lambda A:A[0]+str(U(A[1]))
  X={"2":2,"3":3,"4":4,"5":5,"6":6,"7":7,"8":8,"9":9,"T":10,"J":11,"Q":12,"K":13,"A":14}
  def V(A):return([A[0]]+[int(X[A[1]])])
  def U(c):
   if c==10:c='T'
   if c==11:c='J'
   if c==12:c='Q'
   if c==13:c='K'
   if c==14:c='A'
   return(c)
  def P(A):
   S=[];C=[];t=len(A)
   for x in A:S.append(x[0]);C.append(x[1])
   B=[0]*9;q=len(set(C));p=K(C);D=list(set(C));D.sort()
   B[2]=1/f(13**(4-p));B[6]=1/f(13**(3-p));B[8]=1/f(13**(2-p))
   if (p,q)==(2,4):B[3]=1/1100;B[7]=5/34
   if (p,q)==(3,3):B[3]=1/169;B[7]=1/169
   if (p,q)==(4,2):B[3]=1/13;B[7]=1
   if (p,q)==(2,3):B[3]=5/169;B[7]=1
   if (p,q)==(3,2):B[3]=1;B[7]=1
   for x in O(D):D[x]-=x
   j=M(D);h=K(D)-5;B[5]=13**h
   for x in O(D):
    if j+h<D[x]<j-h and D[x]!=j:B[5]*=13
   W=K(S);B[4]=(4**(W-t))*(13-W)/52
   return(B,M(S))
  def E(B,h,u):
   x=0;D=[];C=[]
   while 1:
    k=list(C)
    C=[]
    while 1:
     p=list(B);del p[x]
     if len(D)==3:break
     if P(p)[0][h]>=P(B)[0][h]:C.append(B[x])
     x+=1
     if x>len(p):break
    if len(C)==0:break
    for x in O(C):
     if k==C or not((u in C[x])and(len(C)-1)):D.append(C[x]);del B[B.index(C[x])]
   return(D)
  s=input()
  A=s.split(' ')
  b=list(map(V,A));G,u=P(b);F=[649739,72192,4164,693,508,254,46.3,20,1.4];H=[]
  for x in O(F):F[x]=1-((1-(1/F[x]))**4)
  for x in O(F):H.append(G[x]-F[x])
  Y=H.index(max(H));p=[]
  e=E(list(b),Y,u);g=list(e)
  for x in O(e):e[x]=J(e[x])
  print(' '.join(e)if len(e)else'')
  for x in g:
   if x in b:del b[b.index(x)]
  s=input()
  if len(s):
   A=s.split(' ')
   b+=list(map(V,A))
  print(3)
  s=input()
  A=s.split(' ')
  b+=list(map(V,A));G,u=P(b);H=[]
  for x in O(F):H.append(G[x]-F[x])
  Y=H.index(max(H))
  e=E(list(b),Y,u)
  for x in e:
   if x in b:del b[b.index(x)]
  for x in O(b):b[x]=J(b[x])
  print(' '.join(b[:5]))
  print()
  

  • (I / O) ถ่ายแบบมาจาก PlumberBot -Edit: การแก้ไขข้อผิดพลาดอย่างกว้างขวางด้วยแตงโมที่ถูกทำลายได้ -Edit: เนื่องจากกฎใหม่บรรทัดใหม่ต่อท้ายหลังผลลัพธ์สุดท้าย

LuckyBot, Python

Pairbot เชิญเพื่อน Luckybot ของเขาซึ่งผุดขึ้นมาเพื่อหาโอกาส Luckybot ได้เฝ้าดูตัวละครโป๊กเกอร์จำนวนมากและคาดการณ์ว่าเขาจะหาเคล็ดลับสำหรับโป๊กเกอร์: โชค ทุกคนรู้ถึงข้อดีที่แท้จริง (ตัวอย่างเช่น James Bond) พึ่งพาและได้รับมือที่ดีไม่ใช่ทักษะ ดังนั้นเขาไม่ได้ดูไพ่ของเขาและพยายามที่จะแพ็คโชคให้มากที่สุดเท่าที่จะทำได้

lucky_number=24 #IMPORTANT

from random import randint as roll


def lucky_shuffle(i):
    return sorted(i, key=lucky_dice)


def lucky_dice(seed):
    return sum(roll(1,6)for i in range(roll(1,6)))


hand=lucky_shuffle(input().split())

throw=lucky_dice(lucky_number)%5
print("true\n"+" ".join(hand[throw:]))

hand=hand[:throw]+lucky_shuffle(input().split())

hand=lucky_shuffle(hand)
hand=lucky_shuffle(hand)
#One more for good luck
hand=lucky_shuffle(hand)
#maybe one more
hand=lucky_shuffle(hand)
#I got a good feeling about this one
hand=lucky_shuffle(hand)

hand=lucky_shuffle(hand)
#I think I'm done
hand=lucky_shuffle(hand)
#for real this time


hand=lucky_shuffle(hand)

print("3")
hand=hand+lucky_shuffle(input().split())
#All right, I got a real good feeling about this,
#let me shuffle some more luck into them cards!


def extra_super_lucky_shuffle(item):
 return lucky_shuffle(lucky_shuffle(lucky_shuffle(\
    lucky_shuffle(lucky_shuffle(lucky_shuffle(\
        lucky_shuffle(lucky_shuffle(lucky_shuffle(item)))))))))


def super_duper_extra_ultra_uber_luckyshuffle(item):
    return extra_super_lucky_shuffle(extra_super_lucky_shuffle(\
        extra_super_lucky_shuffle(extra_super_lucky_shuffle(item))))


hand=super_duper_extra_ultra_uber_luckyshuffle(super_duper_extra_ultra_uber_luckyshuffle(hand))
#cmoooooooooooooooon
print(hand[:5])