পাহাড়ের উপর ইস্টার ডিম হান্ট


17

ইস্টার ডিম হান্ট

বট ডিম পাবার আগে ডিম পাবে। বট খুশি।

সংক্ষিপ্ত বিবরণ

এটি ইস্টার এবং ইস্টার ডিম শিকারের traditionতিহ্যের সম্মানে একটি চ্যালেঞ্জ!

আপনার বটটি প্রতিটি দিকের দু'টি স্পেসের দৃষ্টি রয়েছে যার মধ্যে ত্রিভুজ রয়েছে, আপনার চারপাশে একটি 5x5 বর্গ তৈরি করছে যা আপনি দেখতে পাচ্ছেন। এটি ডিমের সন্ধান করছে এবং যে সবচেয়ে বেশি ডিম খুঁজে পায় সে জিতবে!

বোর্ড

বোর্ডে oএস থাকবে, যা ইস্টার ডিম, #গুলি, যা দেয়াল, *গুলি, যা অন্যান্য খেলোয়াড়, এবং গুলি, খালি স্থান রয়েছে।

  • এটি প্রান্ত দৈর্ঘ্য সহ একটি বর্গক্ষেত্র হবে (number of entries) * 3
  • এটি প্রাচীর দ্বারা বেষ্টিত করা হবে।
  • দেয়ালগুলির অভ্যন্তরে এলোমেলোভাবে স্থাপন করা, সরল রেখার দেয়ালের একটি ভাণ্ডার #হবে, যার দৈর্ঘ্য 2 এবং 10 এর মধ্যে থাকবে। থাকবে (number of entries) * 3তাদের।
  • ডিমগুলি তখন এলোমেলোভাবে স্থাপন করা হবে। তাদের মধ্যে কিছু থাকবে (number of entries) * 4এবং এগুলি কেবল ফাঁকা ( ) স্কোয়ারে তৈরি করা হবে ।
  • বোর্ড তৈরির প্রক্রিয়াটি সঠিকভাবে কাজ করার জন্য কমপক্ষে en জন প্রবেশাধিকারী থাকতে হবে।

এখানে একটি জেএসফিডাল যা আপনাকে পরীক্ষা করার জন্য একটি এলোমেলো বোর্ড তৈরি করবে । এখানে একটি উদাহরণ রয়েছে (number of entries) = 7:

#####################
#        o         ##
#    #    o        ##
#    #o    ######  ##
######     #       ##
## o #     #       ##
##  o#   #o#    o o##
##   #o  # # o  #   #
##   # o # #    #   #
##  ##   # #  o #   #
##  #    #  o   # # #
##  # o  #   ## # # #
##  #           # # #
# o #          ## # #
# o oo         ##o  #
#o  ####### oo ##   #
#        #      #   #
#   o o o#          #
#   o ####   o     o#
#                   #
#####################

বোর্ড তৈরির পরে, প্রতিটি খেলোয়াড়কে এলোমেলো স্কোয়ারে (ফাঁকা জায়গা) স্থাপন করা হয় ।

ইনপুট

আপনি ছয় লাইন ইনপুট নেবেন। প্রথম পাঁচটি লাইন আপনার দৃষ্টিভঙ্গির ক্ষেত্র (বোর্ডের সীমানার বাইরে ফাঁকা স্থানগুলি প্রতিনিধিত্ব করবে X, এবং মাঝের স্থানটি সর্বদা *আপনিই থাকবে) এবং ষষ্ঠ লাইনটি খালি (প্রথমে) থাকবে will

আউটপুট

আপনি তিনটি লাইন আউটপুট হবে। প্রথমে আপনি যে দিকে যেতে চান:

1  2  3
8 YOU 4
7  6  5

(9 আপনি Aনড়াচড়া করতে না চাইলে একটি বিকল্প নেই), দ্বিতীয়, টেট্যাক, Cআউটার বা Nঅন্য কিছু (এটি শীঘ্রই গভীরতার সাথে ব্যাখ্যা করা হবে), এবং থ্রাইড লাইনটি 1024 অবধি দৈর্ঘ্যের কোনও স্ট্রিং হবে এটি আপনার বটের স্মৃতি হবে। আপনি এটি যা চান তার জন্য এটি ব্যবহার করতে পারেন বা আপনি এটি ফাঁকা রেখে যেতে পারেন। এই মেমরিটি পরের রানে আপনার প্রোগ্রামের ইনপুটটির ষষ্ঠ লাইন হবে।

আউটপুটটির পরবর্তী সমস্ত লাইন উপেক্ষা করা হবে এবং যদি কেবল একটি লাইন থাকে তবে দ্বিতীয়টি ফাঁকা বলে ধরে নেওয়া হয়।

চলন্ত

নিম্নলিখিত স্থানটি আপনি কোথায় সরিয়ে নিয়েছেন তা নির্ধারণ করতে ব্যবহৃত হয়:

  • আপনি যখন স্থানান্তরিত হন, আপনি একটি ফাঁকা জায়গায় ( ) শেষ হলে, আপনার প্লেয়ারটি সেই জায়গাতে স্থাপন করা হবে।
  • যদি আপনি কোনও দেয়াল ( #) এ গিয়ে থাকেন তবে আপনার পদক্ষেপটি উপেক্ষা করা হবে এবং আপনি নিজের পালা হারাবেন।
  • যদি আপনি একটি ডিম ( o) বা কোনও খেলোয়াড় ( *) এ শেষ করেন তবে এই তথ্যটি সংরক্ষণ করা হয় এবং প্রত্যেকে স্থানান্তরিত হওয়ার পরে ব্যবহার করা হবে।

সবাই সরে যাওয়ার পরে, অস্পষ্টতাগুলি সমাধান হয়ে যায়।

যদি দু'জন খেলোয়াড় একই স্থানে অবতরণ করে থাকে তবে লড়াই হয়! এখানে A/ C/ Nখেলতে আসে। Aটেট্যাক বিটস্ Nআউটিং (সাধারণ আক্রমণ), Nআউটিং বিটস Cআউন্টার (আপনি কিছুই প্রতিরোধ করতে পারবেন না), এবং Cআউটার বিটস Aটিট্যাক (পাল্টা আক্রমণ)) যে খেলোয়াড় এই লড়াইয়ে জিতবে তারা তাদের স্কোয়ারে থাকবে এবং যে প্লেয়ার হারাবে তারা তাদের শুরু হওয়া মূল স্কোয়ারে ফিরে যায়। টাই হওয়ার সময়ে উভয় খেলোয়াড়ই যেখানে ছিলেন সেখানে ফিরে যান।

যদি কোনও হেরে যাওয়া বা বাঁধা খেলোয়াড় তারা যেখানে ছিল সেখানে ফিরে যায় এবং সেখানে অন্য একজন খেলোয়াড় থাকে তবে লড়াই হয় না এবং অন্য খেলোয়াড়টিও তার আসল জায়গায় ফিরে আসবে। এই স্পেসে যদি অন্য খেলোয়াড় থাকে তবে তা খেলোয়াড় ফিরে যায় এবং সমস্ত খেলোয়াড় আলাদা স্পেসে না আসা পর্যন্ত এটি চলতে থাকে।

যদি এক জায়গায় তিন বা ততোধিক খেলোয়াড় থাকে তবে তারা সবাই তাদের মূল অবস্থানে ফিরে যায়।

যদি কোনও খেলোয়াড় এখনও একটি ডিমের উপর দাঁড়িয়ে থাকে ...

  • খেলোয়াড়টি বেছে Aনিলে ডিম নষ্ট হয়ে যায়।
  • প্লেয়ারটি চয়ন করা থাকলে C, কিছুই ঘটে না এবং প্লেয়ারটি তার আসল জায়গায় ফিরে যায়।
  • প্লেয়ার বেছে Nনিলে খেলোয়াড় ডিম তুলে! খেলোয়াড়ের স্কোর এক দ্বারা বাড়ানো হয় এবং ডিমটি সরানো হয়।

ভাষাসমূহ

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

স্কোরিং

আপনার স্কোর দশটি রান সংগ্রহের মধ্যে আপনি সংগ্রহ করেছেন ডিমের গড় সংখ্যা। একটি রান শেষ হয় যখন সমস্ত ডিম সংগ্রহ করা হয় বা (number of entries * 25)পালা শেষ হয়ে যায়। আমি ম্যানুয়ালি এটি নিশ্চিত করব যে প্রতিটি মানচিত্রের জন্য সমস্ত ডিম পৌঁছানো সম্ভব (ক্রমাগত মানচিত্র উত্পন্ন করে যতক্ষণ না সমস্ত ডিম পৌঁছানো যায়)।

স্কোরবোর্ড

নিম্নলিখিত সমস্ত শর্ত পূরণ হলে একটি স্কোরবোর্ড যুক্ত করা হবে:

  • ধনাত্মক বা শূন্য স্কোর সহ কমপক্ষে সাতটি বৈধ এন্ট্রি জমা দেওয়া হয়েছে (নিম্নচোটিত নয়)
  • এই চ্যালেঞ্জটি তৈরির পরে কমপক্ষে ৪৮ ঘন্টা কেটে গেছে (ইউটিসি ১৪:২৩)

এই প্রাক-প্রতিযোগিতার সময়কালে নিয়মগুলি পরিবর্তন হবে না, যেখানে কোনও নিয়ম অস্পষ্ট ছিল সে বিষয়ে স্পষ্টতা যোগ করা ব্যতীত। স্কোরবোর্ডটি স্থাপন করার পরে, পরীক্ষার প্রোগ্রামটি এখানেও পোস্ট করা হবে যাতে আপনি নিজের প্রবেশ পরীক্ষা করতে পারেন। এর জন্য পরীক্ষামূলক কোডটি এখনও কার্য-প্রগতিতে রয়েছে তবে এটি প্লেযোগ্য এবং এটি কার্যকর। এখানে গিটহাব রেপো।


4
7 টি এন্ট্রি পোস্ট হওয়ার আগে আমরা কি টেস্টিং প্রোগ্রামটি পেতে পারি? আমি পোস্টিংয়ের আগে পরীক্ষা করতে চাই , এটি "বোবা" টেস্ট-বটের বিরুদ্ধে থাকলেও। মনে হচ্ছে এটি অন্য বেশ কয়েকজন না হওয়া পর্যন্ত পোস্ট না করাতে একটি উল্লেখযোগ্য সুবিধা দেয়।
জিওবিটস

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

1
একটি নমুনা নিয়ন্ত্রণ প্রোগ্রাম এখানে খুব দরকারী হবে।
স্টারবিয়াম্রেনবোলাবস

3
আমি মেমরি লাইনের আইডিয়াটি পছন্দ করি
আইনাসিও

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

উত্তর:


3

Cart'o'Gophers

এখানে অন্য জমা দেওয়া হল - এবং এটি আসলে প্রতিযোগিতামূলক হতে বোঝানো হয়েছিল। আবার, এটি রুবিতে। সুতরাং এটি দিয়ে চালান ruby cartogophers.rb। এটি প্রত্যাশার চেয়ে অনেক বেশি সময় নিয়েছে ...

require 'zlib'
require 'base64'

def encode map, coords
    zipped = Zlib::Deflate.deflate map.join
    encoded = Base64.encode64(zipped).gsub("\n",'')
    "#{coords[:x]}|#{coords[:y]}|#{map.length}|#{encoded}"
end

def decode memory
    memory =~ /^(\d+)[|](\d+)[|](\d+)[|](.*)$/
    coords = {x: $1.to_i, y: $2.to_i}
    n_rows = $3.to_i
    encoded = $4
    decoded = Base64.decode64 encoded
    unzipped = Zlib::Inflate.inflate decoded
    n_cols = unzipped.length / n_rows;
    return unzipped.scan(/.{#{n_cols}}/), coords
end

def update map, fov, coords
    if coords[:x] < 2
        map.map! { |row| '?' << row }
        coords[:x] += 1
    elsif coords[:x] >= map[0].length - 2
        map.map! { |row| row << '?' }
    end

    if coords[:y] < 2
        map.unshift '?' * map[0].length
        coords[:y] += 1
    elsif coords[:y] >= map.length - 2
        map.push '?' * map[0].length
    end

    fov.each_index do |i|
        map[coords[:y]-2+i][coords[:x]-2, 5] = fov[i]
    end

    return map, coords
end

def clean_up map
    map.each do |row|
        row.gsub!('*', ' ')
    end
end

DIRECTIONS = [
    [],
    [-1,-1],
    [ 0,-1],
    [ 1,-1],
    [ 1, 0],
    [ 1, 1],
    [ 0, 1],
    [-1, 1],
    [-1, 0],
    [ 0, 0]
]

def move_to dir, coords
    {
        x: coords[:x] + DIRECTIONS[dir][0],
        y: coords[:y] + DIRECTIONS[dir][1]
    }
end

def get map, coords
    if coords[:x] < 0 || coords[:x] >= map[0].length ||
       coords[:y] < 0 || coords[:y] >= map.length
        return '?'
    end
    map[coords[:y]][coords[:x]]
end

def set map, coords, value
    unless coords[:x] < 0 || coords[:x] >= map[0].length ||
       coords[:y] < 0 || coords[:y] >= map.length
        map[coords[:y]][coords[:x]] = value
    end
    map[coords[:y]][coords[:x]]
end

def scan_surroundings map, coords
    not_checked = [coords]
    checked = []
    cost = { coords => 0 }
    direction = { coords => 9 }
    edges = {}

    while not_checked.length > 0
        current = not_checked.pop

        checked.push current
        (-1..1).each do |i|
            (-1..1).each do |j|
                c = { x: current[:x]+i, y: current[:y]+j }
                unless not_checked.include?(c) || checked.include?(c)
                    if get(map, c) == '#'
                        checked.push c
                    elsif get(map, c) == '?'
                        checked.push c
                        edges[current] = { cost: cost[current], move: direction[current] }
                    else
                        not_checked.unshift c

                        cost[c] = cost[current] + 1
                        if direction[current] == 9 # assign initial direction
                            direction[c] = DIRECTIONS.find_index([i,j])
                        else
                            direction[c] = direction[current]
                        end

                        if get(map, c) == 'o'
                            return direction[c], if cost[c] == 1 then 'N' else 'A' end
                        end

                        edges[c] = { cost: cost[c], move: direction[c] } if c[:x] == 0 || c[:x] == map[0].length - 1 ||
                                                                            c[:y] == 0 || c[:y] == map.length - 1
                    end
                end
            end
        end
    end

    # If no egg has been found return the move to the closest edge
    nearest_edge = edges.keys.sort_by { |c| edges[c][:cost] }.first
    if edges.length > 0
        return edges[nearest_edge][:move], 'A'
    else
        # The entire map has been scanned and no more eggs are left.
        # Wait for the game to end.
        return 9, 'N'
    end
end

input = $<.read.split "\n"
fov = input[0..4]
memory = input[5]

if memory
    map, coords = decode memory
    map, coords = update(map, fov, coords)
else
    map = fov
    coords = {x: 2, y: 2}
end
clean_up map

move, attack = scan_surroundings(map, coords)

memory = encode map, move_to(move, coords)

puts "#{move}
#{attack}
#{memory}"

এই বটটি এর আগে যা দেখেছিল তা স্মরণ করে এবং প্রতিটি ঘুরে আরও বড় মানচিত্র তৈরির চেষ্টা করে। এরপরে এটি নিকটতম ডিমের জন্য প্রস্থের প্রথম সন্ধানটি ব্যবহার করে এবং সে পথে চলে। যদি বর্তমান মানচিত্রে পৌঁছানোর মতো কোনও ডিম না পাওয়া যায় তবে বটটি তার মানচিত্রের নিকটতম উন্মুক্ত প্রান্তের দিকে এগিয়ে যায় (যাতে মানচিত্রটি দ্রুত দিকে প্রসারিত করতে পারে যেদিকে এটি চলতে পারে)।

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

বট মানচিত্রটি সঞ্চয় করতে মেমরিটি ব্যবহার করে এবং মানচিত্রে এর নতুন অবস্থানটি (এই পদক্ষেপটি সফল হবে। ল্যাপ ব্রেকগুলি, জিপড এবং বেস 64 এনকোডযুক্ত (মানচিত্রের সারিগুলির সংখ্যা সহ, যাতে লাইন ব্রেকগুলি পুনরায় স্থাপন করা যায়) ছাড়াই মানচিত্রটি সংরক্ষণ করা হয়। এই সংকোচনে আকারটি সঙ্কুচিত মানচিত্রের প্রায় এক তৃতীয়াংশে নামিয়ে আনে, তাই 1000 বাইটের বেশি ছায়া থাকায় আমি প্রায় 3000 কোষের মানচিত্র সংরক্ষণ করতে পারতাম, যা প্রায় 18 বট সহ একটি মানচিত্রের সম্পূর্ণ অন্বেষণের সাথে মিলে যায়। যতক্ষণ না অনেকগুলি জমা দেওয়ার কাছাকাছি কোথাও নেই, আমি মনে করি না যে এই মামলার কোনও সমাধান নির্ধারণ করার জন্য আমাকে বিরক্ত করা যেতে পারে।

5 dumbbotটি এবং 1 naivebot(আমার অন্যান্য জমা) এর বিরুদ্ধে কয়েকটি পরীক্ষা চলার পরে এটি হয় খুব খারাপভাবে পারফরম্যান্স করেছে (1 বা 2 ডিমের মতো) বা অন্যদেরকে যথেষ্ট ব্যবধানে (7 থেকে 9 ডিম) ছাড়িয়ে গেছে। আমি আরও ভাল লড়াইয়ের কৌশল এবং আমি কীভাবে নির্ধারণ করতে পারি যে আমি আসলে স্থানান্তরিত করেছি কিনা তা নিয়ে আমি ভাবতে পারি। উভয়ই কিছুটা স্কোর উন্নতি করতে সক্ষম হতে পারে।

ওহ এবং যদি আপনি বটের নামটি নিয়ে ভাবছেন, আপনার স্টিকের অর্ডার অফ ( এই কমিকের শেষ প্যানেল ) পড়া উচিত ।

সম্পাদনা: আবিষ্কারকৃত মানচিত্রের প্রান্তগুলি সনাক্ত করার জন্য কয়েকটি বাগ ছিল। এখন যেহেতু আমি তাদের সংশোধন করেছি এই বট সর্বদা 205 dumbbotএস এবং 1 এর বিপরীতে স্কোর পায় naivebot। ওটা অনেকটা এটার মতই! আপনি যদি $stderr.puts mapএখন আমার বোটে যোগ করেন তবে আপনি সত্যিই দেখতে পারেন যে তিনি কীভাবে পদ্ধতিতে মানচিত্রটি উদঘাটন করেন এবং এর মধ্যে সমস্ত ডিম সংগ্রহ করেন। বটের মূল কোষে ফিরে যাওয়ার সম্ভাবনা কমাতে (যা আংশিকভাবে মানচিত্রটিকে সরিয়ে দেয়) আমি যখনই কোনও ডিমের উপরে না Aপড়ার পরিবর্তে বেছে নেওয়ার সিদ্ধান্ত নিয়েছি N

(এটি 6 naivebotটির বিরুদ্ধে খুব ভাল পারফরম্যান্স করে না , বিশেষত যেহেতু যখন তারা দু'বার বারবার ডিম ধরতে এবং বেছে নিতে চায় তখন অন্য বট দিয়ে "অচলাবস্থা" শেষ করা খুব সম্ভব হয় N। আমি সে সম্পর্কে ভাবতে হবে ... )


3

জাভা বানি

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

পরিকল্পনা এগিয়ে চলছে:

  • দেয়াল / সীমার বাইরে ভিত্তিতে সিদ্ধান্ত নিন
  • এলোমেলোভাবে না করে কোনও উদ্দেশ্য নিয়ে পাথ বেছে নিন
  • আমি আগে যে দিকে যাচ্ছিলাম তা নির্ধারণ করতে মেমরিটি ব্যবহার করুন

আপডেট 1 আমার বানি যদি অন্য একটি ডিম না দেখেন তবে সেগুলি অনুসরণ করবে। এছাড়াও এটি নিজস্ব পদ্ধতিতে "নিকটতম ডিম সন্ধান করুন" কোডটি রিফ্যাক্টর করে।

import java.util.*;

public class EasterEggHunt {

    // board chars
    public static final char EGG = 'o';
    public static final char WALL = '#';
    public static final char BUNNY = '*';
    public static final char SPACE = ' ';
    public static final char OUT_OF_BOUNDS = 'X';

    // player moves
    public static final char ATTACK = 'A';
    public static final char COUNTER = 'C';
    public static final char NOTHING = 'N';

    // directions
    public static final int UPPER_LEFT = 1;
    public static final int UP = 2;
    public static final int UPPER_RIGHT = 3;
    public static final int RIGHT = 4;
    public static final int LOWER_RIGHT = 5;
    public static final int DOWN = 6;
    public static final int LOWER_LEFT = 7;
    public static final int LEFT = 8;
    public static final int STAY = 9;


    // the size of the immediate area
    // (I'll be at the center)
    public static final int VISION_RANGE = 5;

    public static void main(String[] args) {

        Scanner input = new Scanner(System.in);

        char[][] immediateArea = new char[VISION_RANGE][VISION_RANGE];

        for (int i = 0; i < VISION_RANGE; ++i) {
            String line = input.nextLine();
            for (int j = 0; j < VISION_RANGE; ++j) {
                immediateArea[i][j] = line.charAt(j);
            }
        }

        String memory = input.nextLine();

        int moveDirection = decideMoveDirection(immediateArea, memory);
        System.out.println(moveDirection);

        char action = decideAction(immediateArea, memory, moveDirection);
        System.out.println(action);

        // change the memory?
        System.out.println(memory);

    }

    private static int decideMoveDirection(char[][] immediateArea, String memory) {

        // if there's a nearby egg, go towards it
        int direction = nearestBoardObject(immediateArea, EGG);

        // if we didn't find an egg, look for a bunny
        // (maybe he knows where to find eggs)
        if (direction == STAY)
            direction = nearestBoardObject(immediateArea, BUNNY);

        // otherwise, pick a random direction and go
        // we want to also have the chance to stop and catch our breath
        if (direction == STAY)
            direction = new Random().nextInt(STAY + 1);

        return direction;
    }

    private static int nearestBoardObject(char[][] immediateArea, char boardObject) {

        // start at the center and go outward (pick a closer target over a farther one)
        int spacesAway = 1;
        int meX = immediateArea.length / 2;
        int meY = immediateArea[meX].length / 2;

        while (spacesAway <= immediateArea.length / 2) {

            // I like to look right, and go clockwise
            if (immediateArea[meX][meY + spacesAway] == boardObject)
                return RIGHT;
            if (immediateArea[meX + spacesAway][meY + spacesAway] == boardObject)
                return LOWER_RIGHT;
            if (immediateArea[meX + spacesAway][meY] == boardObject)
                return DOWN;
            if (immediateArea[meX + spacesAway][meY - spacesAway] == boardObject)
                return LOWER_LEFT;
            if (immediateArea[meX][meY - spacesAway] == boardObject)
                return LEFT;
            if (immediateArea[meX - spacesAway][meY - spacesAway] == boardObject)
                return UPPER_LEFT;
            if (immediateArea[meX - spacesAway][meY] == boardObject)
                return UP;
            if (immediateArea[meX - spacesAway][meY + spacesAway] == boardObject)
                return UPPER_RIGHT;

            ++spacesAway;
        }

        // if the target object isn't in the immediate area, stay put
        return STAY;

    }

    private static char decideAction(char[][] immediateArea, String memory, int moveDirection) {

        char destinationObject = getDestinationObject(immediateArea, moveDirection);

        switch (destinationObject) {

            case EGG:
                // don't break the egg
                return NOTHING;
            default:
                // get really aggressive on everything else
                // other players, walls, doesn't matter
                return ATTACK;

        }

    }

    private static char getDestinationObject(char[][] immediateArea, int moveDirection) {

        // start at my spot (middle of the board) and figure out which direction I'm going
        int targetX = immediateArea.length / 2;
        int targetY = immediateArea[targetX].length / 2;

        switch (moveDirection) {

            case RIGHT:
                ++targetY;
                break;
            case LOWER_RIGHT:
                ++targetX;
                ++targetY;
                break;
            case DOWN:
                ++targetX;
                break;
            case LOWER_LEFT:
                ++targetX;
                --targetY;
                break;
            case LEFT:
                --targetY;
                break;
            case UPPER_LEFT:
                --targetX;
                --targetY;
                break;
            case UP:
                --targetX;
                break;
            case UPPER_RIGHT:
                --targetX;
                ++targetY;
                break;
            // otherwise we aren't moving

        }

        return immediateArea[targetX][targetY];

    }

}

আমি আরও শিখেছি যে জাভা এনামগুলি ক্লাসে বেশ পূর্ণ, এবং আমি পছন্দ করি নেট নেটগুলি আরও অনেক ভাল।
ব্রায়ান জে

0

Nআইভোট (রুবিতে)

ডিমের ঘূর্ণায়মান হওয়ার জন্য এখানে একটি খুব সরল বট দেওয়া আছে (আমরা দ্রুত এই ঠিক 7 টি সাবমিশন হিট করতে চাই, তাই না?) আমার রুবি খুব মুশকিল নয় তাই এই কোডটি যথাযথ রুবিবাদীদের ব্যথায় সঙ্কুচিত করতে পারে। আপনার নিজের ঝুঁকিতে পড়ুন।

input = $<.read
$data = input.split("\n")

def is_egg x, y
    $data[y+2][x+2] == 'o'
end

def is_wall x, y
    $data[y+2][x+2] == '#'
end

def is_empty x, y
    $data[y+2][x+2] == ' '
end

def is_player x, y
    $data[y+2][x+2] == '*'
end

if (is_egg(-2,-2) || is_egg(-2,-1) || is_egg(-1,-2)) && !is_wall(-1,-1) || is_egg(-1,-1)
    dir = 1
elsif is_egg(0,-2) && !is_wall(0,-1) || is_egg(0,-1)
    dir = 2
elsif (is_egg(2,-2) || is_egg(2,-1) || is_egg(1,-2)) && !is_wall(1,-1) || is_egg(1,-1)
    dir = 3
elsif is_egg(2,0) && !is_wall(1,0) || is_egg(1,0)
    dir = 4
elsif (is_egg(2,2) || is_egg(2,1) || is_egg(1,2)) && !is_wall(1,1) || is_egg(1,1)
    dir = 5
elsif is_egg(0,2) && !is_wall(0,1) || is_egg(0,1)
    dir = 6
elsif (is_egg(-2,2) || is_egg(-2,1) || is_egg(-1,2)) && !is_wall(-1,1) || is_egg(-1,1)
    dir = 7
elsif is_egg(-2,0) && !is_wall(-1,0) || is_egg(-1,0)
    dir = 8
else
    dir = rand(8) + 1
end

attack = 'N'
puts "#{dir}
#{attack}
"

সাথে চালাও ruby naivebot.rb

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


0

WallFolower

(ইচ্ছাকৃত পাং) পাইথন 3 এ :

import sys
import random

#functions I will use
dist       = lambda p1,p2: max(abs(p2[1] - p1[1]), abs(p2[0] - p1[0]))
distTo     = lambda p    : dist((2,2), p)
cmp        = lambda x,y  : (x > y) - (x < y)
sgn        = lambda x    : (-1,0,1)[(x>0)+(x>=0)]
move       = lambda p    : (sgn(p[0] - 2), sgn(p[1] - 2))
unmove     = lambda p    : (p[0] * 2 + 2, p[1] * 2 + 2)
outputmove = lambda p    : (1,2,3,8,9,4,7,6,5)[(sgn(p[0] - 2) + 1) + 3*(sgn(p[1]-2) + 1)]
def noeggfinish(move):
    print(outputmove(unmove(move)))
    print('ACN'[random.randint(0, 2)])
    print("1"+move)
    sys.exit(0)

#beginning of main body
view    = [list(l) for l in map(input, ('',)*5)] #5 line input, all at once.
memory  = input() #currently used only as last direction moved in a tuple
eggs    = []
enemies = []
for y in range(5):
    for x in range(5):
        if   view[y][x] == 'o': eggs    += [(x,y)]
        elif view[y][x] == '*': enemies += [(x,y)]

eggs.sort(key = lambda p:distTo(p)) #sort by how close to me they are.

tiedeggs = []
end = 0
for egg in eggs[:]:
    if end:break
    for enemy in enemies:
        exec({
            -1: 'eggs.remove(egg)',
             0: 'tiedeggs += egg',
             1: 'end=1'
        }[cmp(dist(enemy, egg), distTo(egg))])
        if end:break
if eggs:
    print(outputmove(eggs[0]))
    print('N')              #no attack here
    print("0"+move(eggs[0]))
    sys.exit(0)
elif tiedeggs:
    print(outputmove(tiedeggs[0]))
    print('N')              #no attack here
    print("0"+move(tiedeggs[0]))
    sys.exit(0) 
#now there are no eggs worth going for
#do a LH wall follow

lastmove = eval(memory[1:]) #used to resolve ambiguity
if lastmove[0] and lastmove[1]:
    lastmove[random.randint(0,1)] = 0 #disregard diagonal moves
if eval(memory[0]):
    exec("check=view[%n][%n]"%{(0,-1):(0,0),(1,0):(4,0),(0,1):(4,4),(-1,0):(0,4)}[lastmove])
    if check == '#':
        noeggfinish(lastmove)
    else:pass
#currently unimplemented
#move randomly
noeggfinish(tuple([(x,y) for x in [-1,0,1] for y in [-1,0,1] if (x,y) != (0,0)))

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

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


1
আমি যখন আপনার বটকে টেস্টার.পিপি দিয়ে চালাচ্ছি, কনসোলে আমি এই ত্রুটিটি
পেয়েছি

একই অবস্থা. আপনি কি এটি দেখতে পারেন? আমি এর বিরুদ্ধে আমার নতুন বট পরীক্ষা করতে চাই like
মার্টিন ইন্ডার

@ m.buettner যদি আপনি পরিবর্তন কি হবে sys.exit(0)থেকে exit(0)? এছাড়াও, আমার এটি নিয়ে কাজ করা দরকার (এই মুহুর্তে, এটি নিজেকে একটি `` হিসাবে ধরে নিয়েছে) তবে আমার কাছে আসলে সময় নেই। আমার যখন সময় হবে, আমি এসে এটি ঠিক করব।
জাস্টিন

দুর্ভাগ্যক্রমে, কুইনকুনস, এটি কোনও পরিবর্তন করেনি।
মার্টিন এন্ডার
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.