Lista con repeticiones

PorJosé A. Alonso 27-octubre-20153-noviembre-2015

Definir la función

   tieneRepeticiones :: Eq a => [a] -> Bool

1	tieneRepeticiones :: Eq a => [a] -> Bool

tal que (tieneRepeticiones xs) se verifica si xs tiene algún elemento repetido. Por ejemplo,

   tieneRepeticiones [3,2,5,2,7]          ==  True
   tieneRepeticiones [3,2,5,4,7]          ==  False
   tieneRepeticiones (5:[1..2000000000])  ==  True
   tieneRepeticiones [1..20000]           ==  False

tieneRepeticiones [3,2,5,2,7] == True

tieneRepeticiones [3,2,5,4,7] == False

tieneRepeticiones (5:[1..2000000000]) == True

tieneRepeticiones [1..20000] == False

Soluciones

tieneRepeticiones :: Eq a => [a] -> Bool
tieneRepeticiones []     = False
tieneRepeticiones (x:xs) = x `elem` xs || tieneRepeticiones xs

tieneRepeticiones :: Eq a => [a] -> Bool

tieneRepeticiones [] = False

tieneRepeticiones (x:xs) = x `elem` xs || tieneRepeticiones xs

15 Comentarios

tieneRepeticiones :: Eq a => [a] -> Bool
tieneRepeticiones [] = False
tieneRepeticiones (x:xs) = not (null (rep (x:xs)))
    where rep []     = []
          rep (x:xs) = [y | y <- xs , x == y] ++ rep xs

tieneRepeticiones :: Eq a => [a] -> Bool

tieneRepeticiones [] = False

tieneRepeticiones (x:xs) = not (null (rep (x:xs)))

where rep [] = []

rep (x:xs) = [y | y <- xs , x == y] ++ rep xs

Responder

 {- Hay una opción más fácil usando una función
predefina en Data.List -}

import Data.List

tieneRepeticiones2 :: Eq a => [a] -> Bool
tieneRepeticiones2 xs = xs == nub xs

{- Hay una opción más fácil usando una función

predefina en Data.List -}

import Data.List

tieneRepeticiones2 :: Eq a => [a] -> Bool

tieneRepeticiones2 xs = xs == nub xs

Responder

 --La definición anterior es incorrecta
--La correcta sería:
import Data.List
tieneRepeticiones2 :: Eq a => [a] -> Bool
tieneRepeticiones2 xs = not (xs == nub xs)

--La definición anterior es incorrecta

--La correcta sería:

import Data.List

tieneRepeticiones2 :: Eq a => [a] -> Bool

tieneRepeticiones2 xs = not (xs == nub xs)

Responder

tieneRepeticiones :: Eq a => [a] -> Bool
tieneRepeticiones [] = False
tieneRepeticiones (x:xs) | elem x xs = True
                         | otherwise = tieneRepeticiones xs

tieneRepeticiones :: Eq a => [a] -> Bool

tieneRepeticiones [] = False

tieneRepeticiones (x:xs) | elem x xs = True

| otherwise = tieneRepeticiones xs

Responder

Chema Cortés dice:

28-octubre-2015 a las 11:02

Algo más compacta:

Haskell

tieneRepeticiones :: Eq a => [a] -> Bool tieneRepeticiones [] = False tieneRepeticiones (x:xs) = x `elem` xs || tieneRepeticiones xs

1
2
3

tieneRepeticiones :: Eq a => [a] -> Bool
tieneRepeticiones [] = False
tieneRepeticiones (x:xs) = x `elem` xs || tieneRepeticiones xs

Responder

silgongal dice:

27-octubre-2015 a las 20:02

Haskell

import Data.List tieneRepeticiones :: Eq a => [a] -> Bool tieneRepeticiones xs = not(xs == nub xs)

1
2
3
4

import Data.List

tieneRepeticiones :: Eq a => [a] -> Bool
tieneRepeticiones xs = not(xs == nub xs)

Responder
manvermor dice:

27-octubre-2015 a las 22:12

Haskell

tieneRepeticiones :: Eq a => [a] -> Bool tieneRepeticiones xs = nub xs /= xs

1
2

tieneRepeticiones :: Eq a => [a] -> Bool
tieneRepeticiones xs = nub xs /= xs

Responder
1. manvermor dice:
  
  27-octubre-2015 a las 22:16
  
  — Me falta Import Data.List
  
  Responder

{-Esa es la otra idea,es facil pero me tardo mas de una hora para convertir en realidad-}
tieneRepeticiones :: Eq a => [a] -> Bool
tieneRepeticiones xs | (length ys-n)  >0     =True
                     |otherwise = False
              where n=length xs
                    ys=[(a,b)|(a,b)<-zip u v,a==b]
                    u=concatMap (replicate n) xs
                    v=concat (replicate n xs)

{-Esa es la otra idea,es facil pero me tardo mas de una hora para convertir en realidad-}

tieneRepeticiones :: Eq a => [a] -> Bool

tieneRepeticiones xs | (length ys-n) >0 =True

|otherwise = False

where n=length xs

ys=[(a,b)|(a,b)<-zip u v,a==b]

u=concatMap (replicate n) xs

v=concat (replicate n xs)

Responder

guache dice:

27-octubre-2015 a las 22:44

{-Arriba tienen soluciones más cortas y simples,lo que voy a hacer es simplificar un poco la mía-}
tieneRepeticiones2 :: Eq a => [a] -> Bool
tieneRepeticiones2 xs | length[(a,b)|(a,b)0 =True
|otherwise = False
where n =length xs

Responder

{-Esa es la otra idea,es facil pero me tardo mas de una hora para convertir en realidad-}
tieneRepeticiones :: Eq a => [a] -> Bool
tieneRepeticiones xs | (length ys-n)  >0     =True
                     |otherwise = False
              where n=length xs
                    ys=[(a,b)|(a,b)<-zip u v,a==b]
                    u=concatMap (replicate n) xs
                    v=concat (replicate n xs)

{-Esa es la otra idea,es facil pero me tardo mas de una hora para convertir en realidad-}

tieneRepeticiones :: Eq a => [a] -> Bool

tieneRepeticiones xs | (length ys-n) >0 =True

|otherwise = False

where n=length xs

ys=[(a,b)|(a,b)<-zip u v,a==b]

u=concatMap (replicate n) xs

v=concat (replicate n xs)

Responder

{-Arriba tienen soluciones más cortas y simples,lo que voy a hacer es simplificar un poco la mía-}

tieneRepeticiones2 :: Eq a => [a] -> Bool
tieneRepeticiones2 xs | length[(a,b)|(a,b)<-zip (concatMap (replicate n) xs)  ( concat (replicate n xs)),a==b]-n >0 =True
                      |otherwise = False
                where n =length xs

tieneRepeticiones2 :: Eq a => [a] -> Bool

tieneRepeticiones2 xs | length[(a,b)|(a,b)<-zip (concatMap (replicate n) xs) ( concat (replicate n xs)),a==b]-n >0 =True

|otherwise = False

where n =length xs

Responder

 tieneRepeticiones :: Eq a => [a] -> Bool
tieneRepeticiones [] = False 
tieneRepeticiones (x:xs) | or (map (x==) xs) = True
                         | otherwise = tieneRepeticiones xs

tieneRepeticiones :: Eq a => [a] -> Bool

tieneRepeticiones [] = False

tieneRepeticiones (x:xs) | or (map (x==) xs) = True

| otherwise = tieneRepeticiones xs

Responder

carruirui3 dice:

28-octubre-2015 a las 10:40

Haskell

tieneRepeticiones :: Eq a => [a] -> Bool tieneRepeticiones [] = False tieneRepeticiones (x:xs) = x `elem` xs || tieneRepeticiones xs

1
2
3

tieneRepeticiones :: Eq a => [a] -> Bool
tieneRepeticiones [] = False
tieneRepeticiones (x:xs) = x `elem` xs || tieneRepeticiones xs

Responder

tieneRepeticiones :: Eq a => [a] -> Bool
tieneRepeticiones []     = False
tieneRepeticiones (n:xs) = 
    ((length (filter (/= n) xs)) < length xs) ||tieneRepeticiones xs

tieneRepeticiones :: Eq a => [a] -> Bool

tieneRepeticiones [] = False

tieneRepeticiones (n:xs) =

((length (filter (/= n) xs)) < length xs) ||tieneRepeticiones xs

Responder

Lista con repeticiones

Soluciones

15 Comentarios

Escribe tu soluciónCancel reply

Entradas recientes

Buscar

Correo electrónico

Soluciones

Se puede imprimir o compartir con

15 Comentarios

Escribe tu soluciónCancel reply

Entradas recientes

Buscar

Correo electrónico