Menu Close

Juego de bloques con letras

Para el juego de los bloques se dispone de un conjunto de bloques con una letra en cada una de sus dos caras. El objetivo del juego consiste en formar palabras sin que se pueda usar un bloque más de una vez y sin diferenciar mayúsculas de minúsculas. Por ejemplo, si se tiene tres bloques de forma que el 1º tiene las letras A y B, el 2ª la N y la O y el 3º la O y la A entonces se puede obtener la palabra ANA de dos formas: una con los bloques 1, 2 y 3 y otra con los 3, 2 y 1.

Definir la función

   soluciones :: [String] -> String -> [[String]]

tal que (soluciones bs cs) es la lista de las soluciones del juego de los bloque usando los bloques bs (cada bloque es una cadena de dos letras mayúsculas) para formar la palabra cs. Por ejemplo,

   ghci> soluciones ["AB","NO","OA"] "ANA"
   [["AB","NO","OA"],["OA","NO","AB"]]
   ghci> soluciones ["AB","NE","OA"] "Bea"
   [["AB","NE","OA"]]
   ghci> soluciones ["AB","NE","OA"] "EvA"
   []
   ghci> soluciones ["AB","NO","OA","NC"] "ANA"
   [["AB","NO","OA"],["AB","NC","OA"],["OA","NO","AB"],["OA","NC","AB"]]
   ghci> soluciones ["AB","NO","OA","NC"] "Anca"
   [["AB","NO","NC","OA"],["OA","NO","NC","AB"]]
   ghci> soluciones (["AB","NO","OA"] ++ replicate (10^6) "PQ") "ANA"
   [["AB","NO","OA"],["OA","NO","AB"]]

Soluciones

import Data.List (delete)
import Data.Char (toUpper)
 
soluciones :: [String] -> String -> [[String]]
soluciones _ []      = [[]]
soluciones bs (c:cs) = [b:rs | b <- bs, 
                               toUpper c `elem` b,
                               rs <- soluciones (delete b bs) cs]

5 soluciones de “Juego de bloques con letras

  1. erisan
    import Data.Char
    import Data.List
     
    soluciones :: [String] -> String -> [[String]]
    soluciones xs ys = 
        [soluciona x ys | x <- permutations xs, 
                          length (soluciona x ys) == length ys]
     
    soluciona :: [String] -> String -> [String]
    soluciona xs ys = [x | (x,y) <- zip xs ys, toUpper y `elem` x]
  2. fracruzam
    import Data.Maybe
    import Data.Char
    import Data.List
     
    soluciones :: [String] -> String -> [[String]]
    soluciones fs ls = soluciona [([],ls,fs)]
     
    soluciona :: [([String],String,[String])] -> [[String]]
    soluciona ((ps,(q:qs),rs):xs)
        | isNothing e = soluciona xs
        | otherwise   =
            soluciona (xs ++ [(ys:ps, qs, delete ys rs) |
                                            ys <- fromJust e])
      where e = encuentra q rs
    soluciona ((ps,[],_):xs) = reverse ps : soluciona xs
    soluciona   _            = []
       -- Cada terna representa:
       --     (Fichas usadas en orden invero,
       --         letras restantes que buscar,
       --            batería de fichas donde buscar)
     
    encuentra :: Char -> [String] -> Maybe [String]
    encuentra x rs | null xs   = Nothing
                   | otherwise = Just xs
      where xs = filter (pertenece x) rs
       -- λ> encuentra 'x' ["HO","LA"]  λ> encuentra 'A' ["HO","LA"]
       -- Nothing                       Just ["LA"]
     
    pertenece :: Char -> String -> Bool
    pertenece x xs = xm `elem` xs || xM `elem` xs
      where xm = toLower x
            xM = toUpper x
       -- λ> pertenece 'h' "HOLA"  λ> pertenece 'h' "7OLA"
       -- True                     False
  3. abrdelrod
    import Data.Char
    import Data.List
     
    soluciones :: [String] -> String -> [[String]]
    soluciones bs cs = (map (take n) . filter (p xs)) (permutations bs)
       where xs = map toUpper cs
             n = length cs
             p [] _ = True
             p _ [] = False
             p (x:xs) (ys:yss) = elem x ys && p xs yss
  4. manvermor
    import Data.List
    import Data.Char
     
    soluciones :: [String] -> String -> [[String]]
    soluciones bs cs = [ take (length cs) ys | ys <- permutations bs, clasifica zs ys] 
       where zs = map toUpper cs
     
    clasifica [] _ = True
    clasifica _ [] = False
    clasifica (c:cs) (bs:bss) = elem c bs && clasifica cs bss
  5. Chema Cortés
    import Data.List (delete)
    import Data.Char (toUpper)
     
    soluciones :: [String] -> String -> [[String]]
    soluciones _ []      = [[]]
    soluciones [] _      = [[]]
    soluciones bs (c:cs) = [ xs:xss | xs <- filter (toUpper c `elem`) bs
                                    , xss <- soluciones (delete xs bs) cs ]

Escribe tu solución

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