Viết chương trình hoặc hàm có trong danh sách các số nguyên dương. Mỗi số nguyên này biểu thị độ dài cạnh của hình vuông trên mặt phẳng 2D. Mỗi hình vuông có thể được di chuyển đến bất kỳ tọa độ nguyên nào trong mặt phẳng, nhưng nó không thể xoay và nó không thể chồng lên các hình vuông khác.

Sử dụng một ký tự ASCII có thể in khác nhau cho mỗi ô vuông (không bao gồm không gian được sử dụng cho sự trống rỗng), chương trình / chức năng của bạn cần in bất kỳ sự sắp xếp nào của các hình vuông có đối xứng phản xạ ngang hoặc dọc. Nếu không có sự sắp xếp như vậy tồn tại thì không có gì nên được in.

Các hình vuông là các nhân vật khác nhau chỉ để họ có thể được phân biệt. Chỉ có hình dạng được tạo bởi sự kết hợp của tất cả các hình vuông cần phải đối xứng. Bạn có thể giả sử danh sách sẽ không chứa hơn 94 phần tử (vì có 94 ký tự).

Ví dụ: nếu đầu vào là [2, 1, 2, 2, 2], một đầu ra có thể là:

DD--
DD--
Z
FFPP
FFPP

Hình này có một đường đối xứng ngang; nửa trên và dưới của nó là hình ảnh phản chiếu. Dưới đây là một số khả năng khác: (Lưu ý rằng hình vuông không cần chạm và bất kỳ ký tự nào cũng có thể được sử dụng miễn là không có hai hình vuông được tạo từ cùng một ký tự.)

  55
  55
  %%
  %%
@
  HH
  HH
  ((
  ((

       G

     11 33
     11 33

    22   44
    22   44

Dòng đối xứng cũng có thể là ranh giới giữa các ký tự, ví dụ [2, 4]:

!!!!
!!!!  ++
!!!!  ++
!!!!

Một số bộ hình vuông không thể sắp xếp đối xứng, ví dụ [1, 2, 3]:

AAA BB C
AAA BB         (these can't be vertically or horizontally symmetric => no output)
AAA

Và hãy nhớ rằng hình dạng tổng thể có thể đối xứng ngay cả khi ranh giới hình vuông không. ví dụ: một đầu ra hợp lệ cho [2, 1, 1, 1, 1, 4]là:

AA----
AA----
BC----
DE----

Tương tự, một đầu ra hợp lệ cho [1, 1, 2, 3, 5]là:

44444
44444
44444
44444
44444
33301
33322
33322

Ghi chú

• Danh sách đầu vào sẽ luôn có từ 1 đến 94 yếu tố.
• Lấy đầu vào theo bất kỳ cách hợp lý nào: stdin, dòng lệnh, tệp văn bản, hàm arg. Nó có thể được định dạng một chút cho phù hợp với nhu cầu của bạn, ví dụ {1, 2, 3, 4}hoặc [1 2 3 4].
• Đầu ra cho thiết bị xuất chuẩn hoặc tương tự. Bất kỳ số lượng không gian hàng đầu / dấu hoặc dòng mới đều tốt miễn là hình dạng kết quả có đường đối xứng.
• Một đường chéo đối xứng không được tính (nếu không điều này sẽ siêu dễ dàng). Ngoài ra, nó phải là đối xứng phản xạ, không phải quay hoặc chuyển tiếp.
• Tôi thực sự không chắc nhiệm vụ này khó tính như thế nào. Bạn có thể đăng câu trả lời một phần giải quyết một số tập hợp con của vấn đề (đặc biệt nếu bạn muốn thể hiện một thuật toán đặc biệt thông minh). Những điều này không đủ điều kiện để giành chiến thắng.
  • Ví dụ: bạn có thể giả định rằng đầu vào luôn có ít nhất một sắp xếp đối xứng (vì vậy các danh sách như [1, 2, 3]không bao giờ là đầu vào).
  • Hoặc, ví dụ, bạn chỉ có thể xem xét các sắp xếp trong đó các ranh giới hình vuông, cũng như hình dạng tổng thể, là đối xứng. Trong trường hợp này, [1, 1, 2, 3, 5]sẽ không có đầu ra.
  • Nếu bạn muốn phát điên lên, bạn có thể mở rộng ý tưởng để hình chữ nhật hoặc thậm chí polyominoes .

Chấm điểm

Điểm của bạn là kích thước của chương trình của bạn theo byte . Điểm thấp nhất sẽ thắng. Tiebreaker đi câu trả lời được đăng đầu tiên.

Python 2, 460 452 437 byte

exec"""def f(L):
 if[]==L:
  X{2}[map(" ".__lt__,q)for q in G]);Z{2}zip(*X));C=Z==Z[::-1]or X==X[::-1]
  if C:print"\\n".join(map("".join,G))
  return C
 x=L[-1];T=S-x+1;R=range(x)
 for n in range(T*T):
  i=n%T;j=n/T
  if all({1}=" "{0}):
{0}:{1}chr(32+len(L))
   r=f(L[:-1])
{0}:{1}" "
   if r:return r""".format("   for a,b in[(a,b)for a in R for b in R]","G[i+a][j+b]=","=filter(sum,")
L=input()
S=sum(L)
G=[S*[" "]for _ in[0]*S]
f(L)

Bây giờ chỉ chơi golf nhẹ, nhưng đây là thứ để bắt đầu. Tôi đã thử sử dụng execcho dòng 10 và 12, nhưng vì một số lý do, nó đã không cho phép tôi.

Nhập danh sách Lqua STDIN, ví dụ [2, 1, 2, 2, 2]. Chương trình chỉ đơn giản là thử mọi khả năng đặt hình vuông vào sum(L) x sum(L)lưới.

Đầu ra mẫu (dòng trống được loại bỏ cho gọn):

[2, 1, 2, 2, 2]

%%       
%%       
$$       
$$       
"        
##       
##       
!!       
!!      

[2, 4]

""""  
""""  
""""  
""""  
 !!   
 !!   

[2, 1, 1, 1]

$!!  
#!!  
 "   

[1, 1, 2, 3, 5]

%%%%%       
%%%%%       
%%%%%       
%%%%%       
%%%%%       
$$$##       
$$$##       
$$$"!       

[1, 4, 1, 8]

$$$$$$$$      
$$$$$$$$      
$$$$$$$$      
$$$$$$$$      
$$$$$$$$      
$$$$$$$$      
$$$$$$$$      
$$$$$$$$      
# """" !      
  """"        
  """"        
  """"        

[8, 1, 4, 1]

$   !!!!!!!!  
    !!!!!!!!  
####!!!!!!!!  
####!!!!!!!!  
####!!!!!!!!  
####!!!!!!!!  
    !!!!!!!!  
"   !!!!!!!!  

(The algorithm starts placing from the last square first, prioritising left then up)

Phiên bản ít gây nhầm lẫn (452 ​​byte):

def f(L):
 if[]==L:
  X=filter(sum,[map(" ".__lt__,q)for q in G]);Z=filter(sum,zip(*X));C=Z==Z[::-1]or X==X[::-1]
  if C:print"\n".join(map("".join,G))
  return C
 x=L[-1];T=S-x+1;R=range(x);V=[(a,b)for a in R for b in R]
 for n in range(T*T):
  i=n%T;j=n/T
  if all(G[i+a][j+b]<"!"for a,b in V):
   for a,b in V:G[i+a][j+b]=chr(32+len(L))
   r=f(L[:-1])
   for a,b in V:G[i+a][j+b]=" "
   if r:return r
L=input()
S=sum(L)
G=[S*[" "]for _ in[0]*S]
f(L)