Lấy hai danh sách các số nguyên không âm và xuất ra hộp ASCII như được xác định bên dưới.

• Các góc và giao điểm là điểm cộng: +(ASCII-mã 43)
• Các đường thẳng đứng là các thanh |(ASCII-mã 124)
• Các đường ngang là các điểm trừ -(ASCII - mã 45)

Danh sách đầu vào đầu tiên chỉ định số lượng điểm trừ giữa mỗi dấu cộng, theo hướng ngang.

Danh sách đầu vào thứ hai chỉ định số lượng thanh giữa mỗi dấu cộng, theo hướng dọc.

Thật dễ dàng để giải thích với một vài ví dụ:

0    // No minuses between each + sign
0    // No bars between + signs

++
++

------------------
1 2   // First a single minus, then two minuses 
1 2   // First  one bar, then two bars

+-+--+
| |  |
+-+--+
| |  |
| |  |
+-+--+


------------------
1 0 3 0 2 0
2 1 0 0

+-++---++--++
| ||   ||  ||
| ||   ||  ||
+-++---++--++
| ||   ||  ||
+-++---++--++
+-++---++--++
+-++---++--++

Làm rõ:

• Thứ tự và định dạng đầu vào là tùy chọn
• Chỉ các hộp nên được in / hiển thị, nhưng không gian dấu hoặc dòng mới được chấp nhận.
• Bạn có thể tùy chọn thêm 1 vào tất cả các giá trị đầu vào nếu thuận tiện hơn. Ví dụ thứ hai sau đó sẽ là : 2 3; 2 3.

Đây là mã golf, vì vậy mã ngắn nhất tính bằng byte sẽ thắng.

MATL , 25 22 21 byte

'|-+ '2:"1tiYsQ(]E!+)

Sử dụng đầu vào có 1thêm (được cho phép bởi thử thách).

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

Giải trình

Mã ban đầu xây dựng một mảng chứa 1các chỉ mục cột của các ký tự không phải khoảng trắng trong kết quả cuối cùng, và 0ngược lại. Vì vậy, nếu đầu vào đầu tiên là [2 1 4 1 3 1](sẽ [1 0 3 0 2 0]ở định dạng dựa trên 0) thì mảng này sẽ là

1 0 1 1 0 0 0 1 1 0 0 1 1

Lưu ý cách độ dài chạy của số không liên quan đến đầu vào. Cụ thể, mảng này được xây dựng như sau:

1. Bắt đầu mảng thành một 1.
2. Tính tổng tích lũy của đầu vào và thêm 1. Trong ví dụ này cho [3 4 8 9 12 13].
3. Mở rộng mảng từ bước 1 bằng cách gán 1cho các mục có chỉ số (dựa trên 1) được đưa ra bởi bước 2. Các mục trung gian được tự động đặt thành 0.

Một mảng tương tự được xây dựng cho các hàng. Đầu vào thứ hai [3 2 1 1](hoặc [2 1 0 0 ]) cho

1 0 0 1 0 1 1 1

Bây giờ mảng thứ hai được nhân với 2, hoán vị và thêm vào phát sóng đến đầu tiên. Điều này mang lại cho mảng 2D

3 2 3 3 2 2 2 3 3 2 2 3 3
1 0 1 1 0 0 0 1 1 0 0 1 1
1 0 1 1 0 0 0 1 1 0 0 1 1
3 2 3 3 2 2 2 3 3 2 2 3 3
1 0 1 1 0 0 0 1 1 0 0 1 1
3 2 3 3 2 2 2 3 3 2 2 3 3
3 2 3 3 2 2 2 3 3 2 2 3 3
3 2 3 3 2 2 2 3 3 2 2 3 3

Lập chỉ mục vào chuỗi '|-+ 'cho kết quả cuối cùng dưới dạng mảng char 2D. Vì lập chỉ mục là mô-đun và dựa trên 1, chỉ mục 0tương ứng với phần tử cuối cùng (dấu cách).

'|-+ '                   % Push this string
      2:"       ]        % Do this twice
         1               % Push 1 (initial array)
          t              % Push another 1 (contents to be filled in)
           i             % Take input
            Ys           % Cumulative sum
              Q          % Add 1
               (         % Fill 1 into those entries of the array
                 E       % Multiply by 2
                  !      % Transpose
                   +     % Add, with broadcast
                    )    % Index (modular, 1-based) into the string

Python 2, 117 byte

def f(h,v):r="+"+"+".join("-"*i for i in h)+"+\n";print r+r.join(("|"+"|".join(" "*i for i in h)+"|\n")*i for i in v)+r

Hãy thử nó trên ideone.

Không mong đợi quá nhiều từ điều này. Thực sự đơn giản, chỉ cần sử dụng tham gia python và nhân chuỗi để kéo mọi thứ lại với nhau.

JavaScript (ES6), 83 byte

(a,b,g=(a,[s,t])=>t+a.map(n=>s.repeat(n)+t).join``+`
`)=>g(b,[g(a,` |`),g(a,`-+`)])

Đầu ra bao gồm hai dòng mới.

CJam, 50 byte

0lS/:i0++:H;lS/:i0+{H{'-*}%'+*N+o{H{S*}%'|*N+o}*}%

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

Bình thường, 45 byte

AQj.i*hlH]Js.i*hlG\+m*d\-G-mjb*d]XJ"+-""| "Hk

Một chương trình lấy đầu vào của hai danh sách được phân tách bằng dấu phẩy trên STDIN và in kết quả.

Có lẽ vẫn còn một số golf để được thực hiện ở đây.

Dùng thử trực tuyến

Giải thích sau

Haskell, 55 byte

f[a,b]x=a:do n<-x;(b<$[1..n])++[a]
g x=f[f"+-"x,f"| "x]

Xác định hàm glấy hai danh sách đầu vào và trả về danh sách chứa các dòng của đầu ra

PowerShell v2 +, 89 byte

param($a,$b)($x="+$(($a|%{'-'*$_})-join'+')+")
$b|%{,"|$(($a|%{' '*$_})-join'|')|"*$_;$x}

Dang, đừng nghĩ rằng tôi hoàn toàn có thể bắt được JavaScript.

Đưa đầu vào $avà$b như là mảng rõ ràng. Đặt biến $xlà hàng trên cùng của các hộp dựa trên việc lặp qua $avà một số nối chuỗi. Cái đó được gói gọn trong các ô, vì vậy nó được đặt trên đường ống. Sau đó, chúng tôi lặp lại $b, mỗi lần lặp đặt hai chuỗi trên đường ống - chuỗi kiểu giống nhau nhưng có khoảng trắng và |thay vì dấu gạch nối và +, và $x. Các chuỗi đó được tập hợp từ đường ống với ẩn Write-Outputkhi hoàn thành chương trình, với dòng mới mặc định giữa chúng.

Ví dụ

PS C:\Tools\Scripts\golfing> .\make-some-ascii-boxes.ps1 @(0) @(0)
++
++

PS C:\Tools\Scripts\golfing> .\make-some-ascii-boxes.ps1 @(1,0,3,0,2,0) @(2,1,0,0)
+-++---++--++
| ||   ||  ||
| ||   ||  ||
+-++---++--++
| ||   ||  ||
+-++---++--++
+-++---++--++
+-++---++--++

PS C:\Tools\Scripts\golfing> .\make-some-ascii-boxes.ps1 @(1,4,1) @(1,2,1)
+-+----+-+
| |    | |
+-+----+-+
| |    | |
| |    | |
+-+----+-+
| |    | |
+-+----+-+

Ruby, 66 byte

->x,y{d=->c,m,z=x{c+z.map{|w|m*w}*c+c+$/}
d[d[?+,?-],d[?|,' '],y]}

Thạch , 30 26 byte

Ḣị“+-“| ”ị@
1;+\Ṭ
Ç€,€/Ñ€Y

Kiểm tra nó tại TryItOnline

Làm sao?

Đầu vào được lấy là một danh sách gồm hai danh sách [vertical, horizontal]và sử dụng tùy chọn tăng dần
- vì vậy, ví dụ 3 lấy [[3,2,1,1], [2,1,4,1,3,1]]
Mỗi cái sau đó được chuyển đổi thành một mảng boolean chỉ ra rowType hoặc rowCharacterType, ví dụ: [[1,0,0,1,0,1,1,1], [1,0,1,1,0,0,0,1,1,0,0,1,1]]
Các hộp được xây dựng bằng cách tạo các hàng từ các ký tự được xác định bởi các kết hợp rowType và rowCharacterType - tức là một rowType xác định một "+-"hoặc "| "một rowCharacterType xác định một trong hai ký tự đó.

Ḣị“+-“| ”ị@ - Link 1, create a row: [rowType, [rowCharaterTypes]]
Ḣ           - head - get the rowType
  “+-“| ”   - list of strings ["+-", "| "]
 ị          - index into (if rowType is 1 "+-"; if rowType is 0 "| ")
         ị@ - index into with reversed operands (index into that from rowCharaterTypes)
                (replace each 1 in rowCharaters with "+" or "|" and each 0 with "-" or " ")

1;+\Ṭ - Link 2, create the Type lists from the inputs: int[] nCharacters
1;    - 1 concatenated with the input
  +\  - reduce with addition (accumulation provides the indices)
    Ṭ - boolean array with 1s at those indices
            As an example take the vertical of example 3:
            [3,2,1,1] -> [1,3,2,1,1] -> [1,4,6,7,8] -> [1,0,0,1,0,1,1,1]
            each of which will be passed as a rowType for Link 1

Ç€,€/Ñ€Y - Main link, takes one argument: [Vertical, Horizontal] (incremented option)
Ç€       - call the last link (2) for each of the two lists in the input
  ,€/    - pair each and reduce (making a list of [rowtype [rowCharacterTypes]])
     р  - call the next link (1) for each
       Y - join on line feeds