Die erste Zeile besteht aus ceil(n/2)Elementen, bei denen jedes Element:<space><odd-number><space>

Die zweite Zeile besteht aus ceil(n/2)Elementen, aber jedes Element ist / \nur eines.

Sie können n >= 0und annehmen n <= 10.

Beispiele

Eingabe: 3

 1  3
/ \/ \

Eingabe: 10

 1  3  5  7  9
/ \/ \/ \/ \/ \

Beispiel in Python 3, 103 Bytes:

lambda a:print("".join([" "+str(i)+" "for i in range(1,a+1,2)]+["\n"]+["/ \\"for i in range(1,a+1,2)]))

Kürzester Code in Bytes gewinnt :)

05AB1E , 19 15 14 12 Bytes

05AB1E verwendet die CP-1252- Codierung.
4 Bytes gespart dank Adnan .
2 Bytes dank Carusocomputing gespart

ÅÉðìDg…/ \×»

Probieren Sie es online!

Erläuterung

ÅÉ               # list of uneven number up to input
  ðì             # prepend a space to each
    Dg           # get length of list
      …/ \       # push the string "/ \"
          ×      # repeat the string length-list times
           »     # join rows by spaces and columns by newlines

Pyke, 16 Bytes

S2%idm+dJil*"/ \

Probieren Sie es hier aus!

17 Bytes und mehr genial

S2%i`~Bd.:il*"/ \

Probieren Sie es hier aus!

Dies verwendet IMHO einen AWESOME-Algorithmus, um sicherzustellen, dass die erste Zeile korrekt ausgerichtet ist.

S                 - range(1, input+1)
 2%               -  ^[::2]
   i              -   i = ^
    `             -    str(^)
     ~Bd.:        -     ^.translate("><+-.,[]", " ") <-- awesome bit here
          il      -  len(i)
            *"/ \ - ^ * "/ \"

Dadurch werden alle Zeichen in der Liste mit Zeichenfolgen durch Leerzeichen ersetzt. ~Benthält alle Zeichen in der Sprache Brain **** und dies ist das erste Mal, dass ich diese Variable verwende.

Das Programm `~Bd.:macht das:

`~Bd.: - input = [1, 3, 5, 7]
`      - str(input)  # stack now ["[1, 3, 5, 7]"]
 ~B    - "><+-.,[]"  # stack now ["[1, 3, 5, 7]", "><+-.,[]"]
   d   - " "         # stack now ["[1, 3, 5, 7]", "><+-.,[]", " "]
    .: - translate() # stack now [" 1  3  5  7 "]

Python 2, 63 Bytes

lambda n:' '.join(n%2*`n`for n in range(n+1))+'\n'+-~n/2*'/ \\'

Kleiner Trick für die erste Zeile: Sie gibt keine geraden Zahlen aus, sondern nimmt sie als leere Zeichenfolge, was dazu führt, dass ein leeres Leerzeichen (0 wäre da) und doppelte Leerzeichen zwischen den Zahlen ohne Änderung des Bereichs beginnt. Der Nachteil ist ein führendes Feld in der geraden Zahl n

Python 2 3, 67 65 63 60 Bytes

Hier ist nichts zu verrückt, ich denke, der erste Abschnitt kann wahrscheinlich kürzer gemacht werden, aber ich bin nicht ganz sicher, wie . Ich nutze die Tatsache, dass in diesem Fall -~n/2funktionieren wird ceil.

lambda n:-~n//2*' %d '%(*range(1,n+1,2),)+'\n'+-~n//2*'/ \\'

Nachfolgend finden Sie alternative 61- und 65-Byte-Lösungen in Python 2:

lambda n:-~n/2*' %d '%tuple(range(1,n+1,2))+'\n'+-~n/2*'/ \\'
lambda n:' '+'  '.join(map(str,range(1,n+1,2)))+'\n'+-~n/2*'/ \\'

^{Vielen Dank an Rod für das Speichern von 2 Bytes und Artyer für das Speichern eines weiteren Bytes durch Versionswechsel :)}

JavaScript (ES6), 55 Byte

f=n=>n%2?f(n-1).replace(`
`,` ${n} 
/ \\`):n?f(n-1):`
`

<input type=number min=1 max=10 oninput=o.textContent=f(this.value)><pre id=o>

Beachten Sie das Leerzeichen am Ende der zweiten Zeile.

Python 2, 53 Bytes

lambda n:" 1  3  5  7  9"[:-~n/2*3]+'\n'+-~n/2*"/ \\"

Nutzt die Einschränkung n <= 10, um die oberste Zeile zu generieren, indem ein Teil einer fest codierten Zeichenfolge abgeschnitten wird.

Die Ausgänge für 1 bis 10 sind

 1 
/ \
 1 
/ \
 1  3 
/ \/ \
 1  3 
/ \/ \
 1  3  5 
/ \/ \/ \
 1  3  5 
/ \/ \/ \
 1  3  5  7 
/ \/ \/ \/ \
 1  3  5  7 
/ \/ \/ \/ \
 1  3  5  7  9
/ \/ \/ \/ \/ \
 1  3  5  7  9
/ \/ \/ \/ \/ \

Die Ausgabe für 0 besteht aus zwei Leerzeilen.

Vim, 73 59 56 Bytes

Dies ist eine IMO mit sehr vielen Bytes für ein scheinbar einfaches Problem. Mir fehlt offensichtlich etwas.

caw="/2*2
caw1357911/"
DYp:s;.;/ \\;g
k:s// & /g

Probieren Sie es online!

Unbedruckbares:

^Acaw^R=^R"/2*2      # Transform a number into the next odd number (3->5,4>5)
^[^Acaw1357911^[/^R" # Insert 1357911, delete everything after the number above
DYp:s;.;/ \\;g       # Duplicate the line, replace numbers with / \
k:s// & /g           # On the line above, add spaces around numbers
<trailing newline>

Mathematica, 65 Bytes

" "<>Range[1,#,2]~StringRiffle~"  "<>"
"<>"/ \\"~Table~⌈#/2⌉&

Anonyme Funktion. Nimmt eine Zahl als Eingabe und gibt eine Zeichenfolge als Ausgabe zurück. Die Unicode-Zeichen lauten U + 2308 LEFT CEILING für \[LeftCeiling]und U + 2309 RIGHT CEILING für \[RightCeiling].

WinDbg, 100 Bytes

.echo;.for(r$t1=1;@$t1<=2*@$t0+@$t0%2;r$t1=@$t1+2){j@$t1<=@$t0 .printf"\b %d \n",@$t1;.printf"/ \\"}

Die Eingabe erfolgt durch Setzen eines Wertes im Pseudoregister $t0 .

Es sieht so aus, als wäre es hier am kürzesten, den String während des Aufbaus auszudrucken, anstatt ihn zuerst aufzubauen und das Ganze anzuzeigen. Ich hätte eine kürzere Lösung, wenn WinDbg mich an die Adresse schreiben lassen würde0 .

Wie es funktioniert:

.echo;                                            * Print a new line that'll be deleted
.for(r$t1=1; @$t1 <= 2*@$t0+@$t0%2; r$t1=@$t1+2)  * Enumerate 1 to 4*ceil($t0/2), count by 2
{
    j@$t1<=@$t0                                   * If $t1 <= $t0...
        .printf"\b %d \n",@$t1;                   * ...Print $t1 (and newline for last n)
        .printf"/ \\"                             * ...Else print the / \'s
}

Ausgabe für jeden Wert von n:

0:000> .for(r$t0=0;b>@$t0;r$t0=@$t0+1){.printf"\n\nn=%d\n",@$t0; .echo;.for(r$t1=1;@$t1<=2*@$t0+@$t0%2;r$t1=@$t1+2){j@$t1<=@$t0 .printf"\b %d \n",@$t1;.printf"/ \\"}}


n=0



n=1
 1 
/ \

n=2
 1 
/ \

n=3
 1  3 
/ \/ \

n=4
 1  3 
/ \/ \

n=5
 1  3  5 
/ \/ \/ \

n=6
 1  3  5 
/ \/ \/ \

n=7
 1  3  5  7 
/ \/ \/ \/ \

n=8
 1  3  5  7 
/ \/ \/ \/ \

n=9
 1  3  5  7  9 
/ \/ \/ \/ \/ \

n=10
 1  3  5  7  9 
/ \/ \/ \/ \/ \

> <> (FISH), 69 60 68 55 Bytes

5|v&+%1:,2
1->:?!v:
8~v!?l<on$o:*4
a&/o
1->:?!;"\ /"ooo

Fügen Sie es in diesen Online-Dolmetscher ein!

Die Zahl 5 in der ersten Zeile ist Ihr Eingabewert (fest codiert als 5, ersetzt durch 0-a oder i für Benutzereingaben).

Bearbeiten 1: Neue Zeilenposition in den ersten Zeilenbereich verschoben (war leer), um insgesamt 9 Byte Platz aus einer neuen Zeile zu sparen.

Edit 2: Wie von user7150406 bemerkt, war die Ausgabe falsch (es werden keine Leerzeichen gedruckt). Dies wurde mit einem Verlust von 8 Bytes behoben.

Edit 3: Die Logik wurde komplett geändert. Es macht keinen Sinn, zu überprüfen, ob die Zahl ungerade ist. Legen Sie stattdessen alle Zahlen auf den Stapel und entfernen Sie jede zweite. Byte gespeichert 13!

Java, 118 112 Bytes

Bearbeiten: 6 Bytes dank @peech gespeichert

Golf gespielt:

String M(int n){String o=" ";int i=1;n+=1;for(;i<n;i+=2)o+=i+"  ";o+="\n";for(i=0;i<n/2;i++)o+="/ \\";return o;}

Ungolfed:

public String M(int n)
{
    String o = " ";
    int i=1;
    n += 1;
    for (; i < n;i+=2)
        o += i + "  ";
    o += "\n";
    for (i = 0; i < n/2; i++)
        o += "/ \\";
    return o;  
}

Testen:

    OddMountains om = new OddMountains();
    System.out.println(om.M(1));
    System.out.println();
    System.out.println(om.M(3));
    System.out.println();
    System.out.println(om.M(5));
    System.out.println();
    System.out.println(om.M(7));
    System.out.println();
    System.out.println(om.M(10));

 1  
/ \

 1  3  
/ \/ \

 1  3  5  
/ \/ \/ \

 1  3  5  7  9  
/ \/ \/ \/ \/ \

C # 6, 95 Bytes

n=>{var o="";int i=1;for(;i<=n;i+=2)o+=$" {i} ";o+='\n';for(i=1;i<=n;i+=2)o+="/ \\";return o;};

Volles Lambda:

Func<int, string> a = n=>
{
    var o="";int i=1;
    for(;i<=n;i+=2)
        o+=$" {i} ";
    o+='\n';
    for(i=1;i<=n;i+=2)
        o+="/ \\";
    return o;
};

CJam, 26 23 Bytes

Sri,:)2%_S2**N@,"/ \\"*

Probier es aus!

-3 danke an 8478 (Martin Ender)

Game Maker Language (GM 8.0), 97 Byte

m=ceil(argument0/2)e=""for(i=1;i<2*m;i+=2)e+=" "+string(i)+" "return e+"#"+string_repeat("/ \",m)

Vorausgesetzt, dass die Eingabe höchstens 10 ist, chr(48+i)funktioniert anstelle von string(i), obwohl die Anzahl der Bytes gleich ist.

Lesbar:

m = ceil(argument0/2)
e = ""
for (i = 1; i < 2*m; i += 2 )
  e += " " + string(i) + " "
return e + "#" + string_repeat("/ \", m)

Pyth, 24 22 Bytes

K-SQyMS5+dj*2dK*lK"/ \

Danke an 42545 (ETHproductions) für -1 Byte

Online-Dolmetscher

11 Testfälle

> <> (Fisch) 52 63 62 Bytes

<v!?:-1:!?-1%2:
 >~la}}" "72.
v!?-2lno<o"  "
o
>:?!;"\ /"ooo1-

Probieren Sie es online!

Einfach platzieren n auf den Stapel und los geht's!

Ein Großteil davon stammt aus der Antwort von @ Teal-Pelican :).

Bearbeiten: Die Ausgabe ist in beiden Übermittlungen nicht richtig ausgerichtet! Festsetzung...

Edit2: Ich musste einige Bytes opfern, aber die Ausgabe ist jetzt tatsächlich korrekt.

Edit3: Kein Spaß mehr mit \ /Spiegeln und ich spare 1 Byte.

Ausgabe:

 1  3  5  7  9
/ \/ \/ \/ \/ \

C 100 79 77 Bytes

#define P(s)for(i=0;i++<n;printf(s,i++));puts("");
i;f(n){P(" %d ")P("/ \\")}

R 70 69 68 58 Bytes

cat(paste("",z<-seq(,scan(),2)),"\n");for(i in z)cat("/ \\")

3:
#>  1  3 
#> / \/ \

10:
#>  1  3  5  7  9 
#> / \/ \/ \/ \/ \

Bash, 64, 59, 57, 51, 49, 4845 Bytes

BEARBEITEN:

• minus 3 Bytes (benutze $ 1 anstelle von STDIN)
• ein weiteres Byte durch Ersetzen -s ""durch-s\
• minus 2 Bytes durch Ersetzen von printf durch seq -f (Danke @Adam!)
• Skript statt Funktion überarbeitet (um die > <> zu schlagen )
• überflüssige Leerzeichen entfernt
• den sed ausdruck etwas optimiert

Golf gespielt

Chunk (45 Byte):

seq -f" %g " -s\  1 2 $1|sed 'p;s| . |/ \\|g'

Funktion (Originalversion) (57 Bytes):

M() { printf " %s %.0s" `seq 1 $1`|sed 'p;s| . |/ \\|g';}

Prüfung

--- mountains.sh ----
#!/bin/bash
seq -f" %g " -s\  1 2 $1|sed 'p;s| . |/ \\|g'

>./mountains.sh 10
 1  3  5  7  9 
/ \/ \/ \/ \/ \

>M 10
 1  3  5  7  9 
/ \/ \/ \/ \/ \

Befunge 93 , 64 Bytes

Probieren Sie es online!

 &61p1   v+2,,,"/ \"
_v#!`" ":<+2.," ":
 <^p00p10"|<"
@ >91+,$1v

Ruby 82 60 Bytes

Schnelle und schmutzige Ruby-Lösung könnte definitiv besser optimiert werden, wenn ich mit Ruby besser wäre

puts "",1.step($*[0].to_i,2).map{|x|$><<" #{x} ";"/ \\"}*""

Verwendung: prog.rb 10
Ausgabe:

 1  3  5  7  9
/ \/ \/ \/ \/ \

edit: zahlreiche bearbeitungen und optimierungen von @Manatwork!

JavaScript (ES6), 66 64 Bytes

n=>(f=n=>n?f(n-1)+(n%2?n+s:s):s=" ")(n)+`
`+"/ \\".repeat(++n/2)

Erstellt rekursiv die erste Zeile und hängt dann die zweite an. Die erste Zeile wird mit der Beobachtung erstellt, dass es sich einfach um den Bereich [0 ... n] handelt, bei dem jedes Element n in ein Leerzeichen umgewandelt wird, wenn es gerade ist, oder n mit einem Leerzeichen verkettet wird, wenn es ungerade ist.

Python 2, 60 Bytes

6 Bytes gespart dank @Kade!

lambda s:" "+"  ".join(`range(s+1)`[4::6])+"\n"+-~s/2*"/ \\"

Batch, 107 Bytes

@set s=
@set t=
@for /l %%i in (1,2,%1)do @call set s=%%s%%  %%i&call set t=%%t%%/ \
@echo%s%
@echo %t%

Scala, 99 95 Bytes

(? :Int)=>for(i<-0 to 1)println(1 to ?filter(c=>c%2>0)map(c=>if(i<1)s" $c "else"/ \\")mkString)

Ungolfed

(? :Int) => 
    for (i<-0 to 1)
        println(
            1 to ?filter(c=>c%2>0)
                  map(c=>if(i<1)s" $c "else"/ \\")
                  mkString
        )

Ruby, 48 Bytes

->x{" 1  3  5  7  9 "[0..3*x-=x/2]+?\n+"/ \\"*x}

Oktave, 45 Bytes

f=@(n)reshape(sprintf(' /%d \',1:2:n),2,[]);

Test:
f (8)

 1  3  5  7
/ \/ \/ \/ \

QBIC , 35 Bytes

:[1,a,2|X=X+!b$+@ | Y=Y+@/ \|]?X ?Y

Erläuterung:

:           gets a CMD line param as INT 'a'
[1,a,2|     FOR b = 1 to a STEP 2
X=X+!b$+@ | Add to X$ the counter of our FOR loop and a trailing space
            Leading space is provided by the cast-to-string function.
Y=Y+@/ \|   Add to Y$ the mountain.
]           Close the first possible language construct (IF, DO or FOR). In this case: NEXT
?X ?Y       Print X$, Print Y$. The space adds a newline in the resulting QBASIC.

Kitanai , 140 Bytes

$0[0]$1[int(input":")]$2[""]$3[""]$0#?(mod@2)($2[add(add(@" ")(string($0@)))"  "]
$3[add@"/ \"])?(neq@($1@))([add@1]&1)print($2@)print($3@)%

Perl, 46 + 2 ( -plFlag) = 48 Bytes

@_=map$_%2?$_:"",0..$_;$_="@_$/"."/ \\"x(@_/2)

Verwenden von:

perl -ple '@_=map$_%2?$_:"",0..$_;$_="@_$/"."/ \\"x(@_/2)' <<< 7    

Oder 52 Bytes:

@_=map$_%2?$_:"",0..pop;print"@_$/","/ \\"x(@_/2),$/

Verwenden von:

perl -e '@_=map$_%2?$_:"",0..pop;print"@_$/","/ \\"x(@_/2),$/' 7