রোবট! এই আচার সংগ্রহ করুন!

10

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

আপনাকে অবশ্যই আকারে ইনপুট নিতে হবে:

P.......
..1..2..
.......P
........
P3PP...4
.......P

অর্থাত্, উভয়রই একাধিক লাইন ., P(আচার) বা একটি অঙ্ক (রোবটের আইডি)। (আপনি ধরে নিতে পারেন যে প্রতিটি লাইন সমান দৈর্ঘ্যের, প্যাডযুক্ত .।) আপনি এই রেখাগুলি একটি অ্যারে হিসাবে ইনপুট করতে পারেন, বা এসটিডিএন থেকে স্লারপ করতে পারেন, বা কমা-বিচ্ছিন্ন একক লাইনে পড়তে পারেন, বা একটি ফাইল পড়তে পারেন, বা যা যা করতে পারেন তা করতে পারেন ইনপুট নিতে চান

আপনার আউটপুট অবশ্যই nলাইন আকারে হওয়া উচিত , যেখানে nসর্বোচ্চ রোবট আইডি। (রোবট আইডি সর্বদা ১ থেকে শুরু করে ধারাবাহিক হবে) প্রতিটি লাইনে রোবটের পথ থাকবে, L(বাম), R(ডান), U(উপরে) এবং D(নীচে) বর্ণগুলি থেকে গঠিত । উদাহরণস্বরূপ, এখানে p ধাঁধাটির একটি উদাহরণ আউটপুট:

LLU
RDR
LRRR
D

এটাও হতে পারে

LLU RDR LRRR D

অথবা

["LLU","RDR","LRRR","D"]

বা আপনি যে কোনও ফর্ম্যাট চান, যতক্ষণ আপনি সমাধানটি অনুমিত হওয়ার কথা বলতে পারেন।

আপনার লক্ষ্যটি হচ্ছে সর্বোত্তম আউটপুটটি সন্ধান করা, এটিই সর্বনিম্ন পদক্ষেপ রয়েছে। সমস্ত রোবট থেকে প্রাপ্ত পদক্ষেপের পরিমাণকে পদক্ষেপের পরিমাণ গণনা করা হয়। উদাহরণস্বরূপ, উপরের উদাহরণটিতে 4 টি পদক্ষেপ ছিল। মনে রাখবেন যে একাধিক সমাধান হতে পারে তবে আপনাকে কেবল একটি আউটপুট করতে হবে।

স্কোরিং:

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

এখানে পরীক্ষার মামলা রয়েছে। এগুলি এলোমেলোভাবে আমি লিখেছিলাম এমন একটি ছোট রুবি স্ক্রিপ্ট দিয়ে তৈরি করা হয়েছিল।

P.......1.
..........
P.....P...
..P.......
....P2....
...P.P....
.PP..P....
....P....P
PPPP....3.
.P..P.P..P

....P.....
P....1....
.P.....PP.
.PP....PP.
.2.P.P....
..P....P..
.P........
.....P.P..
P.....P...
.3.P.P....

..P..P..P.
..1....P.P
..........
.......2P.
...P....P3
.P...PP..P
.......P.P
..P..P..PP
..P.4P..P.
.......P..

..P...P...
.....P....
PPPP...P..
..P.......
...P......
.......P.1
.P..P....P
P2PP......
.P..P.....
..........

......PP.P
.P1..P.P..
......PP..
P..P....2.
.P.P3.....
....4..P..
.......PP.
..P5......
P.....P...
....PPP..P

শুভকামনা, এবং আচারগুলি খুব বেশিক্ষণ সেখানে বসে থাকতে দেবে না, বা তারা ক্ষতিগ্রস্ত করবে!

ওহ, এবং কেন আচার?

কেন না?

code-challenge  path-finding 
— ডোরকনব
সূত্র
3
এটি দেখানোর কোনও যুক্তিসঙ্গত উপায় নেই যে আপনি আসলে "সর্বোত্তম আউটপুট" পেয়েছেন যেহেতু এটি মূলত ট্র্যাভেল সেলসম্যান (পুরুষ) সমস্যা এবং এনপি সম্পূর্ণ।
— ওয়ালি
@ ওয়াল হুম, তাই না? সম্ভবত কারও দেওয়া পরীক্ষার মামলার ন্যূনতম পদক্ষেপগুলি খুঁজে পাওয়া উচিত এবং তারপরে সমস্ত উত্তর তার উপর ভিত্তি করে তৈরি করা যেতে পারে।
— ডুরকনব
2
পরীক্ষার কেসটি সম্ভবত ন্যূনতম জোর করার জন্য যথেষ্ট ছোট - যদি কেউ এটি করতে চায়। এবং / অথবা যারা উত্তর দিয়েছেন তারা পরীক্ষার ক্ষেত্রে কী পেয়েছেন তা বলতে পারতেন এবং আপনার ন্যূনতমতমটির সাথে মিলে যাওয়ার জন্য অন্যান্য উত্তরগুলির প্রয়োজন হতে পারে।
— ওয়ালি
3
রোবট কি একে অপরের মধ্য দিয়ে যেতে পারে? যদি তা না হয় তবে পাথগুলিকে ব্যাখ্যার সময়সীমাবদ্ধতাগুলি কী?
— পিটার টেলর
1
@ গ্যারেথ এর সাথে সমস্যাটি হ'ল পরীক্ষাগুলি প্রকাশ না হওয়া পর্যন্ত স্কোরগুলি জানা যাবে না এবং তারপরে সাবমিশনগুলি ইতিমধ্যে টেস্টকেসগুলি দেখতে পাবে।
— ডুরকনব

উত্তর:

6

রুবি, 15 + 26 + 17 + 26 + 17 = 101

রোবট আচার আবিষ্কার করে!

ঠিক আছে, নীচের সুপার-নেভ অ্যালগরিদম ব্যবহার করে লোকদের শুরু করার জন্য এখানে একটি বেসলাইন রয়েছে:

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

টেস্ট কেস # 1 এর মতো দেখতে এটি এখানে:

টিসি 1 এর জন্য অ্যানিমেটেড উদাহরণ

অবশ্যই এটি খুব ভাল নয় তবে এটি একটি শুরু!

কোড:

Tile = Struct.new(:world, :tile, :x, :y) do
    def passable?
        tile =~ /\.|P/
    end

    def manhattan_to other
        (self.x - other.x).abs + (self.y - other.y).abs
    end

    def directions_to other
        directions = []
        directions << ?U if self.y > other.y
        directions << ?D if self.y < other.y
        directions << ?L if self.x > other.x
        directions << ?R if self.x < other.x
        directions
    end

    def one_step direction
        nx,ny = case direction
            when ?U then [self.x, self.y - 1]
            when ?D then [self.x, self.y + 1]
            when ?L then [self.x - 1, self.y]
            when ?R then [self.x + 1, self.y]
        end

        self.world[nx,ny]
    end

    def move direction
        destination = one_step(direction)
        raise "can't move there" unless destination && destination.passable?

        destination.tile, self.tile = self.tile, ?.
    end
end

class World
    DIRECTIONS = %w(U D L R)

    def initialize s
        @board = s.split.map.with_index { |l,y| l.chars.map.with_index { |c,x| Tile.new(self, c, x, y) }}
        @width = @board[0].length
    end

    def [] x,y
        y >= 0 && x >= 0 && y < @board.size && x < @board[y].size && @board[y][x]
    end

    def robots
        tiles_of_type(/[0-9]/).sort_by { |t| t.tile }
    end

    def pickles
        tiles_of_type ?P
    end

    def tiles_of_type type
        @board.flatten.select { |t| type === t.tile }
    end

    def inspect
        @board.map { |l| l.map { |t| t.tile }*'' }*?\n
    end
end

gets(nil).split("\n\n").each do |input|
    w = World.new(input)
    steps = Hash[w.robots.map { |r| [r.tile, []] }]
    while (pickles_remaining = w.pickles).size > 0
        current_targets = Hash.new(0)

        w.robots.each do |r|
            target_pickle = pickles_remaining.min_by { |p| [current_targets[p], r.manhattan_to(p)] }

            possible_moves = World::DIRECTIONS.select { |d| t = r.one_step(d); t && t.passable? }
            raise "can't move anywhere" if possible_moves.empty?

            direction = (r.directions_to(target_pickle) & possible_moves).first || possible_moves[0]

            current_targets[target_pickle] += 1
            steps[r.tile] << direction
            r.move(direction)
        end
    end

    puts steps.values.map &:join
    p steps.values.map { |v| v.size }.max
end

মূল প্রশ্নে টেস্ট কেস কোড-ব্লকের বিন্যাসের ঠিক বিন্যাসে STDIN এ ইনপুট নেয়। এই পরীক্ষাগুলির ক্ষেত্রে এটি কী মুদ্রণ করে:

DDLLDLLLLULLUUD
LDLRRDDLDLLLLDR
URDDLLLLLULLUUL
15
ULDLDDLDRRRURRURDDDDDDDLLL
UUULDDRDRRRURRURDLDDDDLDLL
ULUURURRDDRRRRUUUDDDDLDLLL
26
URRRDRUDDDDLLLDLL
RUUUDLRRDDDLLLDLL
LDRDDLDDLLLLLLLUU
RUUURDRDDLLLLLUUU
17
DULLUUUUULDLDLLLLLDDRUUUUR
UDLRRRURDDLLLUUUUURDRUUUUD
26
LDDLDUUDDDUDDDDDR
ULUULDDDDDRDRDDDR
LULLDUUDDDRDRDDDR
UUUURDUURRRRDDDDD
LDLLUDDRRRRRRUDRR
17
— পল প্রেস্টিজ
সূত্র
1

পাইথন, 16 + 15 + 14 + 20 + 12 = 77

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

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

কোড:

def parse_input(string):
    pickles = []
    size = len(string) - string.count('\n')
    poses = [None] * (size - string.count('.') - string.count('P'))
    for y,line in enumerate(string.strip().split('\n')):
        for x,char in enumerate(line):
            if char == '.':
                continue
            elif char == 'P':
                pickles.append((x,y))
            else:
                poses[int(char)-1] = (x,y)
    return pickles, poses

def move((px,py),(tx,ty)):
    if (px,py) == (tx,ty):
        return (px,py)
    dx = tx-px
    dy = ty-py
    if abs(dx) <= abs(dy):
        if dy < 0:
            return (px,py-1)
        else:
            return (px,py+1)
    else:
        if dx < 0:
            return (px-1,py)
        else:
            return (px+1,py)

def distance(pos, pickle):
    return abs(pos[0]-pickle[0]) + abs(pos[1]-pickle[1])

def calc_closest(pickles,poses,index):
    distances = [[distance(pos,pickle) for pickle in pickles] for pos in poses]
    dist_diffs = []
    for i, pickle_dists in enumerate(distances):
        dist_diffs.append([])
        for j, dist in enumerate(pickle_dists):
            other = [d[j] for d in distances[:i]+distances[i+1:]]
            dist_diffs[-1].append(min(other)-dist)

    sorted = pickles[:]
    sorted.sort(key = lambda ppos: -dist_diffs[index][pickles.index(ppos)])
    return sorted

def find_best(items,level):
    if level == 0:
        best = (None, None)
        for rv, rest in find_best(items[1:],level+1):
            val = distance(items[0],rest[0]) + rv
            if best[0] == None or val < best[0]:
                best = (val, [items[0]] + rest)
        return best

    if len(items) == 1:
        return [(0,items[:])]

    size = len(items)
    bests = []
    for i in range(size):
        best = (None, None)
        for rv, rest in find_best(items[:i]+items[i+1:],level+1):
            val = distance(items[i],rest[0]) + rv
            if best[0] == None or val < best[0]:
                best = (val, [items[i]] + rest)
        if best[0] != None:
            bests.append(best)
    return bests

def find_best_order(pos,pickles):
    if pickles == []:
        return 0,[]
    best = find_best([pos]+pickles,0)
    return best

def walk_path(pos,path):
    history = ''
    while path:
        npos = move(pos, path[0])
        if npos == path[0]:
            path.remove(path[0])

        if npos[0] < pos[0]:
            history += 'L'
        elif npos[0] > pos[0]:
            history += 'R'
        elif npos[1] < pos[1]:
            history += 'U'
        elif npos[1] > pos[1]:
            history += 'D'
        pos = npos
    return history

def find_paths(input_str):
    pickles, poses = parse_input(input_str)                 ## Parse input string and stuff
    orig_pickles = pickles[:]
    orig_poses = poses[:]
    numbots = len(poses)

    to_collect = [[] for i in range(numbots)]               ## Will make a list of the pickles each bot should go after
    waiting = [True] * numbots
    targets = [None] * numbots
    while pickles:
        while True in waiting:                              ## If any bots are waiting for a new target
            index = waiting.index(True)
            closest = calc_closest(pickles,poses,index)     ## Prioritizes next pickle choice based upon how close they are RELATIVE to other bots
            tar = closest[0]

            n = 0
            while tar in targets[:index]+targets[index+1:]:                 ## Don't target the same pickle!
                other_i = (targets[:index]+targets[index+1:]).index(tar)
                dist_s = distance(poses[index],tar)
                dist_o = distance(poses[other_i],tar)
                if dist_s < dist_o:
                    waiting[other_i] = True
                    break

                n += 1
                if len(closest) <= n:
                    waiting[index] = False
                    break
                tar = closest[n]

            targets[index] = tar
            waiting[index] = False      

        for i in range(numbots):                            ## Move everything toward targets  (this means that later target calculations will not be based on the original position)
            npos = move(poses[i], targets[i])
            if npos != poses[i]:
                poses[i] = npos
            if npos in pickles:
                to_collect[i].append(npos)
                pickles.remove(npos)
                for t, target in enumerate(targets):
                    if target == npos:
                        waiting[t] = True               

    paths = []
    sizes = []

    for i,pickle_group in enumerate(to_collect):                    ## Lastly brute force the most efficient way for each bot to collect its allotted pickles
        size,path = find_best_order(orig_poses[i],pickle_group)
        sizes.append(size)
        paths.append(path)
    return max(sizes), [walk_path(orig_poses[i],paths[i]) for i in range(numbots)]

def collect_pickles(boards):
    ## Collect Pickles!
    total = 0
    for i,board in enumerate(boards):
        result = find_paths(board)
        total += result[0]
        print "Board "+str(i)+": ("+ str(result[0]) +")\n"
        for i,h in enumerate(result[1]):
            print '\tBot'+str(i+1)+': '+h
        print

    print "Total Score: " + str(total)

boards = """
P.......1.
..........
P.....P...
..P.......
....P2....
...P.P....
.PP..P....
....P....P
PPPP....3.
.P..P.P..P

....P.....
P....1....
.P.....PP.
.PP....PP.
.2.P.P....
..P....P..
.P........
.....P.P..
P.....P...
.3.P.P....

..P..P..P.
..1....P.P
..........
.......2P.
...P....P3
.P...PP..P
.......P.P
..P..P..PP
..P.4P..P.
.......P..

..P...P...
.....P....
PPPP...P..
..P.......
...P......
.......P.1
.P..P....P
P2PP......
.P..P.....
..........

......PP.P
.P1..P.P..
......PP..
P..P....2.
.P.P3.....
....4..P..
.......PP.
..P5......
P.....P...
....PPP..P
""".split('\n\n')

collect_pickles(boards)

আউটপুট:

Board 0: (16)

    Bot1: DLDLLLLDLLULUU
    Bot2: LDLDLLDDLDRURRDR
    Bot3: URDDLLLULULURU

Board 1: (15)

    Bot1: ULRDRDRRDLDDLUL
    Bot2: DDURURULLUUL
    Bot3: ULRRDRRRURULRR

Board 2: (14)

    Bot1: URRRDDDDDRLLUL
    Bot2: UUURDRDDLD
    Bot3: DDDLDDLUUU
    Bot4: RULLLDUUUL

Board 3: (20)

    Bot1: DLULUUUUULDLLLULDDD
    Bot2: LURDDURRDRUUUULUULLL

Board 4: (12)

    Bot1: LDDLDR
    Bot2: ULUULRRR
    Bot3: LUURURDR
    Bot4: RRRDRDDDR
    Bot5: LLDLRRRDRRRU

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