^{Inspiriert von Display eine Kette kleiner Berge mit einer ungeraden Zahl oben drauf! von @sygmei .}

Warum eine Bergkette, wenn Sie eine massive haben können?

Erstellen Sie ein Programm, das eine eingegebene Nummer verwendet und einen Berg mit jeder ungeraden Nummer bis zur eingegebenen Nummer druckt.

(Wo "Südwesten" bedeutet directly below and to the leftund "Südosten" bedeutet directly below and to the right)

Jede Zahl wird einen /Südwesten und einen \Südosten haben. Es beginnt 1oben und die nächste Nummer geht südwestlich von a /oder südöstlich von a \. Die nächste Zahl steht in der Zeile, die am nächsten und am weitesten links liegt.

Bei einer mehrstelligen Nummer muss nur die erste Ziffer an der richtigen Stelle mit den anderen Ziffern direkt danach stehen, und nur die erste Ziffer sollte diese haben \und /daraus hervorgehen.

Der Berg bis 1 oder 2 ist nur:

 1
/ \

Ein Berg bis zu 3 oder 4 ist nur:

   1
  / \
 3
/ \

Für 25 oder 26:

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

Letzte zwei Zeilen, in denen die Eingabe 121 ist:

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

Und die letzten beiden Zeilen, in denen die Eingabe 1019 ist:

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

Sie können davon ausgehen, dass die Eingabe größer als 0 und kleiner als 10001 ist (exklusiv).

Nachgestellte Leerzeichen sind in Ordnung, und zusätzliche führende Leerzeichen sind in Ordnung, solange sie in allen Zeilen gleich sind.

Dies ist Code-Golf , also gewinnt das kürzeste Programm in Bytes.

Eine ungolfed Antwort darauf finden Sie online hier (In Python auf repl.it), wenn Sie weitere Testfälle benötigen.

05AB1E , 54 52 47 46 Bytes

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

Probieren Sie es online aus!

Erläuterung

                                                # 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

Ich hätte 5 Bytes sparen können, ÅɹL£D€g__ÏRv"/ \ "yg×N·©úˆy4jJðÛ®>úˆ}¯R»wenn ich nur diesen Bugfix für j gepusht hätte, den ich vor einigen Wochen geschrieben habe : /

Stapel, 335 Bytes

@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 Bytes

^{Vielen Dank an TFeld für das Speichern von 11 Bytes und Artyer für das Speichern von 6 Bytes}

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 Bytes + 1 für -pOption

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

Formatierte Version (Original-Golfversion verwendet echte "neue Linien" anstelle von \ 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 Bytes

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 }

Formatiert:

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