es3

# -*- coding: utf-8 -*-
'''
Una regione e' stata suddivisa concettualmente in quadrati adiacenti.
Ogni  quadrato della griglia risultante e' univocamente identificato da una
coppia di interi positivi (x,y) ad indicare che il quadrato appartiene alla x-ma colonna
e y-ma riga della griglia, CON IL QUADRATO (1,1) SITUATO IN BASSO A SINISTRA (ATTENZIONE!).

Disponiamo di robottini in grado di muoversi tra i quadrati della griglia ma solo in
orizzontale (da sinistra verso destra) e verticale (dal basso verso l'alto).
Uno spostamento del robottino viene indicato da un intero A (positivo o negativo).
Se il robottino si trova nel quadratino di coordinate (x,y):
-  l'intero +A positivo indica uno spostamento in verticale fino al quadrato (x,y+|A|)
-  l'intero -A negativo indica uno spostamento in orizzontale della griglia fino al quadrato (x+|A|,y)
Una sequenza di interi (positivi o negativi) indica dunque un percorso del robottino.
Ad esempio se il robottino e' nel quadrato (1,1), la sequenza 5,-2,-2,2,-4 lo porta nel quadrato (9,8).

Ci vengono forniti un insieme I di quadrati della griglia indicati dalle loro coordinate (x,y)
e due percorsi di due robottini, che partono entrambi dal quadrato (1,1) e terminano in uno stesso quadrato.
Il primo percorso comincia con un numero positivo, il secondo con un numero negativo
e il quadrato iniziale e quello finale sono gli unici quadrati che i due percorsi hanno in comune.
Vogliamo sapere quanti dei quadrati dell'insieme I ricadono nella zona circoscritta dai due percorsi.
Nota che un quadrato (x,y) e' nella zona circoscritta se i due robottini
attraversano la colonna x della griglia e i quadrati di quella colonna attraversati
dai due robottini  sono rispettivamente (x,y1) ed (x,y2) con y1>y>y2).
(quindi i quadrati di I che si trovano sui percorsi NON vanno contati)

Ad esempio per per l'insieme
    I={ (11, 2), (8,5), (4,6), (7,1), (2,9), (3,4), (7,6), (6,6), (5,2)}
e i due percorsi:
    p1 =  5 -2 -2 2 -4
    p2 = -3  2 -5 5
Ovvero (indicando con '+' i movimenti con A positivo, con '-' quelli con A negativo,
        con '*' i quadrati di I, con 'o' l'origine e con 'X' la destinazione)
    y
    ^
  11|
  10|
   9| *
   8|    +---X
   7|    +   +
   6|+--*-** +
   5|+      *+
   4|+ *     +
   3|+  +-----
   2|+  +*     *
   1|o---  *
    |_______________________>x
              11111111112
     12345678901234567890

la risposta e' 4 perche' gli unici quadrati che ricadono nella zona circoscritta sono
{(3, 4), (6, 6), (7, 6), (8, 5)}

Scrivere una funzione es3(fmappa) che prende in input  il percorso del file di testo contenente
i percorsi dei due robottini e l'insieme dei quadrati I e restituisce il numero di quadrati
dell'insieme I che risultano circoscritti dai due percorsi.

I dati sono organizzati  nel file come segue:
- una serie di righe vuote
- il percorso del primo robottino ( ciascuno spostamento del percorso
  separato dal successivo da spazi e il tutto in una o piu' righe consecutive)
- una serie di righe vuote
- il percorso del secondo  robottino ( ciascuno spostamento del percorso
  separato dal successivo da spazi e il tutto in una o piu' righe consecutive)
- una serie di righe vuote
- una sequenza di coppie (x,y) che indicano i quadrati dell'insieme (le coppie separate
 da virgole e spazi ed in una o piu' righe consecutive)
- una serie di righe vuote

Si veda ad esempio il file mp1.txt

NOTA: il timeout previsto per questo esercizio è di 1 secondo per ciascun test.

ATTENZIONE: quando caricate il file assicuratevi che sia nella codifica UTF8
(ad esempio editatelo dentro Spyder)'''

import operator

def es3(fmappa):
    '''Implementare la funzione qui'''
    var,enable, p1,p2,q,ins1,ins2=True,False,'','','',[],[]

     #Apertura del file e lettura dati
    with open(fmappa, 'r') as file:
        t=file.read()
        t=t.split('\n')

    #Traduzione file da lista di stringhe in p1-p2-q
    for r in t:

        if r=='':
            if var or enable==True:
                continue
            else:
                enable=True

        elif r[0].isnumeric() or r[0]=='-':
            var=False
            if enable:
                p2+=r
            else:
                p1+=r

        else:
            q+=r.replace(' ','')

    #Traduzione di q in una lista di tuple (x,y)
    r=[]
    for t in q[1:-1].split( '),(' ):
        r.append(tuple(map(int, t.split(','))))
    r.sort(key=operator.itemgetter(1))



    ins0=set()
    for n in r:
#        if n[1] not in ins0:
            ins0.add(n)
    ins0.discard(1)
#    l0=list(ins0)

    #creazione dei percorsi e update degli insiemi
    x1,y1,n,enable=1,1,0,False
    for i in p1:
        if i==' ':
            enable=False

        elif i=='-':
            enable=True

        else:
            if not enable:
                #numero positivo
#                while y1 <= l0[n] <= y1+int(i):
#                    if y < l0[n] < y+int(i):
#                        ins1.add((x,l0[n]))
#                   n+=1
                y1+=int(i)
                ins1.append((x1,y1))
            else:
                #numero negativo
                x1+=int(i)

    x1,y1,n,enable=1,1,0,False
    for i in p2:
        if i==' ':
            enable=False

        elif i=='-':
            enable=True

        else:
            if not enable:
                #numero positivo
#                while y1 <= l0[n] <= y1+int(i):
#                    if y1 < l0[n] < y1+int(i):
#                        ins2.add((x1,l0[n]))
#                    n+=1
                y1+=int(i)
                ins2.append((x1,y1))
            else:
                #numero negativo
                x1+=int(i)

    c,n,n1=0,0,0
    maxx=ins1[-1] if ins1[-1]<ins2[-1] else ins2[-1]
    for p in ins0:
        #se è nei bordi massimi del rettangolo associato
        if p[1]!= 1 and p[0]<maxx[0] and p[1]<maxx[1]:
            #aggiusta le coordinate delle y
            while p[1]<ins1[n][1] and n<len(ins1):
                n+=1
            while p[1]<ins2[n1][1] and n1<len(ins2):
                n1+=1
            if ins1[n][[0] < p[0] < ins2[n1][0] or ins2[n1][0] < p[0] < ins1[n][0]:
                c=c+1

    return c