Siguiente mayor

PorJosé A. Alonso 20-marzo-201926-marzo-2022

Definir la función

   siguienteMayor :: Ord a => [a] -> [Maybe a]

1	siguienteMayor :: Ord a => [a] -> [Maybe a]

tal que (siguienteMayos xs) es la lista obtenida sustiyendo cada elemento de xs por el primer elemento de xs a la derechha de x que sea mayor que x, si existe y Nothing en caso contrario. Por ejemplo,

   λ> siguienteMayor [4,5,2,3,9]
   [Just 5,Just 9,Just 3,Just 9,Nothing]
   λ> siguienteMayor [9,5,2,3,4]
   [Nothing,Nothing,Just 3,Just 4,Nothing]
   λ> siguienteMayor [9,5,2,2,4]
   [Nothing,Nothing,Just 4,Just 4,Nothing]
   λ> siguienteMayor "betis"
   [Just 'e',Just 't',Nothing,Just 's',Nothing]
   λ> siguienteMayor "sevilla"
   [Just 'v',Just 'v',Nothing,Just 'l',Nothing,Nothing,Nothing]

λ> siguienteMayor [4,5,2,3,9]

[Just 5,Just 9,Just 3,Just 9,Nothing]

λ> siguienteMayor [9,5,2,3,4]

[Nothing,Nothing,Just 3,Just 4,Nothing]

λ> siguienteMayor [9,5,2,2,4]

[Nothing,Nothing,Just 4,Just 4,Nothing]

λ> siguienteMayor "betis"

[Just 'e',Just 't',Nothing,Just 's',Nothing]

λ> siguienteMayor "sevilla"

[Just 'v',Just 'v',Nothing,Just 'l',Nothing,Nothing,Nothing]

Soluciones

import Data.Maybe (listToMaybe)

-- 1ª solución
siguienteMayor :: Ord a => [a] -> [Maybe a]
siguienteMayor [] = []
siguienteMayor (x:xs)
  | null ys   = Nothing : siguienteMayor xs
  | otherwise = Just (head ys) : siguienteMayor xs
  where ys = [y | y <- xs, y > x]

-- 2ª solución
siguienteMayor2 :: Ord a => [a] -> [Maybe a]
siguienteMayor2 []     = []
siguienteMayor2 (x:xs) = listToMaybe [y | y <- xs, y > x] : siguienteMayor2 xs

-- 3ª solución
siguienteMayor3 :: Ord a => [a] -> [Maybe a]
siguienteMayor3 []     = []
siguienteMayor3 (x:xs) = listToMaybe (dropWhile (<=x) xs) : siguienteMayor3 xs

import Data.Maybe (listToMaybe)

-- 1ª solución

siguienteMayor :: Ord a => [a] -> [Maybe a]

siguienteMayor [] = []

siguienteMayor (x:xs)

| null ys = Nothing : siguienteMayor xs

| otherwise = Just (head ys) : siguienteMayor xs

where ys = [y | y <- xs, y > x]

-- 2ª solución

siguienteMayor2 :: Ord a => [a] -> [Maybe a]

siguienteMayor2 [] = []

siguienteMayor2 (x:xs) = listToMaybe [y | y <- xs, y > x] : siguienteMayor2 xs

-- 3ª solución

siguienteMayor3 :: Ord a => [a] -> [Maybe a]

siguienteMayor3 [] = []

siguienteMayor3 (x:xs) = listToMaybe (dropWhile (<=x) xs) : siguienteMayor3 xs

Pensamiento

Si vivir es bueno
es mejor soñar,
y mejor que todo,
madre, despertar.

Antonio Machado

8 Comentarios

siguienteMayor :: Ord a => [a] -> [Maybe a]
siguienteMayor [x] = [Nothing]
siguienteMayor (x:xs) = (encuentraMayor x xs) : siguienteMayor xs

encuentraMayor :: Ord a => a -> [a] -> Maybe a
encuentraMayor x xs | null b = Nothing
                    | otherwise = Just (head b)
  where b = [a | a <- xs, a > x]

siguienteMayor :: Ord a => [a] -> [Maybe a]

siguienteMayor [x] = [Nothing]

siguienteMayor (x:xs) = (encuentraMayor x xs) : siguienteMayor xs

encuentraMayor :: Ord a => a -> [a] -> Maybe a

encuentraMayor x xs | null b = Nothing

| otherwise = Just (head b)

where b = [a | a <- xs, a > x]

Responder

Import Data.List

siguienteMayor :: Ord a => [a] -> [Maybe a]
siguienteMayor xs = aux  (init (tails xs))
  where aux [] = []
        aux [[x]] = [Nothing]
        aux (xs:xss) | fst (propiedad xs) = (snd (propiedad xs)):aux xss
                     | otherwise = (Nothing):aux xss
        

propiedad :: Ord a => [a] -> (Bool, Maybe a)
propiedad [] = (True,Nothing)
propiedad [x] = (False,Nothing)
propiedad (x:y:ys) | y > x = (True,Just y)
                   | otherwise = propiedad (x:ys)

Import Data.List

siguienteMayor :: Ord a => [a] -> [Maybe a]

siguienteMayor xs = aux (init (tails xs))

where aux [] = []

aux [[x]] = [Nothing]

aux (xs:xss) | fst (propiedad xs) = (snd (propiedad xs)):aux xss

| otherwise = (Nothing):aux xss

propiedad :: Ord a => [a] -> (Bool, Maybe a)

propiedad [] = (True,Nothing)

propiedad [x] = (False,Nothing)

propiedad (x:y:ys) | y > x = (True,Just y)

| otherwise = propiedad (x:ys)

Responder

danmorper2 dice:

20-marzo-2019 a las 14:52

Haskell

siguienteMayor :: Ord a => [a] -> [Maybe a] siguienteMayor [] = [] siguienteMayor (x:xs) = (find (<x) xs):(siguienteMayor xs)

1
2
3

siguienteMayor :: Ord a => [a] -> [Maybe a]
siguienteMayor [] = []
siguienteMayor (x:xs) = (find (<x) xs):(siguienteMayor xs)

Responder

siguienteMayor :: Ord a => [a] -> [Maybe a]
siguienteMayor [] = []
siguienteMayor (x:xs) = aux x xs :  siguienteMayor xs
  where aux x xs | null ys  = Nothing
                 | otherwise = Just (head ys)
                   where ys = filter (>x) xs

siguienteMayor :: Ord a => [a] -> [Maybe a]

siguienteMayor [] = []

siguienteMayor (x:xs) = aux x xs : siguienteMayor xs

where aux x xs | null ys = Nothing

| otherwise = Just (head ys)

where ys = filter (>x) xs

Responder

siguienteMayor :: Ord a => [a] -> [Maybe a]
siguienteMayor [] = []
siguienteMayor [x] = [Nothing]
siguienteMayor (x:xs) = (aux x xs):siguienteMayor xs
  where  aux x xs | null d = Nothing
                 | otherwise = Just (head d)
          where d = filter (>x) xs

siguienteMayor :: Ord a => [a] -> [Maybe a]

siguienteMayor [] = []

siguienteMayor [x] = [Nothing]

siguienteMayor (x:xs) = (aux x xs):siguienteMayor xs

where aux x xs | null d = Nothing

| otherwise = Just (head d)

where d = filter (>x) xs

Responder

primerMayor (x:xs) | ([k | k <- xs, x < k]) == [] = Nothing
                   | otherwise = Just (head [k | k <- xs, x < k])
siguienteMayor [] = []
siguienteMayor (x:xs) = [(primerMayor (x:xs))] ++ (siguienteMayor xs)

primerMayor (x:xs) | ([k | k <- xs, x < k]) == [] = Nothing

| otherwise = Just (head [k | k <- xs, x < k])

siguienteMayor [] = []

siguienteMayor (x:xs) = [(primerMayor (x:xs))] ++ (siguienteMayor xs)

Responder

siguienteMayor :: Ord a => [a] -> [Maybe a]
siguienteMayor [] = []
siguienteMayor [x] = [Nothing]
siguienteMayor (x:xs) | null d = [Nothing]++ siguienteMayor xs
                      | otherwise = [Just(head d)]++ siguienteMayor xs
  where d = [y | y <- xs , y > x]

siguienteMayor :: Ord a => [a] -> [Maybe a]

siguienteMayor [] = []

siguienteMayor [x] = [Nothing]

siguienteMayor (x:xs) | null d = [Nothing]++ siguienteMayor xs

| otherwise = [Just(head d)]++ siguienteMayor xs

where d = [y | y <- xs , y > x]

Responder

ireprirod dice:

28-abril-2019 a las 22:07

Solución en Maxima:
siguienteMayor (xs):= if emptyp (xs) then [] else g(xs)$
g(xs):=if emptyp (f(xs)) then
(cons(Nothing, siguienteMayor (rest(xs))))
else (cons (first(f(xs)),siguienteMayor (rest (xs)))) $
f(xs) := delete (Nada,create_list(p(x,first(xs)),x,xs))$
p(x,y):=if x>y then x else Nada$

Responder

Siguiente mayor

Soluciones

Pensamiento

8 Comentarios

Escribe tu soluciónCancel reply

Entradas recientes

Buscar

Correo electrónico

Soluciones

Pensamiento

Se puede imprimir o compartir con

8 Comentarios

Escribe tu soluciónCancel reply

Entradas recientes

Buscar

Correo electrónico