Menu Close

Juego de bloques con letras

José A. Alonso,

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

5 soluciones de “Juego de bloques con letras”

  1. Responder
    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. Responder
    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. Responder
    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. Responder
    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. Responder
    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.