ব্যবসায়ীদের কাছে মৃত্যু

Question

আপনি লাভের আশায় বিদেশী ব্যবসায়ী। 5 টি পণ্য রয়েছে যা লোকেরা বাণিজ্য করতে চায়: Apricot, Boars, Canaries, Daffodils এবং Earwigs। শীতে শুরু করে, আপনাকে কী উত্পাদন করতে হবে তা সিদ্ধান্ত নেওয়া দরকার। তারপরে, শরত্কালে, আপনি ভ্রমণ এবং একটি লাভের জন্য আপনার দিনগুলি ট্রেডিংয়ে ব্যয় করেন।

গেমপ্লের

আপনি স্টোরেজে প্রতিটি পণ্য 10 দিয়ে গেমটি শুরু করেন। প্রতি বছর, আপনি প্রতিটি পণ্য 2 গ্রাহক হবে।

গেমের শুরুতে, আপনি প্রতি বছরের পরিমাণ উত্পাদন করতে সক্ষম হবেন সেই পরিমাণের সাথে আপনি 5 টি পণ্যের একটি তালিকা পাবেন (যেমন 5-A,6-B,3-C,12-D,4-E:)। তারপরে আপনি E এর মাধ্যমে একটি চিঠি এ ফিরে আসবেন কী সিদ্ধান্ত নেবেন তা স্থির করে।

তারপরে, শরত্কালে আপনি আপনার পণ্যগুলি (স্টোরেজ সহ) বাজারে আনবেন। আপনার বাণিজ্যে 50 টি পালা রয়েছে।

আপনি সিদ্ধান্ত নিতে হবে আপনি Pবাজারটি খোলেন, ইল করতে Sবা Lইভা করতে চান কিনা । ক্রেতাদের তখন বিক্রেতাদের সাথে এলোমেলোভাবে জুড়ি দেওয়া হবে। যদি কোনও গোষ্ঠীর অতিরিক্ত থাকে তবে এলোমেলো অতিরিক্ত এই পালাটি মিস করবে। কোনও ব্যবসায়ীকে এড়িয়ে গেলে, তারা Sঅন্যথায় তা গ্রহণ করবে T। বিক্রেতা স্থির করতে হবে তিনি কি বিক্রি করতে চায়, এবং পরিমাণ (উদা: 3-A), এবং তারপর তিনি যা মেনে নেবেন (উদা: 5-B,2-D,1-E) (মান কোন না সব )। তারপরে ক্রেতাকে বলা হবে যে বিক্রেতার কী পণ্য বিক্রয় করছে, তারপরে বিক্রয়কারীরা তার যে পণ্য গ্রহণ করবে এবং সে তার ব্যবসায়ের জন্য কোনও পণ্য বেছে নিতে পারে (যেমন: Dবা Xকিছুই নয়)।

সমস্ত ব্যবসা-বাণিজ্য শেষ হওয়ার পরে, বা বাজার ছাড়ার পরে, আপনি প্রতিটি পণ্যের 2 টি ব্যবহার করবেন এবং বছর শুরু হবে। আপনার যদি কোনও 1 টি পণ্যের 2 টিরও কম থাকে তবে আপনি মারা যাবেন (এবং উত্তীর্ণ Q)।

আপনার স্কোরটি আপনি গত বছরের সংখ্যা হবে এবং 50 গেমসের পরে, আপনার স্কোর আপনার মোট স্কোরের জন্য গড় হবে।

.চ্ছিক চলন

যে কোনও সময় আপনি Gআপনার পণ্য জিজ্ঞাসা করতে ফিরে আসতে পারেন

যে কোনও সময়ে আপনি Nআপনার ইনভেন্টরিতে নতুন পণ্য সংখ্যা জিজ্ঞাসা করতে ফিরে আসতে পারেন (গত বছরের কোনও খেলোয়াড়ের দ্বারা উত্পাদিত, এবং নতুন পণ্যগুলি পুরানো পণ্যগুলির আগে কেনাবেচা হবে)

যে কোন সময়ে আপনি আসতে পারেন Tবর্তমান চালু ফ্রেজ জন্য: Produce, Market, অথবা Trading

কোনও ব্যবসায়ের সময় Iআপনি যে খেলোয়াড়ের সাথে বাণিজ্য করছেন তার অনন্য পরিচয়দাতার সন্ধান করতে পারেন ।

কোনও ব্যবসায়ের সময়, আপনি Mব্যবসায়িক সংখ্যার প্রশ্নে ফিরে আসতে পারেন

এটি কীভাবে কোড করবেন:

আপনি যে কোনও মানক ভাষা ব্যবহার করতে পারেন এবং command.txtআপনার প্রোগ্রামটি চালনার জন্য আদেশটি অন্তর্ভুক্ত থাকতে হবে ।

আপনার প্রোগ্রামের সাধারণ প্রবাহটি হ'ল:

Get productivity
While alive:
    Output product you want to produce
    While in trading:
        Output whether you want to purchase or sell
        Get whether or not you were skipped.  If not skipped:
            If purchasing:
                print product you offer, and products you will accept
            Else:
                Get product offered, products being accepted, and choose the product you will give

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

ভেতরের ক্রিয়াকাণ্ড

জমা দেওয়া প্রতিটি প্রোগ্রামের জন্য 5 টি বট থাকবে। একই ধরণের বটগুলির জন্য আইডি আলাদা হবে।

একজন প্রদত্ত পণ্য উত্পাদনশীলতা উত্পাদন করতে পারে তার পরিমাণকে আমি বলব। প্রতিটি পণ্যকে একটি বেস উত্পাদনশীলতা দেওয়া হবে, যেখানে সমস্ত বেস উত্পাদনশীলতা 30 পর্যন্ত যোগ হবে the স্কোরগুলির মধ্যে একটি সর্বাধিক 3 হওয়া নিশ্চিত করা হবে এবং সমস্ত কমপক্ষে 2 হবে।

তারপরে, প্রতিটি খেলোয়াড়ের উত্পাদনশীলতা বেস উত্পাদনশীলতা থেকে পৃথক হবে (একটি মান +2, অন্য +1, তারপরে +0, -1 দ্বারা পৃথক হবে এবং অবশিষ্ট মান -2 দ্বারা পৃথক হবে)।

বেস উত্পাদনশীলতা গেম থেকে গেমে পরিবর্তিত হবে।

স্কোর:

seer:                10.128 years
level_headed_trader: 8.196 years
introvert:           6.856 years
random_ando:         5.408 years
hoarder_trader:      4.12 years
ratio_trader:        3.532 years
scared_trader:       3.056 years

Comments

সুতরাং, যদি 10 জন ব্যবহারকারী জমা দেওয়া প্রোগ্রাম থাকে তবে একটি গেমের 60 (10 জমা + 10 x 5 বট) প্লেয়ার / ব্যবসায়ী থাকবে? এছাড়াও, আমি মনে করি না যে আপনি কোন গেমের সর্বোচ্চ বছরের সংখ্যা কতটা স্থায়ী হতে পারে তা উল্লেখ করেছেন। কেবলমাত্র সেখানে 50 টি গেম থাকবে এবং কোনও গেমের জন্য সেই ব্যবসায়ী / প্লেয়ারের স্কোর হবে যে তারা কত দিন স্থায়ী ছিল।

— AndoDaan

না। আমার বটগুলি বাকীগুলির চেয়ে আলাদা নয়। যদি 10 জন জমা দেওয়া থাকে তবে সেখানে (10 players + 4 my bots)*5ব্যবসায়ী থাকবে। গেমটি সেট আপ হয়েছে তাই চিরকালের জন্য কোনও গেম চালানো অসম্ভব। অবশেষে প্রত্যেকেই মারা যাবে।

— নাথান মেরিল

@ অ্যান্ডোডান আমি এক সপ্তাহ পরে এটিতে একটি অনুদান রাখব। সেখানে হবে জমা হতে।

— নাথান মেরিল

@ এন্ডোডান ইম এক সাথে ব্যস্ত: ডি

— ইটারঅফকোড

@ বেটাডেকে বিভিন্ন বৈকল্পিক পদক্ষেপের কারণে এটি শক্ত। একমাত্র আউটপুট যা সর্বদা ঘটবে তা হ'ল প্রথম উত্পাদনশীলতা, চূড়ান্ত q, আপনাকে বাদ দেওয়া হয়েছিল কিনা, এবং আপনি যদি কিনে থাকেন তবে বিক্রেতার অফার এবং গ্রহণযোগ্য পণ্য। আমি আশা করি ইনপুটগুলি সুস্পষ্ট।

— নাথান মেরিল

Answer 1

দ্রষ্টা

এই প্রোগ্রামটি ভবিষ্যতের পূর্বাভাস দেয় এবং তিনি এমন ব্যবসায় নির্বাচন করেন যা তার প্রত্যাশিত জীবনকাল বাড়িয়ে তুলবে।

এটি সম্পূর্ণরূপে সমাপ্ত হয়নি, কারণ তিনি কেবল কীভাবে জিনিস কেনা জানেন তবে কী জিনিস বিক্রি করবেন না, তাই ভবিষ্যতে একটি আপডেটের আশা করুন। নির্বিশেষে, আমি বিশ্বাস করি যে তিনি প্রতিদ্বন্দ্বিতাপূর্ণ হয়ে উঠবেন।

$| = 1;
@names = ('A','B','C','D','E');
@counts = (12,12,12,12,12);
%names = ('A',0,'B',1,'C',2,'D',3,'E',4);

sub predict{
 local @a = @_;
 local $minval = 1000;
 local $minloc = 0;
 for(0..~~@a-1){
  if($a[$_]<$minval){
   $minloc = $_;
   $minval = $a[$_]
  }
  $a[$_]-=2;
 }
 if($minval <= 1){return (0,@a)}
 if($minval == 100){return (10000,@a)}
 $a[$minloc] += $productivity[$minloc];
 local @b = predict(@a);
 @b[0]++;
 return @b;
}

sub choice{
 local @a = @_;
 local $minloc = 0;
 local $minval = 1000;
 for(0..~~@a-1){
  if($a[$_]<$minval){
   $minloc = $_;
   $minval = $a[$_]
  }
 }
 return $minloc;
}


$productivity = <>;
@productivity = split(',',$productivity);

#@c = predict(@counts);
#print "@c\n";
$alive = 1;
while($alive){
 for(0..4){
  $counts[$_] -= 2;
 }
 $choice = choice(@counts);
 print "$names[$choice]\n";
 $counts[$choice] += $productivity[$choice];
 for(1..50){
  print "P\n";
  chomp($in = <>);
  if($in eq "T"){
   chomp($forsale = <>);
   ($quantity,$type) = split("-",$forsale);
   $type = $names{$type};
   #print "$quantity, $type\n";
   chomp($in = <>);
   @options = split(",",$in);
   @baseline = predict(@counts);
   $lifespan = shift @baseline;
   $basescore = $lifespan * 1000;
   @bestcounts = @counts;
   for(0..4){
    $basescore -= 10**(-1 * $baseline[$_]);
   }
   #print "Base: $basescore\n";
   @hypo = ();
   $bestscore = $basescore;
   $choice = "X";
   for(0..$#options){$curchoice = $_;
    ($cost,$ctype) = split("-",$options[$curchoice]);
    $ctype = $names{$ctype};
    @tempcounts = @counts;
    $tempcounts[$type] += $quantity;
    $tempcounts[$ctype] -= $cost;
    @curhypo = predict(@tempcounts);
    @hypo[$curchoice] = [@curhypo];
    #print "@curhypo\n";
    $lifespan = shift @curhypo;
    $score = $lifespan * 1000;
    for(0..4){
     $score -= 10**(-1 * $curhypo[$_]);
    }
    #print"$score\n";
    if($score > $bestscore){
     $bestscore = $score;
     $choice = $names[$ctype];
     @bestcounts = @tempcounts;
    }
   }
   print "$choice\n";
   @counts = @bestcounts;
  }
  #print"@counts\n";
  #@c = predict(@counts);
  #print "@c\n";
 }
}

আমি এই প্রোগ্রামটি এভাবে চালাচ্ছি:

perl seer.plx

Comments

আমি আপনার প্রোগ্রামটি কাজ করতে পেয়েছি, তবে আমাকে $| = 1শুরুতে যুক্ত করতে হয়েছিল। আপনার পরবর্তী সংশোধনের জন্য, দয়া করে এটি করুন। এছাড়াও, আপনার বটটি এত ভাল করে নি। ফলাফলগুলি দেখার জন্য: পেস্টবিন.com

— নাথান মেরিল

@ নাথানমিরিল খুব সংক্ষিপ্ত জীবনযাত্রা কান্ডা উদ্ভট .... আমি এখন তা একবার দেখে নিই।

— ফিনোটপি পি

Answer 2

স্তরের নেতৃত্বাধীন ব্যবসায়ী

এই বটটি তার পরিমাণগুলি যতটা সম্ভব সমান করার চেষ্টা করে

command.txt

python leveller.py

leveller.py

import sys

def current_goods():
    print "G"
    return parse_goods(readline())

def parse_goods(good_string):
    return dict([(a, int(b))
                 for a, b in [product.split("-")
                              for product in good_string.split(",")]])

def get_minimum(goods):
    cur_min = 200
    min_good = "X"
    for good, amount in goods.items():
        if amount < cur_min:
            min_good = good
            cur_min = amount
    return min_good

def get_maximum(goods):
    cur_max = -1
    max_good = "X"
    for good, amount in goods.items():
        if amount > cur_max:
            max_good = good
            cur_max = amount
    return max_good

def add_goods(x, y):
    return {k: int(x.get(k, 0)) + int(y.get(k, 0)) for k in set(x) | set(y)}

def readline():
    line = sys.stdin.readline().strip()
    if line == 'Q' or not line:
        exit()
    return line

def output_goods(goods):
    print ",".join([good+"-"+str(amount) for good, amount in goods.items()])

def output_good(good, amount):
    print good+"-"+str(amount)

def current_turn_is(turn):
    print "T"
    return readline() == turn

turns = MARKET, PRODUCE, TRADING, SKIPPED = "M", "P", "T", "S"
market_options = PURCHASE, SELL = "P", "S"
items = APRICOTS, BOARS, CANARIES, DAFFODILS, EARWIGS, NOTHING = "A", "B", "C", "D", "E", "X"

productivity = parse_goods(readline())
while True:
    product_to_produce = get_minimum(current_goods())
    print product_to_produce
    while current_turn_is(MARKET):
        print SELL
        if readline() != SKIPPED:
            maximum = get_maximum(current_goods())
            goods = {"A": 1, "B": 1, "C": 1, "D": 1, "E": 1}
            del goods[maximum]
            output_good(maximum, 1)
            output_goods(goods)

Answer 3

ভীত ব্যবসায়ী

এই ব্যবসায়ী কম নম্বর পাওয়া এড়ায়

command.txt

python scared.py

scared.py

import sys

def current_goods():
    print "G"
    return parse_goods(readline())

def parse_goods(good_string):
    return dict([(a, int(b))
                 for a, b in [product.split("-")
                              for product in good_string.split(",")]])

def get_minimum(goods):
    cur_min = 200
    min_good = "X"
    for good, amount in goods.items():
        if amount < cur_min:
            min_good = good
            cur_min = amount
    return min_good

def get_maximum(goods):
    cur_max = -1
    max_good = "X"
    for good, amount in goods.items():
        if amount > cur_max:
            max_good = good
            cur_max = amount
    return max_good

def add_goods(x, y):
    return {k: int(x.get(k, 0)) + int(y.get(k, 0)) for k in set(x) | set(y)}

def readline():
    line = sys.stdin.readline().strip()
    if line == 'Q' or not line:
        exit()
    return line

def output_goods(goods):
    print ",".join([good+"-"+str(amount) for good, amount in goods.items()])

def output_good(good, amount):
    print good+"-"+str(amount)

def current_turn_is(turn):
    print "T"
    return readline() == turn

turns = MARKET, PRODUCE, TRADING, SKIPPED = "M", "P", "T", "S"
market_options = PURCHASE, SELL = "P", "S"
items = APRICOTS, BOARS, CANARIES, DAFFODILS, EARWIGS, NOTHING = "A", "B", "C", "D", "E", "X"

productivity = parse_goods(readline())
while True:
    current = current_goods()
    min_product = get_minimum(current)
    min_amount = current[min_product]
    product_to_produce = min_product if min_amount < 4 else get_minimum(productivity)
    print product_to_produce
    while current_turn_is(MARKET):
        print SELL
        if readline() != SKIPPED:
            current = current_goods()
            maximum = get_maximum(current)
            minimum = get_minimum(current)
            to_offer = {maximum: max(productivity[maximum]/productivity[minimum], 1)}
            output_good(minimum, 1)
            output_goods(goods=to_offer)

Answer 4

হোর্ডার ব্যবসায়ী

এই ব্যবসায়ী যথাসম্ভব পণ্য পাওয়ার চেষ্টা করে।

command.txt

python hoarder.py

hoarder.py

import sys

def current_goods():
    print "G"
    return parse_goods(readline())

def parse_goods(good_string):
    try:
        return dict([(a, int(b))
                     for a, b in [product.split("-")
                                  for product in good_string.split(",")]])
    except:
        raise IOError(good_string)

def get_minimum(goods):
    cur_min = 200
    min_good = "X"
    for good, amount in goods.items():
        if amount < cur_min:
            min_good = good
            cur_min = amount
    return min_good

def get_maximum(goods):
    cur_max = -1
    max_good = "X"
    for good, amount in goods.items():
        if amount > cur_max:
            max_good = good
            cur_max = amount
    return max_good

def add_goods(x, y):
    return {k: int(x.get(k, 0)) + int(y.get(k, 0)) for k in set(x) | set(y)}

def readline():
    line = sys.stdin.readline().strip()
    if line == 'Q' or not line:
        exit()
    return line

def output_goods(goods):
    print ",".join([good+"-"+str(amount) for good, amount in goods.items()])

def output_good(good, amount):
    print good+"-"+str(amount)

def current_turn_is(turn):
    print "T"
    return readline() == turn

turns = MARKET, PRODUCE, TRADING, SKIPPED = "M", "P", "T","S"
market_options = PURCHASE, SELL = "P", "S"
items = APRICOTS, BOARS, CANARIES, DAFFODILS, EARWIGS, NOTHING = "A", "B", "C", "D", "E", "X"

productivity = parse_goods(readline())
while True:
    product_to_produce = get_minimum(add_goods(current_goods(), productivity))
    print product_to_produce
    while current_turn_is(MARKET):
        print PURCHASE
        if readline() != SKIPPED:
            offered_good = parse_goods(readline())
            accepted_goods = parse_goods(readline())
            minimum = get_minimum(accepted_goods)
            current = current_goods()
            if minimum not in current or current[minimum] < accepted_goods[minimum]:
                print NOTHING
            elif accepted_goods[minimum] < offered_good.values()[0]:
                print minimum
            elif accepted_goods[minimum] == offered_good.values()[0] \
                    and productivity[minimum] > productivity[offered_good.keys()[0]]:
                print minimum
            else:
                print NOTHING

Answer 5

অনুপাত ব্যবসায়ী

এই বটটি তার উত্পাদনশীলতার অনুপাতের সাথে মিলে এমন পণ্য সরবরাহ করে

command.txt

python ratio.py

ratio.py

import sys

def current_goods():
    print "G"
    return parse_goods(readline())

def parse_goods(good_string):
    return dict([(a, int(b))
                 for a, b in [product.split("-")
                              for product in good_string.split(",")]])

def get_minimum(goods):
    cur_min = 200
    min_good = "X"
    for good, amount in goods.items():
        if amount < cur_min:
            min_good = good
            cur_min = amount
    return min_good

def get_maximum(goods):
    cur_max = -1
    max_good = "X"
    for good, amount in goods.items():
        if amount > cur_max:
            max_good = good
            cur_max = amount
    return max_good

def add_goods(x, y):
    return {k: int(x.get(k, 0)) + int(y.get(k, 0)) for k in set(x) | set(y)}

def readline():
    line = sys.stdin.readline().strip()
    if line == 'Q' or not line:
        exit()
    return line

def output_goods(goods):
    print ",".join([good+"-"+str(amount) for good, amount in goods.items()])

def output_good(good, amount):
    print good+"-"+str(amount)

def current_turn_is(turn):
    print "T"
    return readline() == turn

turns = MARKET, PRODUCE, TRADING, SKIPPED = "M", "P", "T", "S"
market_options = PURCHASE, SELL = "P", "S"
items = APRICOTS, BOARS, CANARIES, DAFFODILS, EARWIGS, NOTHING = "A", "B", "C", "D", "E", "X"

productivity = parse_goods(readline())
while True:
    current = current_goods()
    min_product = get_minimum(current)
    min_amount = current[min_product]
    product_to_produce = min_product if min_amount < 4 else get_minimum(productivity)
    print product_to_produce
    while current_turn_is(MARKET):
        print SELL
        if readline() != SKIPPED:
            current = current_goods()
            maximum = get_maximum(current)
            minimum = get_minimum(current)
            to_offer = {maximum: max(productivity[maximum]/productivity[minimum], 1)}
            output_good(minimum, 1)
            output_goods(goods=to_offer)

Answer 6

পরিবার কৃষক - জাভা

পাঁচটি পরিবার কৃষক যে কোনও বিভাগে কাজ করে যে কোনও বিভাগে সর্বাধিক উপার্জন করতে পারে তার সাথে সমস্ত উত্পাদন বিকল্প কভার করার জন্য তাদের যথাসাধ্য চেষ্টা করে। তবে প্রাথমিক কার্যভারের পরে পরিবারের সদস্যরা সবাই নিজেরাই ধর্মঘট করে; প্রাথমিক কার্যভার পরে তারা জোটে না। আমি ট্রেড করার সময় তাদের একে অপরকে সাহায্য করার কাছাকাছি যেতে পারি।

FamilyFarmers.java

import java.io.IOException;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileLock;
import java.nio.file.FileSystems;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.util.Scanner;

public class FamilyFarmers {
    final int MIN_PRODUCTION_CUTOFF = 4; // If my decision making has ended up
                                            // with a family member producing
                                            // less than this number, he will
                                            // just produce his most productive
                                            // item
    final int NUMBER_PRODUCTS = 5;
    final int MAX_TRADES = 50; // The number of trades per phase
    final byte EOF = 04;
    final byte NEW_LINE = 10;
    final int BILLBOARD_SIZE = 1000;

    boolean alive = true;

    int[] myInventory;

    int myNumber;
    // Primarily, the line this instance of the program will be printing on in
    // the billboard number 0 will be the "boss", and will do a bunch of the
    // calculations (To avoid them being done multiple times)
    MappedByteBuffer familyBillboard;
    String myProduct; // What product (single string character) we will be
                        // making
    Scanner stdin = new Scanner(System.in);

    /**
     * @param args
     *            A string in the form A-#,B-#,C-#,D-#,E-# representing the
     *            productivity of each good.
     * @throws IOException
     * @throws InterruptedException
     * @throws UnexpectedPhaseTokenException
     */
    public static void main(String[] args) throws IOException, InterruptedException {
        new FamilyFarmers();
    }

    public FamilyFarmers() throws IOException, InterruptedException {
        Runtime.getRuntime().addShutdownHook(new Thread() {
            public void run() {
                familyBillboard.clear();
                familyBillboard.put(new byte[familyBillboard.limit()]);
                Runtime.getRuntime().halt(0);
            }
        });
        initialSetup();
        mainLoop();
    }

    protected void mainLoop() throws InterruptedException {
        int tradeCounter = 0; // 50 trades per phase
        String currentStage;
        int toTrade = -1;
        int toGet = -1;
        boolean purchase = false;

        while (alive) {
            System.out.println("T");
            currentStage = stdin.nextLine();
            if (currentStage.equals("P")) { // Production period
                System.out.println(myProduct);
                /*
                System.out.println("G");
                String currentInv = stdin.nextLine();
                myInventory = parseProducts(currentInv);
                toTrade = getMostProduct();
                toGet = getLeastProduct();
                */
                tradeCounter = 0;

            } else if (currentStage.equals("M")) { // Market
                System.out.println("G");
                String currentInv = stdin.nextLine();
                myInventory = parseProducts(currentInv);
                tradeCounter++;
                purchase = (Math.random() >= 0.5);
                toTrade = getMostProduct();
                toGet = getLeastProduct();

                // If my goods are fairly even, it's time to head home!
                if (myInventory[toTrade] - myInventory[toGet] <= 2) {
                    System.out.println("L");
                    continue;
                }

                // If I don't have much to trade...
                if (toTrade <= 6) {
                    // But my goods levels are fairly even...
                    if (toGet >= 4) {
                        // I'll just leave the market
                        System.out.println("L");
                    }
                }

                if (purchase) {
                    System.out.println("P");
                } else {
                    System.out.println("S");
                }

            } else if (currentStage.equals("T")) {
                String toSend = "";
                if (purchase) { // Buying
                    boolean finished = false;
                    String offer = stdin.nextLine();
                    offer += "," + stdin.nextLine();
                    String[] offers = parseOffer(offer);
                    int quantityOffered = Integer.parseInt(offers[0].split("-")[0]);
                    int productOffered = offers[0].split("-")[1].charAt(0) - 65;

                    // This loop will probably never get off the first
                    // iteration...
                    // Go through the offers, blindly pick the first one that
                    // looks good.
                    for (int index = 1; index < offers.length && !finished; index++) {
                        int quantityDesired = Integer.parseInt(offers[index].split("-")[0]);
                        int productDesired = offers[index].split("-")[1].charAt(0) - 65;

                        // If the request would leave me with less than two, I'm
                        // not interested
                        if (quantityDesired - (myInventory[productDesired]) > 2) {
                            // Too rich for my blood!
                            continue;
                        }
                        if (productDesired == toGet) {
                            // I'm not interested in trading what I'm trying to
                            // get!
                        }
                        if (productOffered == toGet) {
                            // Since this is what I want to trade for, I'll be
                            // willing to consider different offers than
                            // otherwise

                            if (quantityDesired <= quantityOffered * 1.25
                                    && myInventory[productDesired] - quantityDesired > 4) {
                                System.out.println((char) (productDesired + 65));
                                finished = true;
                            }

                            // If I would otherwise die without the product,
                            // I'll accept a really bad trade
                            // (Remember that the incoming offers are already
                            // sorted least to highest)
                            if (myInventory[toGet] < 2 && tradeCounter > MAX_TRADES / 2) {
                                System.out.println((char) (productDesired + 65));
                                finished = true;
                            }
                        }

                        // If the product is what I'm trying to trade, and the
                        // offer isn't too bad
                        if (productDesired == toTrade && quantityOffered * 1.25 <= quantityDesired) {
                            System.out.println((char) (productDesired + 65));
                            finished = true;
                        }

                        // If I am offered either as much as or more of
                        // something, I'll do it.
                        if (quantityOffered >= quantityDesired) {
                            System.out.println((char) (productDesired + 65));
                            finished = true;
                        }
                    }

                    if (!finished) {
                        // If we get this far, nothing struck my fancy
                        System.out.println("X");
                    }

                } else { // Selling
                    int[] toBuy = getSameProducts(toGet);

                    // Make some self-beneficial offers in the first few rounds.
                    if (tradeCounter <= 5) {
                        toSend = "" + ("2-" + ((char) (toTrade + 65)));
                        for (int index = 0; index < toBuy.length; index++) {
                            toSend += (",3-" + ((char) (toBuy[index] + 65)));
                        }
                    } else {
                        // Basic offer. Just offer 1:1 for what I want.
                        toSend = "" + ("2-" + ((char) (toTrade + 65)));
                        for (int index = 0; index < toBuy.length; index++) {
                            toSend += (",2-" + ((char) (toBuy[index] + 65)));
                        }
                    }

                    // If trading has been going for awhile and I would die the
                    // next turn, I frantically offer everything I have for what
                    // I need to survive one more turn. This is probably a
                    // terrible strategy!
                    if (myInventory[toGet] < 2 && tradeCounter > MAX_TRADES / 2) {
                        toSend += ("4-" + ((char) (toTrade + 65))) + ",2-" + ((char) (toGet + 65));
                    }

                    if (toSend.length() < 6) {
                        // I couldn't find enough to sell...
                        System.out.println(toSend + "," + toSend);
                        // That's safe, right?
                        break;
                    }

                    // Put the products I would accept on a line after the
                    // product I want to sell
                    String[] splitSend = toSend.split(",");
                    toSend = splitSend[0] + "\n";
                    boolean first = true; // Don't prepend a comma on the first string

                    for (int index = 1; index < splitSend.length; index++) {
                        if (!first){
                            toSend += ",";
                        }
                        toSend += splitSend[index];
                        first = false;
                    }

                    System.out.println(toSend);

                }

            } else if (currentStage.equals("S")) { // I was skipped! Darn it!
            } else {
                // AAK! I received a token I don't know what to do with! I must
                // be dead...
                alive = false;
            }
        }
    }

    /**
     * Returns the offers, sorted from least product desired to most, with the
     * product being offered at the first index
     * 
     * @param offer
     * @return String[] index 0 contains the product being offered, the
     *         following indicies are the desired products ordered from least to
     *         most
     */
    protected String[] parseOffer(String offer) {
        String[] splitOffers = offer.split(",");

        // Sort. Just using selection sort. The first index contains the string
        // with the product being asked for,
        // so should not be sorted.
        for (int index = 1; index < splitOffers.length; index++) {
            int indexOfMin = index;
            int minimum = Integer.parseInt(splitOffers[index].split("-")[0]);
            for (int jdex = index + 1; jdex < splitOffers.length; jdex++) {
                int thisValue = Integer.parseInt(splitOffers[jdex].split("-")[0]);
                if (thisValue < minimum) {
                    indexOfMin = jdex;
                    minimum = thisValue;
                }
            }
            String temp = splitOffers[index];
            splitOffers[index] = splitOffers[indexOfMin];
            splitOffers[indexOfMin] = temp;

        }

        return splitOffers;
    }

    /**
     * Returns an array of the indices of the product which I have the same
     * quantity of in myInventory
     * 
     * @param startingIndex
     *            - The index of a value to match
     * @return
     */
    protected int[] getSameProducts(int startingIndex) {
        int[] toReturn = new int[0];

        for (int index = startingIndex + 1; index < myInventory.length; index++) {
            if (myInventory[index] == myInventory[startingIndex]) {
                int[] temp = new int[toReturn.length + 1];
                for (int jdex = 0; jdex < toReturn.length; jdex++) {
                    temp[jdex] = toReturn[jdex];
                }
                temp[temp.length - 1] = index;
                toReturn = temp;
            }
        }

        return toReturn;
    }

    /**
     * Returns the index of the product which I have the least of in myInventory
     * I can't help but feel that this lacks object-oriented design...
     * 
     * @return
     */
    protected int getLeastProduct() {
        int toReturn = 0;

        for (int index = 1; index < myInventory.length; index++) {
            toReturn = myInventory[index] < myInventory[toReturn] ? index : toReturn;
        }

        return toReturn;
    }

    /**
     * Returns the index of the product which I have the most of in myInventory
     * I can't help but feel that this lacks object-oriented design...
     * 
     * @return
     */
    protected int getMostProduct() {
        int toReturn = 0;

        for (int index = 1; index < myInventory.length; index++) {
            toReturn = myInventory[index] > myInventory[toReturn] ? index : toReturn;
        }

        return toReturn;
    }

    /**
     * Returns an int[] containing the productivity of each product in
     * alphabetical order
     * 
     * @param products
     * @return
     */
    protected int[] parseProducts(String products) {
        int[] toReturn;
        // Split the string so that each line of the array has #-P
        String[] lineProductivities = products.split(",");

        // Split each string in the array so that it is just the number
        for (int index = 0; index < lineProductivities.length; index++) {
            lineProductivities[index] = lineProductivities[index].split("-")[0];
        }

        toReturn = new int[lineProductivities.length];

        for (int index = 0; index < lineProductivities.length; index++) {
            toReturn[index] = Integer.parseInt(lineProductivities[index]);
        }

        return toReturn;
    }

    /**
     * Append my productivity string to the family billboard. If the file was
     * empty when I got here (contained no newlines), I am the boss! The boss
     * gives orders.
     * 
     * @throws IOException
     * @throws InterruptedException
     */
    protected void initialSetup() throws IOException, InterruptedException {
        String input;
        myNumber = 0;
        FileChannel familyBillboardFC;
        Path billboardPath = FileSystems.getDefault().getPath("family_billboard.txt");
        FileLock billboardLock;
        byte[] argsByteArray;

        byte currentByte = 0;

        input = stdin.nextLine();

        // Open the file and lock it
        familyBillboardFC = FileChannel.open(billboardPath, StandardOpenOption.WRITE, StandardOpenOption.READ);
        billboardLock = familyBillboardFC.lock();

        // Map the contents of the file to a space in memory
        familyBillboard = familyBillboardFC.map(FileChannel.MapMode.READ_WRITE, 0, BILLBOARD_SIZE);

        // Convert the incoming string into an array of bytes
        argsByteArray = input.getBytes();

        for (int index = 0; index < BILLBOARD_SIZE; index++) {
            currentByte = familyBillboard.get();
            if (currentByte == NEW_LINE) {
                myNumber++;
                familyBillboard.mark();
            }
        }

        if (myNumber == 0) {
            familyBillboard.position(0);
            familyBillboard.mark();
        }
        familyBillboard.reset();

        for (byte b : argsByteArray) {
            familyBillboard.put(b);
        }
        familyBillboard.put(NEW_LINE);
        familyBillboard.put(EOF);

        billboardLock.release();

        Thread.sleep(100); // Give other programs a chance to launch

        // Boss needs to wait for awhile to make sure the others have finished
        // writing...
        // I don't have any idea how to do this in an intelligent fashion. It is
        // *probably* safe to sleep for a few hundred milliseconds, but I'm not
        // certain. Instead, I'll try to take out a new lock. If I succeed
        // twice, the file must be finished!
        int counter = 0;
        while (myNumber == 0) {
            billboardLock = familyBillboardFC.tryLock();
            if (billboardLock != null) {
                billboardLock.release();
                counter++;
            } else {
                counter = 0;
                Thread.sleep(10);
            }
            if (counter >= 2) {
                giveOrders();
                break;
            }
        }

        byte foo = familyBillboard.get();
        // Until the boss has written out the instructions, sleep
        while (foo < 65) {
            Thread.sleep(10);
            familyBillboard.reset();
            foo = familyBillboard.get();
        }

        familyBillboard.reset();
        myProduct = String.valueOf((char) familyBillboard.get());
    } // initialSetup()

    /**
     * Run by the boss. Tries to sort the family so that every product is
     * covered and so that whoever can produce the most of a product is
     * producing it. Writes the character code representing the product to
     * produce to the first character of the relevant line in the family
     * billboard.
     */
    protected void giveOrders() {
        final int MAX_LINE_LENGTH = 24;
        int numberMembers = 0;
        byte currentByte = 0;
        Integer[][] productivities; // Table of member's productivities
        char[] selections; // Who will make what. selections[#] = the production
                            // letter for member #

        familyBillboard.position(0);

        // I have seen the rules to these games change. It's easy for me to
        // accommodate more (or less than) 5 instances now. It may not be easy
        // later
        while (currentByte != EOF) {
            currentByte = familyBillboard.get();
            if (currentByte == NEW_LINE) {
                numberMembers++;
            }
        }
        currentByte = 0;
        familyBillboard.reset();

        selections = new char[numberMembers];

        productivities = new Integer[numberMembers][NUMBER_PRODUCTS];

        for (int index = 0; index < numberMembers; index++) {
            byte[] currentLineBytes = new byte[MAX_LINE_LENGTH];
            String currentLine;

            // Read the next line
            for (int jdex = 0; jdex < currentLineBytes.length; jdex++) {
                currentByte = familyBillboard.get();
                if (currentByte == NEW_LINE) {
                    break;
                }
                currentLineBytes[jdex] = currentByte;
            }
            currentLine = new String(currentLineBytes);
            currentByte = 0;

            int[] lineProductivities = parseProducts(currentLine);

            // Need to iterate to get the int[] to Integer[]
            for (int jdex = 0; jdex < NUMBER_PRODUCTS; jdex++) {
                productivities[index][jdex] = lineProductivities[jdex];
            }

        }

        // If there are at least as many producers as products, select the most
        // productive for each producer. If there are overlaps, move the smaller
        // one to the second most productive and re-check for overlaps. If there
        // are overlaps and the productivity is tied, compare the second highest
        // and so on.
        // TODO What if members > 5?
        if (numberMembers <= NUMBER_PRODUCTS) {
            int[] overlapResult;
            for (int index = 0; index < selections.length; index++) {
                selections[index] = (char) (maxInArray(productivities[index]) + 65);
                // Can convert from a max value in productivities to a
                // human-readable character by adding 65, since 0 -> A, 1 -> B,
                // etc.
            }

            int counter = 0; // I imagine there is a possibility of this loop
                                // not terminating. I will use this counter to
                                // forcefully break it.

            // While there is an overlap
            while ((overlapResult = arrayHasOverlaps(selections)) != null && overlapResult[0] != -1) {
                byte productIndex = (byte) (selections[overlapResult[0]] - 65);
                // 0 through the number of production options, where A = 0, B =
                // 1, etc.
                if (productivities[overlapResult[0]][productIndex] > productivities[overlapResult[1]][productIndex]) {
                    int index = findNextHighestFromIndex(productivities[overlapResult[1]], productIndex);
                    selections[overlapResult[1]] = (char) (index + 65);
                }
                if (productivities[overlapResult[1]][productIndex] > productivities[overlapResult[0]][productIndex]) {
                    int index = findNextHighestFromIndex(productivities[overlapResult[0]], productIndex);
                    selections[overlapResult[0]] = (char) (index + 65);
                }
                // Things are beginning to get mega hairy
                if (productivities[overlapResult[0]][productIndex] == productivities[overlapResult[1]][productIndex]) {
                    int index0 = findNextHighestFromIndex(productivities[overlapResult[0]], productIndex);
                    int index1 = findNextHighestFromIndex(productivities[overlapResult[1]], productIndex);
                    if (productivities[overlapResult[0]][index0] > productivities[overlapResult[1]][index1]) {
                        selections[overlapResult[0]] = (char) (index0 + 65);
                    } else {
                        // I can't be bothered to go any further with this... If
                        // they're tied here, then to heck with it!
                        selections[overlapResult[1]] = (char) (index1 + 65);
                    }
                }

                counter++;
                if (counter > BILLBOARD_SIZE) {
                    break;
                }
            }
        }

        // Check for less than my minimum cutoff. If one is, set it to its max.
        for (int index = 0; index < selections.length; index++) {
            byte b = (byte) (selections[index] - 65);
            if (productivities[index][b] < MIN_PRODUCTION_CUTOFF) {
                selections[index] = (char) (maxInArray(productivities[index]) + 65);
            }
        }

        // Write the product to produce to the correct line
        familyBillboard.position(0);
        familyBillboard.put((byte) selections[0]);
        // If we find a newline, write the selected character to the next
        // spot. Otherwise, read the next character
        for (int index = 1; index < selections.length;) {
            byte thisByte = familyBillboard.get();
            if (thisByte == NEW_LINE) {
                familyBillboard.put((byte) selections[index]);
                index++;
            }
        }
    }

    /**
     * Look through the array. Find an element that is either later in the array
     * and <= the value at the incoming index and > the value at the toReturn
     * index, or earlier in the array and < the value at the current index and >
     * the value at toReturn. If we weren't able to set the new index (Maybe we
     * are already at the max value) return the index of the largest value
     * 
     * @param array
     *            the array to search in
     * @param incomingIndex
     *            the index of the value to begin searching with
     * @return an index as described
     */
    protected int findNextHighestFromIndex(Integer[] array, int incomingIndex) {
        int toReturn = incomingIndex;
        int comparisonValue = -1; // The value at toReturn
        int index = (incomingIndex + 1) % array.length;

        for (int counter = 0; counter < array.length; counter++) {
            if (index > incomingIndex && array[index] == array[incomingIndex]) {
                // If we have found an equal value later in the array, return
                // immediately. In the unlikely event everything is equal,
                // don't just take the value at the bottom index!
                return index;
            }
            if (index > incomingIndex && array[index] < array[incomingIndex] && array[index] > comparisonValue) {
                toReturn = index;
                comparisonValue = array[toReturn];
            }
            if (index < incomingIndex && array[index] < array[incomingIndex] && array[index] > comparisonValue) {
                toReturn = index;
                comparisonValue = array[toReturn];
            }

            index++;
            index %= array.length; // How often do you get to use %= ?
        }

        if (comparisonValue == -1) {
            // In the unlikely event we weren't able to set comparisonValue
            // (maybe we are already at the minimum?)
            toReturn = maxInArray(array);
            // This will probably contribute to those endless loops I mentioned
            // above!
        }

        return toReturn;
    }

    /**
     * Checks the array for any two elements being the same. If two are, return
     * the indices. If not, return {-1, -1}
     * 
     * @param selections
     *            The array to examine
     * @return Indices of the overlapping elements or {-1, -1}
     */
    protected int[] arrayHasOverlaps(char[] selections) {
        int[] toReturn = new int[] { -1, -1 };
        for (int index = 0; index < selections.length - 1; index++) {
            for (int jdex = index + 1; jdex < selections.length; jdex++) {
                if (selections[index] == selections[jdex]) {
                    toReturn[0] = index;
                    toReturn[1] = jdex;
                    return toReturn;
                }
            }
        }
        return toReturn;
    }

    /**
     * Returns the index of the max value of an array. In the case of a tie,
     * returns the earliest index.
     * 
     * @param array
     *            the array to read
     * @return the index of the largest element in the array
     */
    protected <T extends Comparable<T>> byte maxInArray(T[] array) {
        byte currentMax = 0;
        for (byte index = 0; index < array.length; index++) {
            currentMax = array[index].compareTo(array[currentMax]) > 0 ? index : currentMax;
        }
        return currentMax;
    }
}

command.txt

cd bots/family_farmer && java FamilyFarmers

এটি দিয়ে সংকলন করা যেতে পারে

javac FamilyFarmer.java

বট / ফ্যামিলি_ফর্মার ফোল্ডারে আর একটি ফাঁকা ফাইল, family_billboard.txt থাকা উচিত।

Comments

আপনি যদি গিথুব থেকে র্যান্ডমঅ্যান্ডো পেয়ে থাকেন তবে বর্তমান অবস্থাটি আমার পক্ষে ভাল কাজ করে।

— নাথান মেরিল

এছাড়াও, আপনার নিজের বটকে নিজের সাথে কাজ করার জন্য এটি অবশ্যই নিয়মের মধ্যে রয়েছে (উদাহরণস্বরূপ)। তবে, আপনি সর্বদা ব্যবসায়ের সময় তাদের সাথে মিলে যাবেন না

— নাথান মেরিল

হুম। আমি সবেমাত্র সর্বশেষতমটি যাচাই করেছিলাম এবং আমার বটটি বের করে আনলাম। এলোমেলো অ্যান্ডো আর ত্রুটি ছুঁচ্ছে না, তবে আমি কোনওভাবেই প্রোগ্রাম থেকে কোনও আউটপুট পাই না ... আমার বটটি দিয়ে, এটি কমপক্ষে আমাকে বলে যে আমার বটটিতে আসল উত্পাদনশীলতা প্রেরণ করছে! আমি জানি পাইথন ২.6..6 কিছুটা বয়স্ক। আপনি কি সংস্করণ ব্যবহার করছেন?

— সোম্পম

২.7..6 আমি আপনার বট থেকে একটি ত্রুটি পেয়েছি, আপনাকে প্রথমে যা উত্পাদন করতে হবে তা আপনাকে প্রেরণ করতে হবে এবং তারপরে (পরের লাইনে) আপনি কী গ্রহণ করবেন।

— নাথান মেরিল

আহ। আমার ভুল বোঝাবুঝি সুখের বিষয়, একটি ওয়ান লাইন

— হ্যাকি

Answer 7

ইন্ট্রোভার্ট - জাভা

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

Introvert.java

import java.util.Scanner;

public class Introvert{

    static int[] current = {10,10,10,10,10};
    static int[] potentialProduction = new int[5];
    static boolean alive = true;

    public static void main(String[] args){
        Scanner s = new Scanner(System.in);
        String input = s.nextLine();
        String[] inputArray = input.split(",");
        for(int i = 0; i < 5; i++){
            potentialProduction[i] = Integer.parseInt(inputArray[i].replaceAll("\\D+",""));
        }

        while(alive){
            int pos = decideProduction();
            produce(pos);
            System.out.println("L");
            for(int i = 0; i < 5; i++){
                current[i] -= 2;
                if(current[i] < 0)
                    alive = false;
            }
        }
        s.nextLine(); //read final `q` message
    }

    public static int decideProduction(){
        int lowestPotential = 9999;
        int lowestPotentialPosition = 9999;
        for(int i = 0; i < 5; i++){
            if(current[i] == 2 || current[i] == 3){
                lowestPotentialPosition = i;
                break;
            }
            int potential = current[i] + potentialProduction[i];
            if(potential < lowestPotential){
                lowestPotential = potential;
                lowestPotentialPosition = i;
            }
        }
        switch(lowestPotentialPosition){
            case 0: System.out.println("A"); return 0;
            case 1: System.out.println("B"); return 1;
            case 2: System.out.println("C"); return 2;
            case 3: System.out.println("D"); return 3;
            case 4: System.out.println("E"); return 4;
            default: System.out.println("A"); return 0;
        }
    }

    public static void produce(int pos){
        current[pos] += potentialProduction[pos];
    }

}

command.txt

java Introvert

সঙ্গে সংকলন

javac Introvert.java

দ্রষ্টব্য: আমি এটি আমার মধ্যাহ্নভোজের বিরতিতে করেছি এবং আমার ওয়ার্ক কম্পিউটারে jdk বা পাইথন নেই তাই আমি এটি একেবারে পরীক্ষা করতে সক্ষম হইনি। যদি এটি কাজ না করে তবে আমাকে জানান এবং আমি এটি ঠিক করার চেষ্টা করব।

Comments

ইন্ট্রোভার্ট.জাভা ৪৪7: ত্রুটি: অনুপস্থিত বিবৃতি

— নাথান মেরিল

@ নাথানম্যারিল এটি ঠিক করতে একটি ডিফল্ট কেস যুক্ত করেছে এবং আমি লক্ষ্য করেছিলাম একটি বাগ ঠিক করার জন্য কিছু অন্যান্য ছোট পরিবর্তনও করেছি। আশা করি এখনই কাজ করা উচিত, কিছুটা পরীক্ষার জন্য পাইথন ইনস্টল করবেন।

— joliwalrus

ইন্ট্রোভার্ট.জভা 18: প্রতীক রাউন্ডগুলি ++ খুঁজে পাচ্ছে না;

— নাথান মেরিল

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

— নাথান মেরিল

ঠিক আছে. জিনিস এখন কাজ করছে। আমি আপনার সমস্ত (সত্য) লুপগুলি সরিয়ে দিয়েছি এবং আপনার প্রোগ্রামটি একেবারে শেষে (আমার qবার্তা গ্রহণ করার জন্য ) ইনপুট গ্রহণ করছে । আপনার পরিবর্তিত কোডটি গিথুবে রয়েছে (মূল প্রকল্পের সাথে)

— নাথন মেরিল

Answer 8

এলোমেলো Ando

প্রতিটি KOTH এর একটি এলোমেলো বট হওয়া উচিত। কোডেড, আশা করি, যাতে এটি অবৈধ ডিলগুলি না করে (যেমনটি স্টকের মধ্যে রয়েছে তার চেয়ে বেশি বিক্রি করার চেষ্টা করা)।

--RandomAndo

math.randomseed(os.time()) math.random()math.random()math.random()

ITEMS = {"A", "B", "C","D", "E"}
MARKETOPTION = {"P", "S"}
MyGoods = {0,0,0,0,0}

local function readline() -- checks for the dying "Q" or just reads line
    local line = io.read("*l")
    if line == "Q" then
        os.exit()
    end

    return line
end

local function getCurrentTurn() -- asks for M,T,P
    print("T")
    return readline()
end

local function getRandom(array) -- returns for a random element in array
    local r=math.random(#array)
    return array[r]
end

local function getRandomMyItems() -- make a list of items I have and return a random one (no more than one of)
    local rgood=math.random(5)
    local amount=1
    while MyGoods[rgood] <= 0 do
        rgood=math.random(5)
    end
    return amount.."-"..ITEMS[rgood]
end

local function parseGoods(goodString) -- specialized to getMyGoods atm
    local goods={0,0,0,0,0}
    local c = 1
    example = "5-A,6-B,3-C,12-D,4-E"
    for good in goodString:gmatch("%d+%p[ABCDE]") do
        goods[c]=goods[c]+good:match("%d+")
        c=c+1
    end

    return goods
end

local function getMyGoods() -- asks for my goods
    print("G")
    local temp = parseGoods(readline())
    for i=1,5 do
        MyGoods[i]=temp[i]
    end
end


productivity = readline() -- doesn't matter

while true==true do

    print(getRandom(ITEMS)) -- produce random item

    while getCurrentTurn()=="M" do
        getMyGoods()

        local action=getRandom(MARKETOPTION) -- make a random market decision
        if action == "S" then -- offer to sell 1 of a random item I  have in stock, will take any 2 offered
            print("S")
            if readline()=="T" then
                print(getRandomMyItems())
                print("2-A,2-B,2-C,2-D,2-E")
            end
        elseif action == "P" then -- if I can do the deal, I will
            print("P")
            if readline()=="T" then
                local offered=readline()
                local accepted =readline()
                local taccepted={}
                for i in accepted:gmatch("%d+%p[ABCDE]") do
                    oitem =i:match("[ABCDE]")
                    oamount = i:match("%d+")
                    for k=1,5 do
                        if ITEMS[k]==oitem and MyGoods[k]>=tonumber(oamount) then
                            table.insert(taccepted, oitem)
                        end
                    end
                    if #taccepted>=1 then
                        print(getRandom(taccepted))
                    else
                        print("X")
                    end
                end
            end
        elseif action == "L" then
            print("L")
        end
    end
end

কমান্ড। টেক্সট হতে হবে:

lua RandomAndo.lua

Comments

কমান্ড.টিএসটিএস দেখতে কেমন?

— নাথান মেরিল

@ নাথানমেরিল হ্যাঁ, দুঃখিত, নীচে যুক্ত হয়েছে।

— AndoDaan

আমি আমার কন্ট্রোলার থেকে আপনার বট চালাতে সমস্যা নিয়ে চলেছি: "সিস্টেম নির্দিষ্ট ফাইলটি খুঁজে পাচ্ছে না"। তবে, আমি সেই কাজটি করার চেষ্টা করছি, আপনার প্রোগ্রামটি কাজ করে না - আমি যখন কমান্ড লাইন থেকে এটি চালাই, তখন আমি পাই: bad argument #1 to 'randomseed' (number expected, got no value)3 লাইনে

— নাথন মেরিল

@ নাথানমেরিল বোবা ভুল সংশোধন করা হয়েছে।

— AndoDaan

ঠিক আছে. দেখে মনে হচ্ছে আপনার কোডটি এখন চলছে এবং এটি আমার শেষের দিকে ঠিক হয়ে গেছে ... তবে এখন আমি আপনার প্রোগ্রাম থেকে কোনও আউটপুট পাচ্ছি না (সম্ভবত এটি আমার আউটপুট পাচ্ছে না, আমি নিশ্চিত নই) যাই হোক, আমি ' আগামীকাল এটিকে ঠিক করার চেষ্টা করব, আমার ঘুমানো দরকার।

— নাথান মেরিল