কোথ: টিএনটি রান চ্যালেঞ্জ

Question

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

আপনার বটটি একটি সম্পূর্ণ প্রোগ্রাম হওয়া উচিত। এটি একটি কমান্ড লাইন আর্গুমেন্ট হিসাবে ইনপুট গ্রহণ করা উচিত। ইনপুটটি "বিশ্বের" একটি মানচিত্র হবে; এখানে একটি উদাহরণ:

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxx xxxxxxxxxxxxxxxxxxxxxxxxxxx
xxx xxxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxx x xxxxxxxxxxxxx@xxxxxxxxxxx
xxxxxx1xxxxxxxxxxxxx xxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxx xxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxx xxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxx xxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxx xxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxx xxxxxxxxxxx
xxxxxxxxxx           xxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxx xxxxxxxxxxxx
xxxxxxxxxxxxxxxxx x x xxxxxxxxxx
xxxxxxxxxxxxxxxxxxxx xxxxxxxxxxx
xxxxxxxxxxxxxx xxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxx xxx xx3xxxxxxxxxx
xxxxxxxxxxxxxxxxxxx xxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxxxx  x
xxxxxxxxxxxxxxxxxxxxxxxxxxx   xx
xxxxxxxxxxxxxxxxxxxxxxxxx      2
xxxxxxxxxxxxxxxxxxxxxxx         

কিংবদন্তিটি নিম্নরূপ:

x: solid block

 : empty air

@: your bot

1,2,3,4,5,6,7,8,9,0: other bots

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

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

আপনি যখন কোনও ব্লকে অবতরণ করেন এটি সরিয়ে ফেলা হয়; আপনি যদি একই ব্লকটি থেকে পরের দিকে থাকেন তবে আপনি পড়ে যাবেন। দুটি বট একই ব্লকে একই টার্নে অবতরণ করতে পারে এবং উভয়ই বেঁচে থাকতে পারে; যদি এটি হয় তবে উভয় বট কেবল নিজেরাই দেখবে অন্য বটকে নয়।

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

ম্যাচ নিয়ামকটি https://paste.ee/p/Xf65d এ উপলব্ধ ।

দয়া করে এমন ভাষা ব্যবহার করুন যা একটি স্ট্যান্ডার্ড লিনাক্স বা ওএসএক্স ইনস্টলতে চালিত হতে পারে।

বর্তমান ফলাফল (100 রাউন্ড):

JumpBot                   31
LookBot                   27
ShyBot                    26
Slow Bot                  15
KnightBot                 2
Moat Builder              0
UpBot                     0
Random Bot                0

Comments

অনুরূপ, যদিও এখানে মূল পার্থক্যটি হ'ল আপনি বেশ কয়েকটি ব্লক "লাফিয়ে" ফেলতে পারেন - সুতরাং যদি কেউ কাউকে আপনি কী করছেন তা দেখে আপনি কেবল তাকে ব্লক করতে পারবেন না।

— স্কাইলার

আপনি স্যান্ডবক্সে ডুপ হিসাবে বন্ধ করতে পারবেন না এবং আমি মনে করি এটি একেবারে এক নয়

— ব্লু

চালগুলি একযোগে বা ক্রমিক হয়? ইনপুটটি কি আসলেই একটি কমান্ড লাইন আর্গুমেন্ট হিসাবে একটি নতুন লাইনযুক্ত স্ট্রিং রয়েছে?

— ফেয়ারসুম

আমি আরম্ভের জন্য দুনিয়া ছাড়াই একবার বটকে কল করার পরামর্শ দেব (আপনি জানেন না যে আপনার রাজ্য ফাইল হিসাবে সংরক্ষণ করা শেষ রাউন্ডের বা এই রাউন্ডের থেকে)

— বউন 1

@ ফেয়ারসাম মুভগুলি একই সাথে; ইনপুটটি আসলে একটি নতুন লাইনযুক্ত কমান্ড লাইনের যুক্তি। পরিবর্তে আপনার যদি এটি স্টিডিন হিসাবে প্রয়োজন হয় তবে আমাকে জানান এবং আমি সম্ভবত কনটোলারটিকে অন্য কোনওটির জন্য পরিবর্তন করতে পারি।

— স্কাইলার 14

Answer 1

স্লো বট (পাইথন)

তিনি একটি লাইনের প্যাটার্নে চলে যান এবং সেগুলি তৈরির আগে তার চালগুলি পরীক্ষা করেন (দীর্ঘ রানটাইম প্রতিরোধে তিনি যখন শেষজনে জীবিত হন তখনও আত্মহত্যা করেন) আমার টেস্ট টুর্নামেন্টে তিনি ১৯৫৫ / ২০০ ব্যাটেল জিতেছিলেন।

import sys
import re


class vec2(object):
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y

    def __add__(self, other):
        return vec2(self.x + other.x, self.y + other.y)

    def __sub__(self, other):
        return vec2(self.x - other.x, self.y - other.y)

    def __iadd__(self, other):
        return self + other

    def __isub__(self, other):
        return self - other

    def __neg__(self):
        return vec2(-self.x, -self.y)


def xy_to_i(vec=vec2(0, 0)):
    vec -= vec2(1, 1)
    vec.y += (vec.x - vec.x % 32) / 32
    return vec.x + vec.y * 33


def i_to_xy(i=0):
    vec = vec2(0, 0)
    vec.x = i % 33
    vec.y = (i - vec.x) / 32 + 1
    vec.x += 1
    return vec


class World(object):
    def __init__(self, map=''):
        self.map = map

    def getPlayerPosition(self):
        return i_to_xy(re.search('@', self.map).start())

    def getNumOtherBots(self):
        return len(re.findall('([0123456789])', ' ' + self.map + ' '))

    def get_tile(self, vec=vec2(0, 0)):
        i = xy_to_i(vec)
        return self.map[i:i + 1]


world = World(sys.argv[1])
pos = world.getPlayerPosition()


def check_moveV(vecd=vec2(0, 0)):
    try:
        vecn = pos + vecd

        if vecn.x > 32 or vecn.x < 1 or vecn.y > 32 or vecn.y < 1 \
            or abs(vecd.x) + abs(vecd.y) > 4:
            return False

        # Note: this will also avoid positions other bots are on (will disappear in the next step).

        return world.get_tile(vecn) == 'x'
    except:
        raise
        return False


def check_move(x=0, y=0):
    return check_moveV(vec2(x, y))


def run():
    if world.getNumOtherBots() == 0:
        return '0 0'  # Suicide if we are the only one left.

    # this creates the "line" pattern

    if check_move(0, -1):
        return '0 -1'

    if check_move(0, 1):
        return '0 1'

    if check_move(1, 0):
        return '1 0'

    if check_move(1, -1):
        return '1 -1'

    # If we get here, we are desperate and need to find a safe place to jump.

    for dx in range(-2, 2):
        for dy in range(-2, 2):
            if check_move(dx, dy):
                return '%i %i' % (dx, dy)

    # If we can't find a place to jump in close range, try long range.

    for dx in range(-4, 4):
        for dy in range(-4, 4):
            if check_move(dx, dy):
                return '%i %i' % (dx, dy)

    # If we get here, we are dead no matter what; accept our fate.

    return '0 0'


print(run())

আমি পাইথনের বিশেষজ্ঞ নই এবং এটি আরও ছোট / আরও ভাল করার 100 টি উপায় রয়েছে

Comments

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

— টিমটেক 5'16 এ

আমি যখন অধ্যবসায় বাস্তবায়ন করি তখন সে আত্মহত্যা হওয়া পর্যন্ত 5 রাউন্ড অপেক্ষা করবে

— প্রথম

দুর্দান্ত, আমি সেটাই প্রস্তাব করতে যাচ্ছি। দুর্দান্ত উত্তর, যাইহোক।

— টিমটেক

Answer 2

জাম্পবোট (সি)

পরবর্তী রাউন্ডে সর্বাধিক সম্ভাব্য পদক্ষেপগুলি নিয়ে মাঠে নামার চেষ্টা করুন।

#include <stdio.h>
#include <stdlib.h>

typedef struct map {
     char *raw_map;
     int size;
     int lines;
     char *pos;
} *MAP;

typedef struct cdata {
     int result;
     MAP m;
     int x;
     int y;
} *CDATA;

typedef struct mdata {
     int x;
     int y;
     int moves;
     int bx;
     int by;
     MAP m;
} *MDATA;

int numberOfMoves(MAP, int, int);
char getAt(MAP, int, int);

int abs(int x)
{
    return x < 0 ? x*-1 : x;
}

void count(void *data, int x, int y)
{
    CDATA d = (CDATA)data;
    char c = getAt(d->m, d->x + x, d->y + y);
    if(c != 'x') return;
    d->result++;
}

void choose(void *data, int x, int y)
{
    MDATA m = (MDATA)data;
    char c = getAt(m->m, m->x + x, m->y + y);
    if(c != 'x') return;
    int moves = numberOfMoves(m->m, m->x+x, m->y+y);
    if(moves > m->moves || (!m->bx && !m->by)) {
        m->moves = moves;
        m->bx = x;
        m->by = y;
    }
}

MAP parse_input(char *input)
{
    MAP m = malloc(sizeof *m);
    if(!m) {
        fprintf(stderr, "failed to alloc map\n");
        return NULL;
    }

    m->size=0;
    m->lines=1;
    m->pos=0;

    char *temp;
    for(temp = input;*temp;temp++) {
        switch(*temp) {
            case '\n': m->lines++; break;
            default: break;
        }
    }
    m->size = (temp + 1) - (input + m->lines);
    m->raw_map = malloc(m->size);
    if(!m->raw_map) {
        fprintf(stderr, "failed to alloc raw_map\n");
        return NULL;
    }

    int index = 0;
    for(temp = input; *temp; temp++) {
        if(*temp == '@') m->pos = m->raw_map + index;
        if(*temp != '\n') m->raw_map[index++] = *temp;
    }

    return m;
}

char getAt(MAP m, int x, int y)
{
    return m->raw_map[x + y*(m->size / m->lines)];
}

void posToXY(MAP m, int *x, int *y)
{
    int index = m->pos - m->raw_map;
    int length = m->size / m->lines;
    *x = index % length;
    *y = index / length;
}

typedef void (*DOFUNC)(void *, int, int);
void processMoves(MAP m, int x, int y, DOFUNC proc, void *data)
{
    int length = m->size / m->lines;    
    int left = x>=4 ? 4 : x;
    int right = x + 4 <= length ? 4 : length - (x + 1);
    int up = y >= 4 ? 4 : y;
    int down = y + 4 <= m->lines ? 4 : m->lines - (y + 1);

    for(int i=-left; i<=right; i++) {
        for(int j=-up; j<=down; j++) {
            if((abs(i) + abs(j) <= 4) && (i || j)) (*proc)(data, i, j);
        }
    }
}

int numberOfMoves(MAP m, int x, int y)
{
    struct cdata d;
    d.result = 0;
    d.x = x;
    d.y = y;
    d.m = m;
    processMoves(m, x, y, &count, &d);
    return d.result;
}

void getMove(MAP m, int *x, int *y)
{
    struct mdata d;
    posToXY(m, &d.x, &d.y);
    d.moves = 0;
    d.bx = 0;
    d.by = 0;
    d.m = m;
    processMoves(m, d.x, d.y, &choose, &d);
    *x = d.bx;
    *y = d.by;
}

int main(int argc, char *argv[])
{
    if(argc != 2) {
        fprintf(stderr, "bad number of arguments %d\n", argc);
        return -1;
    }

    MAP m = parse_input(argv[1]);
    int x=0, y=0;
    getMove(m, &x, &y);
    printf("%d %d\n", x, y);
    return 0;
}

Answer 3

লুকবট (সি)

স্লো বটের সাথে পারফরম্যান্সের অনুরূপ সরল বট, এটি বাদ দিয়ে এলোমেলো সম্ভাব্য পদক্ষেপ করে। প্রিডিকটবটে এটিকে উন্নত করার পরিকল্পনা করুন।

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <assert.h>
#include <sys/time.h>

#define WORLDSZ (32)
#define WORLDSZ_2 (WORLDSZ*WORLDSZ)

int max(int a,int b){return a>b?a:b;}
int min(int a,int b){return a<b?a:b;}

struct Position{
    int x,y;
};
typedef struct Position Position;

struct World{
    Position me;
    double enemymap[WORLDSZ][WORLDSZ]; //chance of enemy present
    bool open[WORLDSZ][WORLDSZ];
};
typedef struct World World;

void world_read(World *world,const char *arg){
    int x,y,i=0;
    for(y=0;y<WORLDSZ;y++,i++){
        for(x=0;x<WORLDSZ;x++,i++){
            if(arg[i]=='@'){world->me.x=x; world->me.y=y;}
            world->enemymap[y][x]=arg[i]>='0'&&arg[i]<='9';
            world->open[y][x]=arg[i]=='x';
        }
    }
}

//returns relative position
Position world_calcmove(World *world){
    const int mex=world->me.x,mey=world->me.y;
    int dx,dy;
    Position poss[40];
    int nposs=0;
    for(dy=max(-mey,-4);dy<=min(WORLDSZ-1-mey,4);dy++){
        const int absdy=abs(dy);
        for(dx=max(-mex,absdy-4);dx<=min(WORLDSZ-1-mex,4-absdy);dx++){
            if(!world->open[mey+dy][mex+dx])continue;
            poss[nposs].x=dx;
            poss[nposs++].y=dy;
        }
    }
    if(nposs==0){
        poss[0].x=poss[0].y=0;
        return poss[0];
    }
    return poss[rand()%nposs];
}

int main(int argc,char **argv){
    if(argc!=2){
        fprintf(stderr,"Call with world!\n");
        return 1;
    }
    struct timeval tv;
    gettimeofday(&tv,NULL);
    srand(tv.tv_sec*1000000ULL+tv.tv_usec);

    World world;
    world_read(&world,argv[1]);
    Position move=world_calcmove(&world);
    printf("%d %d\n",move.x,move.y);
}

Answer 4

শাবক নির্মাতা (পাইথন)

আমি যদি নিজের চারপাশে একটি শূকক খনন করি তবে এর বাইরের কেউই আমাকে ধাক্কা দিতে পারে না।

... "নিজেকে কোণার সিমুলেটর 2016 এ রঙ করুন" নামেও পরিচিত।

import numpy
import sys
import math
import os

if not os.path.exists('./moatbuilder'):
    os.mkdir('./moatbuilder')

raw_field = sys.argv[1]
field = numpy.array([numpy.array(list(i)) for i in raw_field.splitlines()])
field_size = len(field)
x, y = raw_field.replace('\n','').index('@')%field_size, int(raw_field.replace('\n','').index('@')/field_size)
# If there are no holes, it's the first round - reset persistence
if raw_field.count(' ')==0:
    open('./moatbuilder/persistent','w').write('')

def bigmove(target):
    if x < target[0]:
        return min(4, target[0] - x), 0
    elif x > target[0]:
        return max(-4, target[0] - x), 0
    elif y < target[1]:
        return 0, min(4, target[1] - y)
    else:
        return 0, max(-4, target[1] - y)

def smallmove(target):
        if x < target[0]:
        try:
            return min(max(1, list(field[y][x:x+4]).index('x')), target[0] - x), 0
        except:
            return 0, 0
        elif x > target[0]:
        try:
            return max(min(-1, 0-list(reversed(field[y][x-4:x])).index('x')), target[0] - x), 0
        except:
            return 0, 0
        elif y < target[1]:  
        try:
                    return 0, min(max(1, list(field[:,x][y:y+4]).index('x')), target[1] - y)
        except:
            return 0, 0
        else:
        try:
            return 0, max(min(-1, 0-list(reversed(field[:,x][y-4:y])).index('x')), target[1] - y)
        except:
            return 0, 0


try:
    mode = int(open('./moatbuilder/persistent').read())
except:
    mode = 1

# Modes:
# 1 - go to the center
# 2 - go to an outside edge
# 3 - dig moat
if mode==1:
    dx, dy = bigmove((int(field_size/2), int(field_size/2)))
    if dx==0 and dy==0:
        open('./moatbuilder/persistent', 'w').write('2')
        mode = 2
if mode==2:
    dx, dy = bigmove((int(field_size-1), int(field_size/2)))
    if dx==0 and dy==0:
        dy = 1
        open('./moatbuilder/persistent', 'w').write('3')
        mode = 3
elif mode==3:
    direction = max(field_size-x, field_size-y)%2
    if direction == 1:
        if x > y:
            dx, dy = smallmove((y, y))
        else:
            dx, dy = smallmove((x, field_size - 1))
        if dx==0 and dy==0:
            dx = 1
    else:
        if y > x:
            dx, dy = smallmove((x, x))
        else:
            dx, dy = smallmove((field_size - 1, y))
        if dx==0 and dy==0:
            dy = 1

print "%i %i" % (dx, dy)

Comments

এটি আসলে বেশ সুন্দরভাবে কাজ করে, তবে এটি দীর্ঘদিন বেঁচে থাকা বটের বিরুদ্ধে হারাবে (কেন আমি লাইন প্যাটার্ন

— বিটিডব্লু বেছে নেব

আপনি নিজের ইন্ডেন্টেশনটি স্মলমোভ () এ ঠিক করতে চাইতে পারেন ... আমার অজগর এটি খায় না :)

— টমসমেডিং

Answer 5

মন্টে (পাইথন)

দুঃখিত, সেই শ্লেষটি সবেমাত্র তৈরি করতে হয়েছিল।

যাইহোক, এই বটটি সম্ভাব্য সরানো সমস্ত সেটগুলিতে একটি মন্টি কার্লো ট্রি অনুসন্ধান করে কাজ করে । জাম্পবোটের কথা চিন্তা করুন, আরও গভীরতার সাথে।

চালাতে, এটির জন্য অতিরিক্ত কমান্ড লাইন আর্গুমেন্ট প্রয়োজন (নিয়ামকটিতে নির্দিষ্ট করা যেতে পারে)। এটি নিয়ন্ত্রণ করে যে বটটি কত সময় অনুসন্ধান করবে (এমএসে); আমি পরীক্ষায় 750-1500 ব্যবহার করেছি।

কোড:

import sys
import math
import copy
#from profilestats import profile
pmap = sys.argv[2].split("\n")
pmap = [list(r) for r in pmap]

#find a player
#@profile
def find(tmap,bot):
   r,c=-1,-1
   for row in range(len(tmap)):
      for col in range(len(tmap[row])):
         if tmap[row][col]==bot:
            r,c=row,col
   return r,c

mer,mec=find(pmap,'@')
bots=[(mer,mec)]

#find all the other players
for b in range(10):
   r,c=find(pmap,str(b))
   if r != -1:
      bots.append((r,c))

#getter function, treats oob as spaces
def get(tmap,r,c):
   if r<0 or r>=len(tmap) or c<0 or c>=len(tmap[r]):
      return ' '
   return tmap[r][c]

#returns manhattan distance between 2 positions  
def dist(r1,c1,r2,c2):
   return abs(r1-r2)+abs(c1-c2)

#gets all possible moves from a map
#@profile 
def moves(tmap,ther=-1,thec=-1):
   if ther==-1: ther,thec = find(tmap,'@')
   pos=[]
   for r in range(-4,5):
      for c in range(-4,5):
         if abs(r)+abs(c)<=4 and get(tmap,ther+r,thec+c)=='x':
            pos.append((r,c))
   return pos


ttlmoves = 40
#monte-carlo tree node
class MCNode:
   def __init__(self):
      self.wins=0
      self.simu=0
      self.chld=[]
      self.cmap=[[]]
      self.prnt=None
      self.r=-1
      self.c=-1
   def add(self, cnode):
      self.chld.append(cnode)
      cnode.prnt = self
   #used to balance exploitation and exploration
   #@profile
   def param(self,cin):
      return self.chld[cin].wins/self.chld[cin].simu\
             + 1.414 * math.sqrt( math.log(self.simu) / \
             self.chld[cin].simu )
   #finds the child with the highest param
   #@profile
   def best(self):
      vals = [self.param(x) for x in range(len(self.chld))]
      binx = 0
      bval = vals[0]
      for x in range(len(vals)):
         if vals[x]>bval:
            binx=x
            bval=vals[x]
      return self.chld[binx]


#update all the parents 
#@profile   
def backprog(leaf):
   par = leaf.prnt
   if not (par is None):
      par.wins+=leaf.wins
      par.simu+=leaf.simu
      backprog(par)

#expand all the moves from a position
#@profile
def expand(rootn):
   ther,thec = rootn.r,rootn.c
   for r,c in moves(rootn.cmap,rootn.r,rootn.c):
      nmap = copy.deepcopy(rootn.cmap)
      nmap[ther+r][thec+c] = '@'
      nmap[ther][thec]=' '
      nnode = MCNode()
      nm = moves(nmap,ther+r,ther+c)
      nnode.wins = len(nm)
      nnode.simu = ttlmoves
      nnode.r=ther+r
      nnode.c=thec+c
      nnode.cmap = nmap
      rootn.add(nnode)
      backprog(nnode)

root = MCNode()
m = moves(pmap,mer,mec)
root.wins = len(m)
root.simu = ttlmoves
root.cmap=copy.deepcopy(pmap)
root.r=mer
root.c=mec
expand(root)

#simulate a bunch of outcomes
import time
curt  = lambda: int(round(time.time() * 1000))
strt = curt()
ttme = int(sys.argv[1])
while curt()-strt < ttme:
   tnode=root
   while tnode.chld:
      tnode=tnode.best()
   expand(tnode)

#choose the most explored one
bnode = max(root.chld,key=lambda n:n.simu)

#output
print("{} {}".format((bnode.c-mec),(bnode.r-mer)))

বিচার

25 রাউন্ড:

MonteBot            14
JumpBot             6
ShyBot              5
LookBot             1
KnightBot           0
SlowBot             0

100 রাউন্ড:

JumpBot             38
MonteBot            36
ShyBot              15
LookBot             14
SlowBot             2
KnightBot           0

200 রাউন্ড:

MonteBot            87
JumpBot             64
LookBot             33
ShyBot              21
SlowBot             5
KnightBot           0

উপরে ব্যবহৃত সিমুলেশনগুলির সন্ধানের সময় 750 ব্যবহার করা হয়েছে longer

উন্নতি

এই বটটির এখনও উন্নতি প্রয়োজন:

1. পারফরম্যান্স: অনুসন্ধানের জন্য এটি পুরো সময় প্রয়োজন।
2. ভবিষ্যদ্বাণী: এটি অন্যান্য বটের চালনার জন্য অ্যাকাউন্ট করবে না।
3. ভারসাম্য: আমি নিশ্চিত নই যে আমি কোন নোডটি অন্বেষণ করব তা গণনা করতে আমি যে ইউসিটি সূত্রটি ব্যবহার করছি তা সর্বোত্তম কিনা।

Answer 6

শাইবট (পাইথন)

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

import sys
map = sys.argv[1]
map = map.split("\n")
map = [list(r) for r in map]

def find(map,bot):
   r,c=-1,-1
   for row in range(len(map)):
      for col in range(len(map[row])):
         if map[row][col]==bot:
            r,c=row,col
   return r,c


mer,mec=find(map,'@')
bots=[(mer,mec)]

for b in range(10):
   r,c=find(map,str(b))
   if r != -1:
      bots.append((r,c))

avg=[0,0]

for b in bots:
   avg[0]+=b[0]
   avg[1]+=b[1]

avg[0] = avg[0]/len(bots)
avg[1] = avg[1]/len(bots)

def get(map,r,c):
   if r<0 or r>=len(map) or c<0 or c>=len(map[r]):
      return ' '
   return map[r][c]

def dist(r1,c1,r2,c2):
   return abs(r1-r2)+abs(c1-c2)

pos=[]
for r in range(-4,5):
   for c in range(-4,5):
      if abs(r)+abs(c)<=4 and get(map,mer+r,mec+c)=='x':
         pos.append((r,c))

if len(pos)==0:
   bestr,bestc=0,0
else:
   bestr,bestc=pos[0]

for r,c in pos:
   if dist(mer+r,mec+c,avg[0],avg[1])>dist(mer+bestr,mec+bestc,avg[0],avg[1]):
      bestr,bestc=r,c

print(str(bestc)+" "+str(bestr))

Answer 7

নাইটবট (জাভা)

এটি দাবা জাতীয় কাজ, এবং টুইচ মত নামকরণ ...

...

.........

............................ দুঃখিত ...

public class KnightBot{
   private static String[] map;
   private static int myx;
   private static int myy;
   public static void main(String[] args){
      map=args[0].split("\n");
      for(int y=0;y<map.length;y++){
         if(map[y].indexOf("@")!=-1){
            myy = y;
            myx = map[y].indexOf("@");
            break;
         }
      }
      System.out.println(move((int)(Math.random()*4),4));
   }
   public static String move(int dir,int tries){
      if(tries==0)return "0 0";
      int x=dir<2?1:-1;
      int y=dir%2==0?2:-2;
      if((myx+x<0||myx+x>=map[0].length()||myy+y<0||myy+y>=map.length)||map[y+myy].charAt(myx+x)!='x'){
         x=dir<2?2:-2;
         y=dir%2==0?1:-1;
      }
      if((myx+x<0||myx+x>=map[0].length()||myy+y<0||myy+y>=map.length)||map[y+myy].charAt(myx+x)!='x')
         return move(++dir>3?0:dir,tries-1);
      return x+" "+y;
   }
}

SwirlyBot (জাভা)

এগুলি পরিষ্কারভাবে সর্বোত্তম সমাধান নয়, তবে আমি আশা করি মিডলিভেল পরীক্ষার জন্য কার্যকর হবে।

public class SwirlyBot{
   private static String[] map;
   private static int myx;
   private static int myy;
   public static void main(String[] args){
      map=args[0].split("\n");
      for(int y=0;y<map.length;y++){
         if(map[y].indexOf("@")!=-1){
            myy = y;
            myx = map[y].indexOf("@");
            break;
         }
      }
      System.out.println(move(0));
   }
   public static String move(int dir){
      switch(dir){
         case 0:
            if(!safe(0,1)){
               if(safe(1,1)){
                  return "1 1";//Down-Right
               }else{
                  if(safe(1,0)){
                     return "1 0";//Right
                  }
               }
            }
            break;
         case 1:
            if(!safe(1,0)){
               if(safe(1,-1)){
                  return "1 -1";//Up-Right
               }else{
                  if(safe(0,-1)){
                     return "0 -1";//Up
                  }
               }
            }
            break;
         case 2:
            if(!safe(0,-1)){
               if(safe(-1,-1)){
                  return "-1 -1";//Up-Left
               }else{
                  if(safe(-1,0)){
                     return "-1 0";//Left
                  }
               }
            }
            break;
         case 3:
            if(!safe(-1,0)){
               if(safe(-1,1)){
                  return "-1 1";//Down-Left
               }else{
                  if(safe(0,1)){
                     return "0 1";//Down
                  }
               }
            }
            break;
         case 4:
            if(safe(0,-1))return "0 -1";
            break;
         case 5:
            if(!safe(0,2)){
               if(safe(1,2)){
                  return "1 2";//Down-Right
               }else{
                  if(safe(2,2)){
                     return "2 2";
                  }else{
                     if(safe(2,1)){
                        return "2 1";
                     }else{
                        if(safe(2,0)){
                           return "2 0";//Right
                        }
                     }
                  }
               }
            }
            break;
         case 6:
            if(!safe(2,0)){
               if(safe(2,-1)){
                  return "2 -1";//Up-Right
               }else{
                  if(safe(2,-2)){
                     return "2 -2";
                  }else{
                     if(safe(1,-2)){
                        return "1 -2";
                     }else{
                        if(safe(0,-2)){
                           return "0 -2";//Up
                        }
                     }
                  }
               }
            }
            break;
         case 7:
            if(!safe(0,-2)){
               if(safe(-1,-2)){
                  return "-1 -2";//Up-Left
               }else{
                  if(safe(-2,-2)){
                     return "-2 -2";
                  }else{
                     if(safe(-2,-1)){
                        return "-2 -1";
                     }else{
                        if(safe(-2,0)){
                           return "-2 0";//Left
                        }
                     }
                  }
               }
            }
            break;
         case 8:
            if(!safe(-2,0)){
               if(safe(-2,1)){
                  return "-2 1";//Down-Left
               }else{
                  if(safe(-2,2)){
                     return "-2 2";
                  }else{
                     if(safe(-1,2)){
                        return "-1 2";
                     }else{
                        if(safe(0,2)){
                           return "0 2";//Down
                        }
                     }
                  }
               }
            }
            break;
      }
      if(dir<8)return move(dir+1);
      return "0 -1";
   }
   public static boolean safe(int x, int y){
      return !((myx+x<0||myx+x>=map[0].length()||myy+y<0||myy+y>=map.length)||map[y+myy].charAt(myx+x)!='x');
   }
}

Comments

হ্যালো, এবং পিপিসিজিতে আপনাকে স্বাগতম! দুর্দান্ত উত্তর!

— NoOneIs এখানে

Answer 8

র্যান্ডম বট, আপবট

প্রতিযোগিতা করতে দুটি শুরু বট:

র্যান্ডম বট: এলোমেলোভাবে চলমান একটি উদাহরণ বট।

import random

x = random.randint(-4, 4)
y = random.randint(max(-4, -4 + abs(x)), min(4, 4 - abs(x)))
print x, y

আপবট: উপরে উঠে যায় এমন একটি উদাহরণ বট।

print '0 -1'

Comments

আমি আমার (এখন মুছে ফেলা) র্যান্ডম ওয়াকার উত্তরের জন্য 10 টি পরীক্ষার রাউন্ড চালিয়েছি এবং হাসিখুশিভাবে, আপবট খুব ভাল করছে। তিনি 10 রাউন্ডের মধ্যে 7 পেয়েছেন।

— user48538

এখানে আমি পরীক্ষার ফলাফল এবং পরীক্ষার স্ক্রিপ্টটি ব্যবহার করেছি (এবং হ্যাক করেছি) ।

— user48538

জিপ ফাইল হিসাবে সরবরাহিত এখানে সম্পূর্ণ পরীক্ষার ফলাফল রয়েছে ।

— user48538

আপবোট ভাল করে তোলে কারণ সে একবারে কেবল একটি ব্লক সরিয়ে নিয়ে যায়, তাই সাধারণত কোনও প্রাচীরের মধ্যে দৌড়তে বেশি সময় লাগে এটি র‌্যান্ডম বটের চেয়ে কোনও গর্তে যেতে।

— স্কাইলার

@ জাইবিন ১০১১: আপনি জানেন, আপনি কেবল এটি চালাতে পারবেন, পুরো টুর্নামেন্ট খেলার জন্য 'y' চাপুন এবং রাউন্ডের জন্য ১০ টি প্রবেশ করুন।

— স্কাইলার

Answer 9

স্টালকারবট (পাইথন)

এটি যতটা নিকটতম বট দেখেছে তার কাছাকাছি পৌঁছে যাবে। স্লো বটের (অর্থহীন) স্বয়ংক্রিয় আত্মহত্যার লক্ষ্যবস্তু। (যদি আমি এটির মতো স্কোয়ারে থাকি এবং অন্য কোনও খেলোয়াড় না থাকে তবে এটি আমাকে দেখতে পাবে না এবং আত্মহত্যা করবে))

#!/usr/bin/python3
from math import inf
from sys import argv

class Vector:
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y

    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)

    def __sub__(self, other):
        return Vector(self.x - other.x, self.y - other.y)

    def __neg__(self):
        return Vector(-self.x, -self.y)

    def __abs__(self):
        return self.x ** 2 + self.y ** 2  # Technically the square of the magnitude, but we only need it for comparison.

    def __iter__(self):
        yield self.x
        yield self.y

def get_location(grid, target='@'):
    for i, line in enumerate(grid):
        for j, char in enumerate(line):
            if char == target:
                return Vector(i, j)

def main(grid):
    my_location = get_location()

    min_distance = inf
    min_distance_direction = None

    for i in range(10):
        enemy_location = get_location(str(i))

        if enemy_location is not None:
            direction = enemy_location - my_location
            distance = abs(direction)

            if distance < current_min:
                min_distance = distance
                min_distance_direction = direction

            if distance == 1:
                break

    if min_distance_direction is not None:
        return min_distance_direction

    for d in range(1, 5):
        for x in range(-d, d):
            for y in (d - abs(x), abs(x) - d):
                if grid[x][y] == ' ':
                    return x, y

    return 0, 0

if __name__ == '__main__':
    print(*main(argv[1].splitlines()))

Comments

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

— আর

@ রিকার বোঝা। যুক্তিটি পরিবর্তন না করা এটি বোধগম্য, তবে সেই কোডটি পড়তে আমার সমস্যা হচ্ছে, তাই আমি ফর্ম্যাটিংটি পরিষ্কার করার সিদ্ধান্ত নিয়েছি।

— সলোমন উকো

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

— আর

@ রিকার মূলত, এমন কোনও সম্পাদনা করবেন না যা স্কোরকে প্রভাবিত করতে পারে।

— সলোমন উকো