Menu Close

Ordenación según una cadena

José A. Alonso,

Dada una lista xs y una cadena cs de la misma longitud, la ordenación de xs según cs consiste en emparejar los elementos de cs con los de xs (de forma que al menor elemento de cs le corresponde el menor de xs, al segundo de cs el segundo de xs, etc.) y ordenar los elementos de xs en el mismo orden que sus correspondientes elementos de cs. Por ejemplo, si xs es [6,4,2] y cs es «CAB» entonces a ‘A’ le corresponde el 2, a ‘B’ el 4 y a ‘C’ el 6; luego la ordenación es [6,2,4].

Definir la función

   ordenacion :: Ord a => [a] -> String -> [a]

tal que (ordenacion xs ys) es la ordenación de la lista xs según la cadena cs. Por ejemplo,

   ordenacion [6,4,2] "CAB"     ==  [6,2,4]
   ordenacion [1,5,3] "ABC"     ==  [1,3,5]
   ordenacion [1,5,3,7] "ABEC"  ==  [1,3,7,5]

Soluciones

import Data.List (sort)
import Data.Maybe (fromJust)
 
ordenacion :: Ord a => [a] -> String -> [a]
ordenacion xs cs =
  [fromJust (lookup y diccionario) | y <- cs]
  where diccionario = zip (sort cs) (sort xs)
Posted in Inicial
Tagged , , , ,

4 Comments

  1. alerodrod5
    Responder 
     
import Data.List
ordenacion :: Ord a => [a] -> String -> [a]
ordenacion xs ys  = concat[elemento a xs ys |a<-ys]
 
paresordenados xs ys = zip (sort (nub xs)) (sort (nub ys))
 
elemento :: Ord a => Char -> [a]-> String -> [a]
elemento a xs ys | a `elem`ys = [x | (x,y) <-paresordenados xs ys, y==a]
                 | otherwise = []
  2. agumaragu1
    Responder 
    import Data.List (sort, nub)
import Data.Maybe (isJust, fromJust)
 
ordenacion :: Ord a => [a] -> String -> [a]
ordenacion xs cs = [fromJust x | c <- cs, let x = lookup c ys, isJust x]
  where ys = zip ((sort.nub) cs) ((sort.nub) xs)
  3. angruicam1
    Responder 
    import Data.List (sort)
import Data.Maybe (fromJust)
 
ordenacion :: Ord a => [a] -> String -> [a]
ordenacion xs ys = map (fromJust . flip lookup dic) ys
  where dic = zip (sort ys) (sort xs)
  4. menvealer
    Responder 
    import Data.List
 
ordenacion :: Ord a => [a] -> String -> [a]
ordenacion xs ys = head [a | (a,b) <- ts, b == ys]
  where ts = map unzip $ permutations $ zip (sort xs) (sort ys)

Escribe tu solución

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