Menu Close

Árbol de Navidad

Definir el procedimiento

   arbol :: Int -> IO ()

tal que (arbol n) dibuja el árbol de Navidad con una copa de altura n y un tronco de altura la mitad de n. Por ejemplo,

   λ> arbol 5
 
        X
       XXX
      XXXXX
     XXXXXXX
    XXXXXXXXX
        X
        X
 
   λ> arbol 6
 
         X
        XXX
       XXXXX
      XXXXXXX
     XXXXXXXXX
    XXXXXXXXXXX
         X
         X
         X
 
   λ> arbol 7
 
          X
         XXX
        XXXXX
       XXXXXXX
      XXXXXXXXX
     XXXXXXXXXXX
    XXXXXXXXXXXXX
          X
          X
          X

Soluciones

arbol :: Int -> IO ()
arbol n = do
  putStrLn ""
  sequence_ [putStrLn c | c <- triangulo n]
  sequence_ [putStrLn c | c <- rectangulo n]
  putStrLn ""
 
triangulo :: Int -> [String]
triangulo n =
    [replicate (n-k) ' ' ++ replicate (1+2*k) 'X' | k <- [0..n-1]]
 
rectangulo :: Int -> [String]
rectangulo n =
    [replicate n ' ' ++ "X" | _ <- [1..n `div` 2]]

4 soluciones de “Árbol de Navidad

  1. fracruzam
    arbol :: Int -> IO ()
    arbol n = do copa (n-1) 1 n
                 base (n-1) (div n 2)
     
    copa :: Int -> Int -> Int -> IO ()
    copa e x 0 = return ()
    copa e x n = do putStrLn (esp ++ (concat $ replicate x "X") ++ esp)
                    copa (e-1) (x+2) (n-1)
      where esp = concat $ replicate e " "
     
    base :: Int -> Int -> IO ()                         
    base _ 0 = return ()
    base e n = do putStrLn (esp ++ "X" ++ esp)
                  base e (n-1)
      where esp = concat $ replicate e " "
     
    {- 
    *Main> arbol 8
           X       
          XXX      
         XXXXX     
        XXXXXXX    
       XXXXXXXXX   
      XXXXXXXXXXX  
     XXXXXXXXXXXXX 
    XXXXXXXXXXXXXXX
           X       
           X       
           X       
           X  
    -}
  2. josejuan
     
    arbol' n = [[c x y | x ← [12 × n - 1]]
                       | y ← [1 … n + n ÷ 2]]
      where c x y | x ≡ n ∨ (y ≤ n ∧ (abs (x - n)) < y) = 'X'
                  | otherwise                           = ' '
     
    arbol = decorado "X"
     
    -- Decoremos un poco el árbol ;D
    decorado xs = putStrLn ∘ decorar (cycle xs)unlines ∘ arbol'
     
    decorar    _        []  = []
    decorar (y:ys) ('X':xs) = y: decorar ys xs
    decorar    ys  ( x :xs) = x: decorar ys xs
     
     
    arbolConBolas     = decorado "XX*X"
    arbolFelizNavidad = decorado "Feliz·Navidad·"
     
    {-
     
    > arbolConBolas 7
          X
         X*X
        XX*XX
       X*XXX*X
      XX*XXX*XX
     X*XXX*XXX*X
    XX*XXX*XXX*XX
          X
          *
          X
     
    > arbolFelizNavidad 7
          F
         eli
        z·Nav
       idad·Fe
      liz·Navid
     ad·Feliz·Na
    vidad·Feliz·N
          a
          v
          i
     
    -}
  3. abrdelrod
    arbol :: Int -> IO ()
    arbol n = do 
      sequence_ [putStrLn ((concat $ replicate (n-div m 2) " ") ++ 
                           (concat $ replicate m "X")) 
                | m <- [1,3..2*n-1]]
      sequence_ [putStrLn (concat (replicate n " ") ++ "X") 
                | _ <- [1..div n 2]]
     
    -- *Main> arbol 7
    --        X
    --       XXX
    --      XXXXX
    --     XXXXXXX
    --    XXXXXXXXX
    --   XXXXXXXXXXX
    --  XXXXXXXXXXXXX
    --        X
    --        X
    --        X
    • abrdelrod

      Con un poco de espacio entre árbol n y el dibujo del árbol:

      arbol :: Int -> IO ()
      arbol n = do 
        putStrLn ""
        sequence_ [putStrLn ((concat $ replicate (n-div m 2) " ") ++ 
                             (concat $ replicate m "X")) 
                  | m <- [1,3..2*n-1]]
        sequence_ [putStrLn (concat (replicate n " ") ++ "X") 
                  | _ <- [1..div n 2]]

Escribe tu solución

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