Menu Close

Primero no consecutivo

José A. Alonso,

Definir la función

   primeroNoConsecutivo :: (Eq a,Enum a) => [a] -> Maybe a

tal que (primeroNoConsecutivo xs) es el primer elemento de la lista xs que no es igual al siguiente de su elemento anterior en xs o Nothing si tal elemento no existe. Por ejemplo

   primeroNoConsecutivo [1,2,3,4,6,7,8] == Just 6
   primeroNoConsecutivo "bcdfg"         == Just 'f'
   primeroNoConsecutivo "bcdef"         == Nothing

Soluciones

import Data.Maybe (listToMaybe)
 
-- 1ª solución
primeroNoConsecutivo1 :: (Eq a, Enum a) => [a] -> Maybe a
primeroNoConsecutivo1 xs
  | null ys   = Nothing
  | otherwise = Just (head ys)
  where ys = [y | (z,y) <- zip xs (tail xs), y /= succ z]
 
-- 2ª solución
primeroNoConsecutivo2 :: (Eq a, Enum a) => [a] -> Maybe a
primeroNoConsecutivo2 xs = 
  listToMaybe [y | (z,y) <- zip xs (tail xs), y /= succ z]
 
-- 3ª solución
primeroNoConsecutivo3 :: (Eq a,Enum a) => [a] -> Maybe a
primeroNoConsecutivo3 (x:y:zs)
  | succ x /= y = Just y 
  | otherwise   = primeroNoConsecutivo3 (y:zs)
primeroNoConsecutivo3 _ = Nothing
 
-- 4ª solución
primeroNoConsecutivo :: (Eq a,Enum a) => [a] -> Maybe a
primeroNoConsecutivo [] = Nothing
primeroNoConsecutivo (x:ys) = aux x ys
  where aux _ [] = Nothing
        aux x' (z:zs) | z == succ x' = aux z zs
                      | otherwise    = Just z

Otras soluciones

  • Se pueden escribir otras soluciones en los comentarios.
  • El código se debe escribir entre una línea con <pre lang="haskell"> y otra con </pre>

Pensamiento

«La única enseñanza que un profesor puede dar, en mi opinión, es la de pensar delante de sus alumnos.»

Henri Lebesgue.

Posted in Medio
Tagged , , , , , , , ,

6 Comments

  1. Enrique Zubiría
    Responder 
    primeroNoConsecutivo :: (Eq a, Enum a) => [a] -> Maybe a
primeroNoConsecutivo []     = Nothing
primeroNoConsecutivo (x:[]) = Nothing
primeroNoConsecutivo (x:y:xs)
  | y /= succ x = Just y
  | otherwise   = primeroNoConsecutivo (y:xs)
  2. rebgongor
    Responder 
    primeroNoConsecutivo :: (Eq a,Enum a) => [a] -> Maybe a
primeroNoConsecutivo [] = Nothing
primeroNoConsecutivo xs
  | xs /= ys  = Just n
  | otherwise = Nothing
  where n  = head $ tail $ dropWhile (`elem` xs) ys
        ys = enumFromTo (head xs) (last xs)
  3. marmarsan
    Responder

    En Maxima

    primeroNoConsecutivo(xs) :=
  if emptyp(xs) then false
  else aux(1+first(xs),rest(xs))$
 
aux(x,ys) :=
  if emptyp(ys) then false
  elseif is(x # first(ys)) then first(ys)
  else aux(1+x,rest(ys))$
  4. pedperpal
    Responder

    En Python

    def primeroNoConsecutivo(xs):
    for i in range(1, len(xs)):
        if xs[i] - xs[i-1] > 1:
            return xs[i]
  5. juljimjai
    Responder

    En Julia

    function primeroNoConsecutivo(xs)
  for i in 1:(length(xs)-1)
    if xs[i+1] != xs[i] + 1
      return xs[i+1]
    end
  end
end
  6. claniecas
    Responder 
    primeroNoConsecutivo :: (Eq a,Enum a) => [a] -> Maybe a
primeroNoConsecutivo xs
  | zs /= []  = Just (head zs)
  | otherwise = Nothing
  where ys = [head xs..last xs]
        zs = [a | (a,b) <- zip xs ys, a /= b]

Escribe tu solución

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.