木が2つあります。どちらも、まっすぐな体と体の下のいくつかの余分なブロックで構成されています。（0-indexed）位置0,4,7,9,10に余分なブロックがある例：

XXXXXXXXXXX
X   X  X XX

ピースは、thの位置にブロックがあるかどうかを示すth文字を含む01バイナリシーケンスとして表すことができます。上の例はとして表すことができます。ii10001001011

2番目のピースを垂直にフリップすることで、2つのピースをまとめることができます（水平方向にフリップすることもできます）。フリップの後、2つのピースを合わせて高さ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

この例では、合計幅が12ブロックになりました。

2つの部分を表す入力として2つの文字列を受け取り、最小の達成可能な幅 3の整数を出力するプログラムまたは関数を作成する必要があります。

入力

• 文字からなる二つの文字列0と1。
• 両方の文字列に少なくとも1つの文字が含まれています。
• 1つのスペースで結合された2つの文字列を受け取ることを選択できます。

出力

• 達成可能な最小の合計幅である単一の正の整数。

例

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

これはコードゴルフなので、最短のエントリーが勝ちます。

Pyth、37 35 34 32 31バイト

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

入力改行を区切ります。

デモンストレーション、テストハーネス。

説明：

高レベルでは、通常の文字列と逆の文字列の組み合わせごとに、2番目の文字列を指定された数だけ左にシフトし、最初の文字列との重複をチェックします。これは、オーバーラップのないシフト量が見つかるまで繰り返されます。そのシフト量が最初の文字列の長さに加算され、結果が2番目の文字列の長さと比較されます。高い値が印刷されます。

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.

ピップ、72 70 48バイト

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

2つの文字列をコマンドライン引数として受け取ります。コメント付きのフォーマット済み：

                     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)

一番下のピースが左に突き出ているオーバーラップを計算しているだけなので、上下のピースを逆にして試してみる必要があります。内側のループを通るたびに、合計に2がなければ、適合です。次に、ボトムピースの最後に別のゼロを追加して、再試行します。

   0010
    111
   0121

   0010
   111_
   1120

   0010
  111__
  11110

   0010
 111___
 111010

   0010
111____
1110010

合計幅を見つけるために、要素pを文字のリストと合計に分割します。長さが不均一なリストの項目ごとの操作では、長いリストの長さが保持されるため、この合計の長さはまさに必要なものです。（分割の数が先行ゼロを排除するように単に加算するために必要です$+[0101 10] = 111が、$+^[0101 10] = [0 1 1 1]。）

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

ルビー127 130

これは非常に長いことが判明しました... :(

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

テスト：http : //ideone.com/te8XWk

読み取り可能なRuby：

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

短くすることができませんでした...

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>