14

有两块木头。两者都由笔直的身体和身体下方的一些额外的块组成。在（0索引）位置0、4、7、9、10处有额外块的示例块：

XXXXXXXXXXX
X   X  X XX

该片段可以表示为01二进制序列，第ith个字符显示在第ith个位置是否有块。上面的示例可以表示为10001001011。

我们可以通过垂直翻转第二个（或者也可以水平翻转）来将它们组合在一起。翻转后，我们可以找到一个对齐，可以将两部分放在一起以使其高度为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个块。

您应该编写一个程序或函数，该程序或函数接收两个字符串作为代表两个片段的输入，并输出一个高度为3 的最小可实现宽度的整数。

输入值

两个字符串，由字符0和组成1。
两个字符串均包含至少一个字符。
您可以选择将两个字符串作为一个字符串并由一个空格连接在一起。

输出量

一个正整数，可以达到的最小总宽度。

例子

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

这是代码高尔夫球，因此最短的入场券获胜。

code-golf packing

— Randomra
source

第一个示例中的棋子是否应该是该示例的第二部分中的棋子？如果是这样，那么其中之一是错误的。

— mdc32

@ mdc32它们不是同一块，但为了避免混淆，更改了第一个。

— randomra'5

7

Pyth，37 35 34 32 31字节

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

将输入换行符分隔开。

示范，测试线束。

说明：

在高层次上，对于正常和反向字符串的每种组合，我们将第二个字符串向左移动给定数量的位置，并检查与第一个字符串的重叠情况。重复该过程直到找到没有重叠的移位量。该偏移量被加到第一字符串长度，并且将结果与第二字符串长度进行比较。打印出较高的值。

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.

— 伊萨格
source

4

点，72 70 48字节

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

将两个字符串作为命令行参数。格式化，并带有注释：

                     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，则为拟合；否则为0。然后，再在底片的末端加上另一个零，然后重试。

为了找到总宽度，我们将的元素p分为字符列表和总和。不规则长度列表上的逐项操作保留了较长列表的长度，因此，此总和的长度正是我们需要的长度。（拆分是必要的，因为仅将数字相加即可消除前导零：$+[0101 10] = 111，但$+^[0101 10] = [0 1 1 1]。）

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

— DLosc
source

3

红宝石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

— 克里斯蒂安·卢帕斯库（Cristian Lupascu）
source

您可以测试新添加的示例吗？该[[m,n],[m,n.reverse],[n,m],[n,m.reverse]]零件可能不正确。（我不确定，但我犯了类似的错误。）

— randomra 2015年

@randomra当然！请查看测试链接；我在那里添加了新测试。

— Cristian Lupascu 2015年

谢谢，很抱歉给您带来了麻烦。我的直觉是您需要[n.reverse,m]代替，[n,m.reverse]但我不了解Ruby。

— randomra 2015年

@randomra实际上未通过测试'0010110111100', '001011010101001001100'并说期望：28，实际：30。所有其他测试均通过。因此，您已经很好地测试了极端案例。:)

— 克里斯蒂安·卢帕斯库

1

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>

展开摘要

— edc65
source

包装木片

输入值

输出量

例子

Pyth，37 35 34 32 31字节

点，72 70 48字节

红宝石127 130

JavaScript（ES6）160