Oggi, 11 novembre, è noto come il Giorno della Memoria , il Giorno dell'Armistizio o il Giorno dei Veterani (a seconda del paese), ed è un giorno di riflessione e gratitudine per i membri delle forze armate e il loro servizio, in particolare hanno iniziato a riflettere la fine delle ostilità europee nella prima guerra mondiale. Riflettiamo su questo con un semplice output di arte ASCII di 11/11.

Dato un ingresso n, uscita una resa ASCII dell'arte 11/11che è nalto unità. In particolare, ciascuno 1è composto da tubi verticali ||, la barra è composta da barre //e ogni personaggio è a due spazi di distanza. Si noti che ciò significa variare l'ampiezza dell'output, ad esempio, per il n=3seguito, vedere come la "parte inferiore" della barra è due spazi da 1sinistra a sinistra, ma è quattro spazi dalla 1destra, in modo che la parte superiore della barra si allinea in modo appropriato ed è a due spazi dalla 1sua destra.

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


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


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


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


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

e così via.

Ingresso

Un unico intero positivo in qualsiasi formato conveniente , n > 0.

Produzione

Una rappresentazione in arte ASCII di 11/11, seguendo le regole e gli esempi sopra. Le linee guida iniziali / finali o altri spazi bianchi sono opzionali, a condizione che i caratteri siano allineati in modo appropriato.

Regole

• È accettabile un programma completo o una funzione. Se una funzione, è possibile restituire l'output anziché stamparlo.
• Sono vietate le scappatoie standard .
• Si tratta di code-golf quindi si applicano tutte le normali regole del golf e vince il codice più breve (in byte).

Gelatina , 24 byte

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

TryItOnline!

Come?

⁾| Ḥẋ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 byte

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

05AB1E , 24 byte

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

Provalo online!

Spiegazione

                          # 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

Versione precedente a 26 byte

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

Provalo online!

Perl, 45 byte

-9 byte grazie a @Gabriel Benamy

47 byte di codice + 1 byte per -nflag.

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

Corri con -nEbandiere:

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

JavaScript (ES6), 88 77 byte

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

L'approccio ricorsivo potrebbe non essere , non potrebbe essere più breve .

.map versione (88 byte):

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

Comprensione array (86 byte):

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

for versione loop (89 byte):

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

.replace versione (85 byte):

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

Retina, 29 byte

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

Porta della mia soluzione JavaScript. Nota lo spazio dopo $*e due spazi dopo ||.

V , 30 byte

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

Provalo online!

Come al solito, ecco un hexdump:

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

Lotto, 130 byte

@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: //=// %

Non è una porta della mia soluzione JavaScript. Dato |che è difficile manipolarli in Batch, li utilizzo xcome segnaposto e li sostituisco in output, ciò riduce anche convenientemente la dimensione del mio codice. Inizia impostando sl'output desiderato per n=1( nviene passato sulla riga di comando), quindi inserisce gli spazi necessari per ottenere la prima riga per il valore effettivo di n, quindi scorre attraverso la stampa della stringa e spostando la barra lasciata di un carattere ogni volta.

BaCon , 71 byte

Un programma BASIC completo su una riga.

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

Lisp comune, 216 byte

Dichiarerò subito che questa è una terribile soluzione alla sfida. Tuttavia, funziona e sono stanco.

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

Per qualche ragione, invece di fare qualcosa di sano, ho deciso di affrontare questo con un ciclo all'interno di una formatchiamata. Questo ciclo scorre attraverso i contenuti restituiti dall'altro costrutto di ciclo reale alla fine, con gli ultimi sei elementi rimossi (quindi i ripetuti butlast). Il contenuto del valore restituito da questo costrutto di loop consiste in un conteggio di riempimento per la parte anteriore delle barre, i caratteri di riempimento (spazi), il conteggio di riempimento per la parte posteriore delle barre e infine gli stessi caratteri di riempimento.

Sono piuttosto nuovo di Lisp e capisco che qui c'è sicuramente molto margine di miglioramento.

Python 2, 76 75 71 byte

Continuo a lavorare su una versione più breve, non male però.

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

^{grazie mbomb007 per aver rilevato un errore!}

R, 86 byte

Solo un semplice forapproccio ad anello:

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

Retina , 40 byte

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

Provalo online!

Spiegazione

.+
x $&$* //  x

Questo trasforma l'ingresso Nin

x S//  x

Dove Scorrisponde agli Nspazi.

;{:`x
||  ||

Qui stanno accadendo due cose. ;{:indica che questa fase e l'ultima devono essere eseguite in un ciclo fino a quando non riescono a cambiare la stringa. :indica che il risultato di questa fase deve essere stampato dopo ogni iterazione e ;indica che il risultato finale del ciclo (e quindi dell'intero programma) non deve essere stampato. Lo stage stesso sostituisce semplicemente xs con || ||la prima iterazione (e non fa nulla in seguito), quindi ora abbiamo la prima riga dell'output richiesto (e stampiamo).

   //
  // 

Infine, questo sposta //un personaggio a sinistra, purché ci siano ancora almeno tre spazi a sinistra del //. Successivamente torniamo alla fase precedente (che ora stampa solo la riga corrente, poiché non ci sono più xs) e quindi ripetiamo.

Rubino, 60 byte

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

C, 116 94 89 byte

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

Provalo su Ideone

Rubino, 76 74 73 byte

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

Come funzione sono necessari 73 72 byte, contando la definizione:

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

Powershell, 66 byte

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

C #, 150 byte

golfed:

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

test:

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

Produzione:

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

Groovy, 63 caratteri / byte

Ecco il mio tentativo con Groovy, utilizzando una chiusura anonima e semplici loop per stampare l'arte ASCII sull'output standard:

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

Puoi provarlo online qui . Basta fare clic su "Modifica in console" e quindi su "Esegui script".

Cercando di fare lo stesso e restituendo una stringa invece di stampare, non sono riuscito a scendere sotto i 71 byte:

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

Python 3, 78 byte

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

Sto ancora cercando di accorciare ...