Mínima diferencia entre elementos de una lista

7 Comentarios

1. Haskell

   import Data.List diferencia :: Num t => [t] -> [[t]] diferencia []=[] diferencia (x:xs) =[abs (x-y)|y<-xs] : diferencia xs minimaDiferencia :: (Num a, Ord a) => [a] -> a minimaDiferencia xs = head (sort (concat (diferencia xs))

   1 2 3 4 5 6 7 8

   import Data.List   diferencia :: Num t => [t] -> [[t]] diferencia []=[] diferencia (x:xs) =[abs (x-y)|y<-xs] : diferencia xs                        minimaDiferencia :: (Num a, Ord a) => [a] -> a minimaDiferencia xs = head (sort (concat (diferencia xs))

   Responder

2. Haskell

   minimaDiferencia :: (Num a, Ord a) ⇒ [a] → a minimaDiferencia = minimum ∘ (zipWith ⊟ ↩ tail) ∘ sort

   1 2	minimaDiferencia :: (Num a, Ord a) ⇒ [a] → a minimaDiferencia = minimum ∘ (zipWith ⊟ ↩ tail) ∘ sort

   Responder

3. Haskell

   import Data.List (sort) minimaDiferencia :: (Num a, Ord a) => [a] -> a minimaDiferencia zs@(_:_:_) = buscaMinimo (z:ys) (z-y) where (y:z:ys) = sort zs buscaMinimo :: (Num a, Ord a) => [a] -> a -> a buscaMinimo (x:y:xs) m | x == y = 0 | n < m = buscaMinimo (y:xs) n | otherwise = buscaMinimo (y:xs) m where n = y - x buscaMinimo _ m = m minimaDiferencia _ = error "La lista debe contener mas de un elemento"

   1 2 3 4 5 6 7 8 9 10 11 12

   import Data.List (sort)   minimaDiferencia :: (Num a, Ord a) => [a] -> a minimaDiferencia zs@(_:_:_) = buscaMinimo (z:ys) (z-y)   where (y:z:ys) = sort zs         buscaMinimo :: (Num a, Ord a) => [a] -> a -> a         buscaMinimo (x:y:xs) m | x == y    = 0                                | n <  m    = buscaMinimo (y:xs) n                                | otherwise = buscaMinimo (y:xs) m           where n = y - x         buscaMinimo _        m = m minimaDiferencia _  = error "La lista debe contener mas de un elemento"

   Responder

4. Haskell

   import Data.List minimaDiferencia :: (Num a, Ord a) => [a] -> a minimaDiferencia xs = minimo (abs (a-b)) ys where (a:b:ys) = sort xs minimo :: (Num a, Ord a) => a -> [a] -> a minimo d (x:y:xs) | z <= d = minimo z (y:xs) | otherwise = minimo d (y:xs) where z = abs (x-y) minimo d _ = d

   1 2 3 4 5 6 7 8 9 10 11

   import Data.List   minimaDiferencia :: (Num a, Ord a) => [a] -> a minimaDiferencia xs = minimo (abs (a-b)) ys                       where (a:b:ys) = sort xs   minimo :: (Num a, Ord a) => a -> [a] -> a minimo d (x:y:xs) | z <= d = minimo z (y:xs)                   | otherwise = minimo d (y:xs)                   where z = abs (x-y) minimo d _ = d

   Responder

5. Haskell

   import Data.List (sort) minimaDiferencia :: (Num a, Ord a) => [a] -> a minimaDiferencia xs = minimum $ aux (sort xs) where aux [] = [] aux [x] = [x] aux (x:y:xs) = (y-x) : aux (y:xs)

   1 2 3 4 5 6 7

   import Data.List (sort)   minimaDiferencia :: (Num a, Ord a) => [a] -> a minimaDiferencia xs = minimum $ aux (sort xs)       where aux [] = []             aux [x] = [x]             aux (x:y:xs) = (y-x) : aux (y:xs)

   Responder

6. Haskell

   minimaDiferencia :: (Num a, Ord a) => [a] -> a minimaDiferencia xs = minimum [abs (x-y) | (x,y) <- listaDeElementos xs] listaDeElementos :: [t] -> [(t, t)] listaDeElementos [] = [] listaDeElementos (x:xs) = [(x,y) | y <- xs] ++ listaDeElementos xs

   1 2 3 4 5 6

   minimaDiferencia :: (Num a, Ord a) => [a] -> a minimaDiferencia xs = minimum [abs (x-y) | (x,y) <- listaDeElementos xs]      listaDeElementos :: [t] -> [(t, t)] listaDeElementos [] = [] listaDeElementos (x:xs) = [(x,y) | y <- xs] ++ listaDeElementos xs

   Responder

7. minimaDiferencia xs = head (sort (todaslasrestas xs)) todaslasrestas [x,y] = [abs(x-y)] todaslasrestas (x:xs) = restas (x:xs) ++ todaslasrestas xs restas [] = [] restas [x,y] = [abs(x-y)] restas (x:y:z:xs) = abs (x-y) : restas (x:z:xs)

   1 2 3 4 5 6 7 8

   minimaDiferencia xs = head (sort (todaslasrestas xs))   todaslasrestas [x,y]  = [abs(x-y)] todaslasrestas (x:xs) = restas (x:xs) ++ todaslasrestas xs   restas []         = [] restas [x,y]      = [abs(x-y)] restas (x:y:z:xs) = abs (x-y) : restas (x:z:xs)

   Responder