[Tous langages] Atelier de Noël : dessinons un sapin !

Salutation les agrumes !

Je vous propose un petit atelier de programmation pour les fêtes : dessiner un sapin !

Le programme à réaliser

Écrire un programme qui prends un nombre entier positif non-nul n en entrée, et qui dessine un sapin de cette taille.

Un sapin d’ordre n est constitué de n rangées de * disposées… ben, en sapin ; et d’un tronc #. Le sapin doit être bien droit et son tronc centré.

Parce que c’est mieux avec des exemples :

Sapin d’ordre 3 :

1
2
3
4

  *
 ***
*****
  #

Sapin d’ordre 5 :

1
2
3
4
5
6

    *
   ***
  *****
 *******
*********
    #

L’ordre du sapin peut être codé en dur dans le programme, tant qu’il est à un seul endroit et qu’on peut le modifier en changeant un simple chiffre.

La sortie peut se faire n’importe où (console, page web…) tant que les contraintes ci-dessus sont respectées.

N’oubliez pas de préciser le langage et la version utilisés !

Pour les débutants

Essayez simplement de réaliser le programme, c’est un exercice intéressant.

Pour les expérimentés

Réalisez ce programme de la façon la plus originale possible. Ça peut être le code le plus court, le plus étrange, le pire abus de votre langage, etc.

Dans tous les cas, expliquez à vos lecteurs quels sont les astuces utilisées.

À noter que les astuces suivantes sont trop classiques et donc ne devraient pas être utilisées :

• Utiliser des caractères qui sont identiques graphiquement mais qui ne sont pas les mêmes.
• Récupérer la solution depuis une source externe.
• Coder la solution en dur.
• En fait à peu près tout ce qui est dans cette liste.

Je vais voir ce que je peux faire.

Je ne comprends pas le point 1 "langage custom" et le 4 "coder en dur".

J’enlève le langage custom, ça n’a que peu de sens ici.

« Coder la solution en dur », ça veut dire que le sapin doit être généré, et pas juste enregistré dans une constante dans le programme.

Oh ça me rappel un exercice de fac. Je vais voir pour faire ça dans la soirée.

Pour le jeu du plus court, je peux proposer ça en Python (≥ 3.6), à peaufiner :

1
2
3

#n=int(input())
for i in range(n):print(f'{"*"*(i*2+1):^{2*n}}')
print(' '*(n-1)+'#')

J’obtiens le même nombre de charactères avec une solution légèrement différente :

1
2

for i in range(n):print(' '*(n-1-i)+'*'*(1+2*i))
print(' '*(n-1)+'#')

Edit : sa solution fonctionne chez moi, Python 3.6.2.

@SpaceFox, c’est du Python 3.6, il faut les f-strings pour que ça puisse fonctionner.

OK, je rajoute de préciser le langage et la version utilisés alors

Oh mon dieu, dès que j’ai une petite heure (ou deux) je vous ponds un challenger du code le plus inutilement compliqué en Python.

Idée pour ceux qui veulent, générer la décoration du sapin, c’est Noël apres tout.

C’est bien comme ça qu’on utilise Haskell?

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

import Control.Monad

main :: IO ()
main = do
  putStrLn "Ordre du sapin?"
  n <- readLn
  -- Affiche le haut ligne par ligne
  forM_ [0..(n-1)] $ \i -> do
    forM_ [0..(n-i-2)] $ \_ -> do
      putStr " "
    forM_ [0..(2*i)] $ \_ -> do
      putStr "*"
    putStr "\n"
  -- Affiche le tronc
  forM_ [0..(n-2)] $ \_ -> do
    putStr " "
  putStrLn "#"

Et la version pas aussi courte que j’aurais voulu:

1
2
3

n=5
r=replicate
main=mapM putStrLn$[r(n-i)' '++r(2*i-1)'*'|i<-[0..n]]++[r(n-1)' '++"#"]

Je n’ai pas eu d’imagination. https://jsfiddle.net/2ogejkjv/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

var A = (n) => {
    var l = (n, t) => new Array(n+1).join(t?"*":" "),
        A = "";

    for (var i = 0; i < n; i++)
        A += l(n-i) + l(i*2+1, 1) + "\n";

    return A + l(n) + "#";
};

document.body.innerHTML = `<pre>${A(6)}</pre>`;

Une version en Kotlin qui tourne dans un navigateur : loriswit.github.io/sapin/

Code source :

import org.w3c.dom.HTMLInputElement
import kotlin.browser.document

fun main(args: Array<String>)
{
    val input = document.createElement("input") as HTMLInputElement
    input.type = "range"
    input.min = "2"
    input.max = "30"
    input.value = "10"
    input.addEventListener("input", { draw(input.value.toInt()) })
    
    val height = document.createElement("h1")
    height.id = "height"
    
    val canvas = document.createElement("pre")
    canvas.id = "canvas"
    
    document.body?.appendChild(height)
    document.body?.appendChild(input)
    document.body?.appendChild(canvas)
    
    draw(input.value.toInt())
}

fun draw(height: Int)
{
    val tree = StringBuilder()
    for(i in 0 until height)
        tree.append(" ".repeat(height - i - 1) + "*".repeat(i * 2 + 1) + "\n")
    tree.append(" ".repeat(height - 1) + "#")
    
    document.getElementById("height")?.innerHTML = "n = $height"
    document.getElementById("canvas")?.innerHTML = tree.toString()
}

Voilà pour moi, en python, de manière récursive.

1
2
3
4
5
6
7
8

N = 5
def fn(n):
    if n != 0:
        print(n*' '+((N-n)*2+1)*'*')
        fn(n-1)
    else:
        print(N*' '+'#')
fn(N)

Dyalog APL:

1

{⎕IO←0⋄(⍵(¯1+2×⍵)⍴(∊↓⍉↑(⌽⍳⍵)(1+2×⍳⍵)(⌽⍳⍵))/(3×⍵)⍴' ' '*' ' ')⍪(' ' '#' ' '/⍨(⍵-1),1,(⍵-1))}

J’suis pas trop satisfait, y’a encore de la répétition…

edit: en plus court

1

{n←⍵⋄↑(⊂'#',⍨' '⍴⍨⍵-1),⍨{(' '⍴⍨n-⍵),('*'⍴⍨¯1+2×⍵)}¨⍳⍵}

Ça existe encore APL ?!

Bon, un code un peu (beaucoup) trop long et pas forcément bien fait, mais le résultat est là !

Mon beau sapin, roi des forêts…

@FougereBle, le tronc ne respecte pas la contrainte : le tronc devrait être constitué d’un seul # centré sous le corps du sapin.

Alors voilà. J’avais oublié cette contrainte.

Un sapin et la fonction x -> |x|, c’est presque la même chose non ?

1
2
3
4
5

N = 7
lentab = N*2+1
mat = [[' ' if j < abs(i-(lentab)//2) or j == N else '*' for i in range(lentab)]for j in range(N+1)]
mat[-1][lentab//2] = '#'
for line in mat: print(''.join(line))