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

❯ N=6;N=$[N-1];for i in {0..$N};do printf ' %.0s' {0..$[N-i]};printf '*%.0s' {0..$[2*i]};echo;done;printf ' %.0s' {0..$N};printf '#'
      *
     ***
    *****
   *******
  *********
 ***********
      #

N = 5

for y in range(N):
    for x in range(-N+1, N):
        print('*' if abs(x) <= y else ' ', end='')
    print()

print(' ' * (N-1) + '#')

from scipy.special import comb
N = 11
midtab = (N*2+1)//2
mat = [[' ' if (comb(j,i-midtab)+comb(j,-i+midtab)) == 0 or j == N else '*' for i in range(N*2+1)]for j in range(N+1)]
mat[-1][midtab] = '#'
for line in mat: print(''.join(line))

             int
            main(
           void) {
          int n, b,
         s;if(scanf(
        "%d",&n) != 1
       ||n<1)return 1;
      for(b=n-1, s=1; b
     >= 0; b--, s += 2){
    int i; for (i=0; i<b;
   i++) putchar(' ');for(i
  = 1;i<s;i++)putchar('*');
 puts("*"); } for(b = 1; b <
n;b++)putchar(' ');puts("#");
          return 0;
              }

$ ./sapin.exe
10
         *
        ***
       *****
      *******
     *********
    ***********
   *************
  ***************
 *****************
*******************
         #

#include <stdio.h>
#include <stdlib.h>
#include <string.h>


int
main(int argc, char **argv)
{
    sscanf(argv[1], "%d", &argc);
    argv[0] = calloc(1, argc * 2 + 1);
    argv[1] = argv[0] + argc;
    goto init;
loop:
    memset(argv[1] -= 1, '*', (argc - (argv[1] - argv[0])) * 2 + 1);
    printf("%s\n", argv[0]);
init:
    memset(argv[0], ' ', argc * 2);
    if (argv[1] > argv[0]) goto loop;
    printf("%s\n", (argv[0][argc - 1] = '#', argv[0]));
    return 0;
}

$ ./x 7
      *                
     ***
    ***** 
   *******     
  *********    
 ***********   
*************  
      #        

#include <cstdio>
#include <string>

template <int size, int pos>
struct Feuilles
{
    std::string operator()()
    {
        return Feuilles<size, pos - 2>()() + std::string(((size - pos) / 2), ' ') + std::string(pos, '*') + "\n";
    }
};

template <int size>
struct Feuilles<size, 1>
{
    std::string operator()()
    {
        return std::string((size / 2), ' ') + "*\n";
    }
};

template <int size>
struct Sapin
{
    std::string operator()()
    {
        return Feuilles<size, size>()() + std::string((size / 2), ' ') + "#\n";
    }
};

int main()
{
    // ne pas mettre de chiffre pair ou négatif
    puts(Sapin<5>()().c_str());
}

(n=gets.to_i).times{|i|puts" "*(n-i-1)+"*"*(1+2*i)+(i+1<n ?"":"\n"+" "*i+"#")}

let sapin n =
  let rec line c = function
    | (0, 0) -> print_newline ()
    | (0, chars) -> print_char c; line c (0, chars-1)                                                                                   
    | (spaces, chars) -> print_char ' '; line c (spaces-1, chars)
  in let rec sapin_aux = function
    | 0 -> ()
    | i -> sapin_aux (i-1); line '*' (n-i, i*2-1)
  in sapin_aux n; line '#' (n-1, 1)
in sapin (int_of_string (read_line ()))

package main

import (
    "fmt"
    "strings"
)

func main() {
    var n int
    if _, err := fmt.Scan(&n); err == nil {
        for i := 1; i <= n; i++ {
            fmt.Println(strings.Repeat(" ", n-i) + strings.Repeat("*", i*2-1))
        }
        fmt.Println(strings.Repeat(" ", n-1) + "♯")
    }
}

puts" "*((n=gets.to_i).times{|i|puts" "*(n-i-1)+"*"*(1+2*i)}-1)+"#"

import struct
import types
from dis import opmap as OPMAP


CODE = """
# Define sys.stdout.write as 'put' local function

    LOAD_CONST      0
    LOAD_CONST      None
    IMPORT_NAME     sys
    LOAD_ATTR       stdout
    LOAD_ATTR       write
    STORE_FAST      put

# Now print the N first lines of the Christmas Tree

    LOAD_CONST      0
    STORE_FAST      i

@begin_lines_loop

    LOAD_FAST       i
    LOAD_FAST       n
    COMPARE_OP      0
    POP_JUMP_IF_FALSE   >end_lines_loop

# Print the n-i spaces

    LOAD_FAST       n
    LOAD_FAST       i
    BINARY_SUBTRACT
    STORE_FAST      n_spaces

    LOAD_CONST      0
    STORE_FAST      j

@begin_spaces_loop

    LOAD_FAST       j
    LOAD_FAST       n_spaces
    COMPARE_OP      0
    POP_JUMP_IF_FALSE   >end_spaces_loop

    LOAD_FAST       put
    LOAD_CONST      ' '
    CALL_FUNCTION   1
    POP_TOP

    LOAD_FAST       j
    LOAD_CONST      1
    INPLACE_ADD
    STORE_FAST      j

    JUMP_ABSOLUTE   >begin_spaces_loop

@end_spaces_loop

# Print the i*2+1 stars

    LOAD_FAST       i
    LOAD_CONST      2
    BINARY_MULTIPLY
    LOAD_CONST      1
    BINARY_ADD
    STORE_FAST      n_stars

    LOAD_CONST      0
    STORE_FAST      j

@begin_stars_loop

    LOAD_FAST       j
    LOAD_FAST       n_stars
    COMPARE_OP      0
    POP_JUMP_IF_FALSE   >end_stars_loop

    LOAD_FAST       put
    LOAD_CONST      '*'
    CALL_FUNCTION   1
    POP_TOP

    LOAD_FAST       j
    LOAD_CONST      1
    INPLACE_ADD
    STORE_FAST      j

    JUMP_ABSOLUTE   >begin_stars_loop

@end_stars_loop

    LOAD_FAST       put
    LOAD_CONST      '\\n'
    CALL_FUNCTION   1
    POP_TOP

    LOAD_FAST       i
    LOAD_CONST      1
    INPLACE_ADD
    STORE_FAST      i

    JUMP_ABSOLUTE   >begin_lines_loop

@end_lines_loop

# Now print the foot of the Christmas Tree. (n spaces + '#' and a newline)

    LOAD_CONST      0
    STORE_FAST      i

@begin_foot_loop

    LOAD_FAST       i
    LOAD_FAST       n
    COMPARE_OP      0

    POP_JUMP_IF_FALSE   >end_foot_loop

    LOAD_FAST       put
    LOAD_CONST      ' '
    CALL_FUNCTION   1
    POP_TOP

    LOAD_FAST       i
    LOAD_CONST      1
    INPLACE_ADD
    STORE_FAST      i

    JUMP_ABSOLUTE   >begin_foot_loop

@end_foot_loop

    LOAD_FAST       put
    LOAD_CONST      '#\\n'
    CALL_FUNCTION   1
    RETURN_VALUE
"""

STACK_SIZE = 10


def get_index(lst, val):
    """Helper function: get the index of val in the lst.

    If val is not in lst, it is appended to it and its index is returned.

    """
    try:
        return lst.index(val)
    except ValueError:
        lst.append(val)
        return len(lst) - 1


def parse(code_lines, args):
    """Parse python pseudo-assembly code of a function.

    Params:
        code_lines: code as splitted lines.
        args: tuple giving the positional parameter names of the function.

    Returns:
        statements: a list of (offset, opcode_name, arg) tuples.
        var_names: the indexed list of local variable names used in the code.
        names: the indexed list of 'global' names used in the code.
        consts: the indexed list of constants used in the code.
        labels: a label -> byte offset mapping.

    """
    names = []
    consts = [None]
    var_names = list(args)
    labels = {}
    offset = 0
    statements = []

    for line in code_lines:
        line = line.strip()
        if not line or line.startswith('#'):
            continue
        if line.startswith('@'):
            labels[line[1:]] = offset
            continue
        opcode, *arg = line.split(maxsplit=1)
        if arg:
            arg = arg[0]
            if opcode in {'LOAD_FAST', 'STORE_FAST'}:
                arg = get_index(var_names, arg)
            elif opcode in {'IMPORT_NAME', 'LOAD_ATTR'}:
                arg = get_index(names, arg)
            elif opcode in {'LOAD_CONST'}:
                arg = get_index(consts, eval(arg))
            elif opcode in {'CALL_FUNCTION', 'COMPARE_OP'}:
                arg = eval(arg)

            statements.append((offset, opcode, arg))
            offset += 3
        else:
            statements.append((offset, opcode, None))
            offset += 1

    return statements, var_names, names, consts, labels


def resolve_addresses(statements, labels):
    """Replace :relative and >absolute args with their values."""
    for idx, elt in enumerate(statements):
        offset, opcode, arg = elt
        if not isinstance(arg, str):
            continue
        if arg.startswith(':'):
            rel_address = labels[arg[1:]] - offset - 3
            statements[idx] = (offset, opcode, rel_address)
        elif arg.startswith('>'):
            abs_address = labels[arg[1:]]
            statements[idx] = (offset, opcode, abs_address)


def dump_bytecode(statements):
    """Dump an list of (offset, opcode_name, arg) tuples to python bytecode."""
    op_arg = struct.Struct('<BH')
    op_no_arg = struct.Struct('B')
    return b''.join(
        (op_arg.pack(OPMAP[opcode], arg)
         if arg is not None else
         op_no_arg.pack(OPMAP[opcode])
         for _, opcode, arg in statements)
    )


def mk_func(code, name, args=(), stack_size=STACK_SIZE):
    """Assemble code to a Python function object."""
    statements, lvars, names, consts, labels = parse(code.splitlines(), args)
    resolve_addresses(statements, labels)
    bytecode = dump_bytecode(statements)

    code_obj = types.CodeType(
        len(args),      # argcount
        0,              # kwonlyargcount
        len(lvars),     # nlocals
        STACK_SIZE,     # stacksize
        0,              # flags
        bytecode,       # codestring
        tuple(consts),  # constants
        tuple(names),   # names
        tuple(lvars),   # varnames
        '<bytecode>',   # filename
        name,           # name (of the function)
        1,              # firstlineno
        b''             # lnotab

        # Too lazy to generate a valid lnotab, anyway the compiled function
        # WOULD NEVER throw an exception, right? As hardcore elite python
        # bytecode writers, we don't need this, as this is used only by the
        # poor souls who happen to write code with bugs in it.
    )
    return types.FunctionType(code_obj, globals())

if __name__ == '__main__':
    sapin = mk_func(CODE, 'sapin', ('n'))
    sapin(5)

import Enum
s=fn n->map flat_map(1..n,&([[32,n-&1],[?*,&1*2-1],[10,1]]))++[[32,n-1],[?#,1]],&apply(List,:duplicate,&1)end
IO.puts s.(String.to_integer hd System.argv)

Ｇ↗↘←Ｎ*Ｍ↓#