Hoje, 11 de novembro, é conhecido como Dia da Lembrança , Dia do Armistício ou Dia dos Veteranos (dependendo do país), e é um dia de reflexão e gratidão para os militares e seus serviços, que começaram especificamente a refletir o fim das hostilidades europeias na primeira guerra mundial. Vamos refletir sobre isso com uma simples saída de arte ASCII de 11/11.

Dada uma entrada n, produza uma representação em arte ASCII 11/11disso com nunidades de altura. Especificamente, cada um 1é composto por tubos verticais ||, a barra é composta por barras //e cada caractere tem dois espaços separados. Observe que isso significa variar larguras de saída - por exemplo, n=3abaixo, veja como a "parte inferior" da barra é de dois espaços 1à esquerda, mas há quatro espaços à 1direita, de modo que a parte superior da barra alinha-se apropriadamente e há dois espaços à 1direita.

n = 1
||  ||  //  ||  ||


n = 2
||  ||   //  ||  ||
||  ||  //   ||  ||


n = 3
||  ||    //  ||  ||
||  ||   //   ||  ||
||  ||  //    ||  ||


n = 4
||  ||     //  ||  ||
||  ||    //   ||  ||
||  ||   //    ||  ||
||  ||  //     ||  ||


n = 5
||  ||      //  ||  ||
||  ||     //   ||  ||
||  ||    //    ||  ||
||  ||   //     ||  ||
||  ||  //      ||  ||

e assim por diante.

Entrada

Um número inteiro positivo único em qualquer formato conveniente , n > 0.

Saída

Uma representação de arte ASCII de 11/11, seguindo as regras e exemplos acima. Novas linhas à esquerda / à direita ou outro espaço em branco são opcionais, desde que os caracteres sejam alinhados adequadamente.

Regras

• Um programa completo ou uma função são aceitáveis. Se uma função, você pode retornar a saída em vez de imprimi-la.
• As brechas padrão são proibidas.
• Isso é código-golfe, portanto todas as regras usuais de golfe se aplicam e o código mais curto (em bytes) vence.

Gelatina , 24 bytes

⁾| Ḥẋ2µ,Ṛðj
⁶ẋṖ;⁾//ṙḶÇ€Y

TryItOnline!

Quão?

⁾| Ḥẋ2µ,Ṛðj - Link 1, join two "11"s with: middle
⁾|          - string literal: "| "
   Ḥ        - double          "||  "
    ẋ2      - repeat twice    "||  ||  "
      µ     - monadic chain separation
       ,    - pair with
        Ṛ   - reversed       ["||  ||  ","  ||  ||"]
         ð  - dyadic chain separation
          j - join with input "||  ||  middle  ||  ||"

⁶ẋṖ;⁾//ṙḶÇ€Y - Main link: n       e.g. 5
⁶            - literal ' '        ' '
 ẋ           - repeat n times     "     "
  Ṗ          - remove last entry  "    "
   ;         - concatenate with
    ⁾//      - literal "//"       "    //"
        Ḷ    - lowered range(n)   [0,1,2,3,4]
       ṙ     - rotate left        ["    //","   // ","  //  "," //   ","//    "]
         Ç€  - call last link (1) as a monad for €ach
           Y - join with line feeds

JavaScript (ES6), 57 bytes

n=>" ".repeat(n).replace(/./g,"||  ||  $'//$`  ||  ||\n")

05AB1E , 24 bytes

<ðׄ//J¹FD"  ||"2׊««,À

Experimente online!

Explicação

                          # implicit input n
<ð×                       # push n-1 spaces
   „//J                   # join with "//"
       ¹F                 # input times do:
         D                # duplicate top of stack
          "  ||"2×        # push "  ||  ||"
                  Â       # push "||  ||  "
                   Š      # move the top of the stack down 2 places on the stack
                    ««    # concatenate the top 3 elements of the stack
                      ,   # print with newline
                       À  # rotate top of stack left

Versão anterior de 26 bytes

F"||  "2שð¹N-<ׄ//ðN×®RJ,

Experimente online!

Perl, 45 bytes

-9 bytes graças a @Gabriel Benamy

47 bytes de código + 1 byte para -nsinalizador.

say$@="||  "x2,$"x$_,"//",$"x++$.,$@while$_--

Executar com -nEsinalizadores:

perl -nE 'say$@="||  "x2,$"x$_,"//",$"x++$.,$@while$_--' <<< 5

JavaScript (ES6), 88 77 bytes

f=(n,i=n)=>i--?`||  ||  ${" ".repeat(i)}//${" ".repeat(n+~i)}  ||  ||
`+f(n,i):""

A abordagem recursiva pode não ser, não poderia ser a mais curta .

.map versão (88 bytes):

n=>[...Array(n)].map((_,i)=>`||  ||  ${" ".repeat(n+~i)}//${" ".repeat(i)}  ||  ||`).join`
`

Compreensão da matriz (86 bytes):

n=>[for(_ of Array(i=n))`||  ||  ${" ".repeat(--i)}//${" ".repeat(n+~i)}  ||  ||`].join`
`

for versão em loop (89 bytes):

n=>{for(a="",i=n;i--;a+=s+" ".repeat(i+2)+`//${" ".repeat(n-i+1)+s}
`)s="||  ||";return a}

.replace versão (85 bytes):

n=>`||  ||  q  ||  ||
`[r="repeat"](n).replace(/q/g,_=>" "[r](--i)+"//"+" "[r](n+~i),i=n)

Retina, 29 bytes

.+
$* 
.
xx$'//$`  xx¶
x
||  

Porta da minha solução JavaScript. Observe o espaço depois $*e dois espaços depois ||.

V , 30 bytes

4i||  2Bi//  Àé XÀ«ñÄf/é Elx

Experimente online!

Como de costume, aqui está um hexdump:

0000000: 3469 7c7c 2020 1b32 4269 2f2f 2020 1bc0  4i||  .2Bi//  ..
0000010: e920 58c0 abf1 c466 2fe9 2045 6c78       . X....f/. Elx

Lote, 130 bytes

@set s=xx//  xx
@set l=@for /l %%i in (2,1,%1)do @call
%l% set s=%%s://= //%%
%l%:l
:l
@echo %s:x=^|^|  %
@set s=%s: //=// %

Não é uma porta da minha solução JavaScript. Como |s são difíceis de manipular no Lote, eu uso xs como espaços reservados e os substituo na saída, isso também reduz meu tamanho de código. Inicia definindo sa saída desejada para n=1( né passada na linha de comando), depois insere espaços conforme necessário para obter a primeira linha para o valor real de n, depois passa pela impressão da sequência e deslocando a barra deixada por um caractere a cada vez.

BaCon , 71 bytes

Um programa BASIC completo em uma linha.

INPUT n:FOR x=1 TO n:?"||  ||",SPC$(n-x+2),"//",SPC$(x+1),"||  ||":NEXT

Lisp comum, 216 bytes

Vou dizer logo de cara que esta é uma solução terrível para o desafio. No entanto, funciona e estou cansado.

(defun arm (n) (format t "~{||  || ~v,,,vA//~v,,,vA ||  ||~%~}" (butlast (butlast (butlast (butlast (butlast (butlast (loop for i from 1 to (+ n 1) append `(,(- (+ n 1) i) #\Space #\Space ,i #\Space #\Space))))))))))

Uso:

* (arm 4)
||  ||     //  ||  ||
||  ||    //   ||  ||
||  ||   //    ||  ||
||  ||  //     ||  ||

Por alguma razão, em vez de fazer qualquer coisa sã, decidi abordar isso com um loop dentro de uma formatchamada. Esse loop percorre o conteúdo retornado pela outra construção de loop real no final, com os últimos seis elementos removidos (portanto, os butlasts repetidos ). O conteúdo do valor retornado por essa construção de loop consiste em uma contagem de preenchimento para a frente das barras, os caracteres de preenchimento (espaços), a contagem de preenchimento para a parte de trás das barras e, finalmente, os mesmos caracteres de preenchimento.

Sou bastante novo no Lisp e entendo que definitivamente há muito espaço para melhorias aqui.

Python 2, 76 75 71 bytes

Ainda trabalhando em uma versão mais curta, não é tão ruim assim.

n=input()
k='||  ||'
for i in range(n):print k,(n-i)*' '+'//'+' '*-~i,k

^{obrigado mbomb007 por capturar um erro!}

R, 86 bytes

Apenas uma forabordagem simples de loop:

x="||  ||";n=scan();for(i in 1:n)cat(x,rep(" ",2+n-i),"//",rep(" ",1+i),x,"\n",sep="")

Retina , 40 bytes

.+
x $&$* //  x
;{:`x
||  ||
   //
  // 

Experimente online!

Explicação

.+
x $&$* //  x

Isso transforma a entrada Nem

x S//  x

Onde Scorresponde aos Nespaços.

;{:`x
||  ||

Há duas coisas acontecendo aqui. ;{:indica que esse estágio e o último devem ser executados em um loop até que falhem ao alterar a sequência. :indica que o resultado desse estágio deve ser impresso após cada iteração e ;indica que o resultado final do loop (e, portanto, de todo o programa) não deve ser impresso. O estágio em si apenas substitui os xpor || ||na primeira iteração (e não faz nada depois), para que agora tenhamos a primeira linha da saída necessária (e a imprima).

   //
  // 

Finalmente, isso muda o //caractere para a esquerda, desde que ainda restem pelo menos três espaços no //. Depois, retornamos ao estágio anterior (que agora imprime apenas a linha atual, pois não há mais xs) e depois repetimos.

Ruby, 60 bytes

->n{n.times{|i|puts (a='||  || ')+' '*(n-i)+'//  '+' '*i+a}}

C, 116 94 89 bytes

c,d;f(a){for(d=a;a--;puts("  ||  ||"))for(c=-1;c<d;)printf(a-c++?c?" ":"||  ||  ":"//");}

Experimente no Ideone

Ruby, 76 74 73 bytes

x="||  ||";n=gets.to_i;puts (1..n).map{|i|x+" "*(n-i+2)+"//"+" "*(i+1)+x}

Como função, são necessários 73 72 bytes, contando a definição:

def f n,x="||  ||";(1..n).map{|i|x+" "*(n-i+2)+"//"+" "*(i+1)+x}*?\n;end

Powershell, 66 bytes

$a=read-host;1..$a|%{$s="||  ";$s*2+" "*($a-$_)+"// "+" "*$_+$s*2}

C #, 150 bytes

Golfe:

string A(int n){string a="",b= "||  ||";for(int i=0;i<n;i++)a+=b+"  //  ".PadLeft(5+n-i,'\0')+string.Concat(Enumerable.Repeat(" ",i))+b+"\n";return a;

Ungolfed:

public string A(int n)
{
  string a = "", b = "||  ||";
  for (int i = 0; i < n; i++)
    a += b + "  //  ".PadLeft(5 + n - i, '\0') + string.Concat(Enumerable.Repeat(" ", i)) + b + "\n";
  return a;
}

Teste:

Console.WriteLine(new ArmisticeDayChallenge().A(11));

Saída:

||  ||            //  ||  ||
||  ||           //   ||  ||
||  ||          //    ||  ||
||  ||         //     ||  ||
||  ||        //      ||  ||
||  ||       //       ||  ||
||  ||      //        ||  ||
||  ||     //         ||  ||
||  ||    //          ||  ||
||  ||   //           ||  ||
||  ||  //            ||  ||

Groovy, 63 caracteres / bytes

Aqui está minha tentativa com o Groovy, usando um fechamento anônimo e loops simples para imprimir a arte ASCII na saída padrão:

{n->n.times{println'|| '*2+' '*(n-it-1)+'//'+' '*it+' ||'*2}}

Você pode experimentá-lo online aqui . Basta clicar em "Editar no console" e depois em "Executar script".

Tentando fazer o mesmo e retornando uma string em vez de imprimir, não consegui ficar abaixo de 71 bytes:

{n->a='';n.times{a+='|| '*2+' '*(n-it-1)+'//'+' '*it+' ||'*2+'\n'};a}

Python 3, 78 bytes

a="||  ||"
def m(n):
    for e in range(n):print(a," "*(n-e),"//"," "*(e+1),a)

Ainda tentando encurtar ...