^{Inspiré par Affichez une chaîne de petites montagnes avec un nombre impair sur le dessus! par @sygmei .}

Pourquoi avoir une chaîne de montagnes alors que vous pouvez en avoir une énorme?

Créez un programme qui prend un numéro d'entrée et imprime une montagne avec chaque nombre impair jusqu'au numéro d'entrée.

(Où «sud-ouest» signifie directly below and to the leftet «sud-est» signifie directly below and to the right)

Chaque numéro aura un /sud-ouest et un \sud-est. Il part du 1haut et le numéro suivant ira au sud-ouest de a /ou au sud-est de a \. Le numéro suivant ira dans la ligne la plus proche du haut et la plus à gauche possible.

Pour un nombre à plusieurs chiffres, seul le 1er chiffre doit être au bon endroit avec les autres chiffres directement après, et seul le premier chiffre doit avoir \et /sortir de celui-ci.

La montagne jusqu'à 1 ou 2 est juste:

 1
/ \

Une montagne jusqu'à 3 ou 4, c'est juste:

   1
  / \
 3
/ \

Pour 25 ou 26:

         1
        / \
       3   5
      / \ / \
     7   9   11
    / \ / \ / \
   13  15  17  19
  / \ / \ / \ / \
 21  23  25
/ \ / \ / \

Deux dernières lignes où l'entrée est 121:

 111 113 115 117 119 121
/ \ / \ / \ / \ / \ / \

Et les deux dernières lignes où l'entrée est 1019:

 993 995 997 999 1001100310051007100910111013101510171019
/ \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \ / \

Vous pouvez supposer que l'entrée sera supérieure à 0 et inférieure à 10001 (exclusif).

Les espaces de fin sont OK, et les espaces de tête supplémentaires sont corrects tant qu'il y a le même sur toutes les lignes.

Il s'agit de code-golf , donc le programme le plus court en octets l'emporte.

Une réponse non gérée à cela peut être trouvée en ligne ici (en Python sur repl.it) si vous avez besoin de plus de cas de test.

05AB1E , 54 52 47 46 octets

ÅɹL£D€g__ÏRv"/ \ "yg×N·©úˆyvy4yg-ð×}J®>úˆ}¯R»

Essayez-le en ligne!

Explication

                                                # implicit input n
ÅÉ                                              # push a list of uneven numbers up to input
  ¹L£                                           # divide into sublists of length 1,2,3...n
     D€g__Ï                                     # remove empty sublists
           R                                    # reverse list
            v                                   # for each sublist
             "/ \ "                             # push the string "/ \ "
                   yg×                          # repeat it len(sublist) times
                      N·©ú                      # prepend (sublist index)*2 spaces
                          ˆ                     # add to global list
                           yv                   # for each number in sublist
                             y4yg-ð×            # prepend spaces until length is 4
                                    }           # end inner loop
                                     J          # join to string
                                      ®>ú       # prepend (sublist index)*2+1 spaces
                                         ˆ      # add to global list
                                          }     # end outer loop
                                           ¯    # push global list
                                            R   # reverse it
                                             »  # join rows by space and columns by newline
                                                # implicitly print

J'aurais pu économiser 5 octets avec ÅɹL£D€g__ÏRv"/ \ "yg×N·©úˆy4jJðÛ®>úˆ}¯R»seulement si j'avais poussé ce correctif pour j j'ai écrit il y a plusieurs semaines : /

Lot, 335 octets

@echo off
set i=
set/ac=w=0
:l
set i=  %i%
set/aw+=2,c+=w
if %c% lss %1 goto l
set s=
set t=
set/ac=w=1
for /l %%a in (1,2,%1) do call:c %%a
echo  %s%
echo%t%
exit/b
:c
if not %c%==0 goto g
echo%i%%s%
set i=%i:~2%
echo%i%%t%
set s=
set t=
set/aw+=1,c=w
:g
set n=%1   (three trailing spaces)
set s=%s%%n:~0,4%
set t=%t% / \
set/ac-=1

Python 2, 160 149 143 octets

^{Merci TFeld pour avoir économisé 11 octets et Artyer pour avoir économisé 6 octets}

x=range(1,input()+1,2);y=[];i=1
while x:y+=[''.join('%-4d'%j for j in x[:i]),'/ \ '*len(x[:i])];x=x[i:];i+=1
while y:print' '*~-len(y)+y.pop(0)

Perl, 134

133 octets + 1 pour l' -poption

 $l="/ \\ ";$t=" ";while($c++<$_) {$t.=sprintf'%-4d',$c++;$v.=$l;if ($i++>=$j){$t=~s/^/  /gm;$t.="
  $v
 ";$i=$v="";$j++}}$_="$t
$v";

Version formatée (la version golfée originale utilise de vraies "nouvelles lignes" au lieu de \ n)

$l="/ \\ ";
$t=" ";
while($c++<$_) {
   $t.=sprintf'%-4d',$c++;
   $v.=$l;
   if ($i++>=$j){
      $t=~s/^/  /gm;
      $t.="\n  $v\n ";
      $i=$v="";
      $j++
   }
}
$_="$t\n$v";

Bash, 425 octets

f() { k=0; o=""; l=1; for (( c=1; c<=$1; c++ )); do o="$o$c "; let c++ k++; if [ $l -eq $k ]; then o=$o"\n"; k=0; let l++; fi; done; s=$[$(echo -e $o | wc -l)*2-1]; p() { for c in $(seq $1); do echo -n " "; done }; IFS=$'\n'; for n in $(echo -e $o); do unset IFS; p $s; let s--; for w in $n; do echo -n "$w"; p $[4-${#w}]; done; echo; p $s; for c in $(seq $(echo $n|wc -w)); do echo -n "/ \ "; done; echo; let s-- j++; done }

Formaté:

l=1
k=0
o=""
for (( c=1; c<=$1; c++ ))
do
        o="$o$c "
        let c++ k++
        if [ $l -eq $k ]
        then
                o=$o"\n"
                k=0
                let l++
        fi
done
s=$[$(echo -e $o | wc -l)*2-1]
p() {
        for c in $(seq $1)
        do
                echo -n " "
        done
}
IFS=$'\n'
for n in $(echo -e $o)
do
        unset IFS
        p $s
        let s--
        for w in $n
        do
                echo -n "$w"
                p $[4-${#w}]
        done
        echo
        p $s
        for c in $(seq $(echo $n|wc -w))
                do echo -n "/ \ "
        done
        echo
        let s-- j++
done