La primera línea está hecha con ceil(n/2)elementos donde cada elemento es:<space><odd-number><space>

La segunda línea está hecha con ceil(n/2)elementos, pero cada elemento es / \solo.

Puedes asumir n >= 0y n <= 10.

Ejemplos

Entrada: 3

 1  3
/ \/ \

Entrada: 10

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

Ejemplo en 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)]))

El código más corto en bytes gana :)

05AB1E , 19 15 14 12 bytes

05AB1E utiliza la codificación CP-1252 .
Guardado 4 bytes gracias a Adnan . Ahorro de
2 bytes gracias a carusocomputing

ÅÉðìDg…/ \×»

Pruébalo en línea!

Explicación

ÅÉ               # 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*"/ \

Pruébalo aquí!

17 bytes y más impresionante

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

Pruébalo aquí!

Esto usa en mi humilde opinión un algoritmo IMPRESIONANTE para asegurarse de que la primera línea esté correctamente alineada.

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

Esto reemplaza todos los caracteres en la lista de cadenas con espacios. ~Bcontiene todos los caracteres en el lenguaje Brain **** y esta es la primera vez que uso esta variable.

El programa `~Bd.:hace esto:

`~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*'/ \\'

Pequeño truco para la primera línea: no imprime los números pares, sino que los toma como una cadena vacía, lo que lleva al inicio del espacio vacío (0 estaría allí), y espacios dobles entre los números sin ninguna modificación en el rango, La desventaja es un espacio líder en el número par n

Python 2 3, 67 65 63 60 Bytes

Nada demasiado loco aquí, creo que la primera sección probablemente se puede hacer más corta, pero no estoy muy seguro de cómo . Utilizo el hecho de que en este caso -~n/2funcionará ceil.

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

A continuación se presentan soluciones alternativas de 61 y 65 bytes en 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*'/ \\'

^{Gracias a Rod por guardar 2 bytes y Artyer por guardar otro byte cambiando la versión :)}

JavaScript (ES6), 55 bytes

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>

Tenga en cuenta el espacio al final de la segunda línea.

Python 2, 53 bytes

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

Aprovecha la restricción n <= 10para generar la línea superior cortando una pieza de una cadena codificada.

Las salidas para 1 a 10 son

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

La salida para 0 es dos líneas vacías.

Vim, 73 59 56 bytes

Este es un IMO de conteo de bytes realmente alto para lo que parece un problema simple. Siento que me falta algo obvio.

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

Pruébalo en línea!

No imprimibles

^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⌉&

Función anónima. Toma un número como entrada y devuelve una cadena como salida. Los caracteres Unicode, respectivamente, son U + 2308 TECHO IZQUIERDO para \[LeftCeiling]y U + 2309 TECHO DERECHO para \[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"/ \\"}

La entrada se realiza estableciendo un valor en el pseudo-registro $t0.

Parece que es más corto aquí solo para imprimir la cadena a medida que se está construyendo en lugar de intentar construirla primero y mostrar todo. Tendría una solución más corta si WinDbg me dejara escribir a la dirección 0.

Cómo funciona:

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

Salida para cada valor de 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 
/ \/ \/ \/ \/ \

> <> (PESCADO), 69 60 68 55 bytes

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

¡Pégalo en este intérprete en línea!

El número 5 en la primera línea es su valor de entrada (codificado como 5, reemplazado por 0-ao i para la entrada del usuario).

Edición 1: movió la nueva ubicación de línea en el espacio de la primera línea (estaba vacío) para ahorrar 9 bytes en general en el espacio de una nueva línea.

Edición 2: como lo señaló el usuario7150406, la salida fue incorrecta (sin espacios de impresión), esto se ha solucionado con una pérdida de 8 bytes.

Edición 3: cambió completamente la lógica, no tiene sentido verificar si el número es impar, en lugar de colocar todos los números en la pila y eliminar cada segundo. Byte guardado 13!

Java, 118 112 bytes

Editar: Guardado 6 Bytes gracias a @peech

Golfizado:

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

Sin golf:

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

Pruebas:

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

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 bytes

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

¡Pruébalo!

-3 gracias a 8478 (Martin Ender)

Game Maker Language (GM 8.0), 97 bytes

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

Dado que la entrada es como máximo 10, chr(48+i)funcionará en lugar de string(i), aunque el número de bytes es el mismo.

Legible:

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

Gracias a 42545 (ETHproductions) por -1 byte

Intérprete en línea

11 casos de prueba

> <> (Pescado) 52 63 62 bytes

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

Pruébalo en línea!

Para usar simplemente lugar n en la pila y ¡listo!

Gran parte de esto está tomado de la respuesta de @ Teal-Pelican :).

Editar: ¡La salida en realidad no está alineada correctamente en>> envío! Fijación...

Edit2: tuve que sacrificar algunos bytes, pero la salida es realmente correcta ahora.

Edit3: No más diversión con \ /espejos y guardo 1 byte.

Salida:

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

Golpetazo, 64, 59, 57, 51, 49, 48, 45 bytes

EDITAR:

• menos 3 bytes (use $ 1 en lugar de STDIN)
• un byte más reemplazado -s ""por-s\
• menos 2 bytes reemplazando printf con seq -f (¡Gracias @Adam!)
• refactorizado a script en lugar de función (para vencer a > <> )
• espacios superfluos eliminados
• optimizado un poco la expresión sed

Golfed

Trozo (45 bytes):

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

Función (versión original) (57 bytes):

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

Prueba

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

Pruébalo en línea!

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

Ruby 82 60 Bytes

La solución rápida y sucia de Ruby definitivamente podría optimizarse mejor si fuera mejor con Ruby

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

Uso: prog.rb 10
Salida:

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

editar: numerosas ediciones y optimizaciones de @Manatwork!

JavaScript (ES6), 66 64 bytes

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

Recursivamente construye la primera línea, luego agrega la segunda. La primera línea se construye con la observación de que es simplemente el rango [0 ... n] con cada elemento n transformado en un espacio si es par, o n concatenado con un espacio si es impar.

Python 2, 60 bytes

¡Guardado 6 bytes gracias a @Kade!

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

Lote, 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)

Sin golf

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

Octava, 45 bytes

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

Prueba:
f (8)

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

QBIC , 35 bytes

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

Explicación:

:           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 ( -plbandera) = 48 bytes

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

Utilizando:

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

O 52 bytes:

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

Utilizando:

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