Pages: [1]   Go Down
Print
Author Topic: Haskell for dummies  (Read 1251 times)
0 Members e 1 Utente non registrato stanno visualizzando questa discussione.
SionAries
Matricola
*
Offline Offline

Posts: 47


« on: 01-04-2012, 17:04:09 »

Salve,

Ieri cercando ulteriori fonti su cui studiare haskell mi sono imbattuto su questo sito : http://learnyouahaskell.com/

Mi rendo conto che per alcuni puo' risultare troppo semplice ma lo trovo buono per capire i concetti fondamentali e ci tenevo a condividerlo.

Ne approfitto per postare un programmino appena fatto per avere qualche feedback.

Il programma prende 2 liste l1 l2 e' ritorna una lista ordinata formata dalla somma degli elementi della prima lista con gli elementi della seconda (cioe il primo elemento di l1 sommato col primo di l2 e  cosi via)


ordListSum [] [] = []
ordListSum [] l2 = l2
ordListSum l1 [] = l1
ordListSum l1 l2 = ordList ((head l1)+(head l2):ordListSum (tail l1) (tail l2))

ordList [] = []
ordList l = minimum l : ordList ((delete l) (minimum l))

delete [] el = []
delete l el = if ( head l == el ) then tail l else (head l):delete (tail l) el


Mi rendo conto che e' cretino ma ci tengo a postarlo per sapere se spezzattare un programma in piccole ricorsioni per poi richiamarle in questo modo annidato e' giusto o sbagliato.

Logged
Franco Barbanera
Moderator
Forumista Eroico
*****
Offline Offline

Posts: 3.077



WWW
« Reply #1 on: 01-04-2012, 18:34:11 »

Quote
ordListSum l1 l2 = ordList ((head l1)+(head l2):ordListSum (tail l1) (tail l2))

Conviene sfruttare il pattern matching per scrivere programmi piu' leggibili

ordListSum x:xs y:ys = ordList ((x+y):ordListSum xs ys)

Logged
Franco Barbanera
Moderator
Forumista Eroico
*****
Offline Offline

Posts: 3.077



WWW
« Reply #2 on: 01-04-2012, 18:36:25 »

Quote
Mi rendo conto che e' cretino ma ci tengo a postarlo per sapere se spezzattare un programma in piccole ricorsioni per poi richiamarle in questo modo annidato e' giusto o sbagliato.

E' l'algoritmo che hai implementato con il tuo programma magari a non essere
il massimo.
Ma se e' quello che volevi implementare, se gira va bene.

FN
Logged
Franco Barbanera
Moderator
Forumista Eroico
*****
Offline Offline

Posts: 3.077



WWW
« Reply #3 on: 01-04-2012, 18:39:34 »

Quote
Ieri cercando ulteriori fonti su cui studiare haskell mi sono imbattuto su questo sito : http://learnyouahaskell.com/

Pare interessante.

Logged
SionAries
Matricola
*
Offline Offline

Posts: 47


« Reply #4 on: 01-04-2012, 18:57:22 »

grazie per la risposta veloce Smiley .

Si e' vero devo familiarizzare col pattern matching , in effetti mi sono limitato a passare gli argomenti alla vecchia maniera .

Quote
Ieri cercando ulteriori fonti su cui studiare haskell mi sono imbattuto su questo sito : http://learnyouahaskell.com/

Pare interessante.




Si, spiega la cose passo passo con un pizzico di ironia (gia solo la home page dice tutto Cheesy ).
Logged
Franco Barbanera
Moderator
Forumista Eroico
*****
Offline Offline

Posts: 3.077



WWW
« Reply #5 on: 02-04-2012, 22:26:36 »

Quote
ordListSum [] [] = []
ordListSum [] l2 = l2
ordListSum l1 [] = l1
ordListSum l1 l2 = ordList ((head l1)+(head l2):ordListSum (tail l1) (tail l2))

Facendo in questo modo pero' non stai veramente "spezzettando il programma".
Al limite ti conviene prima fare la lista delle somme e poi ordinarla.
Fatto cosi' c'e' molto lavoro inutile.

FB

Logged
SionAries
Matricola
*
Offline Offline

Posts: 47


« Reply #6 on: 03-04-2012, 10:56:25 »

Per lavoro inutile intende il fatto che ordino le liste intermedie e non direttamente l' ultima lista?

Perche' con ordListSum l1 l2 = ordList ((head l1)+(head l2):ordListSum (tail l1) (tail l2)) credevo di sfruttare il fatto che la strategia di riduzione di haskell provasse prima a risolvere ordList e per farlo fosse costretto a risolvere il corpo
(head l1)+(head l2):ordListSum (tail l1) (tail l2)  e quindi solo a lista finale ottenuta chiamasse ordList.

Ho capito male la riduzione di haskell ?
Logged
Franco Barbanera
Moderator
Forumista Eroico
*****
Offline Offline

Posts: 3.077



WWW
« Reply #7 on: 03-04-2012, 14:15:29 »

Da commentare e controllare:

Possibile soluzione alternativa

ordSum [] [] = []

ordSum ls1 ls2 = (m1 + m2) : ordSum (delete ls1 m1) (delete ls2 m2)
                      where m1 = minumum ls1
                            m2 = minimum ls2


minumum (x:[]) = x
minumum (x:xs) = if (x < ml) then x else ml
                    where ml = minumum xs
minumum [] = 0



delete [] el = []
delete (x:xs) el = if ( x == el ) then xs else (x:delete xs el)
Logged
SionAries
Matricola
*
Offline Offline

Posts: 47


« Reply #8 on: 06-04-2012, 16:51:42 »

il programma non fa esattamente la stessa cosa perche' io ordino la  somma del primo elemento di l1 con il primo di l2 e cosi via, mentre il suo somma tra loro i minimi di l1 e l2 non considerando la posizione degli elementi.

In ogni modo basta chiamare ordList sulla lista finale tornata da


sumlists [] [] = []
sumlists [] l2 = l2
sumlists l1 [] = l1
sumlists x:xs y:ys = (x+y:sumlists xs ys)
Logged
Franco Barbanera
Moderator
Forumista Eroico
*****
Offline Offline

Posts: 3.077



WWW
« Reply #9 on: 10-04-2012, 17:02:36 »

il programma non fa esattamente la stessa cosa perche' io ordino la  somma del primo elemento di l1 con il primo di l2 e cosi via, mentre il suo somma tra loro i minimi di l1 e l2 non considerando la posizione degli elementi.

Certo, son due algoritmi differenti.

FB
Logged
Pages: [1]   Go Up
Print
Jump to: