Ci sono due pezzi di legno. Entrambi consistono in un corpo dritto e alcuni blocchi extra sotto il corpo. Un pezzo di esempio con blocchi extra nelle posizioni (indicizzate 0) 0,4,7,9,10:

XXXXXXXXXXX
X   X  X XX

Il pezzo può essere rappresentato come una 01sequenza binaria con il icarattere th che mostra se c'è un blocco nella iposizione th. L'esempio superiore può essere rappresentato come 10001001011.

Possiamo mettere insieme due pezzi capovolgendo verticalmente il secondo (e magari capovolgendolo anche in orizzontale). Dopo il flip (s) possiamo trovare un allineamento in cui i due pezzi possono essere uniti per avere un'altezza di 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

L'esempio ha comportato una larghezza totale di 12 blocchi.

Dovresti scrivere un programma o una funzione che riceve due stringhe come input che rappresentano i due pezzi e genera un numero intero la larghezza minima raggiungibile con un'altezza di 3.

Ingresso

• Due stringhe costituite dai caratteri 0e 1.
• Entrambe le stringhe contengono almeno un carattere.
• Puoi scegliere di ricevere le due stringhe come una unita da un singolo spazio.

Produzione

• Un singolo numero intero positivo, la larghezza totale minima raggiungibile.

Esempi

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

Questo è il codice golf, quindi vince l'ingresso più breve.

Pyth, 37 35 34 32 31 byte

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

Prende l'input newline separato.

Dimostrazione , test Harness .

Spiegazione:

Ad alto livello, per ogni combinazione di stringhe normali e invertite, spostiamo la seconda stringa a sinistra di un determinato numero di posizioni e controlliamo la sovrapposizione con la prima stringa. Questo viene ripetuto fino a quando non viene trovata una quantità di spostamento senza sovrapposizioni. Tale quantità di spostamento viene aggiunta alla prima lunghezza della stringa e il risultato viene confrontato con la seconda lunghezza della stringa. Viene stampato il valore più alto.

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

Prende le due stringhe come argomenti della riga di comando. Formattato, con commenti:

                     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)

Stiamo solo calcolando le sovrapposizioni in cui il pezzo inferiore sporge a sinistra, quindi dobbiamo provarlo con entrambi i pezzi superiore e inferiore invertiti. Ogni volta attraverso il ciclo interno, se non ci sono 2 nella somma, è una misura; quindi viriamo un altro zero all'estremità del pezzo inferiore e riproviamo.

   0010
    111
   0121

   0010
   111_
   1120

   0010
  111__
  11110

   0010
 111___
 111010

   0010
111____
1110010

Per trovare la larghezza totale, dividiamo gli elementi pin elenchi di caratteri e somma. Le operazioni a livello di articolo su elenchi di lunghezza irregolare preservano la lunghezza di quella più lunga, quindi la lunghezza di questa somma è esattamente ciò di cui abbiamo bisogno. (La divisione è necessaria perché semplicemente sommando i numeri eliminerà gli zeri iniziali:, $+[0101 10] = 111ma $+^[0101 10] = [0 1 1 1].)

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

Rubino 127 130

Questo si è rivelato essere così lungo ... :(

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

Test: http://ideone.com/te8XWk

Rubino leggibile:

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

Impossibile accorciare ...

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>