কোথ: প্রতিটি মুদ্রার দুটি দিক থাকে

Question

চূড়ান্ত ফলাফল উপলব্ধ

ভূমিকা

ভারী থিমগুলি ( ফ্যান্টাসি ওয়ার , বিশ্বব্যাপী মহামারী ...) নিয়ে আমার আগের কোথার পরে , আমি আবার একটি নতুন আলোকিত খেলা নিয়ে এসেছি। এবার, আপনি "বোর্ড গেমের মতো" পরিস্থিতিতে পড়ছেন। উল্টোদিকে কয়েনের একটি গাদা সত্যিই বড় টেবিলের কেন্দ্রে স্থাপন করা হয়েছে, এবং আপনি লুটপাটের অংশটি পেতে দৃ determined়প্রতিজ্ঞ!

টিপ্পনি

কয়েন : টোকেনগুলি যেগুলি হয় ফ্লিপড বা উল্টানো যায়।
আনপ্লিপড : কয়েনগুলি টেবিলে তাদের মানটি নীচে রেখে দেওয়া হয়। এটি মুদ্রার ডিফল্ট অবস্থা state
উল্টানো : কয়েনগুলি টেবিলে তাদের মান পয়েন্ট আপ করে রাখে।
স্থানীয় : আপনার মুদ্রার গাদা বোঝায়।
গ্লোবাল : কেন্দ্রে মুদ্রার গাদা বোঝায়।

নীতি

শুরুতে খেলার, প্রতিটি খেলোয়াড় দিয়ে শুরু হয় 0 পয়েন্ট এবং 0 কয়েন (ফ্লিপ বা unflipped)। গেমটি টার্ন ভিত্তিক। তাদের পালা চলাকালীন, খেলোয়াড়রা টেবিলের কেন্দ্রে কয়েনের গাদা, তাদের নিজস্ব মুদ্রার গাদা বা অন্যান্য খেলোয়াড়দের সাথে আলাপচারিত 3 টি পদক্ষেপ নিতে পারে।

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

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

(2 ^ nb_players) + (nb_players * 10) - random(1 + (nb_players ^ 2))`

প্রতিটি ক্রিয়া আপনাকে পয়েন্ট দেবে (বা আপনাকে কিছুটা হারাতে সক্ষম করবে) এবং গেমের শেষে আপনার প্রতিটি কয়েন আপনার পয়েন্টগুলিতে যুক্ত করা হবে ( আনলিপডের জন্য -1, উল্টানো জন্য +2 )। সর্বোচ্চ স্কোর প্লেয়ার জিতেছে।

কন্ট্রোলার আপনাকে কমান্ড আর্গুমেন্টগুলির মাধ্যমে ইনপুট সরবরাহ করে এবং আপনার প্রোগ্রামটি স্টাডআউটের মাধ্যমে আউটপুট দিতে হয়।

বাক্য গঠন

ইনপুট

আপনার প্রোগ্রামটি যতবার ডাকা হবে, ততক্ষণ এই ফর্ম্যাটে আর্গুমেন্টগুলি পাবেন:

Round;YourPlayerId;Coins;PlayerId_Points_Flipped_Unflipped;PlayerId_Points_Flipped_Unflipped;...

রাউন্ডগুলি 1-ইনডেক্সড।

উদাহরণ ইনপুট

6;2;52;1_20_3_12;0_-2_0_1;2_12_1_0

এখানে, আপনি দেখুন এটি 6th ষ্ঠ রাউন্ড এবং আপনি খেলোয়াড় ২। কেন্দ্রীয় স্তূপে 52 টি কয়েন রয়েছে। আপনার 12 টি পয়েন্ট রয়েছে, 1 টি উল্টানো মুদ্রা এবং 0 টি উল্লিখিত মুদ্রা। পয়েন্টগুলি নেতিবাচক হতে পারে।

আউটপুট

আপনাকে তিনটি অক্ষর আউটপুট করতে হবে (কোনও স্থান নেই, কোনও বিভাজক নেই), যা প্রতিটি এই ক্রমের সাথে মিল রেখে আপনি এই পালাটি নেবেন। অক্ষরের ক্রম ক্রমের ক্রম নির্ধারণ করে। আপনি একই ক্রিয়াকে একাধিকবার আউটপুট করতে পারেন। আপনার ক্রিয়াটি সম্পন্ন করার জন্য পর্যাপ্ত কয়েন না থাকলে, এটি কেবলমাত্র ব্যবহৃত কয়েনগুলির জন্য সর্বাধিক উপলব্ধ কয়েন এবং গণনা পয়েন্ট ব্যবহার করবে।

N: কিছুই করবেন না
1: কেন্দ্রীয় স্তূপ থেকে 1 টি মুদ্রা নিন [প্রভাবগুলি: +1 স্থানীয় আনপ্লিপড / -1 পয়েন্ট / -১ গ্লোবাল আনপ্লিপড]
2 : কেন্দ্রীয় স্তূপ থেকে 2 কয়েন নিন [প্রভাব: +2 স্থানীয় আনপ্লিপড / -2 পয়েন্ট / -2 গ্লোবাল আনপ্লিপড]
3 : কেন্দ্রীয় স্তূপ থেকে 3 টি কয়েন নিন [প্রভাব: +3 স্থানীয় আনপ্লিপড / -3 পয়েন্ট / -3 গ্লোবাল আনপ্লিপড]
A : আপনার স্তূপ থেকে 1 মুদ্রা পিছনে রাখুন [প্রভাব: -1 স্থানীয় অনাবৃত / +1 পয়েন্ট / +1 গ্লোবাল আনপ্লিপড]
B : আপনার গাদা থেকে ২ টি কয়েন পিছনে রাখুন [প্রভাব: -২ স্থানীয় আনপ্লিপড / +২ পয়েন্ট / + গ্লোবাল আনপ্লিপড]
C : আপনার স্তূপ থেকে 3 টি কয়েন পিছনে রাখুন [প্রভাব: -3 স্থানীয় অনাবৃত / +3 পয়েন্ট / +3 গ্লোবাল আনপ্লিপড]
X : আপনার গাদা থেকে 1 মুদ্রা সরান[ইফেক্টস: -১ স্থানীয় আনপ্লিপড / ০ পয়েন্ট]
Y : আপনার স্তূপ থেকে ২ টি কয়েন সরান [প্রভাব: -২ স্থানীয় আনপ্লিপড / ০ পয়েন্ট]
Z : আপনার গাদা থেকে 3 টি কয়েন সরান [প্রভাব: -3 স্থানীয় অনাবৃত / 0 পয়েন্ট]
R : কয়েন ঘোরান পূর্ববর্তী খেলোয়াড়ের কাছে [প্রভাব: -১২ পয়েন্ট উল্টাপাল্টিতে প্রাপ্ত, +২ পয়েন্ট উল্টানো প্রতি প্রাপ্ত / সকল খেলোয়াড়ের জন্য প্রযোজ্য]
T : পরবর্তী খেলোয়াড়ের কাছে কয়েনগুলি ঘোরান [প্রভাব: -প্লিপ্লিপিত প্রাপ্ত প্রতি +1 পয়েন্ট, উল্লিখিত প্রতি + 2 পয়েন্ট / প্রযোজ্য সমস্ত খেলোয়াড়]
F : 1 মুদ্রা ফ্লিপ করুন [প্রভাব: -1 স্থানীয় অনাবৃত / +1 স্থানীয় ফ্লিপড / +2 পয়েন্ট]
U : আনফ্লিপ 1 মুদ্রা [প্রভাব: +1 স্থানীয় অনাবৃত / -1 স্থানীয় উল্টানো / -2 পয়েন্ট]

উদাহরণ আউটপুট

2FF : দুটি মুদ্রা নেয় এবং দুটি কয়েন ফ্লিপ করে, স্কোর করে -2 + 2 + 2 = 2 points

যদি আপনার আউটপুটটি ভুল হয় তবে নিয়ামক ধরে নিবে NNN।

নিয়ামক

আপনি গিটহাবের নিয়ামকটি খুঁজে পেতে পারেন । এটিতে জাভাতে লেখা দুটি স্যাম্পলবট রয়েছে। এটি চালানোর জন্য, প্রকল্পটি দেখুন এবং এটি আপনার জাভা আইডিইতে খুলুন। mainক্লাসের পদ্ধতিতে প্রবেশের পয়েন্ট Game। জাভা 8 প্রয়োজনীয়।

বট যোগ করার জন্য প্রথমে আপনার জাভা (.class ফাইল) এর সংকলিত সংস্করণ বা ব্যাখ্যামূলক ভাষার উত্সগুলির প্রয়োজন। এগুলি প্রকল্পের মূল ফোল্ডারে রাখুন। তারপরে, playersপ্যাকেজে একটি নতুন জাভা ক্লাস তৈরি করুন (আপনি ইতিমধ্যে বিদ্যমান বটগুলির উদাহরণ নিতে পারেন)। এই শ্রেণিকে Playerপদ্ধতিটি ওভাররাইড করার জন্য অবশ্যই প্রয়োগ করতে হবে String getCmd()। স্ট্রিংটি ফেরত হ'ল আপনার বটগুলি চালানোর শেল কমান্ড। আপনি উদাহরণস্বরূপ এই কমান্ড দিয়ে একটি রুবি বট কাজ করতে পারে: return "C:\Ruby\bin\ruby.exe MyBot.rb";। অবশেষে, Gameক্লাসের শীর্ষে প্লেয়ার অ্যারেতে বট যুক্ত করুন ।

বিধি

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

সমর্থিত ভাষা

আমি প্রতিটি ভাষা চেষ্টা করব এবং সমর্থন করব, তবে এটি অনলাইনে বিনামূল্যে পাওয়া দরকার। আপনি যদি "মূলধারার" ভাষা ব্যবহার না করেন তবে দয়া করে ইনস্টলেশনের জন্য নির্দেশাবলী সরবরাহ করুন।

এখনই, আমি চালাতে পারি: জাভা 6-7-8, পিএইচপি, রুবি, পার্ল, পাইথন 2-3, লুয়া, আর, নোড.জেএস, হাস্কেল, কোটলিন, সি ++ 11 +

চূড়ান্ত ফলাফল

এটি 100 গেমের ফলাফল (পয়েন্টগুলি যোগ করা হয়):

1. BirdInTheHand: 1017790
2. Balance: 851428
3. SecondBest: 802316
4. Crook: 739080
5. Jim: 723440
6. Flipper: 613290
7. Wheeler: 585516
8. Oracle: 574916
9. SimpleBot: 543665
10. TraderBot: 538160
11. EgoisticalBot: 529567
12. RememberMe: 497513
13. PassiveBot: 494441
14. TheJanitor: 474069
15. GreedyRotation: 447057
16. Devil: 79212
17. Saboteur: 62240

গেমগুলির স্বতন্ত্র ফলাফলগুলি এখানে উপলভ্য: http://pasted.co/63f1e924 (প্রতি খেলায় প্রচলিত কয়েন এবং রাউন্ডের সংখ্যা সহ)।

: 50 সুনাম একটি খয়রাত বিজয়ী পুরস্কার প্রদান করা হয় Bird in দ্য হ্যান্ড দ্বারা মার্টিন Büttner ।

আপনার অংশগ্রহণের জন্য আপনাকে সকলকে ধন্যবাদ, পরের KOTH see এ দেখতে পাবেন ~

Comments

" প্রভাবগুলি: -1 স্থানীয় অনাবৃত / +1 স্থানীয় উল্টানো / +2 পয়েন্ট " আমার কাছে ভুল দেখাচ্ছে। এটি কি +3 পয়েন্ট হওয়া উচিত নয়, কারণ আপনি একটি উল্লিখিত মুদ্রার জন্য -1 থেকে একটি উল্টানো মুদ্রার জন্য +2 এ গিয়েছেন?

— পিটার টেলর

@ পিটারটেলর আমি মনে করি পয়েন্টগুলি মুদ্রাগুলির চেয়ে স্বতন্ত্র। প্রতিটি ক্রিয়া প্রাপ্ত বা হারিয়ে যাওয়া বেশ কয়েকটি পয়েন্টের সাথে সম্পর্কিত এবং এগুলি খেলাগুলি শেষে আপনি যে পয়েন্টগুলি আসলে মুদ্রাগুলির জন্য পেয়েছেন তা থেকে স্বতন্ত্র।

— মার্টিন এেন্ডার

আপনি মুদ্রা উল্লেখ করেছেন তাদের "মান" দিয়ে উপরে বা নীচে নির্দেশ করে। এই মানগুলি কিসের জন্য ব্যবহৃত হয়? কয়েন পার্থক্যযোগ্য?

— ব্যবহারকারী 2357112

@ পিটারটেলর যেমন মার্টিন বাটনার বলেছিলেন, আপনি ক্রিয়ার জন্য মুদ্রা পাবেন (এক্ষেত্রে ফ্লিপিংয়ের জন্য +2) এবং শেষে কয়েন থাকার জন্য পয়েন্টও পাবেন (এক্ষেত্রে প্রতিটি ফ্লিপের জন্য +2)।

— থ্রাক্স

আইডিটি কি শূন্য-ভিত্তিক বা এক-ভিত্তিক?

— ফ্রেডরিক

Answer 1

পাখি হাতে, রুবি

def deep_copy(o)
  Marshal.load(Marshal.dump(o))
end

ID = 0
PTS = 1
FLP = 2
UFL = 3

round, id, global, *players = ARGV[0].split(';')
round = round.to_i
id = id.to_i
global = global.to_i

players.map!{ |s| s.split('_').map(&:to_i) }

nplayers = players.size

my_pos = players.find_index { |i, p, f, u| i == id }

state = {
    round: round,
    id: id,
    global: global,
    players: players,
    my_pos: my_pos,
    me: players[my_pos],
    prev_p: players[my_pos-1],
    next_p: players[(my_pos+1)%nplayers],
    ends_game: round == 50 && my_pos == nplayers-1,
    score: 0
}

moves = {
    'N' => ->s{deep_copy(s)},
    '1' => ->s{t = deep_copy(s); coins = [1, t[:global]].min; t[:global] -= coins; t[:me][UFL] += coins; t[:score] -= coins; t},
    '2' => ->s{t = deep_copy(s); coins = [2, t[:global]].min; t[:global] -= coins; t[:me][UFL] += coins; t[:score] -= coins; t},
    '3' => ->s{t = deep_copy(s); coins = [3, t[:global]].min; t[:global] -= coins; t[:me][UFL] += coins; t[:score] -= coins; t},
    'A' => ->s{t = deep_copy(s); coins = [1, t[:me][UFL]].min; t[:global] += coins; t[:me][UFL] -= coins; t[:score] += coins; t},
    'B' => ->s{t = deep_copy(s); coins = [2, t[:me][UFL]].min; t[:global] += coins; t[:me][UFL] -= coins; t[:score] += coins; t},
    'C' => ->s{t = deep_copy(s); coins = [3, t[:me][UFL]].min; t[:global] += coins; t[:me][UFL] -= coins; t[:score] += coins; t},
    'X' => ->s{t = deep_copy(s); coins = [1, t[:me][UFL]].min; t[:me][UFL] -= coins; t},
    'Y' => ->s{t = deep_copy(s); coins = [2, t[:me][UFL]].min; t[:me][UFL] -= coins; t},
    'Z' => ->s{t = deep_copy(s); coins = [3, t[:me][UFL]].min; t[:me][UFL] -= coins; t},
    'F' => ->s{t = deep_copy(s); coins = [1, t[:me][UFL]].min; t[:me][UFL] -= coins; t[:me][FLP] += coins; t[:score] += 2*coins; t},
    'U' => ->s{t = deep_copy(s); coins = [1, t[:me][FLP]].min; t[:me][FLP] -= coins; t[:me][UFL] += coins; t[:score] -= 2*coins; t},
    'R' => ->s{
        t = deep_copy(s)
        (-1...t[:players].size-1).each do |i|
            t[:players][i][FLP] = s[:players][i+1][FLP]
            t[:players][i][UFL] = s[:players][i+1][UFL]
        end
        t[:score] += 2*t[:me][FLP] - t[:me][UFL];
        t
    },
    'T' => ->s{
        t = deep_copy(s)
        (0...t[:players].size).each do |i|
            t[:players][i][FLP] = s[:players][i-1][FLP]
            t[:players][i][UFL] = s[:players][i-1][UFL]
        end
        t[:score] += 2*t[:me][FLP] - t[:me][UFL];
        t
    }
}


results = {}

'N123ABCXYZFURT'.each_char { |c1| 
    s1 = moves[c1][state]
    'N123ABCXYZFURT'.each_char { |c2| 
        s2 = moves[c2][s1]
        'N123ABCXYZFURT'.each_char { |c3| 
            s3 = moves[c3][s2]
            s3[:ends_game] ||= s3[:global] == 0
            results[c1+c2+c3] = s3
        }
    }
}

endingMoves = results.keys.select{|k| results[k][:ends_game]}

endingMoves.each{|k| results[k][:score] += 2*results[k][:me][FLP] - results[k][:me][UFL]}

$> << results.keys.shuffle.max_by {|k| results[k][:score]}

যদি আমাদের উভয়ের প্রোগ্রামগুলিতে কোনও বাগ থাকে তবে এটির মূল অ্যালগোরিদম সম্ভবত ম্যাথিয়াসের ওরাকল এর সাথে খুব মিল similar চূড়ান্ত রাউন্ডের আগে আমরা জানতে পারি না আমরা কোন মুদ্রাটি শেষ করব তা আমরা জানতে পারছি না, আমরা অবিলম্বে প্রাপ্ত পয়েন্টগুলির ভিত্তিতে খাঁটিভাবে বর্তমান চলমান সেটটি মূল্যায়ন করব, আমরা কী ধরণের মুদ্রার অবসান করব তা সম্পূর্ণ উপেক্ষা করে সঙ্গে. যেহেতু কেবলমাত্র 14 ³ = 2744 টি সম্ভাব্য পদক্ষেপের সেট রয়েছে আমরা সেগুলি কতগুলি পয়েন্ট আনব তা সহজেই নির্ধারণ করতে পারি all

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

যদি একাধিক মুভি সেট একই ফলাফল দেয় তবে আমরা একটি এলোমেলো নির্বাচন করি। (আমি এটিকে গেম-টার্মিনেটিং মুভ সেটের পক্ষে পক্ষপাতদুষ্টে পরিবর্তন করতে পারি))

Answer 2

ওরাকল, পাইথন 3

আপডেট: ঘূর্ণনের চেয়ে কয়েনের কম স্তরের পক্ষে বিভিন্ন প্রয়াসের ক্রম পরিবর্তন করেছে।

import sys
import itertools
from copy import deepcopy


MOVES_REQUIRED = 3

FLIPPED = 0
UNFLIPPED = 1


def filter_neighbors(neighbors, me, size):
    limit = size - MOVES_REQUIRED
    for data in neighbors:
        i, _, flipped, unflipped = map(int, data.split('_'))
        if MOVES_REQUIRED < (me - i) % size < limit:
            continue  # Skip neighbors that are too far away
        yield i, [flipped, unflipped]


class Player:
    def __init__(self, raw_data):
        _, me, coins, *data = raw_data.split(';')

        self.num_players = len(data)
        self._me = int(me)
        self._coins = int(coins)
        self._state = dict(filter_neighbors(data, self._me, self.num_players))

    def reset(self):
        self.me = self._me
        self.coins = self._coins
        self.state = deepcopy(self._state)
        self.my_state = self.state[self.me]

    def invalid_move(self, move):
        if move in 'NRT':
            return False

        if move in '123'[:self.coins]:
            return False

        flipped, unflipped = self.my_state
        if flipped and move == 'U':
            return False
        if unflipped and move == 'F':
            return False

        if move in 'AXBYCZ'[:2 * unflipped]:
            return False

        return True

    def N(self):
        return 0

    def one(self):
        self.coins -= 1
        self.my_state[UNFLIPPED] += 1
        return -1

    def two(self):
        self.coins -= 2
        self.my_state[UNFLIPPED] += 2
        return -2

    def three(self):
        self.coins -= 3
        self.my_state[UNFLIPPED] += 3
        return -3

    def A(self):
        self.coins += 1
        self.my_state[UNFLIPPED] -= 1
        return 1

    def B(self):
        self.coins += 2
        self.my_state[UNFLIPPED] -= 2
        return 2

    def C(self):
        self.coins += 3
        self.my_state[UNFLIPPED] -= 3
        return 3

    def X(self):
        self.my_state[UNFLIPPED] -= 1
        return 0

    def Y(self):
        self.my_state[UNFLIPPED] -= 2
        return 0

    def Z(self):
        self.my_state[UNFLIPPED] -= 3
        return 0

    def R(self):
        self.me = (self.me + 1) % self.num_players
        flipped, unflipped = self.my_state = self.state[self.me]
        return 2 * flipped - unflipped

    def T(self):
        self.me = (self.me - 1) % self.num_players
        flipped, unflipped = self.my_state = self.state[self.me]
        return 2 * flipped - unflipped

    def F(self):
        self.my_state[FLIPPED] += 1
        self.my_state[UNFLIPPED] -= 1
        return 2

    def U(self):
        self.my_state[FLIPPED] -= 1
        self.my_state[UNFLIPPED] += 1
        return -2

setattr(Player, '1', Player.one)
setattr(Player, '2', Player.two)
setattr(Player, '3', Player.three)


def scenarii(player):
    for tries in itertools.product('FUABCXYZ123NRT', repeat=MOVES_REQUIRED):
        player.reset()
        points = 0
        for try_ in tries:
            if player.invalid_move(try_):
                break
            points += getattr(player, try_)()
        else:
            yield points, ''.join(tries)


if __name__ == '__main__':
    player = Player(sys.argv[1])
    print(max(scenarii(player))[1])

প্রতিটি একক সম্ভাব্য আউটপুট চেষ্টা করে এবং এই টার্নের জন্য সর্বাধিক পরিমাণ পয়েন্ট পাওয়া যায় এমন একটি রাখুন।

Comments

আহ, আমি এটি বাস্তবায়ন করতে চলেছিলাম, +1 1 :) (আমি এখনও বাস্তবে হতে পারি, কারণ

— এটির

@ মার্টিনবাটনার আমি deepcopyকেবলমাত্র প্রাসঙ্গিক প্রতিবেশী রেখে জায়গার উন্নতি (এভাবে সময় [ ]) উন্নয়নের কথা ভেবেছিলাম । এটি কীভাবে জিনিসগুলিতে প্রভাব ফেলবে তা সম্পর্কে নিশ্চিত নয়।

— 409_ কনফ্লিক্ট

@ থ্রাক্স আমি একটি বাগ ফিক্স করেছি filter_neighborsএবং invalid_moveপ্রশ্নের উত্তরগুলির জন্য অ্যাকাউন্টে পরিবর্তন করেছি mod যদিও আমি ত্রুটিটি পুনরুত্পাদন করতে পারি না: $ python oracle.py '4;7;2040;8_-28_1_10;9_-43_0_9;2_-10_4_3;6_-24_6_3;0_6_2_12;1_48_3_0;10_21_4_8;5_6_5_1;4_-12_3_7;7_10_1_3;3_1_1_0'প্রিন্টসTTR

— 409_ কনফ্লিক্ট

Answer 3

লোভী ঘোরানো, রুবি

round, id, global, *players = ARGV[0].split(';')
round = round.to_i
id = id.to_i
global = global.to_i

players.map!{ |s| s.split('_').map(&:to_i) }

nplayers = players.size

my_pos = players.find_index { |i, p, f, u| i == id }

prev_p = players[my_pos-1]
next_p = players[(my_pos+1)%nplayers]

prev_score = 2*prev_p[2] - prev_p[3]
next_score = 2*next_p[2] - next_p[3]

take_from = prev_p

$><< '3'
if prev_score > next_score || prev_score == next_score && prev_p[3] > next_p[3]
    $><< 'T'
else
    $><< 'R'
    take_from = next_p
end

if take_from[3] >= 3
    $><< 'C'
elsif take_from[3] >= 1
    $><< 'F'
else
    $><< 'N'
end

এটি আর্টঅফকোডের পদ্ধতির সাথে সম্পূর্ণরূপে অনুরূপ, এ ছাড়া যে প্রতিবেশীর কাছ থেকে আমরা আরও বেশি পয়েন্ট পেতে পারি তা যাচাই করে এবং ঘূর্ণনের পরে যদি আমরা 3 বা আরও বেশি মুদ্রা দিয়ে শেষ করি তবে এটির Cপরিবর্তে এটি চয়ন করে F।

এগুলি লেখার পরে, আমি নিশ্চিত যে আরও ভাল পদ্ধতির প্রতিবার লোভনীয়ভাবে সমস্ত পদক্ষেপের মধ্যে থেকে সেরাটি বেছে নেওয়া সম্ভব হবে, সম্ভব হলে গ্রহণের আগে ঘূর্ণন (স্থির "স্থির হয়ে থাকা" বদলে ফেলা হবে, ঘোরানো হবে, মুক্তি পাবেন) অবরুদ্ধ "প্যাটার্ন))

এটি আসলে মালিকানাধীন কয়েনগুলি দ্বারা প্রতিনিধিত্বমূলক অন্তর্নিহিত পয়েন্টগুলিও বিবেচনায় নেয় না (এই ধারণাটি ভিত্তিতে যে গেমটি পর্যাপ্ত রাউন্ডে চলেছে যে সম্ভবত আমার মুদ্রাগুলি যেভাবেই রাখবে না) last

Comments

@ মেগাটম ওফস, এটি ধরার জন্য ধন্যবাদ।

— মার্টিন ইন্ডার

Answer 4

ফ্লিপার, পাইথন 2

ফ্লিপারগুলি কয়েন সংগ্রহ করে এবং উল্টানো দিকে ফ্লিপড করার চেষ্টা করে। ফ্লিপার একটি স্মার্ট খেলোয়াড় নয় তবে গেমটিতে ইতিবাচক শক্তি হওয়ার চেষ্টা করে।

import sys, random

# process input data (not used here):
args = sys.argv[1].split(';')
rounds, myid, coins = map(int, args[:3])
players = [map(int, data.split('_')) for data in args[3:]]

# implement strategy using multiples of 'N123ABCXYZRTFU':
options = '12333FFFFFFFFFFF'
print ''.join(random.choice(options) for i in range(3))

ফিলিপারের কেবল python flipper.py <arg>চালনার দরকার।

Answer 5

সিম্পলবট, পাইথন 3

সিম্পিবট হ'ল, বেশ সরল। সে একটি কৌশল নিয়ে কাজ করেছে এবং সে তা নিয়ে কাজ করবে।

চালানোর জন্য:

python3 main.py

main.pyফাইলের বিষয়বস্তু যেখানে :

def main():
    print("3RF")


if __name__ == "__main__":
    main()

Answer 6

ভারসাম্য, লুয়া

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

চালানোর জন্য তার নিম্নলিখিত কমান্ডের প্রয়োজন:

lua balance.lua

যেখানে ফাইল ভারসাম্য.লুয়ায় নিম্নলিখিত কোডের টুকরা রয়েছে:

local datas={}
local arg=arg[1]..";"

-- parse the arguments
-- add some meta datas for debuging purpose/usefulness
arg:gsub("(.-);",function(c)
  if not datas.round
  then
    datas.round=c+0
  elseif not datas.myID
  then
    datas.myID=c+0
  elseif not datas.coins
  then
    datas.coins=c+0
  else
    datas[#datas+1]={}
    datas[#datas].repr=c
    c=c.."_"
    tmp={}
    c:gsub("(.-)_",function(d) tmp[#tmp+1]=d end)
    datas[#datas].id=tmp[1]+0
    datas[#datas].points=tmp[2]+0
    datas[#datas].flip=tmp[3]+0
    datas[#datas].unflip=tmp[4]+0
    if datas[#datas].id==datas.myID
    then
      datas.myOrder=#datas
      datas.myDatas=datas[#datas]
    end
  end
end)

local actions=""
-- construct actions
for i=1,3
do
  -- if we aren't in balance and can grab more coins
  -- we do it
  if #actions==0 and datas.myDatas.unflip<=datas.myDatas.flip/2 and datas.coins>=3
  then
    actions=actions.."3"
    datas.myDatas.unflip=datas.myDatas.unflip+3
    datas.coins=datas.coins-3
  -- if we couldn't grab coins, but aren't in balance, we flip some coins
  elseif datas.myDatas.unflip>datas.myDatas.flip/2
  then
    actions=actions.."F"
    datas.myDatas.unflip=datas.myDatas.unflip-1
    datas.myDatas.flip=datas.myDatas.flip+1

  -- if we didn't have anything to do on our pile, let's punish
  -- the fools who doesn't follow the great Balance principle
  else
    previous=datas.myOrder<2 and #datas or datas.myOrder-1
    following=datas.myOrder>=#datas and 1 or datas.myOrder+1

    lossPrev=-datas[previous].flip + 2*datas[previous].unflip
    lossFoll=-datas[following].flip+ 2*datas[following].unflip
    if lossFoll>0 and lossPrev>0
    then
      actions =actions.."N"
    elseif lossFoll>=lossPrev
    then
      actions=actions.."T"
      datas[following].unflip,datas[following].flip=datas[following].flip,datas[following].unflip
    else
      actions=actions.."R"
      datas[previous].unflip,datas[previous].flip=datas[previous].flip,datas[previous].unflip
    end
  end
end
print(actions)

Comments

@ থ্রাক্স ধন্যবাদ, স্থির। এই লাইনের জন্য 1-

— সূচিকৃত মানগুলিতে

Answer 7

জ্যানিটর, পাইথন 3

তিনি অন্যান্য প্লেয়ারগুলি এই সমস্ত কয়েন দিয়ে যে গোলযোগ তৈরি করেছেন তা পরিষ্কার করার চেষ্টা করেছেন এবং সেগুলি পুনরায় পুলের মধ্যে রাখবেন।

import sys;
def Parse(S):
    T = S.split(';');
    me = eval(T[1]);
    N = len(T)-3;
    A = list(map(lambda x: list(map(lambda y:int(y),T[3+((2*N+x+me)%N)].split('_'))),range(-3,4)));    
    Dic = {}
    for a in A:
        Dic[a[0]] = a[1:];
    Dic[-1] = [me];
    return Dic;
def Recursive(Dic,me,D):
    if D==3: return '';
    V = Dic[me];
    N = max(Dic.keys());
    Next = (me+1)%N;
    Prev = (N+1+me)%N;
    for i in range(3,0,-1):
        if V[2]>=i:
            Dic[me][2] = Dic[me][2]-i;
            return chr((i-1)+ord('A'))+Recursive(Dic,me,D+1);
    if V[1]>0:
        Dic[me][1] = Dic[me][1]-1;
        Dic[me][2] = Dic[me][2]+1;
        return 'U'+Recursive(Dic,me,D+1);
    if Dic[Next][2]>Dic[Prev][2]:
        return 'T'+Recursive(Dic,Next,D+1);
    return 'R'+Recursive(Dic,Prev,D+1);
Dic = Parse(sys.argv[1]);
me = Dic[-1][0];
print(Recursive(Dic,me,0));

তিনি তার সমস্ত অনাবৃত মুদ্রা ফিরিয়ে দেওয়ার চেষ্টা করেন, যদি তার কাছে কিছু আটকে থাকা ফ্লিপযুক্ত কয়েন থাকে তবে সে সেগুলি সরিয়ে ফেলবে এবং যদি তিনি তার সমস্ত মুদ্রা থেকে মুক্তি পান তবে তিনি অন্য কারও কাছে পাবেন।

Answer 8

বোকা, আর

args <- strsplit(commandArgs(TRUE),";")[[1]]
state <- as.data.frame(do.call(rbind,strsplit(args[-(1:3)],"_")), stringsAsFactors=FALSE)
colnames(state) <- c("id","pts","flipped","unflipped")
state$flipped <- as.integer(state$flipped)
state$unflipped <- as.integer(state$unflipped)
nb <- nrow(state)
score <- function(place) 2*state$flipped[place]-state$unflipped[place]
my_place <- which(state$id==args[2])
next_1 <- ifelse(my_place!=nb,my_place+1,1)
next_2 <- ifelse(next_1!=nb,next_1+1,1)
next_3 <- ifelse(next_2!=nb,next_2+1,1)
previous_1 <- ifelse(my_place!=1,my_place-1,nb)
previous_2 <- ifelse(previous_1!=1,previous_1-1,nb)
previous_3 <- ifelse(previous_2!=1,previous_2-1,nb)
n <- 3
out <- c()
while(n){
    M <- N <- score(my_place)
    R <- switch(n,"1"=score(next_1),
                "2"=cumsum(c(score(next_1),score(next_2))),
                "3"=cumsum(c(score(next_1),score(next_2),score(next_3))))
    P <- switch(n,"1"=score(previous_1),
                "2"=cumsum(c(score(previous_1),score(previous_2))),
                "3"=cumsum(c(score(previous_1),score(previous_2),score(previous_3))))
    M <- c(M,M+R[-n])
    N <- c(N,N+P[-n])
    if(any(R>M & R>0)){
        action <- c("R","RR","RRR")[which.max(R-M)]
        out <- c(out, action)
        state[,3:4] <- state[c((nchar(action)+1):nb,seq_len(nchar(action))),3:4]
        n <- n-nchar(action)
    }else if(any(P>N & P>0)){
        action <- c("T","TT","TTT")[which.max(P-N)]
        out <- c(out, action)
        state[,3:4] <- state[c((nb+1-seq_len(nchar(action))),1:(nb-seq_len(nchar(action)))),3:4]
        n <- n-nchar(action)
    }else if(n>1 & all(R[1]+M[1]>c(0,P[1]+M[1],R[1]+R[2]))){
        out <- c(out,"RT")
        n <- n-2
    }else if(n>1 & all(P[1]+M[1]>c(0,R[1]+M[1],P[1]+P[2]))){
        out <- c(out,"TR")
        n <- n-2
    }else{
        out <- c(out, switch(n,"1"="A","2"="1F","3"="2FF"))
        n <- 0
        }
    }
cat(paste(out,collapse=""))

চালানোর জন্য: Rscript Crook.R

মূলত এটি তার কয়েনগুলি প্রতিবেশীদের সাথে তখনই বিনিময় করে যদি এক্সচেঞ্জটি তার পক্ষে অসম হয়। যদি কোনও উপকারী বিনিময় সম্ভব না হয়, তবে এটি বৈশ্বিক স্তূপের সাথে কয়েনগুলি এমনভাবে বিনিময় করে যা তার অনুপাত অক্ষত রাখে তবে কিছু পয়েন্ট উত্পন্ন করে।

সম্পাদনা করুন: আমি এই বটটিতে সামান্য কিছুটা যুক্ত করেছি এটির পরের এবং পূর্ববর্তী 2 এবং 3 প্লেয়ার স্ট্যাকগুলি কেবল পরেরটির পরিবর্তে পরীক্ষা করে এবং পরীক্ষা করে দেখুন, সামগ্রিকভাবে, এটি বহুবার ঘোরানো উপকারী কিনা।

২ য় সম্পাদনা : @ মার্টিনবাটনার এর ধারণার অনুসরণ করে, বটটি এখন "আরটি" বা "টিআর" সম্পাদন করে, যদি এটি তার প্রতিবেশীদের চেয়ে বেশি উপকারী হয় (যদি আমি এটি বাস্তবায়নে বিড়বিড় না করি :))।

Comments

আপনার সম্পাদনাটি পুনরায়: আপনার পাশের লোকটির কাছে যদি এক টন ফ্লিপড কয়েন থাকে তবে এটি করা ভাল be RTRযাতে আপনি তার কয়েন থেকে দু'বার স্কোর পান।

— মার্টিন এন্ডার

সত্য। যদিও এটি প্রতিবেশীদের একজনকে একবার স্কোর দেবে। তবে আমি সত্যিই এটি সম্পর্কে চিন্তা করব, এটি অবশ্যই অন্বেষণ করার জন্য একটি ধারণা।

— প্ল্যানাপাস

@ মার্টিনব্যাটনার ঠিক আছে শেষ পর্যন্ত আমি বটের মনোভাব রাখার সময় এটি প্রয়োগের একটি উপায় খুঁজে পেয়েছি found পরামর্শের জন্য ধন্যবাদ!

— প্ল্যানাপাস

@ থ্রাক্স ঠিক যাতে পরের গেমটি চালানোর সময় আপনি আমার বট আপডেট করতে ভুলে যাবেন না, আমি ভেবেছিলাম আমার আপনাকে সতর্ক করা উচিত যে আপনার গিথুব রেপোতে আমার বটের সংস্করণটি একটি পুরানো।

— প্ল্যানাপাস

Answer 9

জিম, রুবি

মার্টিন বাটনার লোভী রোটেশন ভিত্তিক ।

PlayerId = 0
Points = 1
Flipped = 2
Unflipped = 3

round, id, global, *players = ARGV[0].split(';')
round = round.to_i
id = id.to_i
global = global.to_i

if(round == 1)
    print '3FF'
    exit
end

players.map!{ |s| s.split('_').map(&:to_i) }

nplayers = players.size

my_pos = players.find_index { |a| a[PlayerId] == id }

coin_vals = players.map{|a| a[Flipped]*2 - a[Unflipped]}

move = [-1,1].max_by{|s|
    swap_gain = coin_vals.rotate(s)
    scores = (0...nplayers).map{|i|
        swap_gain[i]+players[i][Points]
    }
    scores.delete_at(my_pos)-scores.max
}
if move == 1
    print 'R'
else
    print 'T'
end

print ['1F', 'FF'][rand 2]

সেরা অন্য খেলোয়াড়ের তুলনায় তাকে সবচেয়ে বেশি পয়েন্ট কী দেবে তার উপর নির্ভর করে এক বা অন্য দিকে ঘোরান। তারপরে, তিনি দ্রুত নগদ জন্য flips।

Answer 10

TraderBot

এই বটটি যখনই সেই ক্রিয়াটিতে সবচেয়ে বেশি পয়েন্ট নেয় তখনই এটি ঘোরানোর চেষ্টা করে। যদি এটি ঘুরতে না পারে তবে অপ্রস্তুত কয়েনগুলি থেকে পরিত্রাণ পাওয়ার চেষ্টা করুন বা নিম্নলিখিত ক্রিয়ায় তাদের পরিবর্তন করতে আরও কিছু নিন।

import java.util.ArrayList;

আমদানি java.util.List;

পাবলিক ক্লাস ট্রেডারবট {

class Player{
    private int id;
    private int points;
    private int flip;
    private int unflip;

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public int getPoints() {
        return points;
    }
    public void setPoints(int points) {
        this.points = points;
    }
    public int getFlip() {
        return flip;
    }
    public void setFlip(int flip) {
        this.flip = flip;
    }
    public int getUnflip() {
        return unflip;
    }
    public void setUnflip(int unflip) {
        this.unflip = unflip;
    }


}

int round;
int coins;
int otherMaxPoints = 0;
Player myself = new Player();
List<Player> players = new ArrayList<>();

public static void main (String[] s){
    new TraderBot().play(s);
}

private void play(String[] s){
    parse(s[0]);
    System.out.println(action() + action() + action());
}

private int simRotateNext(){
    int flip, unflip;
    int maxP = Integer.MIN_VALUE;
    int myP = 0;
    for (int i = 0; i < players.size(); i++){
        flip = players.get(i).getFlip();
        unflip = players.get(i).getUnflip();
        int next = i + 1 <= players.size() - 1 ? i + 1 : 0;
        int p = 2 * flip - unflip;
        if (p > maxP && players.get(next).getId() != myself.getId()){
            maxP = p;
        } else if (players.get(next).getId() == myself.getId()){
            myP = p;
        }

    }
    return  myP - maxP;
}

private int simRotatePrev(){
    int flip, unflip;
    int maxP = Integer.MIN_VALUE;
    int myP = 0;
    for (int i = players.size() -1; i > 0; i--){
        flip = players.get(i).getFlip();
        unflip = players.get(i).getUnflip();
        int prev = i - 1 >= 0 ? i - 1 : players.size() - 1;
        int p = 2 * flip - unflip;
        if (p > maxP && players.get(prev).getId() != myself.getId()){
            maxP = p;
        } else if (players.get(prev).getId() == myself.getId()){
            myP = p;
        }
    }
    return  myP - maxP;
}

private int rotateNext(){
    int flip, unflip, nflip, nunflip;
    flip = players.get(0).getFlip();
    unflip = players.get(0).getUnflip();
    for (int i = 0; i < players.size(); i++){
        int next = i + 1 <= players.size() - 1 ? i + 1 : 0;
        nflip = players.get(next).getFlip();
        nunflip = players.get(next).getUnflip();
        players.get(next).setFlip(flip);
        players.get(next).setUnflip(unflip);
        players.get(next).setPoints(players.get(next).getPoints() + 2 * flip - unflip);
        flip = nflip;
        unflip = nunflip;
    }
    return myself.getPoints();
}

private int rotatePrev(){
    int flip, unflip,  nflip, nunflip;
    flip = players.get(players.size() -1).getFlip();
    unflip = players.get(players.size() -1).getUnflip();
    for (int i = players.size() -1; i > 0; i--){
        int prev = i - 1 >= 0 ? i - 1 : players.size() - 1;
        nflip = players.get(prev).getFlip();
        nunflip = players.get(prev).getUnflip();
        players.get(prev).setFlip(flip);
        players.get(prev).setUnflip(unflip);
        players.get(prev).setPoints(players.get(prev).getPoints() + 2 * flip - unflip);
        flip = nflip;
        unflip = nunflip;
    }
    return myself.getPoints();
}

private String action() {
    int next = simRotateNext();
    int prev = simRotatePrev();

    if (next > 0 || prev > 0){
        if (next > prev){
            rotateNext();
            return "T";
        } else {
            rotatePrev();
            return "R";
        }
    }

    if (myself.getUnflip() > 3){
        myself.unflip -= 3;
        myself.points += 3;
        return "C";
    }

    if (myself.getUnflip() > 0){
        myself.unflip -= 1;
        myself.points += 2;
        return "F";
    }

    if (myself.getPoints() > otherMaxPoints){
        return "N";
    } else {
        myself.unflip += 3;
        myself.points -= 3;
        return "3";
    }

}

private void parse(String s){
    String[] ps = s.split(";");
    round = Integer.parseInt(ps[0]);
    myself.setId(Integer.parseInt(ps[1]));
    coins = round = Integer.parseInt(ps[2]);
    for (int i = 3; i < ps.length; i++){
        String[] sp2 = ps[i].split("_");
        if (Integer.parseInt(sp2[0]) == myself.getId()){
            myself.setPoints(Integer.parseInt(sp2[1]));
            myself.setFlip(Integer.parseInt(sp2[2]));
            myself.setUnflip(Integer.parseInt(sp2[3]));
            players.add(myself);
        } else {
            Player p = new Player();
            p.setId(Integer.parseInt(sp2[0]));
            p.setPoints(Integer.parseInt(sp2[1]));
            p.setFlip(Integer.parseInt(sp2[2]));
            p.setUnflip(Integer.parseInt(sp2[3]));
            players.add(p);
            if (p.getPoints() > otherMaxPoints){
                otherMaxPoints = p.getPoints();
            }
        }
    }
}
}

চালানোর জন্য: এটি কেবল ডিফল্ট বট হিসাবে একই ফোল্ডারে যুক্ত করুন এবং তারপরে নিম্নলিখিত ক্লাসটি তৈরি করুন

package players;

import controller.Player;

public class TraderBot extends Player {

    @Override
    public String getCmd() {
        return "java TraderBot";
    }   
}

তারপরে Player[] playersঅ্যারেতে এই ক্লাসটি যুক্ত করুন ।

Answer 11

হুইলার

হুইলার কয়েনগুলি ঘোরানোর সময় এটির জন্য সর্বোত্তম সম্ভাব্য পদক্ষেপ গণনা করে।

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

public class Wheeler {

String[] actions = {"TTT", "TTR", "TRR", "TRT", "RRR", "RRT", "RTR", "RTT"};
String paramString;

class Player{
    private int id;
    private int points;
    private int flip;
    private int unflip;

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public int getPoints() {
        return points;
    }
    public void setPoints(int points) {
        this.points = points;
    }
    public int getFlip() {
        return flip;
    }
    public void setFlip(int flip) {
        this.flip = flip;
    }
    public int getUnflip() {
        return unflip;
    }
    public void setUnflip(int unflip) {
        this.unflip = unflip;
    }
    @Override
    public String toString() {
        return "Player [id=" + id + ", points=" + points + ", flip=" + flip + ", unflip=" + unflip + "]";
    }




}

int round;
int coins;
int otherMaxPoints = 0;
Player myself = new Player();
List<Player> players = new ArrayList<>();

public static void main (String[] s){
    new Wheeler().play(s);
}

private void play(String[] s){
    paramString = s[0];
    reset();
    System.out.println(action());
}

private int rotateNext(){
    int flip, unflip, nflip, nunflip;
    flip = players.get(0).getFlip();
    unflip = players.get(0).getUnflip();
    for (int i = 0; i < players.size(); i++){
        int next = i + 1 <= players.size() - 1 ? i + 1 : 0;
        nflip = players.get(next).getFlip();
        nunflip = players.get(next).getUnflip();
        players.get(next).setFlip(flip);
        players.get(next).setUnflip(unflip);
        players.get(next).setPoints(players.get(next).getPoints() + 2 * flip - unflip);
        flip = nflip;
        unflip = nunflip;
    }
    return myself.getPoints();
}

private int rotatePrev(){
    int flip, unflip,  nflip, nunflip;
    flip = players.get(players.size() -1).getFlip();
    unflip = players.get(players.size() -1).getUnflip();
    for (int i = players.size() -1; i > 0; i--){
        int prev = i - 1 >= 0 ? i - 1 : players.size() - 1;
        nflip = players.get(prev).getFlip();
        nunflip = players.get(prev).getUnflip();
        players.get(prev).setFlip(flip);
        players.get(prev).setUnflip(unflip);
        players.get(prev).setPoints(players.get(prev).getPoints() + 2 * flip - unflip);
        flip = nflip;
        unflip = nunflip;
    }
    return myself.getPoints();
}

private String action() {
    int maxPoints = myself.getPoints();
    String action = "1F2";
    for (String s : actions){
        int cPoints = 0;
        for (char c : s.toCharArray()){
            if (c == 'T'){
                cPoints += rotateNext();
            } else {
                cPoints += rotatePrev();
            }
        }
        if (cPoints > maxPoints){
            action = s;
        }
        reset();
    }
    return action;      
}


private void reset(){
    players = new ArrayList<>();
    String[] ps = paramString.split(";");
    round = Integer.parseInt(ps[0]);
    myself.setId(Integer.parseInt(ps[1]));
    coins = round = Integer.parseInt(ps[2]);
    for (int i = 3; i < ps.length; i++){
        String[] sp2 = ps[i].split("_");
        if (Integer.parseInt(sp2[0]) == myself.getId()){
            myself.setPoints(Integer.parseInt(sp2[1]));
            myself.setFlip(Integer.parseInt(sp2[2]));
            myself.setUnflip(Integer.parseInt(sp2[3]));
            players.add(myself);
        } else {
            Player p = new Player();
            p.setId(Integer.parseInt(sp2[0]));
            p.setPoints(Integer.parseInt(sp2[1]));
            p.setFlip(Integer.parseInt(sp2[2]));
            p.setUnflip(Integer.parseInt(sp2[3]));
            players.add(p);
            if (p.getPoints() > otherMaxPoints){
                otherMaxPoints = p.getPoints();
            }
        }
    }
}

}

Answer 12

সাবোটিউর, পাইথন 2

import random
moves = '3R'
print '33' + ''.join(random.choice(moves))

এলোমেলোতার অর্থ সম্ভবত এটি খুব ভালভাবে নাশকতা হবে না, তবে পরে আমি মনে করি আমার এটি 'শেষ' হওয়া পর্যন্ত অপেক্ষা করবে (কতগুলি মুড়ি / মুদ্রা বাকি আছে) এবং তারপরে ঘুরতে হবে, কাছাকাছি পৌঁছনীয় খেলোয়াড়দের কাছ থেকে চুরি করার জন্য দেখার পরে ... প্রকৃতপক্ষে কেবলমাত্র একটি ঘূর্ণন করা খুব দুর্বল বলে মনে করে অন্যান্য লোকেরাও ঘূর্ণন ব্যবহার করার সম্ভাবনা রয়েছে। আমি মনে করি না এটি খুব ভাল কাজ করবে ...

Comments

এইটি সবচেয়ে বেশি যে জিনিসটি করে তা হ'ল মুদ্রার গাদাটি চালানো। পাশাপাশি নিজেকে এবং অন্যকে অনেকগুলি নেতিবাচক পয়েন্ট দিন।

— মেগাটম

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

— নিল

আপনার সিস আমদানির দরকার নেই। : পি

— বিড়াল

Answer 13

সেকেন্ডবেস্ট, পাইথন 3

এই প্রোগ্রামটি সমস্ত সম্ভাব্য 3 পদক্ষেপের সংমিশ্রণগুলির মধ্য দিয়ে যাবে এবং দ্বিতীয় সেরাটিকে বেছে নেবে।

কারণ আপনার যদি সঠিক পদক্ষেপ থাকে তবে এটি সম্ভবত একটি ফাঁদ।

সম্পাদনা: মন্তব্য-আউট ইনপুট সরানো হয়েছে

import sys
from copy import deepcopy
from random import randint
In=str(sys.argv[1])
def V(n,f=10,t=14):
 n=str(n);z=0;s='';d='0123456789';d1='N123ABCXYZRTFU'
 for i in n:z=z*f+d.index(i)
 while z:z,m=divmod(z,t);s=d1[m]+s
 while len(s)<3:s='N'+s
 return s
In=In.split(';')
number=In[0:3]
players=In[3:]
for x in range(0,len(players)):players[x]=players[x].split('_')
for x in players:
 if number[1] in x[0]:self=x
for x in range(0,len(players)):
 for y in range(0,len(players[x])):
  players[x][y]=int(players[x][y])
for x in range(0,len(number)):number[x]=int(number[x])
Pos=list(map(V,range(0,14**3)))
B=[]
C=[]
P1=deepcopy(players)
N1=deepcopy(number)
for x in range(len(Pos)):
    P=True
    y=Pos[x]
    if '1A'in y or '2B'in y or '3C'in y or 'FU'in y or 'A1'in y or 'B2'in y or 'C3'in y or 'UF'in y:
            P=False#stupid check
    if P:#legality check
        z=0
        players=deepcopy(P1)
        number=deepcopy(N1)
        for x in players:
            if str(number[1]) in str(x[0]):self=x
        for w in range(0,3):
            if y[w] in '3':
                if int(number[2])<3:P=False;break
                else:z-=3;self[3]+=3;number[2]-=3
            if y[w] in '2':
                if int(number[2])<2:P=False;break
                else:z-=2;self[3]+=2;number[2]-=2
            if y[w] in '1':
                if int(number[2])<1:P=False;break
                else:z-=1;self[3]+=1;number[2]-=1
            if y[w] in 'A':
                if int(self[3])<1:P=False;break
                else:z+=1;self[3]-=3;number[2]+=3
            if y[w] in 'B':
                if int(self[3])<2:P=False;break
                else:z+=2;self[3]-=2;number[2]+=2
            if y[w] in 'C':
                if int(self[3])<3:P=False;break
                else:z+=3;self[3]-=1;number[2]+=1
            if y[w] in 'X':
                if int(self[3])<1:P=False;break
                else:self[3]-=1
            if y[w] in 'Y':
                if int(self[3])<2:P=False;break
                else:self[3]-=2
            if y[w] in 'Z':
                if int(self[3])<3:P=False;break
                else:self[3]-=3
            if y[w] in 'F':
                if int(self[3])<1:P=False;break
                else:z+=2;self[3]-=1;self[2]+=1
            if y[w] in 'U':
                if int(self[3])<1:P=False;break
                else:z-=2;self[3]+=1;self[2]-=1
            if y[w] in 'R':
                self[2:4]=players[(players.index(self)+1)%len(players)][2:4]
                z+=int(self[3])*-1
                z+=int(self[2])*2
            if y[w] in 'T':
                self[2:4]=players[(players.index(self)-1)%len(players)][2:4]
                z+=int(self[3])*-1
                z+=int(self[2])*2
    if P:
        C.append(z);B.append((z,y))
c=list(set(C))
c.sort()
c=c[::-1][1];D=[]
for x in B:
    if c in x:D.append(x)
print(D[randint(0,len(D)-1)][1])

সম্পাদনা করুন: কোডটি একটি এলোমেলো আইনী পদক্ষেপ মুদ্রণ করছিল। এটি এখন দ্বিতীয় সেরা ফলাফলটি ফিরে আসবে।

Answer 14

শয়তানের বট

যদিও এর আউটপুটটি শয়তানের সংখ্যা মাত্র অর্ধেক, ফলাফলগুলি বেশ বিপর্যয়কর হওয়া উচিত। প্রতি বার 9 টি কয়েন নেওয়া, এটি শেষ পর্যন্ত মুদ্রার গাদা ক্লান্ত করে দেয়। যেহেতু এই বোটটি তার যে কোনও মুদ্রা নেয় সেটিকে কখনই ফ্লিপ করে না, তাই যখন কোনও ঘূর্ণন হয় তখন তার পাশে বসে অন্য কারও পক্ষে এটি অত্যন্ত খারাপ (এই বোটটি তোলা প্রতিটি পর্বের জন্য -9 পয়েন্ট)।

print("333")

COMMAND: python3 devil.py

আমি পরে কিছু বাস্তব বট করতে আশা করি।

Comments

@ প্ল্যানাপাস উফফ! আমি এটা খেয়াল করিনি। আমাকে বলার জন্য ধন্যবাদ!

— ফ্রেডেরিক

Answer 15

আমাকে স্মরণ কর, পাইথন 3

এই প্রোগ্রামটিতে ফিক্সড সেকেন্ডবেস্ট বটের বিরুদ্ধে একটি পরীক্ষা থেকে উল্লেখযোগ্য পরিমাণ ইনবিল্ট ডেটা রয়েছে।

এটা তোলে উচিত কি প্যাচসমূহ ব্যবহার করা সবচেয়ে ভাল হয় সম্পর্কে জানতে তবে এটি অন্যান্য খেলোয়াড়দের ইনপুট ব্যবহার করে না।

সম্পাদনা: অপ্রয়োজনীয় পয়েন্ট গণনা সরানো হয়েছে

সম্পাদনা: নিরক্ষিত প্লেয়ার ইনপুট

import sys
file=sys.argv[0].split('\\')[::-1][0]
from copy import deepcopy
from random import randint
In=str(sys.argv[1])
def V(n,f=10,t=14):
 n=str(n);z=0;s='';d='0123456789';d1='N123ABCXYZRTFU'
 for i in n:z=z*f+d.index(i)
 while z:z,m=divmod(z,t);s=d1[m]+s
 while len(s)<3:s='N'+s
 return s
In=In.split(';')
number=In[0:3]
players=In[3:]
for x in range(0,len(players)):players[x]=players[x].split('_')
for x in players:
 if number[1] in x[0]:self=x
for x in range(0,len(players)):
 for y in range(0,len(players[x])):
  players[x][y]=int(players[x][y])
for x in range(0,len(number)):number[x]=int(number[x])
Pos=list(map(V,range(0,14**3)))
B=[]
P1=deepcopy(players)
N1=deepcopy(number)
for x in range(len(Pos)):
    P=True
    y=Pos[x]
    if '1A'in y or '2B'in y or '3C'in y or 'FU'in y or 'A1'in y or 'B2'in y or 'C3'in y or 'UF'in y:
            P=False
    if P:
        players=deepcopy(P1)
        number=deepcopy(N1)
        for x in players:
            if str(number[1]) in str(x[0]):self=x
        for w in range(0,3):
            if y[w] in '3':
                if int(number[2])<3:P=False;break
                else:self[3]+=3;number[2]-=3
            if y[w] in '2':
                if int(number[2])<2:P=False;break
                else:self[3]+=2;number[2]-=2
            if y[w] in '1':
                if int(number[2])<1:P=False;break
                else:self[3]+=1;number[2]-=1
            if y[w] in 'A':
                if int(self[3])<1:P=False;break
                else:self[3]-=3;number[2]+=3
            if y[w] in 'B':
                if int(self[3])<2:P=False;break
                else:self[3]-=2;number[2]+=2
            if y[w] in 'C':
                if int(self[3])<3:P=False;break
                else:self[3]-=1;number[2]+=1
            if y[w] in 'X':
                if int(self[3])<1:P=False;break
                else:self[3]-=1
            if y[w] in 'Y':
                if int(self[3])<2:P=False;break
                else:self[3]-=2
            if y[w] in 'Z':
                if int(self[3])<3:P=False;break
                else:self[3]-=3
            if y[w] in 'F':
                if int(self[3])<1:P=False;break
                else:self[3]-=1;self[2]+=1
            if y[w] in 'U':
                if int(self[3])<1:P=False;break
                else:self[3]+=1;self[2]-=1
            if y[w] in 'R':
                self[2:4]=players[(players.index(self)+1)%len(players)][2:4]
            if y[w] in 'T':
                self[2:4]=players[(players.index(self)-1)%len(players)][2:4]
    if P:
        B.append(y)
Pos=list(B)
B=[]
#
C=[['NNN',0],['NN1',-1],['NN2',-2],['NN3',-3],['NNR',-6],['NNT',-1],['N1N',-1],['N11',-2],['N12',-3],['N13',-4],['N1X',-1],['N1R',-7],['N1T',-2],['N1F',1],['N1U',-3],['N2N',-2],['N21',-3],['N22',-4],['N23',-5],['N2A',-1],['N2X',-2],['N2Y',-2],['N2R',-8],['N2T',-3],['N2F',0],['N2U',-4],['N3N',-3],['N31',-4],['N32',-5],['N33',-6],['N3A',-2],['N3B',-1],['N3X',-3],['N3Y',-3],['N3Z',-3],['N3R',-9],['N3T',-4],['N3F',-1],['N3U',-5],['NRN',-6],['NR1',-7],['NR2',-8],['NR3',-9],['NRA',-5],['NRB',-4],['NRC',-3],['NRX',-6],['NRY',-6],['NRZ',-6],['NRR',-12],['NRT',-7],['NRF',-4],['NRU',-8],['NTN',-1],['NT1',-2],['NT2',-3],['NT3',-4],['NTA',0],['NTX',-1],['NTR',-7],['NTT',-2],['NTF',1],['NTU',-3],['1NN',-1],['1N1',-2],['1N2',-3],['1N3',-4],['1NA',0],['1NX',-1],['1NR',-7],['1NT',-2],['1NF',1],['1NU',-3],['11N',-2],['111',-3],['112',-4],['113',-5],['11B',0],['11X',-2],['11Y',-2],['11R',-8],['11T',-3],['11F',0],['11U',-4],['12N',-3],['121',-4],['122',-5],['123',-6],['12A',-2],['12C',0],['12X',-3],['12Y',-3],['12Z',-3],['12R',-9],['12T',-4],['12F',-1],['12U',-5],['13N',-4],['131',-5],['132',-6],['133',-7],['13A',-3],['13B',-2],['13X',-4],['13Y',-4],['13Z',-4],['13R',-10],['13T',-5],['13F',-2],['13U',-6],['1XN',-1],['1X1',-2],['1X2',-3],['1X3',-4],['1XR',-7],['1XT',-2],['1RN',-7],['1R1',-8],['1R2',-9],['1R3',-10],['1RA',-6],['1RB',-5],['1RC',-4],['1RX',-7],['1RY',-7],['1RZ',-7],['1RR',-13],['1RT',-8],['1RF',-5],['1RU',-9],['1TN',-2],['1T1',-3],['1T2',-4],['1T3',-5],['1TA',-1],['1TX',-2],['1TR',-8],['1TT',-3],['1TF',0],['1TU',-4],['1FN',1],['1F1',0],['1F2',-1],['1F3',-2],['1FR',-5],['1FT',0],['1UN',-3],['1U1',-4],['1U2',-5],['1U3',-6],['1UA',-2],['1UB',-1],['1UX',-3],['1UY',-3],['1UR',-9],['1UT',-4],['1UU',-5],['2NN',-2],['2N1',-3],['2N2',-4],['2N3',-5],['2NA',-1],['2NB',0],['2NX',-2],['2NY',-2],['2NR',-8],['2NT',-3],['2NF',0],['2NU',-4],['21N',-3],['211',-4],['212',-5],['213',-6],['21B',-1],['21C',0],['21X',-3],['21Y',-3],['21Z',-3],['21R',-9],['21T',-4],['21F',-1],['21U',-5],['22N',-4],['221',-5],['222',-6],['223',-7],['22A',-3],['22C',-1],['22X',-4],['22Y',-4],['22Z',-4],['22R',-10],['22T',-5],['22F',-2],['22U',-6],['23N',-5],['231',-6],['232',-7],['233',-8],['23A',-4],['23B',-3],['23X',-5],['23Y',-5],['23Z',-5],['23R',-11],['23T',-6],['23F',-3],['23U',-7],['2AN',-1],['2A2',-3],['2A3',-4],['2AR',-7],['2AT',-2],['2XN',-2],['2X1',-3],['2X2',-4],['2X3',-5],['2XA',-1],['2XX',-2],['2XR',-8],['2XT',-3],['2XF',0],['2XU',-4],['2YN',-2],['2Y1',-3],['2Y2',-4],['2Y3',-5],['2YR',-8],['2YT',-3],['2RN',-8],['2R1',-9],['2R2',-10],['2R3',-11],['2RA',-7],['2RB',-6],['2RC',-5],['2RX',-8],['2RY',-8],['2RZ',-8],['2RR',-14],['2RT',-9],['2RF',-6],['2RU',-10],['2TN',-3],['2T1',-4],['2T2',-5],['2T3',-6],['2TA',-2],['2TX',-3],['2TR',-9],['2TT',-4],['2TF',-1],['2TU',-5],['2FN',0],['2F1',-1],['2F2',-2],['2F3',-3],['2FA',1],['2FX',0],['2FR',-6],['2FT',-1],['2FF',2],['2UN',-4],['2U1',-5],['2U2',-6],['2U3',-7],['2UA',-3],['2UB',-2],['2UC',-1],['2UX',-4],['2UY',-4],['2UZ',-4],['2UR',-10],['2UT',-5],['2UU',-6],['3NN',-3],['3N1',-4],['3N2',-5],['3N3',-6],['3NA',-2],['3NB',-1],['3NC',0],['3NX',-3],['3NY',-3],['3NZ',-3],['3NR',-9],['3NT',-4],['3NF',-1],['3NU',-5],['31N',-4],['311',-5],['312',-6],['313',-7],['31B',-2],['31C',-1],['31X',-4],['31Y',-4],['31Z',-4],['31R',-10],['31T',-5],['31F',-2],['31U',-6],['32N',-5],['321',-6],['322',-7],['323',-8],['32A',-4],['32C',-2],['32X',-5],['32Y',-5],['32Z',-5],['32R',-11],['32T',-6],['32F',-3],['32U',-7],['33N',-6],['331',-7],['332',-8],['333',-9],['33A',-5],['33B',-4],['33X',-6],['33Y',-6],['33Z',-6],['33R',-12],['33T',-7],['33F',-4],['33U',-8],['3AN',-2],['3A2',-4],['3A3',-5],['3AR',-8],['3AT',-3],['3BN',-1],['3B1',-2],['3B3',-4],['3BA',0],['3BX',-1],['3BR',-7],['3BT',-2],['3BF',1],['3BU',-3],['3XN',-3],['3X1',-4],['3X2',-5],['3X3',-6],['3XA',-2],['3XB',-1],['3XX',-3],['3XY',-3],['3XR',-9],['3XT',-4],['3XF',-1],['3XU',-5],['3YN',-3],['3Y1',-4],['3Y2',-5],['3Y3',-6],['3YA',-2],['3YX',-3],['3YR',-9],['3YT',-4],['3YF',-1],['3YU',-5],['3ZN',-3],['3Z1',-4],['3Z2',-5],['3Z3',-6],['3ZR',-9],['3ZT',-4],['3RN',-9],['3R1',-10],['3R2',-11],['3R3',-12],['3RA',-8],['3RB',-7],['3RC',-6],['3RX',-9],['3RY',-9],['3RZ',-9],['3RR',-15],['3RT',-10],['3RF',-7],['3RU',-11],['3TN',-4],['3T1',-5],['3T2',-6],['3T3',-7],['3TA',-3],['3TX',-4],['3TR',-10],['3TT',-5],['3TF',-2],['3TU',-6],['3FN',-1],['3F1',-2],['3F2',-3],['3F3',-4],['3FA',0],['3FB',1],['3FX',-1],['3FY',-1],['3FR',-7],['3FT',-2],['3FF',1],['3UN',-5],['3U1',-6],['3U2',-7],['3U3',-8],['3UA',-4],['3UB',-3],['3UC',-2],['3UX',-5],['3UY',-5],['3UZ',-5],['3UR',-11],['3UT',-6],['3UU',-7],['RNN',-6],['RN1',-7],['RN2',-8],['RN3',-9],['RNA',-5],['RNB',-4],['RNC',-3],['RNX',-6],['RNY',-6],['RNZ',-6],['RNR',-12],['RNT',-7],['RNF',-4],['RNU',-8],['R1N',-7],['R11',-8],['R12',-9],['R13',-10],['R1B',-5],['R1C',-4],['R1X',-7],['R1Y',-7],['R1Z',-7],['R1R',-13],['R1T',-8],['R1F',-5],['R1U',-9],['R2N',-8],['R21',-9],['R22',-10],['R23',-11],['R2A',-7],['R2C',-5],['R2X',-8],['R2Y',-8],['R2Z',-8],['R2R',-14],['R2T',-9],['R2F',-6],['R2U',-10],['R3N',-9],['R31',-10],['R32',-11],['R33',-12],['R3A',-8],['R3B',-7],['R3X',-9],['R3Y',-9],['R3Z',-9],['R3R',-15],['R3T',-10],['R3F',-7],['R3U',-11],['RAN',-5],['RA2',-7],['RA3',-8],['RAA',-4],['RAB',-3],['RAC',-2],['RAX',-5],['RAY',-5],['RAZ',-5],['RAR',-11],['RAT',-6],['RAF',-3],['RAU',-7],['RBN',-4],['RB1',-5],['RB3',-7],['RBA',-3],['RBB',-2],['RBC',-1],['RBX',-4],['RBY',-4],['RBZ',-4],['RBR',-10],['RBT',-5],['RBF',-2],['RBU',-6],['RCN',-3],['RC1',-4],['RC2',-5],['RCA',-2],['RCB',-1],['RCC',0],['RCX',-3],['RCY',-3],['RCZ',-3],['RCR',-9],['RCT',-4],['RCF',-1],['RCU',-5],['RXN',-6],['RX1',-7],['RX2',-8],['RX3',-9],['RXA',-5],['RXB',-4],['RXC',-3],['RXX',-6],['RXY',-6],['RXZ',-6],['RXR',-12],['RXT',-7],['RXF',-4],['RXU',-8],['RYN',-6],['RY1',-7],['RY2',-8],['RY3',-9],['RYA',-5],['RYB',-4],['RYC',-3],['RYX',-6],['RYY',-6],['RYZ',-6],['RYR',-12],['RYT',-7],['RYF',-4],['RYU',-8],['RZN',-6],['RZ1',-7],['RZ2',-8],['RZ3',-9],['RZA',-5],['RZB',-4],['RZC',-3],['RZX',-6],['RZY',-6],['RZZ',-6],['RZR',-12],['RZT',-7],['RZF',-4],['RZU',-8],['RRN',-12],['RR1',-13],['RR2',-14],['RR3',-15],['RRA',-11],['RRB',-10],['RRC',-9],['RRX',-12],['RRY',-12],['RRZ',-12],['RRR',-18],['RRT',-13],['RRF',-10],['RRU',-14],['RTN',-7],['RT1',-8],['RT2',-9],['RT3',-10],['RTA',-6],['RTX',-7],['RTR',-13],['RTT',-8],['RTF',-5],['RTU',-9],['RFN',-4],['RF1',-5],['RF2',-6],['RF3',-7],['RFA',-3],['RFB',-2],['RFC',-1],['RFX',-4],['RFY',-4],['RFZ',-4],['RFR',-10],['RFT',-5],['RFF',-2],['RUN',-8],['RU1',-9],['RU2',-10],['RU3',-11],['RUA',-7],['RUB',-6],['RUC',-5],['RUX',-8],['RUY',-8],['RUZ',-8],['RUR',-14],['RUT',-9],['RUU',-10],['TNN',-1],['TN1',-2],['TN2',-3],['TN3',-4],['TNA',0],['TNX',-1],['TNR',-7],['TNT',-2],['TNF',1],['TNU',-3],['T1N',-2],['T11',-3],['T12',-4],['T13',-5],['T1B',0],['T1X',-2],['T1Y',-2],['T1R',-8],['T1T',-3],['T1F',0],['T1U',-4],['T2N',-3],['T21',-4],['T22',-5],['T23',-6],['T2A',-2],['T2C',0],['T2X',-3],['T2Y',-3],['T2Z',-3],['T2R',-9],['T2T',-4],['T2F',-1],['T2U',-5],['T3N',-4],['T31',-5],['T32',-6],['T33',-7],['T3A',-3],['T3B',-2],['T3X',-4],['T3Y',-4],['T3Z',-4],['T3R',-10],['T3T',-5],['T3F',-2],['T3U',-6],['TAN',0],['TA2',-2],['TA3',-3],['TAR',-6],['TAT',-1],['TXN',-1],['TX1',-2],['TX2',-3],['TX3',-4],['TXR',-7],['TXT',-2],['TRN',-7],['TR1',-8],['TR2',-9],['TR3',-10],['TRA',-6],['TRB',-5],['TRC',-4],['TRX',-7],['TRY',-7],['TRZ',-7],['TRR',-13],['TRT',-8],['TRF',-5],['TRU',-9],['TTN',-2],['TT1',-3],['TT2',-4],['TT3',-5],['TTA',-1],['TTX',-2],['TTR',-8],['TTT',-3],['TTF',0],['TTU',-4],['TFN',1],['TF1',0],['TF2',-1],['TF3',-2],['TFR',-5],['TFT',0],['TUN',-3],['TU1',-4],['TU2',-5],['TU3',-6],['TUA',-2],['TUB',-1],['TUX',-3],['TUY',-3],['TUR',-9],['TUT',-4],['TUU',-5]]
#
points=0
#
dpoints=self[1]-points
z=0
for x in range(len(Pos)):
    y=Pos[x]
    z=0
    for x in C:
     if x[0]==y:z=x[1]
    B.append((z,y))
B.sort()
B=B[::-1]
G=open(file,'r')
H=G.read().split('#')[::-1]
G.close()
G=open(file,'w')
H[3]=H[3].replace(H[3][8:-1],str(self[1]))
J=eval(H[4][3:-1])
A=[B[0][1],dpoints]
P=1
for x in range(0,len(J)):
 if J[x][0]==A[0]:J[x][1]+=A[1];P=0
if P:J.append(A)
H[4]='\nC='+str(J)+'\n'
s=''
for x in H[::-1]:s+=x;s+='#'
G.write(s[:-1])
G.close()
print(B[0][1])

Comments

আমি মনে করি আপনার ইনপুটটি # 5 লাইনে মন্তব্য করেছে

— অ্যাভেরোয়েস

এটা এখন সংশোধন করা উচিত। এটা ইশারা জন্য ধন্যবাদ।

— ম্যাজেন্টা