Menu Close

Primero no consecutivo

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.

6 soluciones de “Primero no consecutivo

  1. Enrique Zubiría
    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
    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

    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

    En Python

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

    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
    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]

Leave a Reply

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