লিওর পোকারফেস


13

কিংকর্তব্যবিমূঢ়

ভূমিকা

লিও জুজু খেলা উপভোগ করে তবে টেক ইনক। এ তার চাকরিটি কীভাবে ভাল খেলতে হয় তা শেখার জন্য তার কাছে খুব দাবি। লিও, একজন কম্পিউটার বিজ্ঞানী হওয়ায় নিরুৎসাহিত হন না। তিনি ঠিক করেন যে কেবল জুজু শিখতে যে পরিমাণ সময় লাগবে তার থেকে বেশি সময় নেওয়ার সিদ্ধান্ত নিয়েছে এবং তাকে আরও ভাল খেলতে সহায়তা করার জন্য পোকার বট লেখার জন্য এটি ব্যবহার করুন use তবে এখন লিওর একটি সমস্যা রয়েছে: কীভাবে কিছুটা আরও ভাল খেলতে হয় তা বোঝার জন্য, লিওকে একাধিক "লোক" এর একাধিক গেমগুলি পর্যবেক্ষণ করা দরকার, তবে গেমের গুণমান এবং বাস্তবতা উন্নত করতে "মানুষ" বিভিন্ন খেলার শৈলীর প্রয়োজন।

চ্যালেঞ্জ

লিও স্মরণ করিয়ে দেয় যে আসলে প্রোগ্রামিং চ্যালেঞ্জগুলির জন্য উত্সর্গীকৃত একটি ওয়েবসাইট রয়েছে এবং আপনার সহায়তা তালিকাভুক্ত করছে! আপনার কাজ হ'ল একটি প্রোগ্রাম লিখুন যা "পোকারফেস" 5-কার্ডের জুজুর সংশোধিত সংস্করণ খেলবে। আপনার ইচ্ছামতো বিন্যাসে প্রোগ্রামটি 5-কার্ডের হাত হিসাবে ইনপুট নেবে, তার পরে প্রোগ্রামটি আউটপুট দেবে:

  • হুবহু (কেস-সংবেদনশীল) "সত্য" "1" বা "টি" যদি প্লেয়ার কার্ড বিনিময় করতে চান, অন্য কোনও খালি খালি আউটপুট।
  • যদি সত্য হয়, কার্ড এবং / অথবা কার্ডের নাম সূচকের তালিকা প্লেয়ার বিনিময় করতে ইচ্ছুক।
  • 0 এবং 3 এর মধ্যে একটি একক সংখ্যা, যা খেলোয়াড় কত অতিরিক্ত কার্ড চায় তা নির্দিষ্ট করে।
  • খেলোয়াড়টি যে হাতটি ব্যবহার করতে চান তা মুদ্রণ করুন।

(নীচে বিন্যাস দেখুন)

পোকারফেস বিধি

  • পোকারফেস যেহেতু একটি পাঠ্য-ভিত্তিক অ্যাডভেঞ্চার গেম, তাই কার্ডগুলি অবশ্যই একটি ধারাবাহিক উপায়ে উপস্থাপন করতে হবে। কার্ড দুটি চরিত্রের কোড দ্বারা প্রতিনিধিত্ব করা হয়, প্রথম অক্ষরটি স্যুট এবং দ্বিতীয়টি কার্ডটির নাম।
    • তাস:
      • 2-9 = 2-9
      • 10 = টি
      • জ্যাক = জে
      • রানী = প্রশ্ন
      • রাজা = কে
      • এস = এ
    • স্যুট:
      • স্পেডস = এস
      • ক্লাব = সি
      • হৃদয় = এইচ
      • হীরা = D

সুতরাং কোদালগুলির টেক্কাটি এসএ হবে, হৃদয়ের 10 টি এইচটি, হীরার চতুর্থটি ডি 4 ইত্যাদি etc.

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

হাত

  • হাতগুলি দৈর্ঘ্যে হুবহু 5 টি কার্ড (প্রাথমিক ইনপুট এবং চূড়ান্ত আউটপুট)।
  • হাত এখানে বর্ণিত নিয়মের সাথে সামঞ্জস্যপূর্ণ হয় ।

ইনপুট আউটপুট

  • লিও কেবল জাভা জানে তাই আপনার প্রোগ্রামটি অবশ্যই প্রসেস এপিআই (কমান্ড লাইন) এর মাধ্যমে এক্সিকিউটেবল হতে হবে এবং যথাক্রমে ইনপুট এবং আউটপুট জন্য STDIN এবং STDOUT ব্যবহার করুন।
  • উপরের বিস্তারিত ইনপুট এবং আউটপুট প্রতিটি পদক্ষেপের জন্য, ইনপুট এবং আউটপুট প্রতিটি এক লাইনে উপস্থিত থাকতে হবে।
  • চূড়ান্ত আউটপুট পরে কমপক্ষে একটি ট্রেলিং নতুন লাইন থাকতে হবে। (এসটিডিআইএন থেকে ইনপুট পড়ার উপায়ের কারণে এটি ঘটে)
  • ট্রেলিং এবং শীর্ষস্থানীয় স্থান ছাড়া অন্য কোনও বহিরাগত ইনপুট / আউটপুট অনুমোদিত নয়। পার্সারটি সহজভাবে final_hand=...বা এর মতো জিনিসগুলি বুঝতে পারে না draw 0
  • অঙ্কন করার সময়, আউটপুট একটি একক পূর্ণসংখ্যার, আউটপুট বিনিময় করার সময় নীচে সংজ্ঞায়িত পূর্ণসংখ্যার এবং / অথবা কার্ডগুলির একটি তালিকা থাকে এবং যখন মূল হাতের সাথে ডিল করা হয়, আউটপুট নীচে সংজ্ঞায়িত কার্ডগুলির একটি তালিকা।
  • সমস্ত ইনপুট / আউটপুট নম্বরগুলি বেস 10 তে অবশ্যই ইতিবাচক পূর্ণসংখ্যার হতে হবে।
  • আপনি কার্ড ইনপুট জন্য ফর্ম্যাট সংজ্ঞায়িত করতে পারেন (নীচে পোস্ট ফর্ম্যাট দেখুন)।
  • সত্যকে হুবহু "সত্য", "" 1 "বা" টি "হিসাবে সংজ্ঞায়িত করা হয় এবং মিথ্যা অন্য কোনও খালি খালি মান।
  • বিনিময় পদক্ষেপের সময়:
    • কার্ড সূচকগুলি অবশ্যই তাদের মধ্যে কমপক্ষে একটি স্থানের সাথে আউটপুট থাকতে হবে (উদাঃ 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, এস, এস, যা একটি সম্পূর্ণ বাড়ি represent
  • আপনি যদি বিরোধীদের হাত বিশ্লেষণ করে কৌশল তৈরি করতে চান তবে আপনি কোনও <botname>/dataডিরেক্টরিতে ডেটা সঞ্চয় করতে পারেন ।
    • প্রতিযোগিতামূলক বটগুলি তাদের হাত প্রদর্শন করার পরে, তাদের প্রতিটি বট ডেটা ডিরেক্টরিতে লেখা হবে হ্যান্ডস টেক্সটে, প্রতিটি হাত একটি নতুন লাইনে (by n দ্বারা পৃথক) with ফাইলটি US_ASCII এ এনকোড করা হবে।
  • আপনার বট নতুন কার্ড বা এক্সচেঞ্জ কার্ডের জন্য অনুরোধ করার পরে, আপনি bot.jlscফাইলটিতে কোন ফর্ম্যাটটি নির্দিষ্ট করেছেন তার উপর ভিত্তি করে কার্ডগুলি ইনপুট হবে ।

পোস্ট ফর্ম্যাট

  • প্রতিটি পোস্টে অবশ্যই দুটি জিনিস অন্তর্ভুক্ত করতে হবে:
    • আপনার বটের উত্স কোড, বা কোনও জনসাধারণের মুখোমুখি ভাণ্ডারের লিঙ্ক।
    • একটি জিপ ফাইল রয়েছে:
      • আপনার বটের সংকলিত / এক্সিকিউটেবল সংস্করণ (যদি ফাইলটি .exe বা অন্য নন-কম-ফাইলযোগ্য ফাইল হয় তবে দয়া করে আপনার পোস্টে সংকলনের নির্দেশাবলী অন্তর্ভুক্ত করুন)।
      • একটি bot.jlscফাইল, নীচে দেখুন (পার্শ্ব দ্রষ্টব্য: .jlsc এক্সটেনশনটি কেবল আমার এক পার্শ্ব প্রকল্পের কারণে, একটি কনফিগারেশন ফর্ম্যাট below নীচের ফাইলটি সঠিক সিনট্যাক্সের সাথে মেলে, তাই চিন্তা করবেন না)।
    • .Zip ফাইলটিকে অবশ্যই আপনার বটের মতো নামকরণ করতে হবে।
  • যদি আপনার উইন্ডোজ বা অন্য কোনও জিপিং ইউটিলিটি অ্যাক্সেস না থাকে বা যে কোনও কারণেই একটি .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}"

কোথায়:

  • আপনার বট চালানোর জন্য উইন্ডোজ কমান্ড লাইন কমান্ড হ'ল "সেন্টিমিডি" । নোট করুন যে আপনার বট ডিরেক্টরিতে থাকবে <botname>, সুতরাং সেই অনুযায়ী আদেশটি সামঞ্জস্য করুন।
  • "নাম" আপনার বটের নাম।
  • "লিঙ্ক" হ'ল আপনার উত্তরের লিঙ্ক, পোস্ট করার পরে আপনাকে এটি সম্পাদনা করতে হবে।
    • "ইনপুট_হ্যান্ড" হ'ল আপনি কীভাবে মূল ডিলিংটি ফর্ম্যাট করতে চান (-4 {# cards প্রতিনিধিত্বকারী কার্ড 0-4 সহ)।
  • "ইনপুট_1" কীভাবে আপনি চান একটি অতিরিক্ত কার্ডের ইনপুট ফর্ম্যাট করা যায়।
  • "ইনপুট_2" আপনি কীভাবে দুটি অতিরিক্ত কার্ডের ফর্ম্যাট করতে চান তা।
  • "ইনপুট 14" কীভাবে আপনি তিনটি অতিরিক্ত কার্ডের ফর্ম্যাট করতে চান।
  • "ইনপুট_4" কীভাবে আপনি চারটি অতিরিক্ত কার্ডের ফর্ম্যাট করতে চান।

সুনির্দিষ্ট

  • এই ফাঁকগুলি অনুমোদিত নয় ('সাধারণ সমস্যাগুলি' দেখুন)
  • আপনি কোনও বট লিখতে পারবেন না, নিয়ম সেটের মধ্যে সর্বদা যথাসম্ভব সেরা হাত আউটপুট দেবে। (উদাহরণস্বরূপ, দীর্ঘস্থায়ী কোনও ব্রুট-ফোর্স বট নেই, কিছুই লিওবটের মতো 'ভাল' হওয়া উচিত নয়)
  • আপনার বটটি ১০০ এমএস বা তারও কম চলতে হবে (এই বিন্দুতে লেনিয়েন্ট, সর্বাধিক second 1 সেকেন্ড)
  • বটটি তার নির্বাচিত হাতের পরে কোনও আউটপুট উপেক্ষা করা হবে।
  • স্ট্যান্ডার্ড লুফোলগুলি অনুমোদিত নয়।
  • হ্যাঁ, আমি জানি লিনাক্স আরও ভাল, তবে আমার উইন্ডোজ পিসি রয়েছে, তাই আপনার প্রোগ্রামটির সংকলিত / এক্সিকিউটেবল সংস্করণ উইন্ডোজ কমান্ড লাইন থেকে চালানো যেতে পারে তা নিশ্চিত হন।
    • আমি ইতিমধ্যে আমার কম্পিউটারে পাইথন এবং জাভা ইনস্টল করেছি, তবে আমি নতুন সংস্করণে আপডেট করতে এবং অন্যান্য পরিবেশ ইনস্টল করতে ইচ্ছুক, সুতরাং দয়া করে আপনার প্রোগ্রামটি কী ধরণের পরিবেশ প্রয়োজন তা নির্দিষ্ট করুন।
  • আপনি কোনও বট লিখতে পারবেন না যা প্রতিটি ক্ষেত্রে অন্য বটের মতো একই কাজ করে। স্প্যাম বট অনুমোদিত, কিন্তু নিরুৎসাহিত।
  • আপনার বটটি কেবল এটির কার্ড ব্যবহার করতে পারে। এক্সচেঞ্জের মাধ্যমে হারিয়ে যাওয়া কার্ডগুলি যেগুলি দিয়ে শুরু করা হয়নি তা চূড়ান্ত হাতে অবৈধ আউটপুট।
  • ইনপুট এবং আউটপুট কেবলমাত্র ASCII অক্ষর থাকতে পারে।

প্রতিযোগিতা

  • আমি সময় পেলেই টুর্নামেন্টগুলি চালানো হবে (আমার সময়সূচিটি লিওর মতোই প্যাকড, সুতরাং এটি আমার একটু বিরল হবে be অসুবিধার জন্য দুঃখিত))
  • চারটি ব্যক্তি গেমগুলিতে বটগুলি প্রতিটিের বিপরীতে থাকে এবং প্রতিটি সম্ভাব্য সাবসেটের জন্য একটি গেম থাকবে (অর্থাত্ প্রচুর গেমস)।
    • এই প্রক্রিয়াটি পাঁচবার পুনরাবৃত্তি হবে।
    • টুর্নামেন্টের হ্যান্ডলার যেভাবে বটের গোষ্ঠী তৈরি করে তার কারণে, বটের সংখ্যা ৪ দ্বারা বিভাজ্য করে তুলতে তিনটি পর্যন্ত ফিলার বট যুক্ত করা হবে These
  • প্রতি রাউন্ড এবং গেমটি চালানোর পরে, তারা যে সংখ্যাটি গেম জিতেছে তার উপর ভিত্তি করে বটের স্কোরগুলি গণনা করা হবে।
    • একাধিক বট একটি অবস্থান ভাগ করতে পারে (প্রথম পোস্ট দ্বারা প্রথম জয়ের জন্য সম্পর্ক)।
  • একটি টুর্নামেন্ট শেষ হওয়ার পরে, স্কোরগুলি এই পোস্টের নীচে যুক্ত করা হবে।

স্কোরিং

সাধারণ কোথ বিধি। যে বট (গুলি) সর্বাধিক গেমস জিতেছে তারা চ্যালেঞ্জ জিতেছে।

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

}

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

গুরুত্বপূর্ণ লিঙ্ক

দাবি পরিত্যাগী

লিও এবং টেক ইনক। গল্পের উপাদান এবং বাস্তব জীবনের সংস্থাগুলি বা লোকদের সাথে কোনও সাদৃশ্য নিখুঁতভাবে অনিচ্ছাকৃত। (তবে, যখন লিওর 'পরিস্থিতি' প্রশ্ন থেকে শর্ত যুক্ত করে বা বিয়োগ করে, সেগুলি আসলে প্রশ্নের অংশ ...)


1
@ সোক্র্যাটিকফোনিক্স আমি এখনই বা কখনই না এটি ভারী করার পরামর্শ দিই। ইতিমধ্যে জমা দেওয়ার পরে খেলোয়াড়দের স্কোর সামঞ্জস্য করা সত্যিই অন্যায় হবে।
নাথান মেরিল

2
পছন্দ করুন শুধু এফওয়াইআই, এটি 2-3 দিনের মতো স্যান্ডবক্সে ছিল ... কেউ মন্তব্য করেনি। আমার অর্থ, যদিও এটি দুর্দান্ত
সক্রেটিক ফিনিক্স

2
এছাড়াও, নাথনমেরিল সম্ভবতঃ বোবা বোট জয়ের বিষয়ে এখনও ঠিক। সিজাম খানিকটা তদন্ত করার পরে, একটি 5 বাইট প্রোগ্রাম "f"q+ন্যূনতম প্রয়োজনীয়তা পূরণ করে। যদি 10 জন প্রতিযোগিতায় থাকে তবে এটি সম্ভবত সমস্ত নন-বোবা এন্ট্রিগুলিকে মারবে (নন-বোবা এন্ট্রিতে সম্ভবত> 75 টি অক্ষর, 5 * 10 (বোবা বটের স্কোর, শেষ অবধি) = 50 <75 (খুব ছোট স্মার্ট বটের স্কোর) (প্রথম আসছে))। সুতরাং, আপনার সম্ভবত এই চ্যালেঞ্জটি থেকে কোডগলফটি সরিয়ে নেওয়া উচিত
ধ্বংসাত্মক লেবু

2
সিজাম ব্যবহার না করা সত্ত্বেও, মূল বক্তব্যটি দাঁড়িয়েছে যে ডাম্ববটস একটি যুক্তিসঙ্গত কৌশল হবে এবং কোডগলফ অপসারণের সাথে ভারসাম্য আকারের ভিএসের সমস্ত সমস্যা দূর করে
ধ্বংসাত্মক লেবু

1
কোড-গল্ফকে হত্যা করা হয়েছে ....
সকরাটিক ফিনিক্স

উত্তর:


1

(পাইথন), পেয়ারবট, বেশ প্রতিযোগিতামূলক নয় (আমি কীভাবে সিএমডি কমান্ড এবং স্টাফ তৈরি করতে জানি না)

কেউ bot.jlsc, এবং জিপ ফাইল ইত্যাদিতে সহায়তা করার সাথে সাথে প্রতিযোগিতা করবে P


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

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

ইনপুট জন্য ফর্ম্যাট উদাহরণ হিসাবে একই: স্পেস দ্বারা পৃথক


যদি সক্রেটিক ফিনিক্স ফাইল স্টাফগুলিতে সহায়তা করতে পারে তবে এটি ভাল


চতুর! সুতরাং আপনি যে ফাইলটি চান তা এখানেই রয়েছে , আমি আসল .zip
সকরাটিক ফিনিক্স

এছাড়াও, এফজিআইটিডাব্লুয়ের জন্য +1
ফিনিক্স

FGITLOSG এর মতো (ধীর বন্দুকের জমিতে দ্রুততম বন্দুক)।
ধ্বংসাত্মক লেবু

সত্য। আমি নিশ্চিত না যে ইনপুট / আউটপুট সঠিক ফর্মের মধ্যে রয়েছে। আমি যখন কোনও হাত প্রবেশ করি, প্রোগ্রামটি "সত্য" এবং তারপরে তার বর্তমান হাতটি মুদ্রণ করে। আমি বিশ্বাস করি যে আপনি "মিথ্যা" মুদ্রণ করতে চান কারণ "সত্য" ইঙ্গিত করে যে আপনি কার্ড বিনিময় করতে চান । দ্বিতীয়ত, প্রোগ্রামটি অঙ্কনের সময় একটি একক পূর্ণসংখ্যা বা এক্সচেঞ্জের সময় স্পেস দ্বারা পৃথক পূর্ণসংখ্যা মুদ্রণ করা প্রয়োজন। "অঙ্কন 0." নয় আমি প্রধান পোস্টটি স্পষ্ট করার চেষ্টা করব।
সকরাটিক ফিনিক্স

[সুতরাং এটি এখন প্রতিযোগিতা হিসাবে গণ্য হয়?] নতুন বার্তা দেখেনি। আমি এখনই বট সংশোধন করব
ধ্বংসাত্মক লেবু

1

প্লাম্বার, পাইথন

প্লাম্বার ফ্লাশ সম্পর্কে সমস্ত। প্লাম্বার উচ্চতর মান কার্ডগুলিকেও অগ্রাধিকার দেয় (যার অর্থ তিনি কখনও কখনও সোজা ফ্লাশ পেতে পারেন, বিশেষত রাজকীয়গুলি (তাদের হওয়া উচিত) Pl শেরলক 9 দ্বারা গণনাগুলি সঠিক হলে প্লাম্বার প্রায় 20% সময় ফ্লাশ করবে hes

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]))

আমার অন্যান্য দুটি বটের মতো স্পেসে পৃথক করে ইনপুটও নেয়


দ্রষ্টব্য: আমার নিজের টুর্নামেন্ট প্রোগ্রামের বাগের কারণে আমি আউটপুট নিয়মগুলি কিছুটা পরিবর্তন করেছি। আপনার চূড়ান্ত আউটপুটের পরে অবশ্যই কমপক্ষে একটি ট্রেলিং করা নতুন রেখা থাকতে হবে।
সক্রেটিক ফিনিক্স

1

লেডিগাগা, পাইথন 3

  • মামলা কিছুটা অন্ধ
  • বাগ পূর্ণ পোশাক আছে
  • এবং একবারে একবারে পোকার ফেস খেলতে পছন্দ করে

    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()
    
    • (আই / ও) প্লাম্বারবোট-সম্পাদনার পরে মডেল করা হয়েছে: ধ্বংসাত্মক তরমুজ-এর জন্য বিস্তৃত বাগফিক্স ধন্যবাদ-সম্পাদনা: নতুন নিয়মের কারণে, চূড়ান্ত আউটপুট পরে একটি পিছনে নতুন লাইন

কার্ড মানগুলির জন্য জটিল জটিল
ধ্বংসাত্মক লেবু

যে কোনও কিছু ইতিমধ্যে অ্যারেতে প্যাক করা হয়েছে তা আমার জ্ঞানের ছিল। আমি কোডের কোন বিভাগটি ছোট করতে পারি?
ম্যাজেন্টা

def V(A): b=[A[0]];c=A[1] if c=='T':c=10 if c=='J':c=11 if c=='Q':c=12 if c=='K':c=13 if c=='A':c=14 return (b + [int(c)]) থেকে 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] + x[A[1]])
ধ্বংসাত্মক লেবু

পেয়ারবটটি আপনার প্রোগ্রামের থেকে কেবলমাত্র দীর্ঘ এবং এটি পাঠযোগ্য কারণ
ধ্বংসাত্মক লেবু

আমি জানি. খারাপ কোডগল্ফিং অভ্যাস।
ম্যাজেন্টা

0

লাকিবট, পাইথন

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


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])
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.