scendere di profondità in una sequenza con profondità variabile:

A
AmritV (830 points)
6 8 11
asked Dec 19, 2019 in Programmare in Python by AmritV (830 points)
recategorized Jan 6, 2020 by andrea.sterbini
Stavo cercando di capire quale sia il modo migliore di trovare il grado di profondità di una sequenza, e una volta trovato il grado di profondità come fare per iterare su tutti i singoli elementi..

ES, ho una tupla: (1,2,(3,4),5,6,(7,8,(9,10,11)))

1- vorrei che diventi una sequenza del tipo: (1,2,3,4,5,6,7,8,9,10,11)

2- oppure vorrei trovare l'elemento 10,

Se qualcuno mi può dare qualche consiglio ne sarei lieto!! :)
471 views

3 Answers

Best answer
a
a.pietroluongo (11250 points)
15 38 131
answered Dec 19, 2019 by a.pietroluongo (11,250 points)
selected Jan 18, 2020 by AmritV
1.
Vuoi che diventi una tupla o anche una lista?
A
AmritV (830 points)
6 8 11
commented Dec 20, 2019 by AmritV (830 points)
è INDIFFERENTE, vanno bene entrambi i tipi!
a
a.pietroluongo (11250 points)
15 38 131
commented Dec 22, 2019 by a.pietroluongo (11,250 points)
edited Dec 22, 2019 by a.pietroluongo
#  Caso base
se len(a) == 0: non ci sono elementi
se len(a) == 1: se è una tupla la converto in lista altrimenti ritorno [a]

se len(a) > 1

#  Passo ricorsivo
chiamo la funzione sulle sottosequenze di a e per ogni elemento se è una tupla lo converto e lo aggiungo al risultato
s
scutigliani.luca (860 points)
6 10 15
answered Dec 19, 2019 by scutigliani.luca (860 points)
puoi mettere un "level = 1" nell'argomento della funzione e poi incrementarlo di 1 ogni volta che richiami la ricorsione. ad ogni livello avrai solo i passi aggiunti dalle ricorsioni più profonde.
Tommaso Sgroi (12990 points)
6 11 91
answered Dec 20, 2019 by Tommaso Sgroi (12,990 points)
Riguardo alla profondità può aiutarti questo:
Passi alla tua funzione ricorsiva un input=0 chiamato deep, che indicherà il livello di profondità a cui ti trovi. Una volta che verrà fatta una chiamata ricorsiva incrementi quel valore, ciò significherà che sei passato a un livello più profondo. E ogni volta che la tua funzione farà i return e tornerà indietro il tuo valore deep rimarrà SEMPRE del valore a cui sei arrivato nella funzione attuale.
Puoi verificare facendo delle prove con una semplice funzione ricorsiva del tipo:
def prova (deep=0):
    if deep==10:
           print("CASO BASE!")
    else:
           print(deep)
           prova (deep+1)
    print( deep)


Dovrebbe funzionare (fammi sapere se va), così puoi guardare tramite le print nello specifico il valore che assume durante la chiamata e durante i return.
(Ricordo che in python se non è specificato il return ritorna sempre un valore di tipo None).
A
AmritV (830 points)
6 8 11
commented Dec 20, 2019 by AmritV (830 points)

Grazie per la risposta, si la tua funzione funziona con un input di tipo int!!

Ma se vado ad aggiungere una lista del tipo: (1,2,(3,4),5,6,(7,8,(9,10,11))) come argomento della funzione, ricevo un errore del tipo: TypeError: can only concatenate tuple (not "int") to tuple.

Tommaso Sgroi (12990 points)
6 11 91
commented Dec 21, 2019 by Tommaso Sgroi (12,990 points)

Si, infatti questa non è una funzione risolutiva del tuo problema, era solo un esempio ! 

Era solo un modo per farti vedere come tenere il conto della profondità, e oltretutto mostrare come durante la fase dei ritorni la variabile path abbia sempre il valore della profondità a cui ti trovi. Questo dovrebbe aiutarti a comprendere e trovare una via per il problema.

A
AmritV (830 points)
6 8 11
commented Dec 21, 2019 by AmritV (830 points)
Perfetto Grazie Tommaso.

Sono riuscito ad implementare un algoritmo, che mi torna il valore desiderato.

Anche se con alcuni input(in particolare uno di essi), non riesce a darmi il risultato desiderato.
A
AmritV (830 points)
6 8 11
commented Dec 21, 2019 by AmritV (830 points)

Ed il fatto di non comprendere come mai con quel particolare tipo di input, la mia funzione sbaglia risultato...mi fa uscire matto.

Ma sicuramente ci vorrà un poco di tempo e pratica con la ricorsione!laughcool

Tommaso Sgroi (12990 points)
6 11 91
commented Dec 21, 2019 by Tommaso Sgroi (12,990 points)
Perfetto meno male dai , piano piano e con vari debug riuscirai a farcela dai.
Con quale particolare input non funziona?
Puoi dirmi l'algoritmo aggiornato della funzione cosa fa? Così in caso posso darti una mano
A
AmritV (830 points)
6 8 11
commented Dec 21, 2019 by AmritV (830 points)
Certo te ne sarei grato,

Ti riformulo il problema(che è un pochino diverso da come è stato formulato prima): Data una tupla "x", che a sua volta può contenere altre  n tuple(quindi diversi gradi di profondità).

La tupla "x", e le altre tuple all'interno di x(se ci sono), contengono due tipi di valori:

1)il primo valore è un intero ed è sempre -1.

2) il secondo valore è una stringa E SI RIPETE SOLTANTO UNA VOLTA ALL'INTENRO DELLA TUPLA  "x" O DELLE DIVERSE TUPLE CONTENUTE IN "x".

Esempi di input che la funzione può ricevere sono: a) ("ddgg", -1)  |b)  (-1, "ggdd")  |c)  (-1, ("ddggdgd", -1))  |d)  ((-1, ( -1, -1, ("dgdg",  -1))))

-La mia funzione dato un input del genere mi ritorna la stringa, ed il suo pseudo-codice è:

organize( tupla_x):

se il tipo(tupla_x)== intero: ritorno -1

se il tipo(tupla_x)== stringa: ritorno tupla_x

per ogni elemento in tupla_x(ciclo for):

       se il tipo(elemento)==tupla: ritorno organize(elemento) #(RICORSIVAMENTE RICHIAMO LA FUNZIONE):

       altrimenti se il tipo(elemento) ==stringa: ritorno elemento

ritorno -1
A
AmritV (830 points)
6 8 11
commented Dec 21, 2019 by AmritV (830 points)
edited Dec 21, 2019 by AmritV
la funzione non ha problemi a risolvere input del tipo di -a) -b) -c) -d).   ---elencati sopra---

Ma se vado ad inserire questo input: ( ( ( ( -1, -1 ), (-1, -1) ), ( (-1, -1), (-1, -1) ) ), ( ( (-1, -1), (-1, -1) ), ( (-1, -1), (-1, "DGDGDG") ) ) )

Mi ritorna -1.

Ovviamente questo input è molto più complesso degli altri.
Tommaso Sgroi (12990 points)
6 11 91
commented Dec 21, 2019 by Tommaso Sgroi (12,990 points)
edited Dec 21, 2019 by Tommaso Sgroi
Non mi è chiaro "il primo valore è sempre -1", in alcuni input il valore entrante è differente...
A
AmritV (830 points)
6 8 11
commented Dec 21, 2019 by AmritV (830 points)
è sempre -1 di tipo int!!