Segmentos de longitud dada

PorJosé A. Alonso 10-febrero-20151-mayo-2016

Definir la función

   segmentos :: Int -> [a] -> [[a]]

1	segmentos :: Int -> [a] -> [[a]]

tal que (segmentos n xs) es la lista de los segmentos de longitud n de la lista xs. Por ejemplo,

   segmentos 3 [1..5]  ==  [[1,2,3],[2,3,4],[3,4,5]]

1	segmentos 3 [1..5] == [[1,2,3],[2,3,4],[3,4,5]]

Soluciones

import Data.List (tails)

-- 1ª definición (por recursión)
segmentos1 :: Int -> [a] -> [[a]]
segmentos1 n xs 
    | length xs < n = []
    | otherwise     = take n xs : segmentos1 n (tail xs)
                  
-- 2ª definición (con tails):
segmentos2 :: Int -> [a] -> [[a]]
segmentos2 n xs = 
    takeWhile (\ys -> length ys == n) (map (take n) (tails xs))

-- 3ª definición:
segmentos3 :: Int -> [a] -> [[a]]
segmentos3 n xs = 
    take (length xs - n + 1) (map (take n) (tails xs))

--    ghci> length (segmentos1 3 [1..30000])
--    29998
--    (2.99 secs, 13998816 bytes)
--    
--    ghci> length (segmentos2 3 [1..30000])
--    29998
--    (0.05 secs, 16941304 bytes)
--    
--    ghci> length (segmentos3 3 [1..30000])
--    29998
--    (0.04 secs, 10375520 bytes)
--    
--    ghci> length (segmentos2 3 [1..1000000])
--    999998
--    (0.70 secs, 498098336 bytes)
--    
--    ghci> length (segmentos3 3 [1..1000000])
--    999998
--    (0.24 secs, 273979304 bytes)

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

import Data.List (tails)

-- 1ª definición (por recursión)

segmentos1 :: Int -> [a] -> [[a]]

segmentos1 n xs

| length xs < n = []

| otherwise = take n xs : segmentos1 n (tail xs)

-- 2ª definición (con tails):

segmentos2 :: Int -> [a] -> [[a]]

segmentos2 n xs =

takeWhile (\ys -> length ys == n) (map (take n) (tails xs))

-- 3ª definición:

segmentos3 :: Int -> [a] -> [[a]]

segmentos3 n xs =

take (length xs - n + 1) (map (take n) (tails xs))

-- ghci> length (segmentos1 3 [1..30000])

-- 29998

-- (2.99 secs, 13998816 bytes)

--

-- ghci> length (segmentos2 3 [1..30000])

-- 29998

-- (0.05 secs, 16941304 bytes)

--

-- ghci> length (segmentos3 3 [1..30000])

-- 29998

-- (0.04 secs, 10375520 bytes)

--

-- ghci> length (segmentos2 3 [1..1000000])

-- 999998

-- (0.70 secs, 498098336 bytes)

--

-- ghci> length (segmentos3 3 [1..1000000])

-- 999998

-- (0.24 secs, 273979304 bytes)

5 Comentarios

segmentos :: Int -> [a] -> [[a]]
segmentos n xs = [ys | ys <- listas n xs, length ys == n]

listas :: Int -> [a] -> [[a]]
listas n [] = []
listas n xs = [take n xs] ++ listas n (tail xs)

1

2

3

4

5

6

segmentos :: Int -> [a] -> [[a]]

segmentos n xs = [ys | ys <- listas n xs, length ys == n]

listas :: Int -> [a] -> [[a]]

listas n [] = []

listas n xs = [take n xs] ++ listas n (tail xs)

segmentos :: Int -> [a] -> [[a]]
segmentos x xs = reverse (aux x [] xs)
           
aux p s n | length n < p = s 
          | otherwise    = aux p ((take p n):s) (tail n)

1

2

3

4

5

segmentos :: Int -> [a] -> [[a]]

segmentos x xs = reverse (aux x [] xs)

aux p s n | length n < p = s

| otherwise = aux p ((take p n):s) (tail n)

Pedro Martín Chávez dice:

10-febrero-2015 a las 18:46

Haskell

segmentos :: Int -> [a] -> [[a]] segmentos n (x:xs) | n > length (x:xs) = [] | otherwise = take n (x:xs) : segmentos n xs

1
2
3

segmentos :: Int -> [a] -> [[a]]
segmentos n (x:xs) | n > length (x:xs) = []
| otherwise = take n (x:xs) : segmentos n xs

Responder
1. Jesús Navas Orozco dice:
  
  10-febrero-2015 a las 20:10
  
  Esta definición falla para el caso n = 1.
  
  Haskell
  
  segmentos 1 [1..5] [[1],[2],[3],[4],[5]*** Exception: C:\Users\jesus\Desktop\exercitium.hs:(206,1)-(207,65): Non-exhaustive patterns in function segmentos
  
  1
  2
  
  segmentos 1 [1..5]
  [[1],[2],[3],[4],[5]*** Exception: C:\Users\jesus\Desktop\exercitium.hs:(206,1)-(207,65): Non-exhaustive patterns in function segmentos
  
  Responder
Jesús Navas Orozco dice:

10-febrero-2015 a las 20:07

Haskell

segmentos :: Int -> [a] -> [[a]] segmentos n xs | length xs < n = [] | otherwise = take n xs : segmentos n (tail xs)

1
2
3

segmentos :: Int -> [a] -> [[a]]
segmentos n xs | length xs < n = []
| otherwise = take n xs : segmentos n (tail xs)

Responder

Escribe tu soluciónCancel reply