Lý lịch

Đây là sự tiếp nối của thử thách trước đây của tôi , trong đó nhiệm vụ là tính toán hình dạng của một tác phẩm điêu khắc thu được bằng cách thả nam châm vào một đống lớn.

Tin tốt: nghệ sĩ lập dị thích công việc của bạn, và có một dự án khác cho bạn. Ông vẫn làm việc với các tác phẩm điêu khắc từ tính, nhưng đã quyết định mở rộng studio nghệ thuật của mình - vào không gian ! Phương pháp hiện tại của anh là bắn một nam châm hình khối đơn vào quỹ đạo và bắn các nam châm khác vào nó để tạo ra một vệ tinh từ tính khổng lồ.

Đầu vào

Đầu vào của bạn là một danh sách hữu hạn của 0s và 1s, được đưa ra ở định dạng danh sách gốc của ngôn ngữ của bạn hoặc một chuỗi. Nó được hiểu là một "bản thiết kế" của một tác phẩm nghệ thuật và được xử lý theo thứ tự từ trái sang phải như sau.

Bạn bắt đầu với một nam châm đơn trôi nổi tại một số tọa độ nguyên của mặt phẳng 2D và tiếp tục thêm nhiều nam châm theo chỉ thị. Lệnh này 0xoay toàn bộ tác phẩm điêu khắc 90 độ theo hướng ngược chiều kim đồng hồ. Trong trường hợp của chỉ thị 1, nghệ sĩ tìm thấy cột ngoài cùng bên trái của tác phẩm điêu khắc và bắn một nam châm mới vào nó từ bên dưới. Nam châm mới dính vào nam châm tồn tại dưới cùng trong cột và trở thành một phần của tác phẩm điêu khắc. Lưu ý rằng nam châm không dính vào các nam châm khác trong cột lân cận, không giống như trong thử thách trước đó; tốc độ của nó bây giờ là thiên văn!

Đầu ra

Nghệ sĩ muốn biết liệu tác phẩm điêu khắc hoàn chỉnh có phù hợp với nhà để xe của anh ấy không (làm thế nào anh ấy sẽ đưa nó xuống từ quỹ đạo vẫn chưa rõ ràng). Do đó, đầu ra của bạn là chiều rộng và chiều cao của tác phẩm điêu khắc, được sắp xếp từ thấp hơn đến cao hơn. Chúng có thể được cung cấp dưới dạng danh sách hai thành phần, cặp hoặc chuỗi được phân tách bằng dấu phẩy.

Thí dụ

Xem xét chuỗi đầu vào

[1,0,1,1,0,1,0,0,1,1]

Để xử lý nó, chúng tôi bắt đầu với một nam châm trôi nổi trong không gian:

#

Lệnh đầu tiên là 1, vì vậy chúng tôi bắn một nam châm mới từ bên dưới:

#
#

Lệnh tiếp theo là 0, vì vậy chúng tôi xoay tác phẩm điêu khắc:

##

Hai chỉ thị tiếp theo là 1,1, có nghĩa là chúng ta sẽ bắn hai nam châm vào cột ngoài cùng bên trái:

##
#
#

Sau đó, chúng tôi xoay một lần nữa và bắn một lần, theo chỉ dẫn của 0,1:

#
###
#

Cuối cùng, chúng tôi xoay hai lần và bắn hai lần:

  #
###
# #
#

Các tác phẩm điêu khắc kết quả có chiều rộng 3và chiều cao 4, vì vậy chúng tôi đầu ra [3,4].

Quy tắc

Bạn có thể cung cấp một chức năng hoặc một chương trình đầy đủ. Số byte thấp nhất sẽ thắng và các sơ hở tiêu chuẩn không được phép.

Các trường hợp thử nghiệm

[1,0,1] -> [2,2]
[1,0,1,1,0,1,0,0,1,1] -> [3,4]
[1,1,0,1,1,0,1,0,1,1] -> [4,5]
[1,1,0,1,1,0,1,0,1,1,0] -> [4,5]
[1,0,1,0,0,0,1,1,0,0,0,1,1,0,0,0,1,1] -> [3,3]
[0,1,0,1,1,1,1,0,0,1,0,1,0,0,1,1,0,1,0,1,0,0,1,1,0,1,0,0,0,0,1,0,1,0,1,1,0,0,1,1] -> [5,7]
[1,0,1,1,1,1,0,1,0,0,0,0,1,1,1,0,1,1,0,1,0,1,0,0,0,0,0,0,1,1,0,1,0,1,1,1,1,0,1,1,0,0,1,1,1,1,0,0,0,0,1,1,0,0,1,1,0,1,0,0,1,1,0,1,1,0,0,1,0,1,0,0,1,0,1,1,1,0,1,1,0,0,1,0,1,1,0,0,0,1,0,1,1,0,0,1,0,1,1,0] -> [11,12]

Pyth : 34 33 byte

Sml{dCuS?+G,hhGtehGHm,_ekhkGQ],ZZ

Đầu vào là một danh sách các số và số không, giống như trong câu hỏi. Dùng thử trực tuyến: Trình biên dịch / thực thi Pyth

Giải trình:

Đây là bản dịch một đối một của mã Python 2 sau ( 126 byte ).

print sorted(map(len,map(set,zip(*reduce(lambda s,i:([[-b,a]for a,b in s],s+[[min(s)[0],min(s)[1]-1]])[i],input(),[[0,0]])))))

Tôi tạo một danh sách tọa độ của các nam châm đơn. Điều này được khởi tạo với nam châm [0,0]. Sau đó, đối với mỗi số nguyên của kế hoạch chi tiết, tôi thao tác danh sách theo cách sau. Nếu số nguyên tiếp theo là 0, tôi xoay tác phẩm điêu khắc bằng cách thay đổi tọa độ cho mỗi nam châm [a,b]thành [-b,a](về cơ bản nhân với ma trận xoay). Nếu số nguyên tiếp theo là a 1, tôi tìm kiếm mảnh tối thiểu [a,b](tự động là nam châm thấp nhất của cột ngoài cùng bên trái) và nối nam châm [a,b-1]vào danh sách.

Sau khi tất cả các đầu vào được xử lý, tôi tạo 2 bộ (để loại bỏ trùng lặp), một cho các giá trị x và một cho các giá trị y và in các kích thước của chúng theo thứ tự được sắp xếp.

Sml{dCuS?+G,hhGtehGHm,_ekhkGQ],ZZ
                             ],ZZ  starting list G=[(0,0)]
      u                     Q],ZZ  for H in input(): manipulate G
       S                              Sort G after each manipulation
        ?          H                  G = ... if H==1 else ...
                    m,_ekhkG            [(-b,a) for a,b in G)] (rotate)
         +G,hhGtehG                     G+[(G[0][0],G[0][1]-1)]
                                        (G[0] is the lowest magnet in the leftmost column)
     C                             Zip the coords together
                                    (creates 2 lists, x- and y-coords)
 ml{d                              for each of those list compute number of unique values
S                                  sort and print

Một ý tưởng để cải tiến : Sử dụng số phức làm coords cho nam châm. Một vòng quay chỉ là một phép nhân bằng jvà trừ đi jtừ nam châm thấp nhất trong cột ngoài cùng bên trái. Đáng buồn thay, việc tìm kiếm nam châm ngoài cùng bên trái thấp nhất này chiếm quá nhiều ký tự trong Python, thậm chí không nói đến việc tìm hình chữ nhật.

CJam, 48 byte

S]l~{{)S/);Sa+S*a+_z,f{_N*@\+<}}{zW%}?}/_,\z,]$p

Kiểm tra nó ở đây.

Yêu cầu đầu vào dưới dạng mảng kiểu CJam (nghĩa là khoảng trắng thay vì dấu phẩy) và sẽ hiển thị đầu ra tương tự. Nếu bạn muốn sử dụng trực tiếp các trường hợp kiểm tra từ câu hỏi, hãy sao chép chúng thẳng vào trường nhập (bao gồm ->và kết quả) và sử dụng khai thác kiểm tra này để chuyển đổi các dòng thành định dạng đầu vào chính xác (và loại bỏ kết quả):

qN/{S/0=","Ser}%{[

S]\~{{)S/);Sa+S*a+_z,f{_N*@\+<}}{zW%}?}/_,\z,]$p

}/

Giải trình

Tôi chỉ thực hiện các quy tắc theo nghĩa đen. Tôi đang giữ một lưới với tác phẩm điêu khắc hiện tại (dưới dạng một chuỗi các chuỗi), và sau đó với mỗi lệnh tôi sẽ xoay lưới hoặc tôi thêm một khối mới. Các thủ thuật chính để lưu byte là:

• Thêm vào hàng dưới cùng từ bên phải . Điều này là hoàn toàn tương đương. Tôi chỉ là một vòng quay phía trước, và vì lưới điện bắt đầu bất biến xoay vòng, điều đó không thành vấn đề.
• Sử dụng một khoảng trắng để thể hiện các khối bị chiếm đóng và một ký tự dòng mới để thể hiện các khối trống. Vì vậy, nếu bạn thực sự in ra lưới, bạn sẽ không nhìn thấy nhiều và thậm chí nó sẽ không có hình chữ nhật. Tôi đang làm điều này, bởi vì hầu hết các toán tử dựa trên mảng chỉ làm những gì bạn muốn nếu phần tử lưới trong câu hỏi được gói trong một mảng. Và với Svà Ntôi có quyền truy cập vào các chuỗi chứa ký tự khoảng trắng và dòng mới (tức là ký tự được gói trong một mảng), thay vì phải sử dụng, giả sử 1avà 0ađể có được một mảng chứa một số.

Chúng ta hãy đi qua mã:

"Overall program structure:";
S]l~{{...}{...}?}/_,\z,]$p
S]                         "Push a string with a space and wrap it in an array.
                            This is the initial grid containing a single block.";
  l~                       "Read the input and evaluate it.";
    {           }/         "For each instruction in the input...";
     {...}{...}?           "Execute the first block if it's 1, the second if it's 0.";
                  _,       "Duplicate the resulting grid and get its length. This
                            is one of the dimensions.";
                    \      "Swap with the other copy of the grid.";
                     z,    "Zip/transpose it and get its length. This is the other
                            dimension of the grid.";
                       ]$p "Wrap both in an array, sort them, and print the result.";

"The rotation block is simple. A rotation is equivalent to two reflection operations
 along different axes. The simplest ones available are to transpose the grid (which
 is a reflection about the diagonal) and reversing the rows (which is a reflection
 about the horizontal). In CJam these are z for zip/tranpose and W% for reversing
 an array. So I simply put these together in the right order to get a counter-
 clockwise rotation:";
zW%

"Now the interesting part, adding new blocks and growing the grid. This part consists
 of two steps: appending a block to the rightmost block in the bottom row (allowing
 for empty blocks after it). And then potentially padding the rest of the grid with
 new empty cells if the bottom row got longer.";
)S/);Sa+S*a+_z,f{_N*@\+<}
)                         "Split off the bottom row.";
 S/                       "Split the row on occupied blocks.";
   );                     "Split off the final substring - this discards trailing
                           empty cells.";
     Sa+                  "Add a new substring containing an occupied block to the row.";
        S*                "Join all substrings together with spaces, putting back in
                           all the occupied blocks.";
          a+              "Wrap it in an array to add the row back onto the grid.";

 "At this point we need to make sure the grid is still rectangular. The easiest way
  (I found) is to find the maximum row length, add that many empty blocks to each 
  line and then truncate the lines to that length.";

            _             "Duplicate the grid.";
             z,           "Zip/transpose it and get the length. This is the length
                           of the longest row in a ragged array.";
               f{       } "Map this block onto each row, passing in the target length.";
                 _N*      "Duplicate the target length and get a string of that many
                           empty cells.";
                    @\    "Pull up the row and then swap it with those empty cells.";
                      +   "Add the empty cells to the end of the row.";
                       <  "Truncate to the target length.";

Matlab (92)

S=1;for d=input(''),if d,S(find(S(:,1),1,'last')+1,1)=1;else,S=rot90(S);end;end,sort(size(S))

Đầu vào tiêu chuẩn được sử dụng. Dữ liệu nên được giới thiệu trong mẫu [1,0,1,1,0,1,0,0,1,1].

Ung dung:

S = 1; %// initial magnet
for d = input('') %// get directives, and pick them sequentially
    if d %// if directive is 1
        S(find(S(:,1),1,'last')+1,1) = 1; %// add 1 after lowest 1 in column 1. Grow if needed
    else %// if directive is 0
        S = rot90(S); %// rotate counterclockwise. Handy Matlab built-in function
    end
end
sort(size(S)) %// display size sorted

Chạy ví dụ:

>> clear all
>> S=1;for d=input(''),if d,S(find(S(:,1),1,'last')+1,1)=1;else,S=rot90(S);end;end,sort(size(S))
[1,0,1,1,0,1,0,0,1,1]
ans =
     3     4

Con trăn - 211

import numpy as n
p=input()
q=len(p)
a=n.zeros([2*q+1]*2)
a[q,q]=1
for i in p:
 if i:x=a[:,n.where(a.any(0))[0][0]];x[len(x)-n.where(x[::-1])[0][0]+1]=1
 else:a=n.rot90(a)
z=a[:,a.any(1)]
print z[a.any(0)].shape

CJam, 47 byte

1]]q~{{0f+(W%_1#(1tW%a\+z{1b},}{W%}?z}/),\,)]$p

Điều này sẽ đưa đầu vào mảng theo kiểu CJam (được phân tách bằng dấu phẩy thay vì dấu phẩy) từ STDIN và in kết quả sang STDOUT.

Thí dụ:

[1 0 1 0 0 0 1 1 0 0 0 1 1 0 0 0 1 1]

cho

[3 3]

đầu ra.

Giải thích để làm theo sau khi tôi tin rằng điều này không thể được đánh gôn hơn nữa.

Dùng thử trực tuyến tại đây