Elementos no repetidos

PorJosé A. Alonso 22-abril-20191-mayo-2019

Definir la función

   noRepetidos :: Eq a => [a] -> [a]

1	noRepetidos :: Eq a => [a] -> [a]

tal que (noRepetidos xs) es la lista de los elementos no repetidos de la lista xs. Por ejemplo,

   noRepetidos [3,2,5,2,4,7,3]  ==  [5,4,7]
   noRepetidos "noRepetidos"    ==  "nRptids"
   noRepetidos "Roma"           ==  "Roma"

1

2

3

noRepetidos [3,2,5,2,4,7,3] == [5,4,7]

noRepetidos "noRepetidos" == "nRptids"

noRepetidos "Roma" == "Roma"

Soluciones

import Test.QuickCheck

-- 1ª solución
-- ===========

noRepetidos :: Eq a => [a] -> [a]
noRepetidos xs = 
  [x | x <- xs, ocurrencias x xs == 1]
  
-- (ocurrencias x ys) es el número de ocurrencias de x en ys. Por
-- ejemplo,
--    ocurrencias 3 [3,2,5,2,4,7,3]  ==  2
--    ocurrencias 5 [3,2,5,2,4,7,3]  ==  1
ocurrencias :: Eq a => a -> [a] -> Int
ocurrencias x ys = 
  length [y | y <- ys, y == x]

-- 2ª solución
-- ===========
noRepetidos2 :: Eq a => [a] -> [a]
noRepetidos2 [] = []
noRepetidos2 (x:xs) | elem x xs = noRepetidos2 [y | y <- xs, y /= x]
                    | otherwise = x : noRepetidos2 xs

-- Equivalencia
-- ============

-- La propiedad de equivalencia es
prop_equivalencia :: [Int] -> Bool
prop_equivalencia xs =
  noRepetidos xs == noRepetidos2 xs

-- La comprobación es
--    ghci> quickCheck prop_equivalencia
--    +++ OK, passed 100 tests.

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

import Test.QuickCheck

-- 1ª solución

-- ===========

noRepetidos :: Eq a => [a] -> [a]

noRepetidos xs =

[x | x <- xs, ocurrencias x xs == 1]

-- (ocurrencias x ys) es el número de ocurrencias de x en ys. Por

-- ejemplo,

-- ocurrencias 3 [3,2,5,2,4,7,3] == 2

-- ocurrencias 5 [3,2,5,2,4,7,3] == 1

ocurrencias :: Eq a => a -> [a] -> Int

ocurrencias x ys =

length [y | y <- ys, y == x]

-- 2ª solución

-- ===========

noRepetidos2 :: Eq a => [a] -> [a]

noRepetidos2 [] = []

noRepetidos2 (x:xs) | elem x xs = noRepetidos2 [y | y <- xs, y /= x]

| otherwise = x : noRepetidos2 xs

-- Equivalencia

-- ============

-- La propiedad de equivalencia es

prop_equivalencia :: [Int] -> Bool

prop_equivalencia xs =

noRepetidos xs == noRepetidos2 xs

-- La comprobación es

-- ghci> quickCheck prop_equivalencia

-- +++ OK, passed 100 tests.

Pensamiento

Y en perfecto rimo
— así a la vera del agua
el doble chopo del río.

Antonio Machado

11 Comentarios

import Data.List 
noRepetidos :: Eq a => [a] -> [a]
noRepetidos [x] =  [x]
noRepetidos (x:xs) | x`elem`xs = noRepetidos (xs \\[x])
                    | otherwise = x:noRepetidos xs

1

2

3

4

5

import Data.List

noRepetidos :: Eq a => [a] -> [a]

noRepetidos [x] = [x]

noRepetidos (x:xs) | x`elem`xs = noRepetidos (xs \\[x])

| otherwise = x:noRepetidos xs

guicabgod dice:

24-abril-2019 a las 17:25

Falla para los elementos que aparecen más de dos veces. Por ejemplo,

Haskell

λ> noRepetidos [5,2,5,2,5] [5]

1
2

λ> noRepetidos [5,2,5,2,5]
[5]

Responder

luipromor dice:

22-abril-2019 a las 16:33

Haskell

noRepetidos :: Eq a => [a] -> [a] noRepetidos [] = [] noRepetidos (x:xs) | elem x xs = noRepetidos $ filter (/=x) xs | otherwise = x : noRepetidos xs

1
2
3
4
5

noRepetidos :: Eq a => [a] -> [a]
noRepetidos [] = []
noRepetidos (x:xs)
| elem x xs = noRepetidos $ filter (/=x) xs
| otherwise = x : noRepetidos xs

Responder

import Data.List (nub)

noRepetidos :: Eq a => [a] -> [a]
noRepetidos xs =
  [a | (a,b) <- zip (nub xs) [length (filter (==c) xs) | c <- nub xs],
       b == 1]

1

2

3

4

5

6

import Data.List (nub)

noRepetidos :: Eq a => [a] -> [a]

noRepetidos xs =

[a | (a,b) <- zip (nub xs) [length (filter (==c) xs) | c <- nub xs],

b == 1]

ampjargar dice:

23-abril-2019 a las 19:47

Haskell

import Data.List (delete) noRepetidos :: Eq a => [a] -> [a] noRepetidos xs = [x | x <- xs, not (elem x (delete x xs))]

1
2
3
4

import Data.List (delete)

noRepetidos :: Eq a => [a] -> [a]
noRepetidos xs = [x | x <- xs, not (elem x (delete x xs))]

Responder

import Data.List (nub)
noRepetidos :: Eq a => [a] -> [a]
noRepetidos [] = []
noRepetidos [x] = [x]
noRepetidos (x:xs) | x `elem`xs = noRepetidos (dropWhile (==x) (nub xs))
                   | otherwise =[x] ++  noRepetidos xs

1

2

3

4

5

6

import Data.List (nub)

noRepetidos :: Eq a => [a] -> [a]

noRepetidos [] = []

noRepetidos [x] = [x]

noRepetidos (x:xs) | x `elem`xs = noRepetidos (dropWhile (==x) (nub xs))

| otherwise =[x] ++ noRepetidos xs

guicabgod dice:

24-abril-2019 a las 17:39

Falla en el primer ejemplo

λ> noRepetidos [3,2,5,2,4,7,3] [2,5,4,7,3]

1
2

λ> noRepetidos [3,2,5,2,4,7,3]
[2,5,4,7,3]

pero el 2 y el 3 están repetidos.

Responder

En Python

def noRepetidos(xs):
    return [x for x in xs if ocurrencias(x,xs) == 1]
  
# (ocurrencias x xs) es el número de ocurrencias de x en xs. Por
# ejemplo, 
#    >>> ocurrencias(1,[1,2,3,4,3,2,3,1,4]) 
#    2
def ocurrencias(x,xs):
    return len([x1 for x1 in xs if x == x1])

1

2

3

4

5

6

7

8

9

def noRepetidos(xs):

return [x for x in xs if ocurrencias(x,xs) == 1]

# (ocurrencias x xs) es el número de ocurrencias de x en xs. Por

# ejemplo,

# >>> ocurrencias(1,[1,2,3,4,3,2,3,1,4])

# 2

def ocurrencias(x,xs):

return len([x1 for x1 in xs if x == x1])

noRepetidos :: Eq a => [a] -> [a]
noRepetidos [] = []
noRepetidos (x:xs) | elem x xs = noRepetidos (filter (/=x) (x:xs))
                   | otherwise = x:(noRepetidos xs)

1

2

3

4

noRepetidos :: Eq a => [a] -> [a]

noRepetidos [] = []

noRepetidos (x:xs) | elem x xs = noRepetidos (filter (/=x) (x:xs))

| otherwise = x:(noRepetidos xs)

javmarcha1 dice:

27-abril-2019 a las 17:58

Haskell

import Data.List noRepetidos :: Eq a => [a] -> [a] noRepetidos xs = [ x | x <- xs, not(elem x (xs \\ nub xs))]

1
2
3
4

import Data.List

noRepetidos :: Eq a => [a] -> [a]
noRepetidos xs = [ x | x <- xs, not(elem x (xs \\ nub xs))]

Responder
ireprirod dice:

27-abril-2019 a las 20:42

Haskell

noRepetidos :: Eq a => [a] -> [a] noRepetidos xs = [ x | x<-xs, length (filter (==x) xs )== 1]

1
2

noRepetidos :: Eq a => [a] -> [a]
noRepetidos xs = [ x | x<-xs, length (filter (==x) xs )== 1]

Responder

Escribe tu soluciónCancel reply