Mayor sección inicial sin repetidos

11 Comentarios

1. Haskell

   seccion :: Eq a => [a] -> [a] seccion xs = last (nub [ zs | zs <- (subsequences xs), length zs == length (nub zs), isPrefixOf zs xs])

   1 2	seccion :: Eq a => [a] -> [a] seccion xs = last (nub [ zs | zs <- (subsequences xs), length zs == length (nub zs), isPrefixOf zs xs])

   Es poco eficiente

   Responder

2. Haskell

   seccion :: Eq a => [a] -> [a] seccion xs = last [ys | ys <- subsequences (nub xs), ys `isPrefixOf` xs, length ys == length (nub ys)]

   1 2 3 4 5

   seccion :: Eq a => [a] -> [a] seccion xs =     last [ys | ys <- subsequences (nub xs),                ys `isPrefixOf` xs,                length ys == length (nub ys)]

   Responder

   1. Prueba usando la función inits en lugar de subsequences

      Responder

3. Haskell

   import Data.List seccion :: Eq a => [a] -> [a] seccion xs = seccionAux xs [] where seccionAux [] ys = ys seccionAux (x:xs) ys | notElem x ys = seccionAux xs (ys ++ [x]) | otherwise = ys

   1 2 3 4 5 6 7 8

   import Data.List   seccion :: Eq a => [a] -> [a] seccion xs = seccionAux xs []              where seccionAux [] ys = ys                    seccionAux (x:xs) ys                        | notElem x ys = seccionAux xs (ys ++ [x])                        | otherwise = ys

   Responder

4. Por acumuladores

   Haskell

   seccion :: Eq a => [a] -> [a] seccion = acu [] where acu :: Eq a => [a] -> [a] -> [a] acu ys (x:xs) | x `elem` ys = reverse ys | otherwise = acu (x:ys) xs acu ys _ = reverse ys

   1 2 3 4 5 6

   seccion :: Eq a => [a] -> [a] seccion = acu []   where acu :: Eq a => [a] -> [a] -> [a]         acu ys (x:xs) | x `elem` ys = reverse ys                       | otherwise   = acu (x:ys) xs         acu ys  _     = reverse ys

   Responder

5. Haskell

   seccion :: Eq a => [a] -> [a] seccion xs = map fst (takeWhile p (zip xs [0..])) where p (x,n) = notElem x (take n xs)

   1 2 3

   seccion :: Eq a => [a] -> [a] seccion xs = map fst (takeWhile p (zip xs [0..]))    where p (x,n) = notElem x (take n xs)

   Responder

6. Haskell

   seccion :: Eq a => [a] -> [a] seccion ys = combina ys (refina ys) where refina (x:xs) = x: refina (filter (/= x) xs) refina [] = [] combina :: Eq a => [a] -> [a] -> [a] combina [] _ = [] combina _ [] = [] combina (x:xs) (y:ys) | x == y = x:(combina xs ys) | otherwise = []

   1 2 3 4 5 6 7 8 9 10

   seccion :: Eq a => [a] -> [a] seccion ys = combina ys (refina ys)     where refina (x:xs) = x: refina (filter (/= x) xs)           refina []    = []   combina :: Eq a => [a] -> [a] -> [a] combina [] _ = [] combina _ [] = [] combina (x:xs) (y:ys) | x == y = x:(combina xs ys)                       | otherwise = []

   Responder

7. Haskell

   -- Mi definición es parecida a la de fracruzam, pero sin usar "reverse". seccion :: Eq a => [a] -> [a] seccion xs = auxSeccion xs [] where auxSeccion [] ys = ys auxSeccion (x:xs) ys | elem x ys = ys | otherwise = auxSeccion xs (ys ++ [x])

   1 2 3 4 5 6

   -- Mi definición es parecida a la de fracruzam, pero sin usar "reverse". seccion :: Eq a => [a] -> [a] seccion xs = auxSeccion xs []         where auxSeccion [] ys = ys               auxSeccion (x:xs) ys | elem x ys = ys                                    | otherwise = auxSeccion xs (ys ++ [x])

   Responder

8. Haskell

   seccion :: Eq a => [a] -> [a] seccion (x:xs) = aux xs [x] where aux (y:ys) z | elem y z = z | otherwise = aux ys (z++[y])

   1 2 3 4

   seccion :: Eq a => [a] -> [a] seccion (x:xs) = aux xs [x]                            where aux (y:ys) z | elem y z  = z                                               | otherwise = aux ys (z++[y])

   Responder

9. Haskell

   seccion :: Eq a ⇒ [a] → [a] seccion = reverse ∘ last ∘ takeWhile (λxs → null xs ∨ head xs ∉ tail xs) ∘ reverse ∘ tails ∘ reverse

   1 2 3 4 5 6 7

   seccion :: Eq a ⇒ [a] → [a] seccion = reverse         ∘ last         ∘ takeWhile (λxs → null xs ∨ head xs ∉ tail xs)         ∘ reverse         ∘ tails         ∘ reverse

   Responder

10. Version en Maxima

    Haskell

    seccion (xs) := block( [ys : [], x : first(xs)], unless member(x,ys) do ( ys : cons(x,ys), xs : rest(xs), x : first(xs)), reverse(ys))

    1 2 3 4 5 6 7 8

    seccion (xs) := block(   [ys : [],    x : first(xs)],   unless member(x,ys) do (     ys : cons(x,ys),     xs : rest(xs),     x : first(xs)),   reverse(ys))

    Responder