Mostre uma cadeia de pequenas montanhas com um número ímpar no topo!

19

A primeira linha é feita com ceil(n/2)elementos em que cada elemento é:<space><odd-number><space>

A segunda linha é feita com ceil(n/2)elementos, mas cada elemento é / \apenas.

Você pode assumir n >= 0e n <= 10.

Exemplos

Entrada: 3

 1  3
/ \/ \

Entrada: 10

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

Exemplo em 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)]))

O menor código em bytes vence :)

code-golf string ascii-art Sygmei
fonte
3
Você pode assumir que todas as entradas serão menores que 11?
Azul
Sim, todas as entradas serão menores que 11!
Sygmei 23/11
8
Bem vindo ao site! Nosso padrão para code-golf é contar em bytes, não em caracteres. Se você deseja substituir isso, porém, a escolha é sua. Além disso, eu recomendaria o Sandbox da próxima vez :)
Erik o Outgolfer
Eu quis dizer bytes, você está certo! Existe um bom contador de bytes por aí?
Sygmei 23/11
11
Quão especificamente temos que lidar com espaços em branco? Você diz que cada elemento é <space><odd-number><space>, mas os casos de teste não têm espaço após o último número ímpar. É opcional? Além disso, é a saída para n=0duas linhas vazias?
Xnor

Respostas:

12

05AB1E , 19 15 14 12 bytes

05AB1E usa a codificação CP-1252 .
Guardado 4 bytes graças a Adnan .
Economizou 2 bytes graças a carusocomputing

ÅÉðìDg…/ \×»

Experimente online!

Explicação

ÅÉ               # 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
fonte
QUANTO TEMPO ÏEXISTE ?! Isso parece super útil.
Magic Octopus Urn
2
@carusocomputing Um longo tempo: p #
Adnan
2
LDÉÏé o mesmo ÅÉe „ ýðìpode ser substituído por ðì)»:).
Adnan
2
Você pode remover o ), não pode?
Magic Octopus Urn
3
ÅÉðìDg…/ \×»usa em Dgvez de ¹;îsalvar por outro byte também.
Magic Octopus Urn
11

Pyke, 16 bytes

S2%idm+dJil*"/ \

Experimente aqui!

17 bytes e mais impressionante

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

Experimente aqui!

Isso usa IMHO, um algoritmo IMPRESSIONANTE para garantir que a primeira linha esteja alinhada corretamente. 

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

Isso substitui todos os caracteres da lista com strings por espaços. ~Bcontém todos os caracteres no idioma Brain **** e é a primeira vez que usei essa variável.

O programa `~Bd.:faz isso:

`~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
fonte
... isso é ... simplesmente incrível? Você sabe que acabou de vencer 05AB1E e todo mundo, certo?
Erik the Outgolfer
Eu tentei Jelly; certamente será muito mais longo.
Erik the Outgolfer
"Eu usei o charset BF para uniformemente espaço uma matriz de números" As coisas que você nunca pensou que você diria ...
ETHproductions
Isso é realmente inteligente :) Bem feito
Sygmei 23/11/16
@ErikGolfer ー リ ッ ク ゴ ー Não está mais vencendo 05AB1E.
boboquack
6

Python 2, 63 bytes

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

Um pequeno truque para a primeira linha: ela não imprime os números pares, mas os toma como uma sequência vazia, o que leva ao início do espaço vazio (0 estaria lá) e dobra espaços entre os números sem nenhuma modificação no intervalo, a desvantagem é um espaço de liderança no par numerado n

Cajado
fonte
6

Python 2 3, 67 65 63 60 Bytes

Nada muito louco aqui, acho que a primeira seção provavelmente pode ser feita mais curta, mas não sei bem como . Eu uso o fato de que, neste caso -~n/2, funcionará ceil.

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

Abaixo estão soluções alternativas de 61 e 65 bytes no 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*'/ \\'

Agradecimentos a Rod por salvar 2 bytes e Artyer por salvar outro byte alternando a versão :)

Kade
fonte
Se você mudar para o Python 3, poderá substituí-lo %(tuple(...))por %[*...], mas teria que fazer isso #-~n//2
Artyer
@ Artyer Tentei isso, mas lança um monte de erros. Eu acho que precisaria converter rangepara uma lista porque 3 rangeé como o Python 2 xrange.
Kade
você também pode soltar os parênteses que estão ao redor dotuple()
Rod
Você pode fazer (*<iterable>,)para lançar a tupla em Python 3. Isso economiza 1 byte embora depois de ligar n/2para n//2para Python 3.
Artyer
@Rod e Artyer agradecem muito! :)
Kade 23/11
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 snippet

Observe o espaço no final da segunda linha.

Neil
fonte
Droga, eu pensei que .replacepoderia ser melhor, mas eu não me incomodei em verificar ...
ETHproductions
A questão diz "você pode assumir ..."
Solomon Ucko
11
@SolomonUcko O HTML não faz parte da resposta, serve apenas para demonstrar o seu funcionamento. Como tal, também pode limitar o valor entre 1 e 10, pois o resultado não seria válido de outra forma.
Neil
Entendo. Caso contrário, você teria que determinar o espaçamento correto
Solomon Ucko
5

Python 2, 53 bytes

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

Aproveita a restrição n <= 10para gerar a linha superior cortando um pedaço de uma corda codificada.

As saídas de 1 a 10 são

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

A saída para 0 é duas linhas vazias.

xnor
fonte
5

Vim, 73 59 56 bytes

Este é um IMO com contagem de bytes muito alta para o que parece ser um problema simples. Sinto como se estivesse perdendo algo óbvio.

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

Experimente online!

Não imprimíveis:

^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
fonte
Bom, eu sempre votei no vim! No entanto, caracteres não imprimíveis também contam como bytes, portanto, esta solução é realmente de 73 bytes. Me desculpe por isso!
DJMcMayhem
Eu tenho algumas dicas no entanto. 1) Se você usar um separador diferente em seu comando substituto, não precisará escapar da barra, para que possa fazê-lo :s;.;/ \\;g. 2) no seu segundo comando substituto, você pode deixar a pesquisa em branco e ela usará sua última pesquisa (que por acaso é a mesma). Além disso, &é equivalente a \0e um byte mais curto. Então você recebe:s// & /g
DJMcMayhem
Obrigado! Eu esperava ver uma resposta em V de você para ver se você usou uma abordagem diferente para menos bytes, mas está tudo bem! O primeiro comentário, eu acho, é uma função de me esquecer de atualizar o link Experimente Online. O segundo me deu 3 bytes, então obrigado!
nmjcman101
4

Mathematica, 65 bytes

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

Função anônima. Pega um número como entrada e retorna uma string como saída. Os caracteres Unicode, respectivamente, são U + 2308 LEFT CEILING para \[LeftCeiling]e U + 2309 RIGHT CEILING para \[RightCeiling].

LegionMammal978
fonte
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"/ \\"}

A entrada é feita configurando um valor no pseudo-registro $t0 .

Parece que é o mais curto aqui, apenas para imprimir a string enquanto ela está sendo construída, em vez de tentar construí-la primeiro e exibir a coisa toda. Eu teria uma solução mais curta se o WinDbg me deixasse escrever para o endereço 0.

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

Saída 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 
/ \/ \/ \/ \/ \
leite
fonte
4

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

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

Cole-o neste intérprete online!

O número 5 na primeira linha é o seu valor de entrada (codificado como 5, substituído por 0-a ou i para entrada do usuário).

Editar 1: Movido o posicionamento da nova linha para o espaço da primeira linha (estava vazio) para salvar 9 bytes no geral no espaço de uma nova linha.

Edit 2: Conforme observado pelo user7150406, a saída estava incorreta (sem impressão de espaços), isso foi corrigido com uma perda de 8 bytes.

Edit 3: mudou completamente a lógica, não faz sentido verificar se o número é ímpar - coloque todos os números na pilha e remova todos os segundos. Byte salvou 13!

Pelicano-verde
fonte
4

Java, 118 112 bytes

Edit: Saved 6 Bytes graças a @peech

Golfe:

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

Teste:

    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
fonte
Ahhhh, você me venceu :) também queria postar uma resposta em Java. de qualquer forma, aqui estão algumas sugestões para jogar um pouco mais: você não precisa inicializar ino seu primeiro loop for, pode ser assim for(; i < n; i++). Você pode jogar ainda mais com essa alteração: as o += i + " ";alterações no o += i++ + " ";loop for e for for(; i < n; ). Ou seja, se você deseja manter a declaração if. Você pode alterar seu incremento de i para i += 2 e excluir a instrução if inteira, mas, nesse caso, minha segunda proposição não se aplica :) (ps: eu não testei isso :))
Peech
@peech Se há algum consolo, normalmente é uma corrida para mim obter a primeira resposta em C #. Se isso acabar, vou me deparar com uma resposta em Java :) Obrigado pelas dicas. Eu removi a iinicialização do forloop, mas as outras coisas ficaram presas em um loop. Eu poderia precisar de brincar com ele um pouco mais :)
Pete Arden
Estou tão feliz que no meu comentário anterior eu disse "eu não testei isso" ... é claro que não funciona com o += i++ + " ";:). Btw, você tem um pequeno bug em seu código :) desde Java usa floor()na divisão inteira (4/3 = 1), você deve fazê-lo como este: int i = 1; n += 1; for (; i < n; i += 2) { ... jada jada ... }. se você incrementar i i += 2, não será necessário que a instrução if verifique a paridade. Ele também salva outros 3 bytes :) tente aqui: ideone.com/ekaUUH
Peech
@peech Se alguém estiver confiante o suficiente para corrigir meu código, presumo que esteja correto, então, quando não funciona, tento repetidamente, pensando "deve ser eu ..." :) Não se preocupe! Obrigado pelas dicas - eu descobri a floordivisão mim quirk quando se joga com um pouco de Java há poucos dias :)
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 completo:

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

CJam, 26 23 bytes

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

Teste-o!

-3 graças a 8478 (Martin Ender)

Erik, o Outgolfer
fonte
Você pode salvar 3 bytes, evitando parte da manipulação da pilha:Sri,:)2%_S2**N@,"/ \\"*
Martin Ender
@MartinEnder Oh, é por isso que não pude remover isso +. E eu juro, eu realmente usei ed! ... mais curto que Pyth.
Erik the Outgolfer
3

Idioma do criador de jogos (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 a entrada é no máximo 10, chr(48+i) funcionará no lugar de string(i), embora o número de bytes seja o mesmo.

Legível:

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

Pitão, 24 22 bytes

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

Agradecimentos a 42545 (ETHproductions) por -1 byte

Intérprete online

11 casos de teste

Erik, o Outgolfer
fonte
Salve uma cotação com*lK"/ \\
ETHproductions
@ETHproductions então você pode usar \em vez de \\:)
Erik o Outgolfer
3

> <> (Peixe) 52 63 62 bytes

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

Experimente online!

Para usar basta colocar nna pilha e você vai embora!

Muito disso é retirado da resposta da @ Teal-Pelican :).

Editar: a saída não está alinhada corretamente na submissão> <>! A corrigir ...

Edit2: Eu tive que sacrificar alguns bytes, mas a saída está realmente correta agora.

Edit3: Não há mais diversão com \ /espelhos e eu economizo 1 byte.

Resultado:

 1  3  5  7  9
/ \/ \/ \/ \/ \
redstarcoder
fonte
Obrigado por detectar o erro na impressão, estou editando minha resposta agora (bastante trivial para a minha). É interessante ver a resposta da base da mesma forma, mas muitos bytes economizam.
Teal pelican
Não tem problema, fiquei feliz em ver uma submissão! Vai ser interessante ver qual deles acaba sendo menor agora, já que essas mudanças machucam as minhas muito haha.
Redstarcoder #
Parece que eu tenho apenas 5 bytes a menos: p.
Redstarcoder #
Vou dar outra olhada na minha agora para ver se consigo extrair alguns bytes de mote aha.
Teal pelican
11
Cheguei em casa e tive uma idéia para uma nova maneira de fazer isso. Minha nova resposta é 55 bytes! : D - Obrigado por me fazer trabalhar nisso, tem sido divertido.
Teal pelicano
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
fonte
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
fonte
2

Bater, 64, 59., 57, 51, 49., 48., 45 bytes

EDITAR:

  • menos 3 bytes (use $ 1 em vez de STDIN)
  • mais um byte, substituindo -s ""por-s\
  • menos 2 bytes substituindo printf por seq -f (Obrigado @Adam!)
  • refatorado para script em vez de função (para vencer o > <> )
  • espaços supérfluos removidos
  • otimizou a expressão sed um pouco

Golfe

Pedaço (45 bytes):

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

Função (versão original) (57 bytes):

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

Teste

--- 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 
/ \/ \/ \/ \/ \
zepelim
fonte
2
O sedé brilhante. Ao não usar uma função nem printf, você salva 10 bytes:seq -f" %g " -s "" 1 2 $1|sed 'p;s| . |/ \\|g'
Adam
Esse é um bom conselho! Obrigado ! Eu continuo a usar catpara ler a entrada de STDIN, como IMO não é realmente justo usar uma variável pré-definida para passar os dados.
zeppelin
11
$1é apenas o primeiro parâmetro transmitido ao programa. Eu não acho que é trapaça ver meta.codegolf.stackexchange.com/questions/2447/…
Adam
Sim, você está correto. Obrigado novamente !
Zeppelin #
2

Abaixo 93 , 64 bytes

Experimente Online!

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

Ruby 82 60 Bytes

A solução Ruby rápida e suja definitivamente poderia ser melhor otimizada se eu fosse melhor com Ruby

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

Uso: prog.rb 10
Saída:

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

edit: numerosas edições e otimizações por @Manatwork!

Ben Hili
fonte
print→ $><<e use a interpolação de strings " #{x} ". Mas o melhor seria reduzir o número de .eachemitindo 1ª linha diretamente do retorno de chamada e construção da 2ª linha em uma variável: s="";(1..$*[0].to_i).step(2){|x|$><<" #{x} ";s+="/ \\"};puts"",s. Ou até puts"",(1..$*[0].to_i).step(2).map{|x|$><<" #{x} ";"/ \\"}*"".
manatwork
Numeric#stepaceita 2 parâmetros, para evitar a longa sintaxe de intervalo que requer parênteses em torno de: (1..$*[0].to_i).step(2)→ 1.step($*[0].to_i,2).
manatwork
@manatwork realmente boas sugestões! Eu posso me ver usando muitos dos seus conselhos em minhas futuras postagens sobre codegolf, então eu realmente aprecio a entrada.
precisa
1

JavaScript (ES6), 66 64 bytes

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

Cria recursivamente a primeira linha e depois acrescenta a segunda. A primeira linha é construída com a observação de que é simplesmente o intervalo [0 ... n] com cada item n transformado em um espaço se for par, ou n concatenado com um espaço se for ímpar.

ETHproductions
fonte
1

Python 2, 60 bytes

Guardado 6 bytes graças a @Kade!

lambda s:" "+"  ".join(`range(s+1)`[4::6])+"\n"+-~s/2*"/ \\"
Oliver Ni
fonte
Você não precisa usar um list()elenco, removê-lo você fica a 60 :)
Kade
@Kade Os backticks `` `` fazem dele uma string. Eu não posso fazer isso lambda s:" "+" ".join(range(s+1)[1::2])+"\n"+-~s/2*"/ \\"eporque, então, daria uma lista de entradas e morre
Oliver Ni
Você tem certeza?
Kade
@Kade Huh. Não funciona online ... Nunca mente, eu não sei porque eu pensei que não funcionou ...
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
fonte
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)

Ungolfed

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

Ruby, 48 bytes

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

Oitava, 45 bytes

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

Teste:
f (8)

 1  3  5  7
/ \/ \/ \/ \
rahnema1
fonte
Quando a entrada = 0, existe uma / esquerda :)
Sygmei
Não disse que sua resposta não está correta! Só notei que pequena falha engraçado :)
Sygmei
Eu não posso assumir que n == 0 :(
rahnema1
1

QBIC , 35 bytes

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

Explicação:

:           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
fonte
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
fonte
0

Perl, 46 + 2 ( -plsinalizador) = 48 bytes

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

Usando:

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

Ou 52 bytes:

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

Usando:

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