Visualizza post

Questa sezione ti permette di visualizzare tutti i post inviati da questo utente. N.B: puoi vedere solo i post relativi alle aree dove hai l'accesso.


Topics - simone13

Pagine: [1]
1
Base / trovare le macchie di colore più grandi in un file PNG
« il: Settembre 05, 2019, 15:57 »
buon pomeriggio,
ho un problema con il seguente esercizio: dato un file png e dato un colore in input devo scrivere un codice che trovi la macchia di colore più grande e salvi una nuova immagine in formato png con solo la macchia trovata e come sfondo il colore complementare a quello dato. il mio codice consiste nell'avere una funzione che ritorni una lista di coordinate (row,col) di tutti i pixel del colore dato. modifico poi la matrice di RGB, che diventa una matrice di tuple (RGB, boolean=False in modo da ricordare se quel determinato pixel è stato già analizzato. a questo punto per gli elementi della lista delle coordinate di cui ho parlato prima, parte una ricerca ricorsiva in tutte e 4 le direzioni, e qualora trovi dei pixel del colore dato adiacente, il booleano viene convertito in True e la coordinata del pixel viene aggiunta ad una nuova lista che racchiude solo pixel della macchia. la ricorsione termina quando non ci sono più pixel adiacenti da analizzare,e si tornerà alla funzione che chiama la prima ricorsione per vedere se ci sono altri pixel di un'altra macchia non analizzati per far partire un'altra ricorsione. alla fine verranno create diverse liste "macchia" aggiunte in un dizionario con chiave la lunghezza della lista e valore la lista stessa in modo da prendere solo la lista più lunga. creare poi la nuova immagine è estremamente semplice.
il mio codice funziona perfettamente per file png fino ad una certa grandezza, ma quando le macchie immagini iniziano ad essere molto grandi, le limitazioni di python sulla ricorsione interrompno le ricerce dando l'errore "maximum recursion depth exceeded in comparison" non so come risolvere questo problema, un'idea sarebbe trovare un modo iterativo di fare questa ricerca ma non sono riuscito a. pensarlo.
qui c'è il codice ho cercato di essere più chiaro possibile nei commenti spero che qualcuno possa aiutarmi
grazie mille in anticipo
def es1(fname, colore, fnameout):
    # inserite qui il vostro codice
    matrice= immagini.load(fname)
    lista=coordinate(matrice,colore)
    true_false(matrice)
    diz=dizionario(matrice,lista,colore)
    macchia=max(diz)[1]
    #prendo la lista con lunghezza maggiore nel dizionaro/lista
    out=newIm(matrice,macchia,colore)
    immagini.save(out,fnameout)
    return len(macchia)


def coordinate(matrice,colore):
    #crea e ritorna una lista con tutte le coordinate (row,col) dei pixel del colore RGB richiesto
    lista=[]
    for y in list(range(len(matrice))):
        for x in list(range(len(matrice[0]))):
            if matrice[y][x]==colore:
                lista.append((y,x))
    return lista

def true_false(matrice):
    #modifica la matrice ed ogni tupla di RGB diventa una lista di 2 elementi con
    # l'RGB invariato e il valore booleano False
    for row in list(range(len(matrice))):
         for col in list(range(len(matrice[0]))):
             matrice[row][col]=[matrice[row][col], False]     
             
def dizionario(matrice,lista, colore):
    #la funzione inizialmente doveva creare un dizionario con chiave la lunghezza di ogni macchia del colore richiesto
    #e valore la lista delle coordinate di quella macchia. alcune macchie hanno uguale grandezza e in un dizionario non possono esserci
    #due chiavi uguali e le listre non possono essere chiavi quindi il dizionario è in realtà una lista
    dizionario_macchie=[]
    for coord in lista:
        #analizzo ogni elemento della lista di coordinate e se il suo valore booleano nella matrice è False da lì inizia una macchia di colore
        #e inizio la ricerca ai pixel adiacenti e alla fine delle ricorsioni aggiungo la macchia e la lunghezza al dizionario/lista,
        #se il booleano è True, già ho visto quella macchia in una ricorsione precedente e vado avanti
        if matrice[coord[0]][coord[1]][0]==colore and matrice[coord[0]][coord[1]][1]== False:
            macchia=[]
            ric(matrice,coord[0],coord[1],colore,macchia)
            dizionario_macchie.append((len(macchia), macchia))
    return dizionario_macchie


def ric(matrice, row, col, colore, macchia):
    #prendo in input la matrice, le coordinate del pixel dal quale parte la ricorsione, il colore e la macchia che si viene a formare
    # se nella matrice il punto alle coordinate row,col è il colore dato in input e il booleano è False, aggiungo quelle coordinate
    #alla lista macchia e cambio il valore da False a True per evitare di ripassare in futuro per quel punto.
    #mi assicuro poi che i pixel adiacenti non vadano oltre i bordi e richiamo la funzione ric per tutti e 4 i pixel adiacenti.
    #una volta finita la ricorsione si torna alla funzione dizionario, la macchia è completa e la aggiungo nel dizionario/lista
    if matrice[row][col][0]==colore and matrice[row][col][1] == False:
        matrice[row][col][1]=True
        macchia.append((row,col))
        if row-1>0:
            ric(matrice, row-1, col, colore, macchia)
        if row+1<len(matrice):
            ric(matrice, row+1, col, colore, macchia)
        if col+1<len(matrice[0]):
            ric(matrice, row, col+1, colore, macchia)
        if col-1>0:
            ric(matrice, row, col-1, colore, macchia)
   


def newIm(matrice,macchia,colore):
    #creo una nuova matrice che diventerà l'immagine in output
    prova=[]
    for row in list(range(len(matrice))):
        lista=[]
        prova.append(lista)
    for col in list(range(len(matrice[0]))):
        for elem in prova:
            elem.append((255-colore[0],255-colore[1],255-colore[2]))
    for elem in macchia:
        prova[elem[0]][elem[1]]=colore
    return prova

       

2
Base / ricorsione e alberi
« il: Luglio 27, 2019, 16:45 »
buon pomeriggio,
avrei bisogno di un aiuto per risolvere il seguente problema:
ho una lista di interi, su questa lista devo sottrarre due elementi adiacenti  a,b solo se a>=b. il risultato andrà a sostituire i due elementi sottratti modificando la lista. devo scrivere una funzione che ritorni tutte le liste generate dalle possibili combinazioni di sottrazioni:
esempio:
ho la lista 19 -3 2 -10 -20
i risultati sarebbero (senza doppioni):
         [(10,), (30,), (50,),
        (10, -20), (20, 10), (22, 32), (30, -20),
        (19, -3, 32), (20, -10, -20), (22, 2, 10), (22, 12, -20),
        (19, -3, 2, 10), (19, -3, 12, -20), (22, 2, -10, -20),
        (19, -3, 2, -10, -20)]
non posso utilizzare nessun genere di libreria esterna.
il mio ragionamento era di considerare le possibili combinazioni come nodi di un albero, che ha radice la lista iniziale, e come figli le liste generate dalle possibili combinazioni, e di proseguire ricorsivamente fino a quando non posso più fare sottrazioni.
in questo caso l'albero avrebbe come radice (19, -3, 2, -10, -20) e come figli (19, -3, 2, 10), (19, -3, 12, -20), (22, 2, -10, -20) e ognuno di questi figli sarà padre delle combinazioni su questi ultimi. non riesco a scrivere questa funzione ricorsiva. qualcuno può aiutarmi?
grazie in anticipo :)

3
Base / lavorare con le immagini
« il: Febbraio 17, 2019, 20:32 »
buona sera, ho questo esercizio da svolgere e pur avendo una idea su come provare ad implementare il codice avrei bisogno di qualche linea guida di ragionamento soprattutto sul riconoscimento, tra diverse macchie  colorate, di quella maggiore. grazie per la disponibilità e chiedo perdono se ai vostri occhi questo esercizio potrà risultare banale ma per me che ho iniziato da poco non lo è...
il testo dell'esercizio è il seguente:

Definiamo adiacenti di un pixel p di un immagine i pixel adiacenti a p in orizzontale o in  verticale.
Se un pixel e' sul bordo dell'immagine il suo vicinato non comprende i pixel non contenuti nell'immagine.
Il pixel dell'immagine con coordinate(x,y) ha dunque come adiacenti i pixel
con coordinate (x-1,y),(x+1,y),(x,y-1),(x,y+1) appartenenti all'immagine.

Definiamo connessi due pixel se e' possibile dall'uno raggiungere l'altro
spostandosi solo su pixel adiacenti e dello stesso colore (ovviamente perche'
cio' sia possibile e' necessario che i due pixel abbiano lo stesso colore).

Scrivere una funzione es1(fname, colore, fnameout) che, presi:
    -un nome di file contenente una immagine in formato PNG
    -una tupla con un colore in formato RGB
    -un nome di file su cui salvare una immagine in formato PNG
legge l'immagine in fname, cerca l'area massima di pixel adiacenti dell'immagine
con il colore preso in input e registra una nuova immagine nel file fnameout,
contenente soltanto i pixel dell'area massima individuata. Il colore di sfondo
dell'immagine di output deve essere il complementare del colore preso in input
(ovvero il colore che si ottiene complementando a 255 le componenti RGB).

La funzione deve ritornare il numero di pixel dell'area massima individuata.

Assumete che l'area massima sia unica.[email][/email]

4
Base / esercizio a casa
« il: Gennaio 08, 2019, 16:06 »
buon pomeriggio. mi è stato assegnato questo esercizio da svolgere a casa ma pur avendo trovato una possibile logica di ragionamento non riesco proprio ad implementare il mio codice. la mia difficoltà sta anche e soprattutto sul fatto che bisogna usare delle funzioni ricorsive... essendo alle prime armi con la programmazione in generale avrei bisogno di un aiuto. grazie mille in anticipo.
il testo dell'esercizio è il seguente
[/pythoncode]'''
    Si consideri il seguente gioco solitario:
    abbiamo una sequenza iniziale di  N interi,
    una mossa del gioco consiste nel selezionare nella sequenza  due numeri  consecutivi
    la cui somma sia pari, i due numeri vengono eliminati dalla sequenza e
    sostituiti dalla loro  media aritmetica. Il gioco e' vinto se si trova una sequenza
    di mosse che riduce la sequenza  ad un unico numero.
    Una configurazione del gioco e' univocamente determinata dai numeri presenti nella
    sequenza in quel momento.
    Data una configurazione iniziale noi siamo interessati a trovare la lista di tutte
    le possibili configurazioni finali (vale a dire configurazioni per cui non c'e' possibilita'
    di continuare il gioco per mancanza di possibili mosse).
    Si consideri ad esempio l'albero di gioco che si ottiene a partire dalla configurazione
    10 20 30 40 5 1 e che e' riportato  nel file albero_di_gioco.pdf
    le possibili configurazioni finali sono 5:
    8, 14, 17, 15 20 1, 10 25 40 3.
   
    Definire una funzione es2(s) ricorsiva (o che fa uso di funzioni o
    metodi ricorsive/i) che, data una  stringa  che codifica  una  configurazione iniziale
    del gioco, retituisce  la lista delle codifiche delle possibili configurazioni finali.
    - le configurazioni di gioco vanno codificate tramite  stringhe (in queste stringhe i
       numeri della sequenza compaiono uno di seguito all'altro e separati da uno spazio).
    - La lista delle codifiche delle configurazioni finali prodotta in output contiene
      le configurazioni codificate come stringhe. Queste configurazioni devono comparire
      nella lista in ordine crescente rispetto alla loro lunghezza e, a parita' di lunghezza, 
      ordinate in modo crescente rispetto al primo numero in cui differiscono.
      Ad esempio la lista che la funzione es2 se invocata con s='10 20 30 40 5 1'
      deve restituire la lista
      ['8', '14', '17', '15 20 1', '10 25 40 3']

NOTA: il timeout previsto per questo esercizio è di 3 secondi per ciascun test.

ATTENZIONE: Almeno una delle funzioni/metodi che risolvono l'esercizio DEVE essere ricorsiva.
ATTENZIONE: per fare in modo che il macchinario di test riconosca automaticamente la presenza della ricorsione
    questa funzione ricorsiva DEVE essere una funzione esterna oppure il metodo di una classe

ATTENZIONE: Non potete usare altre librerie

ATTENZIONE: Sono vietate le variabili globali

ATTENZIONE: assicuratevi di salvare il programma con encoding utf8
(ad esempio usando come editor Notepad++ oppure Spyder)

'''
[/pythoncode]

5
Base / problemi con un esercizio
« il: Dicembre 01, 2018, 12:58 »
buongiorno. dovrei risolvere questo esercizio ma non ho idea di come ragionarci, poiché risulta difficile anche a chi ha delle basi più solide delle mie, vorrei sapere se qualcuno ha delle idee du come procedere.. non sto chiedendo il codice implementato ma se possibile un consiglio su come ragionare. grazie per l'aiuto.

l'esercizio è il seguente:
'''
Abbiamo una immagine  .PNG .
L'immagine presenta, su uno sfondo nero ( vale a dire di colore (0,0,0)),
segmenti di colore bianco (vale a dire (255,255,255)) orizzontali e verticali di diversa lunghezza.
I segmenti, in alcuni casi, nell'incrociarsi creano rettangoli.
Siamo interessati a trovare quei rettangoli di altezza e larghezza almeno 3
(compreso il bordo, quindi con la parte nera alta e larga almeno 1 pixel)
e che, tranne il bordo completamente bianco, presentano tutti i pixel al loro interno di colore nero.
A questo scopo vogliamo creare una nuova immagine identica alla prima se non per il
fatto che questi rettangoli vengono evidenziati.
Il bordo di questi rettangoli deve essere di colore verde (vale a dire (0,255,0)) e
i pixel interni devono essere di colore rosso (vale a dire (255,0,0)).

Scrivere una funzione es1(fimg,fimg1) che, presi in input gli indirizzi  di due file .PNG,
legge dal primo l'immagine del tipo descritto sopra e salva nel secondo l'immagine
con i rettangoli evidenziati.
La funzione deve infine restituire  il numero di rettangoli che risultano evidenziati.

Per caricare e salvare i file PNG si possono usare load e save della libreria immagini.

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

ATTENZIONE: quando consegnate il programma assicuratevi che sia nella codifica UTF8
(ad esempio editatelo dentro Spyder o usate Notepad++)

ATTENZIONE: non sono permesse altre librerie.
'''


6
Base / ottimizzare in count
« il: Novembre 22, 2018, 17:25 »
buona sera, il mio algoritmo in questo  caso è corretto ma ha bisogno di essere ottimizzato perché non passa alcuni test del mio professore solo perché supera il tempo limite. avevo pensato di ottimizzarlo togliendo la funzione count, ma non so come, ovviamente se da questo forum viene fuori un altro modo sarei molto felice di provarlo.. non so come ottimizzarlo mi potreste dare una mano per favore? grazie mille per la disponibilità il mio codice è il seguente con il comando lasciato dal prof.:
'''
I messaggi scambiati all'interno di un forum sono stati sottoposti ad uno studio.
Dai  vari post  sono state estrapolate parole significative e questi dati sono stati poi
raccolti in un  file di testo.
Nel file, l'inizio di ciascun post e' marcato da una linea che contiene  la stringa
"<POST>" e un intero utilizzato come identificativo del post (che nel seguito dovete lasciare come stringa).
la stringa e l'identificativo possono essere preceduti e seguiti da un numero arbitrario (anche 0) di spazi.
Le parole estrapolate  dal  post sono  nelle linee successive (zero  o piu' parole per
linea) fino alla linea che marca il prossimo post
o la fine del file.
Come esempio si veda il file "fp1.txt".
 
Per ognuna delle parole estrapolate si vogliono ora ricavare le seguenti informazioni:
I1) Il numero totale di occorrenze della parola nei post,
I2) il numero di post in cui la parola compare,
I3) la coppia (occorrenze, post) dove nella seconda coordinata si ha l'identificativo del post
in cui la parola e' comparsa piu' spesso e nella prima il numero di volte che vi e' comparsa,
(nel caso di  diversi post con pari numero massimo di occorrenze della parola va considerato
il post con l'identificativo minore in ordine lessicografico).
Bisogna costruire una tabella avente una riga per ognuna delle differenti parole
utilizzate nel forum. La tabella deve avere 4 colonne 
In una colonna  comparira' la parola e nelle altre tre  le informazioni I1), I2) e I3) dette prima.
Le righe della colonna devono essere ordinate rispetto all'informazione I1) decrescente, a parita'
del valore I1 vanno ordinate rispetto  alla cardinalita' decrescente dell'insieme degli itentificativi
ed a parita', rispetto all'ordine lessicografico delle parole.

Scrivere una funzione es2(fposts) che prende in input  il
percorso del file di testo contenente le estrapolazioni dei post del forum
e restituisce la tabella.
La tabella va restituita sotto forma di lista di dizionari dove
ciascun dizionario ha 4 chiavi: 'parola', 'I1','I2' e 'I3' e ad ogni chiave e'
associata la relativa informazione attinente la parola.
Ad esempio per il file di testo fp1.txt la funzione restituira' la lista:
[{'I1': 6, 'I2': 3, 'I3': (3, '30'), 'parola': 'hw1'},
 {'I1': 3, 'I2': 2, 'I3': (2, '30'), 'parola': 'python'},
 {'I1': 2, 'I2': 1, 'I3': (2,  '1'), 'parola': 'hw2'},
 {'I1': 1, 'I2': 1, 'I3': (1, '21'), 'parola': '30'},
 {'I1': 1, 'I2': 1, 'I3': (1, '30'), 'parola': 'monti'},
 {'I1': 1, 'I2': 1, 'I3': (1,  '1'), 'parola': 'spognardi'},
 {'I1': 1, 'I2': 1, 'I3': (1, '21'), 'parola': 'sterbini'}
 ]

NOTA: il timeout previsto per questo esercizio è di 3 secondi per ciascun test.

ATTENZIONE: quando consegnate il programma assicuratevi che sia nella codifica UTF8
(ad esempio editatelo dentro Spyder o usate Notepad++)
'''
       

def es2(fposts):
    '''Implementare la funzione qui'''
    with open(fposts, "r", encoding="UTF-8") as post:
        lista_finale=[]
        x= post.read()
        x= x.replace("<post>", "<post> ").replace("\n"," ").split("<post>")
        x= x[1:]
        diz={}
    for riga in x:
        diz[riga.split()[0]]= riga.split()[1:]
    parole=[]
    for e in diz.values():
        for q in e:
            parole.append(q)
    for parola in set(parole):       
        diz_finale= {}
        count=0
        for i in range(len(parole)):
            if parola== parole[i]:
                count+=1
        diz_finale["I1"]= count
        contatore=0
        massimo=-1
        for r in sorted(diz.keys()):
            if parola in diz[r]:
                contatore+=1
                z=diz[r].count(parola)
            else:
                z=0
            if z > massimo:
                massimo=z
                tupla=z,r
        diz_finale["I2"]= contatore
        diz_finale["I3"]= tupla
        diz_finale["parola"]= parola
        lista_finale.append(diz_finale)
    return sorted(lista_finale, key= lambda elem: (-elem["I1"], -elem["I2"], elem["parola"]))

7
Base / metodo find()
« il: Novembre 21, 2018, 18:54 »
buonasera. sto cercando di risolvere un codice che dovrebbe risolvere i crucipuzzle, trovare le parole in tutte le direzioni in una matrice di lettere e ritornare una stringa con le lettere mai utilizzate che formano una nuova parola. credevo di averlo finito ma vedendo i test del professore in un paio di casi la stessa parola viene ripetuta più volte nella stessa riga( colonna o anche diagonale). il mio problema è che per trovare le parole uso il metodo find quindi in questi casi la seconda parola non viene trovata. esiste un modo per mettere in una lista, o comunque raccogliere più " indici tro conti find" della stessa parola? se risolvo questo problema ho risolto tutto e posso consegnare il compito con un codice molto buono.
grazie in anticipo e buona serata  :)

8
Benvenuto e regolamento / saluti e presentazion
« il: Novembre 21, 2018, 18:51 »
buona sera a tutti,
mi presento, sono Simone e ho 19 anni. mi sono iscritto al forum perché ho iniziato quest'anno la facoltà di informatica partendo da zero senza aver mai programmato, e ovviamente le difficoltà non mancano ma mi sto abituano velocemente a come si lavoramin questo ambito.  spero di togliermi dei dubbi  sulla programmazione in python o ricevere consigli per terminare in tempo le consegne che il professore ci assegna perchè a volte sono molto complicate. ovviamente cercherò anche io di rendermi utile per quello che posso.
un saluto a tutti

9
Benvenuto e regolamento / Re:Presentazione e saluti
« il: Novembre 21, 2018, 18:49 »
buonasera a tutti spero di risolvere i dubbi che ho riguardo la programmazione in python

Pagine: [1]