Hoy, 11 de noviembre, se conoce como el Día del Recuerdo , el Día del Armisticio o el Día de los Veteranos (según el país), y es un día de reflexión y gratitud para los miembros de las fuerzas armadas y su servicio, específicamente comenzó a reflejar el fin de las hostilidades europeas. en la primera guerra mundial. Reflexionemos sobre eso con una simple salida de arte ASCII de 11/11.

Dada una entrada n, la salida de una representación de arte ASCII 11/11es de nunidades de altura. Específicamente, cada uno 1está compuesto por tubos verticales ||, la barra está compuesta por barras //y cada personaje está separado por dos espacios. Tenga en cuenta que esto significa diferentes anchos de salida; por ejemplo, para más n=3abajo, vea cómo la "parte inferior" de la barra está a dos espacios desde la 1izquierda, pero está a cuatro espacios desde la 1derecha, de modo que la parte superior de la barra se alinea apropiadamente y está a dos espacios del lado 1derecho.

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


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


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


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


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

y así.

Entrada

Un número entero positivo solo en cualquier formato conveniente , n > 0.

Salida

Una representación de arte ASCII de 11/11, siguiendo las reglas y ejemplos anteriores. Las nuevas líneas iniciales / finales u otros espacios en blanco son opcionales, siempre que los caracteres se alineen adecuadamente.

Reglas

• Un programa completo o una función son aceptables. Si es una función, puede devolver el resultado en lugar de imprimirlo.
• Las lagunas estándar están prohibidas.
• Este es el código de golf, por lo que se aplican todas las reglas habituales de golf, y gana el código más corto (en bytes).

Jalea , 24 bytes

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

TryItOnline!

¿Cómo?

⁾| Ḥẋ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׊««,À

Pruébalo en línea!

Explicación

                          # 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

Versión anterior de 26 bytes

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

Pruébalo en línea!

Perl, 45 bytes

-9 bytes gracias a @Gabriel Benamy

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

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

Corre con -nEbanderas:

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

Es posible que el enfoque recursivo no sea el más corto .

.map versión (88 bytes):

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

Comprensión de matriz (86 bytes):

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

for versión de bucle (89 bytes):

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

.replace versión (85 bytes):

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

Retina, 29 bytes

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

Puerto de mi solución JavaScript. Tenga en cuenta el espacio después $*y dos espacios después ||.

V , 30 bytes

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

Pruébalo en línea!

Como de costumbre, aquí hay un 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: //=// %

No es un puerto de mi solución JavaScript. Como los |s son difíciles de manipular en Batch, uso xs como marcadores de posición y los reemplazo en la salida, esto convenientemente también reduce el tamaño de mi código. Comienza configurando sla salida deseada para n=1( nse pasa en la línea de comando), luego inserta espacios según sea necesario para obtener la primera línea para el valor real de n, luego realiza un bucle a través de la impresión de la cadena y desplaza la barra diagonal hacia la izquierda por un carácter cada vez.

BaCon , 71 bytes

Un programa BÁSICO completo en una línea.

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

Lisp común, 216 bytes

Voy a decir de inmediato que esta es una solución horrible para el desafío. Sin embargo, funciona, y estoy 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 alguna razón, en lugar de hacer algo cuerdo, decidí abordar esto con un bucle dentro de una formatllamada. Este bucle itera a través de los contenidos devueltos por la otra construcción de bucle real al final, con los últimos seis elementos eliminados (por lo tanto, la butlasts repetida ). El contenido del valor devuelto por esta construcción de bucle consiste en un recuento de relleno para el frente de las barras, los caracteres de relleno (espacios), el recuento de relleno para la parte posterior de las barras y, finalmente, los mismos caracteres de relleno.

Soy bastante nuevo en Lisp, y entiendo que definitivamente hay mucho margen de mejora aquí.

Python 2, 76 75 71 Bytes

Todavía estoy trabajando en una versión más corta, aunque no está mal.

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

^{¡Gracias mbomb007 por detectar un error!}

R, 86 bytes

Solo un forenfoque de bucle simple :

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

Pruébalo en línea!

Explicación

.+
x $&$* //  x

Esto convierte la entrada N en

x S//  x

Donde Scorresponde aN espacios.

;{:`x
||  ||

Hay dos cosas que suceden aquí. ;{:indica que esta etapa y la última deben ejecutarse en un bucle hasta que no puedan cambiar la cadena. :indica que el resultado de esta etapa debe imprimirse después de cada iteración e ;indica que el resultado final del ciclo (y, por lo tanto, de todo el programa) no debe imprimirse. El escenario en sí solo reemplaza el xs con|| || la primera iteración (y no hace nada después), de modo que ahora tenemos la primera línea de la salida requerida (e imprimirla).

   //
  // 

Finalmente, esto desplaza el //carácter a la izquierda, siempre que haya al menos tres espacios a la izquierda del //. Luego volvemos a la etapa anterior (que ahora solo imprime la línea actual, ya que no hay más xs) y luego repetimos.

Rubí, 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?" ":"||  ||  ":"//");}

Pruébalo en Ideone

Ruby, 76 74 73 bytes

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

Como una función toma 73 72 bytes, contando la definición:

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

Golfizado:

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;

Sin golf:

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

Pruebas:

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

Salida:

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

Groovy, 63 caracteres / bytes

Aquí está mi intento con Groovy, usando un cierre anónimo y bucles simples para imprimir el arte ASCII a la salida estándar:

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

Puedes probarlo en línea aquí . Simplemente haga clic en "Editar en la consola" y luego "Ejecutar script".

Tratando de hacer lo mismo y devolviendo una cadena en lugar de imprimir, no pude obtener menos 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)

Aún tratando de acortar ...