¡Muestra una cadena de pequeñas montañas con un número impar en la parte superior!

19

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

code-golf string ascii-art Sygmei
fuente
3
¿Se puede suponer que todas las entradas serán inferiores a 11?
Azul el
Sí, todas las entradas serán menos de 11!
Sygmei
8
Bienvenido al sitio! Nuestro valor predeterminado para code-golf es contar en bytes, no en caracteres. Sin embargo, si desea anular eso, es su elección. Además, recomendaría el Sandbox la próxima vez :)
Erik the Outgolfer el
Quise decir bytes tienes razón! ¿Hay un buen contador de bytes?
Sygmei
1
¿Qué tan específicamente tenemos que manejar los espacios en blanco? Dices que cada elemento es <space><odd-number><space>, pero los casos de prueba no tienen un espacio después del último número impar. ¿Es opcional? Además, ¿es la salida para n=0dos líneas vacías?
xnor

Respuestas:

12

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
Emigna
fuente
¿Cuánto tiempo ha Ïexistido? Eso parece súper útil.
Urna mágica de pulpo
2
@carusocomputing Mucho tiempo: p
Adnan
2
LDÉÏes lo mismo ÅÉy „ ýðìpuede ser reemplazado por ðì)»:).
Adnan
2
Puedes eliminar el ), ¿no?
Urna de pulpo mágico
3
ÅÉðìDg…/ \×»utiliza en Dglugar de ¹;îotro byte guardar también.
Urna de pulpo mágico
11

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 "]
Azul
fuente
... esto es ... simplemente increíble? Sabes que acabas de vencer a 05AB1E y a todos, ¿verdad?
Erik the Outgolfer el
He intentado Jelly; seguramente será mucho más largo.
Erik the Outgolfer el
"
Usé el juego de
Esto es realmente inteligente :) Bien hecho
Sygmei
@ErikGolfer エ リ ッ ク ゴ ル フ ァ ー No vencer a 05AB1E más.
boboquack
6

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

varilla
fuente
6

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

Kade
fuente
Si se muda a Python 3, puede reemplazarlo %(tuple(...))con %[*...], pero tendría que hacerlo-~n//2
Artyer el
@Artyer Intentó esto, pero arroja un montón de errores. Yo creo que tendría que fundido rangea una lista de 3 a causa rangees como Python 2 de xrange.
Kade
también puedes soltar los paréntesis que rodean eltuple()
Rod
Puedes hacer (*<iterable>,)para lanzar a tupla en Python 3. Esto ahorra 1 byte después de que te conviertas n/2en n//2Python 3.
Artyer
@ Rod y Artyer muchas gracias! :)
Kade
6

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

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

Neil
fuente
Dangit, pensé que .replacepodría ser mejor, pero no me molesté en comprobarlo ...
ETHproductions
La pregunta dice "que puede suponer ..."
Salomón Ucko
1
@SolomonUcko El HTML no es parte de la respuesta, simplemente sirve para demostrar su funcionamiento. Como tal, también podría limitar el valor a entre 1 y 10, ya que el resultado no sería válido de lo contrario.
Neil
Veo. De lo contrario, tendría que determinar el espacio correcto
Solomon Ucko el
5

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.

xnor
fuente
5

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>
nmjcman101
fuente
¡Agradable, siempre voté vim! Sin embargo, los caracteres no imprimibles también cuentan como bytes, por lo que esta solución realmente es de 73 bytes. ¡Lo siento por eso!
DJMcMayhem
Sin embargo, tengo algunos consejos. 1) Si usa un separador diferente en su comando sustituto, no necesitará escapar de la barra diagonal, para que pueda hacerlo :s;.;/ \\;g. 2) en su segundo comando sustituto, puede dejar la búsqueda vacía y usará su última búsqueda (que resulta ser la misma). Además, &es equivalente a \0y un byte más corto. Así que obtienes:s// & /g
DJMcMayhem
¡Gracias! Esperaba ver una respuesta V tuya para ver si usaste un enfoque diferente para menos bytes, ¡pero está bien! Creo que el primer comentario es una función en la que me olvido de actualizar el enlace Pruébelo en línea. El segundo me dio 3 bytes, ¡así que gracias!
nmjcman101
4

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

LegionMammal978
fuente
4

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 
/ \/ \/ \/ \/ \
Leche
fuente
4

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

Pelícano verde azulado
fuente
4

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  
/ \/ \/ \/ \/ \
Pete Arden
fuente
Ahhhh, me has superado :) También quería publicar una respuesta Java. de todos modos, aquí hay algunas sugerencias para jugar al golf un poco más: no necesita inicializar ien su primer bucle for, podría verse así for(; i < n; i++). Puedes jugarlo aún más con este cambio: los o += i + " ";cambios en o += i++ + " ";y para loop se convierten for(; i < n; ). Eso es si quieres mantener la declaración if. Puede cambiar su incremento de i a i += 2 y eliminar la declaración if completa, pero en ese caso mi segunda proposición no se aplica :) (ps: no
he
@peech Si te sirve de consuelo, normalmente es una carrera para mí obtener la primera respuesta de C #. Si eso no funciona, voy a buscar una respuesta de Java :) Gracias por los consejos. Eliminé la iinicialización del forbucle, pero las otras cosas lo atraparon en un bucle. Puede que necesite jugar un poco más :)
Pete Arden
Eh, estoy tan contento de que en mi comentario anterior dije "no he probado esto" ... por supuesto, no funciona con o += i++ + " ";:). Por cierto, usted tiene un pequeño error en su código :) ya que Java utiliza floor()en la división entera (4/3 = 1), debe hacerlo de esta manera: int i = 1; n += 1; for (; i < n; i += 2) { ... jada jada ... }. si incrementa i i += 2, no necesita eso si el estado de cuenta verifica la paridad. También guarda otros 3 bytes :) pruébelo aquí: ideone.com/ekaUUH
peech
@peech Si alguien tiene la confianza suficiente para corregir mi código, supongo que debe ser correcto, así que cuando no funciona, lo intento una y otra vez, pensando "debo ser yo ..." :) ¡No se preocupe! Gracias por los consejos: descubrí la floorpeculiaridad de la división cuando jugué con Java hace unos días :)
Pete Arden
3

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;
};
Yodle
fuente
3

CJam, 26 23 bytes

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

¡Pruébalo!

-3 gracias a 8478 (Martin Ender)

Erik el Outgolfer
fuente
Puede guardar 3 bytes evitando parte de la manipulación de la pila:Sri,:)2%_S2**N@,"/ \\"*
Martin Ender
@MartinEnder Oh, por eso no pude eliminar eso +. Y lo juro, ¡realmente lo usé ed! ... más corto que Pyth.
Erik the Outgolfer el
3

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)
u54112
fuente
3

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

Erik el Outgolfer
fuente
Ahorre una cotización con*lK"/ \\
ETHproductions
@ETHproductions Puede usar en \lugar de \\:)
Erik the Outgolfer
3

> <> (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
/ \/ \/ \/ \/ \
redstarcoder
fuente
Gracias por detectar el error en la impresión, estoy editando mi respuesta ahora (bastante trivial para la mía). Es interesante ver que la respuesta base es la misma pero se guardan muchos bytes.
Teal pelican
No hay problema, ¡me alegró ver una presentación> <>! Será interesante ver cuál termina siendo más pequeño ahora, ya que estos cambios me duelen bastante, jaja.
Redstarcoder
Parece que soy juuuust 5 bytes más pequeño: p.
Redstarcoder
Voy a echar otro vistazo a la mía ahora para ver si puedo exprimir algunos bytes de mote aha.
Teal pelican
1
Llegué a casa y tuve una idea de una nueva forma de hacerlo. ¡Mi nueva respuesta es de 55 bytes! : D - Gracias por hacerme trabajar en esto, ha sido divertido.
Teal pelican
2

C, 100 79 77 bytes

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

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 
#> / \/ \/ \/ \/ \
Jonathan Carroll
fuente
2

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 
/ \/ \/ \/ \/ \
zepelín
fuente
2
El sedes brillante. Al no usar una función ni printf, ahorra 10 bytes:seq -f" %g " -s "" 1 2 $1|sed 'p;s| . |/ \\|g'
Adam
Ese es un buen consejo! Gracias ! Todavía utilizo catpara leer la entrada de STDIN, como la OMI en realidad no es justo usar una variable predefinida para pasar los datos en.
Zeppelin
1
$1es solo el primer parámetro transmitido al programa. No creo que sea trampa ver meta.codegolf.stackexchange.com/questions/2447/…
Adam
Sí, tienes razón. Gracias de nuevo !
zepelín
2

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!

Ben Hili
fuente
print→ $><<y use la interpolación de cadenas " #{x} ". Pero lo mejor sería reducir el número de .eachmediante la salida de la primera línea directamente de la devolución de llamada y la construcción de la segunda línea en una variable: s="";(1..$*[0].to_i).step(2){|x|$><<" #{x} ";s+="/ \\"};puts"",s. O incluso puts"",(1..$*[0].to_i).step(2).map{|x|$><<" #{x} ";"/ \\"}*"".
manatwork
Numeric#stepacepta 2 parámetros, por lo que puede evitar la sintaxis de rango largo que requiere paréntesis alrededor de: (1..$*[0].to_i).step(2)→ 1.step($*[0].to_i,2).
manatwork
@manatwork muy buenas sugerencias! Puedo verme usando muchos de sus consejos en mis futuras publicaciones de codegolf, así que realmente aprecio la entrada.
Ben Hili
1

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.

ETHproducciones
fuente
1

Python 2, 60 bytes

¡Guardado 6 bytes gracias a @Kade!

lambda s:" "+"  ".join(`range(s+1)`[4::6])+"\n"+-~s/2*"/ \\"
Oliver Ni
fuente
No necesita usar un list()yeso, eliminarlo lo lleva a 60 :)
Kade
@Kade Los backticks `` `` lo convierten en una cadena. No puedo hacerlo así lambda s:" "+" ".join(range(s+1)[1::2])+"\n"+-~s/2*"/ \\"eporque entonces daría una lista de entradas y muere
Oliver Ni
¿Estás seguro?
Kade
@Kade Huh. No funciona en línea ... No importa, no sé por qué pensé que no funcionaba ...
Oliver Ni
1

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%
Neil
fuente
1

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
        )
Jabonoso
fuente
1

Ruby, 48 bytes

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

Octava, 45 bytes

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

Prueba:
f (8)

 1  3  5  7
/ \/ \/ \/ \
rahnema1
fuente
Cuando input = 0, hay un / left :)
Sygmei
¡No dije que tu respuesta no es correcta! Acabo de notar esa pequeña falla divertida :)
Sygmei
No puedo suponer n == 0 :(
rahnema1
1

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.
Steenbergh
fuente
0

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@)%
Sygmei
fuente
0

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
Denis Ibaev
fuente