La prima riga è composta da ceil(n/2)elementi in cui ogni elemento è:<space><odd-number><space>

La seconda riga è composta da ceil(n/2)elementi, ma ogni elemento è / \solo.

Puoi assumere n >= 0e n <= 10.

Esempi

Ingresso: 3

 1  3
/ \/ \

Ingresso: 10

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

Esempio in Python 3, 103 byte:

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

Il codice più corto in byte vince :)

05AB1E , 19 15 14 12 byte

05AB1E utilizza la codifica CP-1252 .
Salvati 4 byte grazie ad Adnan .
Salvato 2 byte grazie al carusocomputing

ÅÉðìDg…/ \×»

Provalo online!

Spiegazione

ÅÉ               # 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 byte

S2%idm+dJil*"/ \

Provalo qui!

17 byte e altro fantastico

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

Provalo qui!

Questo utilizza IMHO un algoritmo FANTASTICO per assicurarsi che la prima riga sia correttamente allineata.

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

Ciò sostituisce tutti i caratteri nell'elenco con stringhe con spazi. ~Bcontiene tutti i caratteri nel linguaggio Brain **** e questa è la prima volta che utilizzo questa variabile.

Il programma `~Bd.:fa questo:

`~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 byte

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

Piccolo trucco per la prima riga: non stampa i numeri pari, ma li prende come una stringa vuota, che porta all'inizio dello spazio vuoto (0 sarebbe lì) e raddoppia gli spazi tra i numeri senza alcuna modifica sull'intervallo, il rovescio della medaglia è uno spazio di testa nel numero pari n

Python 2 3, 67 65 63 60 byte

Niente di troppo folle qui, penso che la prima sezione possa essere probabilmente più breve ma non sono sicuro di come . Uso il fatto che in questo caso -~n/2funzionerà per ceil.

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

Di seguito sono riportate soluzioni alternative a 61 e 65 byte 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*'/ \\'

^{Grazie a Rod per aver salvato 2 byte e Artyer per aver salvato un altro byte cambiando versione :)}

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>

Nota lo spazio alla fine della seconda riga.

Python 2, 53 byte

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

Sfrutta la restrizione n <= 10per generare la riga superiore tagliando un pezzo da una stringa codificata.

Le uscite da 1 a 10 sono

 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
/ \/ \/ \/ \/ \

L'output per 0 è di due righe vuote.

Vim, 73 59 56 byte

Si tratta di un IMO con un numero di byte davvero elevato per quello che sembra un semplice problema. Sento che mi manca qualcosa di ovvio.

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

Provalo online!

Unprintables:

^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 byte

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

Funzione anonima. Accetta un numero come input e restituisce una stringa come output. I caratteri Unicode, rispettivamente, sono U + 2308 SINISTRA SOFFITTO per \[LeftCeiling]e U + 2309 DESTRA SOFFITTO per \[RightCeiling].

WinDbg, 100 byte

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

L'immissione viene effettuata impostando un valore nello pseudo-registro $t0.

Sembra che sia il più breve qui solo per stampare la stringa mentre viene costruita piuttosto che provare a costruirla per prima e visualizzare il tutto. Avrei una soluzione più breve se WinDbg mi permettesse di scrivere all'indirizzo 0.

Come funziona:

.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
}

Output per ogni valore di 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 byte

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

Incollalo in questo interprete online!

Il numero 5 sulla prima riga è il valore di input (codificato come 5, sostituito da 0-a o i per l'input dell'utente).

Modifica 1: spostato il posizionamento della nuova riga nello spazio della prima riga (era vuoto) per salvare 9 byte complessivi nello spazio da una nuova riga.

Modifica 2: come notato dall'utente7150406, l'output era errato (nessuna stampa di spazi), questo è stato corretto con una perdita di 8 byte.

Modifica 3: completamente cambiato la logica, non ha senso verificare se il numero è dispari - piuttosto mettere tutti i numeri in pila e rimuoverne ogni secondo. Byte salvato 13!

Java, 118 112 byte

Modifica: 6 byte salvati grazie a @peech

golfed:

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;  
}

test:

    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 byte

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;};

Lambda completa:

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 byte

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

Provalo!

-3 grazie a 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)

Dato che l'input è al massimo 10, chr(48+i)funzionerà al posto di string(i), sebbene il numero di byte sia lo stesso.

Leggibile:

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

Pyth, 24 22 byte

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

Grazie a 42545 (ETHproductions) per -1 byte

Interprete online

11 casi di test

> <> (Pesce) 52 63 62 byte

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

Provalo online!

Per usare semplicemente posto n in pila e via che vai!

Gran parte di questo è tratto dalla risposta di @ Teal-Pelican :).

Modifica: l'output in realtà non è allineato correttamente in entrambi gli invii> <>! Fissaggio...

Edit2: ho dovuto sacrificare alcuni byte, ma l'output è attualmente corretto.

Edit3: non più divertente con i \ /mirror e risparmio 1 byte.

Produzione:

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

C, 100 79 77 byte

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

R, 70 69 68 58 byte

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, 48, 45 byte

MODIFICARE:

• meno 3 byte (utilizzare $ 1 invece di STDIN)
• un altro byte spento sostituendolo -s ""con-s\
• meno 2 byte sostituendo printf con seq -f (Grazie @Adam!)
• refactored allo script anziché alla funzione (per battere > <> )
• rimosso gli spazi superflui
• ottimizzato un po 'l'espressione sed

golfed

Chunk (45 byte):

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

Funzione (versione originale) (57 byte):

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

Test

--- 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 byte

Provalo online!

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

Ruby 82 60 byte

La soluzione Ruby rapida e sporca potrebbe sicuramente essere ottimizzata meglio se fossi meglio con Ruby

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

Utilizzo: prog.rb 10
Output:

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

modifica: numerose modifiche e ottimizzazioni di @Manatwork!

JavaScript (ES6), 66 64 byte

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

Crea ricorsivamente la prima riga, quindi aggiunge la seconda. La prima riga è costruita con l'osservazione che è semplicemente l'intervallo [0 ... n] con ogni elemento n trasformato in uno spazio se pari o n concatenato con uno spazio se dispari.

Python 2, 60 byte

6 byte salvati grazie a @Kade!

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

Lotto, 107 byte

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

(? :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
        )

Rubino, 48 byte

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

Ottava, 45 byte

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

Test:
f (8)

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

QBIC , 35 byte

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

Spiegazione:

:           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 byte

$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 byte

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

usando:

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

O 52 byte:

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

usando:

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