Menu Close

Ordenación pendular

La ordenación pendular de una lista xs es la lista obtenida organizando sus elementos de manera similar al movimiento de ida y vuelta de un péndulo; es decir,

  • El menor elemento de xs se coloca en el centro de la lista.
  • El siguiente elemento se coloca a la derecha del menor.
  • El siguiente elemento se coloca a la izquierda del menor y así sucesivamente, de una manera similar a la de un péndulo.

Por ejemplo, la ordenación pendular de [6,6,8,5,10] es [10,6,5,6,8].

Definir la función

   pendulo :: [Int] -> [Int]

tal que (pendulo xs) es la ordenación pendular de xs. Por ejemplo,

   pendulo [6,6,8,5,10]                 == [10,6,5,6,8]
   pendulo [-9,-2,-10,-6]               == [-6,-10,-9,-2]
   pendulo [11,-16,-18,13,-11,-12,3,18] == [13,3,-12,-18,-16,-11,11,18]

Soluciones

import Data.List (sort)
 
-- 1ª solución
-- ===========
 
pendulo :: [Int] -> [Int]
pendulo xs = reverse (impares ys) ++ y : pares ys
  where (y:ys) = sort xs
 
-- (pares xs) son los elementos de xs que ocupan posiciones pares.
pares :: [a] -> [a]
pares []     = []
pares (x:xs) = x : impares xs
 
-- (impares xs) son los elementos de xs que ocupan posiciones impares.
impares :: [a] -> [a]
impares []     = []
impares (_:xs) = pares xs
 
-- 2ª solución
-- ===========
 
pendulo2 :: [Int] -> [Int]
pendulo2 xs = aux (sort xs) [] True
  where
    aux [] ys _         = ys
    aux (x:xs) ys True  = aux xs (x:ys) False 
    aux (x:xs) ys False = aux xs (ys ++ [x]) True
 
-- Comparación de eficiencia
-- =========================
 
-- La comparación es
--    λ> length (pendulo [1..2*10^4])
--    20000
--    (0.03 secs, 6,501,896 bytes)
--    λ> length (pendulo2 [1..2*10^4])
--    20000
--    (2.37 secs, 8,596,479,096 bytes)

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 mejor obra del matemático es el arte, un arte altamente perfecto, tan audaz como los más secretos sueños de la imaginación, claro y límpido. El genio matemático y el genio artístico se tocan mutuamente.”

Gösta Mittag-Leffler.

4 soluciones de “Ordenación pendular

  1. melgonaco
    pendulo :: [Int] -> [Int]
    pendulo xs = ordena (sort xs)
     
    ordena ys = [ys!!k | k <- filter even [y-1,y-2..0]] ++
                [ys!!k | k <- filter odd [0..y-1]]
      where y = length ys
  2. Enrique Zubiría
    import Data.List
     
    pendulo :: [Int] -> [Int]
    pendulo xs = pendulo' (sort xs) []
     
    pendulo' :: [Int] -> [Int] -> [Int]
    pendulo' [] acc = acc
    pendulo' (x:xs) acc
      | even (length acc) = pendulo' xs (x:acc)
      | otherwise         = pendulo' xs (acc++[x])
  3. fercarnav
    import Data.List
     
    pendulo :: [Int] -> [Int]
    pendulo xs = distribuye (sort xs) []
     
    distribuye :: [Int] -> [Int] -> [Int]
    distribuye []  ys        = ys
    distribuye [a] ys        = a:ys
    distribuye (x1:x2:xs) ys = distribuye xs (x1:ys++[x2])
  4. juabaerui
    import Data.List (sort)
     
    pendulo :: [Int] -> [Int]
    pendulo ys
      | odd y     = [xs!!k | k <- [y-1,y-3..0]] ++ [xs!!k | k <- [1,3..y-1]]
      | otherwise = [xs!!k | k <- [y-2,y-4..0]] ++ [xs!!k | k <- [1,3..y-1]]
      where y  = length xs
            xs = sort ys

Leave a Reply

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