Hôm nay, ngày 11 tháng 11, được gọi là Ngày Tưởng niệm , Ngày đình chiến hoặc Ngày cựu chiến binh (tùy thuộc vào quốc gia), và là một ngày phản ánh và lòng biết ơn đối với các thành viên của quân đội và dịch vụ của họ, đặc biệt bắt đầu phản ánh sự chấm dứt của chiến sự châu Âu trong Thế chiến thứ nhất. Hãy để chúng tôi suy nghĩ về điều đó với một đầu ra nghệ thuật ASCII đơn giản 11/11.

Đưa ra một đầu vào n, đầu ra một biểu hiện nghệ thuật ASCII của đơn vị 11/11đó là ncao. Cụ thể, mỗi cái 1bao gồm các ống thẳng đứng ||, dấu gạch chéo bao gồm các dấu gạch chéo //và mỗi ký tự cách nhau hai khoảng cách. Lưu ý rằng điều này có nghĩa là thay đổi độ rộng đầu ra - ví dụ, đối với n=3bên dưới, hãy xem cách "đáy" của dấu gạch chéo là hai khoảng trắng từ 1bên trái của nó, nhưng là bốn khoảng cách từ 1bên phải của nó, sao cho đỉnh của dấu gạch chéo xếp hàng một cách thích hợp và là hai khoảng trắng từ 1bên phải của nó.

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


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


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


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


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

vân vân

Đầu vào

Một số nguyên dương duy nhất trong bất kỳ định dạng thuận tiện , n > 0.

Đầu ra

Một đại diện nghệ thuật ASCII 11/11, theo các quy tắc và ví dụ trên. Dòng mới hàng đầu / dấu hoặc khoảng trắng khác là tùy chọn, miễn là các ký tự xếp hàng một cách thích hợp.

Quy tắc

• Một chương trình đầy đủ hoặc một chức năng được chấp nhận. Nếu một chức năng, bạn có thể trả lại đầu ra thay vì in nó.
• Sơ hở tiêu chuẩn bị cấm.
• Đây là môn đánh gôn, vì vậy tất cả các quy tắc chơi gôn thông thường đều được áp dụng và mã ngắn nhất (tính bằng byte) sẽ thắng.

Thạch , 24 byte

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

Dùng thử trực tuyến!

Làm sao?

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

Hãy thử trực tuyến!

Giải trình

                          # 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

Phiên bản 26 byte trước đó

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

Hãy thử trực tuyến!

Perl, 45 byte

-9 byte nhờ @Gabriel Benamy

47 byte mã + 1 byte cho -ncờ.

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

Chạy với -nEcờ:

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

Cách tiếp cận đệ quy có thể không thể không ngắn nhất .

.map phiên bản (88 byte):

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

Hiểu mảng (86 byte):

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

for phiên bản vòng lặp (89 byte):

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

.replace phiên bản (85 byte):

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

Võng mạc, 29 byte

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

Cổng giải pháp JavaScript của tôi. Lưu ý không gian sau $*và hai không gian sau ||.

V , 30 byte

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

Hãy thử trực tuyến!

Như thường lệ, đây là một hexdump:

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

Hàng loạt, 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: //=// %

Không phải là một cổng của giải pháp JavaScript của tôi. Vì |khó thao tác trong Batch, tôi sử dụng xs làm trình giữ chỗ và thay thế chúng ở đầu ra, điều này thuận tiện cũng làm giảm kích thước mã của tôi. Bắt đầu bằng cách đặt sthành đầu ra mong muốn cho n=1( nđược truyền trên dòng lệnh), sau đó chèn khoảng trắng khi cần thiết để có được dòng đầu tiên cho giá trị thực của n, sau đó lặp qua in chuỗi và dịch chuyển dấu gạch chéo mỗi lần một ký tự.

BaCon , 71 byte

Một chương trình BASIC hoàn chỉnh trong một dòng.

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

Lisp thông thường, 216 byte

Tôi sẽ tuyên bố ngay lập tức rằng đây là một giải pháp khủng khiếp cho thử thách. Tuy nhiên, nó hoạt động, và tôi mệt mỏi.

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

Sử dụng:

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

Vì một số lý do, thay vì làm bất cứ điều gì lành mạnh, tôi quyết định tiếp cận điều này với một vòng lặp bên trong một formatcuộc gọi. Vòng lặp này lặp lại thông qua các nội dung được trả về bởi cấu trúc vòng lặp thực tế khác ở cuối, với sáu phần tử cuối cùng được loại bỏ (do đó các butlasts lặp lại ). Nội dung của giá trị được trả về bởi cấu trúc vòng lặp này bao gồm số lượng đệm cho mặt trước của dấu gạch chéo, ký tự đệm (khoảng trắng), số lượng đệm cho mặt sau của dấu gạch chéo và cuối cùng là các ký tự đệm.

Tôi còn khá mới mẻ với Lisp và tôi hiểu rằng chắc chắn có rất nhiều cơ hội để cải thiện ở đây.

Python 2, 76 75 71 byte

Vẫn làm việc trên một phiên bản ngắn hơn, mặc dù không quá tệ.

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

^{cảm ơn mbomb007 vì đã bắt lỗi!}

R, 86 byte

Chỉ là một forcách tiếp cận vòng lặp đơn giản :

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

Võng mạc , 40 byte

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

Hãy thử trực tuyến!

Giải trình

.+
x $&$* //  x

Điều này biến đầu Nvào thành

x S//  x

Trường hợp Stương ứng với Nkhông gian.

;{:`x
||  ||

Có hai điều xảy ra ở đây. ;{:chỉ ra rằng giai đoạn này và giai đoạn cuối cùng sẽ được chạy trong một vòng lặp cho đến khi chúng không thay đổi chuỗi. :chỉ ra rằng kết quả của giai đoạn này nên được in sau mỗi lần lặp và ;chỉ ra rằng kết quả cuối cùng của vòng lặp (và do đó của toàn bộ chương trình) không nên được in. Bản thân giai đoạn chỉ thay thế xs bằng || ||lần lặp đầu tiên (và không làm gì sau đó), để bây giờ chúng ta có dòng đầu tiên của đầu ra cần thiết (và in nó).

   //
  // 

Cuối cùng, điều này sẽ dịch chuyển //một ký tự sang trái, với điều kiện vẫn còn ít nhất ba khoảng trắng bên trái //. Sau đó, chúng tôi trở lại giai đoạn trước (hiện chỉ in dòng hiện tại, vì không còn xs) và sau đó lặp lại.

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

Dùng thử trên Ideone

Ruby, 76 74 73 byte

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

Là một hàm, nó cần 73 72 byte, đếm định nghĩa:

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

Chơi gôn

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;

Ung dung:

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

Kiểm tra:

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

Đầu ra:

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

Groovy, 63 ký tự / byte

Đây là nỗ lực của tôi với Groovy, sử dụng một bao đóng ẩn danh và các vòng lặp đơn giản để in nghệ thuật ASCII thành đầu ra tiêu chuẩn:

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

Bạn có thể thử nó trực tuyến ở đây . Chỉ cần nhấp vào "Chỉnh sửa trong bảng điều khiển" và sau đó "Thực thi tập lệnh".

Cố gắng làm tương tự và trả về một chuỗi thay vì in, tôi không thể nhận được dướ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)

Vẫn đang cố rút ngắn ...