# guess the numer


class Configuration:
    length: int = 100

    def __init__(self, length=None):
        try:
            self.length = int(length)
        except ValueError:
            pass
        self.array = [None]*length

    def copy(self) -> 'Self':
        new = Configuration(length=self.length)
        new.array = self.array.copy()
        return new

    def get_points(self) -> list:
        players = self.current_players()
        for p in range(players):
            assert p in self.array
        # assert max(self.array) == players-1
        points = [0]*players
        lastplayer = None
        points_between = 0
        for v in self.array:
            if v is None:
                points_between += 1
                continue
            points[v] += 1
            if lastplayer is not None:
                points_between /= 2
                points[lastplayer] += points_between
            points[v] += points_between
            points_between = 0
            lastplayer = v
        points[lastplayer] += points_between
        return points

    def choose(self,
               place,
               player=None,
               ) -> None:
        if player is None:
            player = self.current_players()
        assert self.array[place] is None
        assert player not in self.array
        self.array[place] = player

    def current_players(self) -> int:
        try:
            return max([v for v in self.array if v is not None]) + 1
        except ValueError:
            return 0

    def optimize(self, players):
        p = self.current_players()
        if p == players:
            return self
        else:
            maxpoint = -1
            bestpos = None
            for i in range(self.length):
                new = self.copy()
                try:
                    new.choose(place=i)
                except AssertionError:
                    del new
                    continue
                cur_fav = new.optimize(players)
                cur_points = cur_fav.get_points()[p]
                if maxpoint < cur_points:
                    maxpoint = cur_points
                    bestpos = i
                    final_config = cur_fav
            self.choose(place=bestpos)
            return final_config

    def rep_underline(self):
        rep = []
        for v in self.array:
            if v is None:
                rep.append('_')
            else:
                rep.append(str(v))
        return rep
    def __str__(self):
        return ' '.join(self.rep_underline())
    def summary(self) -> str:
        ret = str(self)
        points = self.get_points()
        for p in range(self.current_players()):
            point = points[p]
            if point.is_integer():
                point = int(point)
            ret += f'\n Player: {p}'
            ret += f'\n  Points: {point}'
            ret += f'\n  Position: {self.array.index(p)}\n'
        return ret


if __name__ == "__main__":
    import sys
    try:
        N = int(sys.argv[1])
    except IndexError:
        N = 3
    try:
        length = int(sys.argv[2])
    except IndexError:
        length = 10

    c = Configuration(length=length)
    # c.choose(10)
    f=c.optimize(N)
    print(f.summary())