Сегодня, 11 ноября, известен как День памяти , День перемирия или День ветеранов ( в зависимости от страны), и день раздумий и благодарность за военнослужащих и их службы, в частности , начали отражать конец европейских военных действий в первую мировую войну. Давайте поразмышляем об этом с помощью простого вывода ASCII-art 11/11.

Учитывая вход n, выведите ASCII-арт-представление, 11/11которое имеет nвысоту единиц. В частности, каждый 1состоит из вертикальных трубок ||, косая черта состоит из косых //черт, и каждый символ находится на расстоянии двух пробелов. Обратите внимание, что это означает изменение ширины вывода - например, для n=3ниже, посмотрите, как «нижняя часть» косой черты находится на два пробела 1слева от нее, но на четыре пробела 1справа от нее, так что верхняя черта косой черты выстраивается соответственно и в двух пробелах 1справа от него.

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


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


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


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


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

и так далее.

вход

Один положительное целое число в любом удобном формате , n > 0.

Выход

Представление ASCII-art в 11/11соответствии с приведенными выше правилами и примерами. Лидирующие / завершающие символы новой строки или другие пробелы являются необязательными при условии, что символы выстроены в линию соответствующим образом.

правила

• Допустимы либо полная программа, либо функция. Если функция, вы можете вернуть вывод, а не распечатать его.
• Стандартные лазейки запрещены.
• Это код-гольф, поэтому применяются все обычные правила игры в гольф, и выигрывает самый короткий код (в байтах).

Желе , 24 байта

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

TryItOnline!

Как?

⁾| Ḥẋ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 байт

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

05AB1E , 24 байта

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

Попробуйте онлайн!

объяснение

                          # 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

Предыдущая 26-байтовая версия

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

Попробуйте онлайн!

Perl, 45 байт

-9 байтов благодаря @Gabriel Benamy

47 байт кода + 1 байт для -nфлага.

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

Запустить с -nEфлагами:

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

JavaScript (ES6), 88 77 байт

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

Рекурсивный подход не может быть и не может быть самым коротким .

.map версия (88 байт):

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

Понимание массива (86 байт):

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

for версия цикла (89 байт):

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

.replace версия (85 байт):

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

Сетчатка, 29 байт

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

Порт моего решения JavaScript. Обратите внимание на пробел после $*и два пробела после ||.

V , 30 байтов

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

Попробуйте онлайн!

Как обычно, здесь есть hexdump:

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

Пакетный, 130 байт

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

Не порт моего решения JavaScript. Поскольку |в Batch трудно манипулировать xs , я использую s в качестве заполнителей и заменяю их при выводе, это также удобно уменьшает размер моего кода. Начинается с установки sтребуемого вывода для n=1( nпередается в командной строке), затем вставляется пробелы по мере необходимости для получения первой строки для фактического значения n, затем циклически выводится на печать строки и каждый раз смещает косую черту влево на один символ.

BaCon , 71 байт

Полная базовая программа в одной строке.

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

Common Lisp, 216 байт

Я собираюсь сразу заявить, что это ужасное решение проблемы. Тем не менее, это работает, и я устал.

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

Использование:

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

По какой-то причине, вместо того, чтобы делать что-то вменяемое, я решил подойти к этому с помощью цикла внутри formatвызова. Этот цикл перебирает содержимое, возвращенное другой фактической конструкцией цикла в самом конце, с удалением последних шести элементов (таким образом, повторяющихся butlasts). Содержимое значения, возвращаемого этой конструкцией цикла, состоит из счетчика заполнения для передней части косой черты, символов заполнения (пробелов), счетчика заполнения для задней части косой черты и, наконец, тех же символов заполнения.

Я довольно новичок в Лиспе и понимаю, что здесь определенно есть куда улучшаться.

Python 2, 76 75 71 байт

Все еще работает над более короткой версией, хотя и не так уж плохо.

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

^{спасибо mbomb007 за ошибку!}

R 86 байт

Просто простой forподход цикла:

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

Сетчатка , 40 байт

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

Попробуйте онлайн!

объяснение

.+
x $&$* //  x

Это превращает вход Nв

x S//  x

Где Sсоответствует Nпробелам.

;{:`x
||  ||

Здесь происходят две вещи. ;{:указывает, что этот и последний этап должны выполняться в цикле до тех пор, пока они не смогут изменить строку. :указывает, что результат этого этапа должен быть напечатан после каждой итерации, и ;указывает, что конечный результат цикла (и, следовательно, всей программы) не должен быть напечатан. Сама сцена просто заменяет xс|| || на первой итерации (и потом ничего не делает), так что теперь у нас есть первая строка требуемого вывода (и выведите его).

   //
  // 

Наконец, это сдвигает //один символ влево при условии, что осталось еще как минимум три пробела //. После этого мы возвращаемся к предыдущему этапу (который теперь печатает только текущую строку, поскольку больше нет xs), а затем повторяем.

Рубин, 60 байт

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

C 116 94 89 байт

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

Попробуйте это на Ideone

Рубин, 76 74 73 байта

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

В качестве функции требуется 73 72 байта, считая определение:

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

Powershell, 66 байт

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

C #, 150 байт

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

Тестирование:

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

Выход:

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

Groovy, 63 символа / байты

Вот моя попытка использования Groovy с использованием анонимного замыкания и простых циклов для вывода искусства ASCII в стандартный вывод:

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

Вы можете попробовать это онлайн здесь . Просто нажмите «Редактировать в консоли», а затем «Выполнить скрипт».

Пытаясь сделать то же самое и возвращая строку вместо печати, я не мог получить меньше 71 байта:

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

Python 3, 78 байт

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

Все еще пытаюсь сократить ...