Có hai miếng gỗ. Cả hai bao gồm một cơ thể thẳng và một số khối bổ sung bên dưới cơ thể. Một ví dụ với các khối bổ sung tại các vị trí (được lập chỉ mục 0) 0,4,7,9,10:

XXXXXXXXXXX
X   X  X XX

Các mảnh có thể được biểu diễn dưới dạng một 01chuỗi nhị phân với iký tự thứ hiển thị nếu có một khối ở ivị trí thứ. Ví dụ trên có thể được biểu diễn dưới dạng 10001001011.

Chúng ta có thể ghép hai mảnh lại bằng cách lật theo chiều dọc thứ hai (và có thể lật nó theo chiều ngang). Sau khi lật (s) chúng ta có thể tìm thấy một căn chỉnh trong đó hai mảnh có thể được đặt cùng nhau để có chiều cao là 3.

Two example pieces:

XXXXXXXXXXX   XXXXXXXX
X   X  X XX     XXX

Second piece flipped vertically and horizontally:

 XXXXXXXXXXX   
 X   X  X XX
  XXX
XXXXXXXX

Pieces put together:

 XXXXXXXXXXX   
 XXXXX  X XX
XXXXXXXX

Ví dụ dẫn đến tổng chiều rộng là 12 khối.

Bạn nên viết một chương trình hoặc hàm nhận hai chuỗi làm đầu vào đại diện cho hai phần và xuất ra một số nguyên có chiều rộng tối thiểu có thể đạt được với chiều cao là 3.

Đầu vào

• Hai chuỗi bao gồm các ký tự 0và 1.
• Cả hai chuỗi chứa ít nhất một ký tự.
• Bạn có thể chọn nhận hai chuỗi dưới dạng một chuỗi được nối bởi một khoảng trắng.

Đầu ra

• Một số nguyên dương duy nhất, tổng chiều rộng tối thiểu có thể đạt được.

Ví dụ

0 0  =>  1

1 0  =>  1

1 1  =>  2

11 111  =>  5

010 0110  =>  5

0010 111  =>  5

00010 11011  =>  6

01010 10101  =>  5

1001 100001  =>  6

1110001100001 1100100101  =>  14

001101010000101 100010110000  =>  16

0010110111100 001011010101001000000  =>  21

0010110111100 001011010101001001100  =>  28

100010100100111101 11100101100010100100000001  =>  27

0010 10111  =>  5

0100 10111  =>  5

0010 11101  =>  5

0100 11101  =>  5

10111 0010  =>  5

10111 0100  =>  5

11101 0010  =>  5

11101 0100  =>  5

Đây là mã golf nên mục ngắn nhất sẽ thắng.

Pyth, 37 35 34 32 31 byte

eSX0lM.zff-\1@VhY>eYT*Fm,d_d.z0

Đưa dòng mới đầu vào tách ra.

Trình diễn , thử nghiệm khai thác .

Giải trình:

Ở cấp độ cao, đối với mỗi kết hợp của chuỗi bình thường và chuỗi đảo ngược, chúng tôi dịch chuyển chuỗi thứ hai sang trái theo một số vị trí nhất định và kiểm tra sự chồng chéo với chuỗi đầu tiên. Điều này được lặp lại cho đến khi một lượng thay đổi không có sự trùng lặp được tìm thấy. Lượng dịch chuyển đó được thêm vào độ dài chuỗi thứ nhất và kết quả được so sánh với độ dài chuỗi thứ hai. Giá trị cao hơn được in.

eSX0lM.zff-\1@VhY>eYT*Fm,d_d.z0

                            .z     The list of the two input strings.
                       m           Map to 
                        ,d_d       The pair of each string and its reverse.
                     *F            Take the cartesisan product of those lists.
         f                         Filter those pairs of a first string and a 
                                   second string, possibly reversed,
          -\1                      On the absence of the string "1" in
             @V                    The vectorized intersection (intersection
                                   of 0th position, 1st position, etc.) of
               hY                  the first string and
                 >eYT              the second string without the first T elements.
        f                    0     Starting at 0 and counting upwards, find the
                                   lowest T where the result is truthy. 
                                   (where anything passes the inner filter)
    lM.z                           Map the input strings to their lengths.
  X0                               Add the above result to the first entry.
eS                                 Take the maximum of the two values and print.

Pip , 72 70 48 byte

Fp[aRVa]CP[bRVb]L#a+1{I2NI$+plAE:#$+^pp@1.:0}MNl

Lấy hai chuỗi làm đối số dòng lệnh. Được định dạng, với ý kiến:

                     a, b initialized from cmdline args; l is [] (implicit)
F p [aRVa]CP[bRVb]   For each possible pair p of a/reverse(a) with b/reverse(b):
 L #a+1 {            Loop for each potential offset of bottom piece:
  I 2 NI $+p         If no 2's in the sum of p:
   l AE: # $+ ^p     Append the max width of elements of p to l (see below for explanation)
  p@1 .: 0           Append a 0 to bottom piece
 }
MNl                  The answer is min(l); print it (implicit)

Chúng tôi chỉ tính toán các phần trùng lặp trong đó phần dưới cùng nhô ra bên trái, vì vậy chúng tôi cần thử lại với cả phần trên và phần dưới cùng đảo ngược. Mỗi lần qua vòng lặp bên trong, nếu không có 2 giây trong tổng số thì đó là một sự phù hợp; sau đó chúng tôi giải quyết một số 0 khác vào cuối phần dưới cùng và thử lại.

   0010
    111
   0121

   0010
   111_
   1120

   0010
  111__
  11110

   0010
 111___
 111010

   0010
111____
1110010

Để tìm tổng chiều rộng, chúng tôi chia các yếu tố pthành danh sách các ký tự và tổng. Các thao tác theo mục trên các danh sách có độ dài không đồng đều giữ nguyên độ dài của danh sách dài hơn, vì vậy độ dài của tổng này là chính xác những gì chúng ta cần. (Việc chia tách là cần thiết vì chỉ cần tính tổng là số sẽ loại bỏ các số 0 đứng đầu : $+[0101 10] = 111, nhưng $+^[0101 10] = [0 1 1 1].)

C:\> pip.py woodPacking.pip 0010 111
5

Ruby 127 130

Điều này hóa ra là rất lâu ... :(

->m,n{[[m,n],[m,n.reverse],[n,m],[n,m.reverse]].map{|u,d|[(0..l=u.size).find{|i|(d.to_i(2)<<i)&u.to_i(2)<1}+d.size,l].max}.min}

Các xét nghiệm: http://ideone.com/te8XWk

Ruby có thể đọc được:

def pack_length piece1, piece2
  min_possible_packed_length = [
    min_packed_length(piece1, piece2),
    min_packed_length(piece1, piece2.reverse),
    min_packed_length(piece2, piece1),
    min_packed_length(piece2, piece1.reverse)
  ].min

  min_possible_packed_length
end

def min_packed_length up_piece, down_piece
  x = up_piece.to_i 2
  y = down_piece.to_i 2

  # find the smallest shift for the piece placed down 
  # so that they fit together
  min_packed_shift = (0..up_piece.size).find{|i| (y<<i)&x<1 }

  # min pack length cannot be smaller than any of the 
  # two pieces
  [min_packed_shift + down_piece.size, up_piece.size].max
end

JavaScript ( ES6 ) 160

Không thể rút ngắn ...

F=(a,b,c=[...b].reverse(),
K=(a,b,t=a.length)=>{
for(e=i=-1;e&&i++<t;)for(e=j=0;u=b[j];j++)e|=u&a[j+i];
return t<i+j?i+j:t
})=>Math.min(K(a,b),K(a,c),K(b,a),K(c,a))

// test

out=x=>O.innerHTML += x+'\n'

test=[
 ['0', '0', 1],['1', '0', 1],['1', '1', 2],['11', '111', 5]
,['010', '0110', 5],['0010', '111', 5],['0010', '10111', 5]
,['00010', '11011', 6],['01010', '10101', 5],['1001', '100001', 6]
,['1110001100001', '1100100101', 14]
,['001101010000101', '100010110000', 16]
,['0010110111100', '001011010101001000000', 21]
,['0010110111100', '001011010101001001100', 28]
,['100010100100111101', '11100101100010100100000001', 27]
,['0010','10111', 5],['0100','10111', 5]
,['0010','11101', 5],['0100','11101', 5]
,['10111','0010', 5],['10111','0100', 5]
,['11101','0010', 5],['11101','0100', 5]
]

test.forEach(t=>{
  r = F(t[0],t[1]),
  out(
    (r==t[2]?'Ok':'Fail') 
    + ' A: '+t[0]+', B: '+t[1]
    + ', Result: '+r + ', Check:  '+t[2])
})

pre { font-size: 10px }

<pre id=O></pre>