class Robot:
    def __init__(self, ut=''):
        self.ut = ut
        self.rut = self.rovid_ut()
        self.eut = self.atalakit()
        self.koordinatak = self.koordinatakba()
        self.maxtav = self.legnagyobb_tavolsag()
        self.vut = self.vissza_ut()
        self.en = self.energia()
        self.akku = ['kicsi', 'nagy'][self.en > 100]

    def energia(self):
        """az út megtételéhez szükséges energia"""
        e = 2  # indulás
        e += len(self.ut)  # minden lépés egy egység
        for s in range(len(self.ut) - 1):
            if self.ut[s] != self.ut[s + 1]:
                e += 2  # irányváltáskét egység
        return e

    def egyszerusitheto(self):
        """az út egyszerűsíthető-e"""
        if 'ED' in self.ut or 'DE' in self.ut or 'KN' in self.ut or 'NK' in self.ut:
            return True
        else:
            return False

    def rovid_ut(self):
        """az utat egyszerűsíti"""
        rovid = self.ut
        while 'ED' in rovid or 'DE' in rovid or 'KN' in rovid or 'NK' in rovid:
            rovid = rovid.replace('ED', '')
            rovid = rovid.replace('DE', '')
            rovid = rovid.replace('NK', '')
            rovid = rovid.replace('KN', '')
        return rovid

    def atalakit(self):
        """Az útban lévő ismétlődéseket összevonja"""
        # EEEEDDK -> 4E2DK
        uj = ''
        elozo = ''
        szamlalo = 1
        for irany in self.ut + ' ':
            if irany == elozo:
                szamlalo += 1
            else:
                if szamlalo == 1:
                    uj += elozo
                else:
                    uj += str(szamlalo)
                    uj += elozo
                    szamlalo = 1
            elozo = irany
        return uj

    def koordinatakba(self):
        """a út egyes lépéseihez tartozó koordinátákat adja"""
        # az útnak megfelelő koordinátákat adja
        k = [(0, 0)]  # kezdő koordináták
        x, y = 0, 0
        for i in self.ut:
            if i == 'E':
                y += 1
            elif i == 'D':
                y += -1
            elif i == 'K':
                x += 1
            else:
                x += -1
            k.append((x, y))
        return k

    def legnagyobb_tavolsag(self):
        """origótól való legnagyobb távolság"""
        leg = max(self.koordinatak, key=lambda x: x[0] ** 2 + x[1] ** 2)
        return self.koordinatak.index(leg) + 1, round((leg[0] ** 2 + leg[1] ** 2) ** 0.5, 3)

    def vissza_ut(self):
        """origóba történő legrövidebb visszaút"""
        x = self.koordinatak[-1][0]
        y = self.koordinatak[-1][1]
        vut = ''
        if x < 0:
            vut += 'K' * abs(x)
        if x > 0:
            vut += 'N' * x
        if y < 0:
            vut += 'E' * abs(y)
        if y > 0:
            vut += 'D' * y
        return vut

    def irany(self, c):
        """az útban szereplő karakter irány-e vagy szám"""
        if c in ('E', 'D', 'K', 'N'):
            return True
        else:
            return False

    def viszaalakit(self, rovidut):
        """az összevont utat visszaalakítja"""
        # 4E2D -> EEEEDD
        eredeti = ''
        szam = ''
        for i in range(len(rovidut)):
            if not self.irany(rovidut[i]):
                szam += rovidut[i]
            elif self.irany(rovidut[i]) and szam != '':
                eredeti += rovidut[i] * int(szam)
                szam = ''
            else:
                eredeti += rovidut[i]
        return eredeti

    def kirajzol(self):
        """a robot útját kirajzolja"""
        import turtle
        ablak = turtle.Screen()
        ablak.bgcolor("lightgreen")
        robi = turtle.Turtle()
        robi.color('blue')
        robi.pensize(3)
        for i in self.ut:
            if i == 'E':
                robi.setheading(90)
                robi.forward(25)
            elif i == 'D':
                robi.setheading(270)
                robi.forward(25)
            elif i == 'N':
                robi.setheading(180)
                robi.forward(25)
            else:
                robi.setheading(0)
                robi.forward(25)
        ablak.mainloop()

        return


f = open("program.txt")
db = f.readline().strip()
utak = [x.strip() for x in f.readlines()]
f.close()

# 2/a feladat
sorszam = int(input("2/a feladat: adja meg az utasítás sorszámát (1-{}): ".format(len(utak))))
robi = Robot(utak[sorszam - 1])
print("A robot útja", ["nem egyszerűsíthető.", "egyszerűsíthető."][robi.egyszerusitheto()])

# 2/b feladat
print("2/b feladat\n{0} lépést kell tenni az ED, {1} lépést a KN tengely mentén." \
      .format(robi.koordinatak[-1][1], robi.koordinatak[-1][0]))
# 2/c feladat
print("2/c feladat:\nA maximális távolság az origótól:", robi.legnagyobb_tavolsag()[1], "lépés:",
      robi.legnagyobb_tavolsag()[0])

# 3. feladat
print("3. feladat\nAzok az utak, amelyekhez elegendő a kis akku:")
for index, ut in enumerate(utak):
    robi = Robot(ut)
    if robi.akku == 'kicsi':
        print(index + 1, "energia:", robi.energia())

# 4. feladat
print("4. feladat: fájlbaírása a rövidített leírásoknak")
ki = open("ujprogram.txt", "w")
for ut in utak:
    robi = Robot(ut)
    print(robi.atalakit(), file=ki)
ki.close()

# 5. feladat
rovidut = input("5. feladat:\nAdjon meg egy utat: ").upper()
robi = Robot()
print("A visszaalakított út:", robi.viszaalakit(rovidut))
rajz = input("kirajzoljam? (i/n)").upper()
if rajz == 'I':
    Robot(robi.viszaalakit(rovidut)).kirajzol()