Dzisiaj, 11 listopada, znany jest jako Dzień Pamięci , Dzień Zawieszenia Broni , lub Veterans Day (w zależności od kraju), i to dzień refleksji i wdzięczności dla członków sił zbrojnych i ich usług, a konkretnie zaczęły odzwierciedlać zakończeniu działań wojennych europejskich w pierwszej wojnie światowej. Zastanówmy się nad tym dzięki prostemu wyjściu ASCII-art 11/11.

Biorąc pod uwagę dane nwyjściowe, wyprowadza interpretację ASCII-art, 11/11która jest njednostkami wysokości. W szczególności każda z nich 1składa się z pionowych rur ||, ukośnik składa się z ukośników //, a każda postać ma dwie spacje. Zauważ, że oznacza to różne szerokości wyjściowe - na przykład n=3poniżej zobacz, jak „dół” ukośnika to dwie spacje od 1jego lewej strony, ale cztery spacje od 1jego prawej, tak że góra slashu ustawia się odpowiednio w linii i ma dwie spacje od 1prawej.

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


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


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


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


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

i tak dalej.

Wkład

Pojedyncza dodatnia w dowolnym, wygodnym formacie , n > 0.

Wydajność

Reprezentacja ASCII 11/11, zgodnie z powyższymi zasadami i przykładami. Wiodące / końcowe znaki nowej linii lub inne białe znaki są opcjonalne, pod warunkiem, że znaki są odpowiednio ustawione.

Zasady

• Dopuszczalny jest pełny program lub funkcja. Jeśli funkcja, możesz zwrócić dane wyjściowe zamiast je drukować.
• Standardowe luki są zabronione.
• To jest golf golfowy, więc obowiązują wszystkie zwykłe zasady gry w golfa, a wygrywa najkrótszy kod (w bajtach).

Galaretka , 24 bajty

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

TryItOnline!

W jaki sposób?

⁾| Ḥẋ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 bajtów

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

05AB1E , 24 bajty

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

Wypróbuj online!

Wyjaśnienie

                          # 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

Poprzednia 26 bajtowa wersja

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

Wypróbuj online!

Perl, 45 bajtów

-9 bajtów dzięki @Gabriel Benamy

47 bajtów kodu + 1 bajt na -nflagę.

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

Uruchom z -nEflagami:

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

JavaScript (ES6), 88 77 bajtów

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

Podejście rekurencyjne może nie być najkrótsze .

.map wersja (88 bajtów):

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

Zrozumienie tablicy (86 bajtów):

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

for wersja pętli (89 bajtów):

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

.replace wersja (85 bajtów):

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

Siatkówka, 29 bajtów

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

Port mojego rozwiązania JavaScript. Zwróć uwagę na spację po $*i dwie spacje po ||.

V , 30 bajtów

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

Wypróbuj online!

Jak zwykle, zrzut heksowy:

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

Partia, 130 bajtów

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

Nie jest to port mojego rozwiązania JavaScript. Ponieważ w |Batchu trudno manipulować xs, używam s jako symboli zastępczych i zastępuję je na wyjściu, to wygodnie zmniejsza również mój kod. Zaczyna się od ustawienia sżądanego wyniku dla n=1( njest przekazywany w wierszu poleceń), a następnie wstawia spacje w celu uzyskania pierwszego wiersza rzeczywistej wartości n, a następnie wykonuje pętle poprzez drukowanie łańcucha i każdorazowo przesuwając ukośnik w lewo o jeden znak.

BaCon , 71 bajtów

Kompletny program BASIC w jednym wierszu.

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

Common Lisp, 216 bajtów

Od razu stwierdzę, że jest to okropne rozwiązanie tego wyzwania. Niemniej jednak działa i jestem zmęczony.

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

Stosowanie:

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

Z jakiegoś powodu, zamiast robić coś rozsądnego, postanowiłem podejść do tego z pętlą wewnątrz formatpołączenia. Ta pętla dokonuje iteracji przez zawartość zwracaną przez inną rzeczywistą konstrukcję pętli na samym końcu, z usuniętymi ostatnimi sześcioma elementami (a więc powtórzeniami butlasts). Zawartość wartości zwróconej przez tę konstrukcję pętli składa się z liczby dopełnień na początku ukośników, znaków dopełniania (spacji), liczby dopełnień na odwrocie ukośników i wreszcie tych samych znaków dopełniania.

Jestem raczej nowy w Lisp i rozumiem, że zdecydowanie jest tu dużo miejsca na ulepszenia.

Python 2, 76 75 71 bajtów

Nadal pracuję nad krótszą wersją, ale nie jest tak źle.

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

^{dzięki mbomb007 za złapanie błędu!}

R, 86 bajtów

Po prostu proste forpodejście do pętli:

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

Siatkówka , 40 bajtów

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

Wypróbuj online!

Wyjaśnienie

.+
x $&$* //  x

To zmienia dane wejściowe Nw

x S//  x

Gdzie Sodpowiada Nspacjom.

;{:`x
||  ||

Tutaj dzieją się dwie rzeczy. ;{:wskazuje, że ten etap i ostatni powinny być uruchamiane w pętli, dopóki nie zmienią ciągu. :wskazuje, że wynik tego etapu powinien być drukowany po każdej iteracji i ;wskazuje, że końcowy wynik pętli (a zatem całego programu) nie powinien być drukowany. Sam etap po prostu zastępuje xs przy || ||pierwszej iteracji (i nie robi nic potem), dzięki czemu mamy teraz pierwszy wiersz wymaganego wyniku (i go drukujemy).

   //
  // 

W końcu przesuwa to //jedną postać w lewo, pod warunkiem, że pozostaną co najmniej trzy spacje od //. Następnie wracamy do poprzedniego etapu (który teraz drukuje tylko bieżącą linię, ponieważ nie ma więcej xs), a następnie powtarzamy.

Rubinowy, 60 bajtów

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

C, 116 94 89 bajtów

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

Wypróbuj na Ideone

Rubinowy, 76 74 73 bajtów

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

Jako funkcja zajmuje 73 72 bajty, licząc definicję:

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

PowerShell, 66 bajtów

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

C #, 150 bajtów

Gra w golfa:

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;

Nie golfowany:

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

Testowanie:

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

Wydajność:

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

Groovy, 63 znaki / bajty

Oto moja próba z Groovy, używając anonimowego zamknięcia i prostych pętli, aby wydrukować grafikę ASCII na standardowe wyjście:

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

Możesz spróbować online tutaj . Wystarczy kliknąć „Edytuj w konsoli”, a następnie „Wykonaj skrypt”.

Próbując zrobić to samo i zwrócić ciąg zamiast drukowania, nie mogłem dostać poniżej 71 bajtów:

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

Python 3, 78 bajtów

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

Wciąż próbuję skrócić ...