Este desafío fue inspirado por este comercial de Wendy's de 1984.

_{Ilustración de TS Rogers.}

Su tarea es encontrar un 0xBEEF hexadecimal en un bollo binario.

La 'carne' consiste en el siguiente patrón:

1 0 1 1  (0xB)
1 1 1 0  (0xE)
1 1 1 0  (0xE)
1 1 1 1  (0xF)

Y el 'bollo' consiste en una matriz binaria de 12x12, como:

1 1 1 0 0 1 1 1 1 1 1 0
1 1 0 1 0 0 1 0 0 0 0 0
0 1 0 0 0 1 1 1 1 1 0 1
1 0 0 1 0 0 1 0 0 1 0 0
1 0 0 1 0 1 1 0 0 1 1 1
1 1 1 1 1 1 0 0 0 0 1 0
1 1 0 1 1 1 0 0 0 0 0 1
1 0 0 1 1 1 1 0 0 0 0 1
1 0 0 1 1 1 0 1 1 1 1 1
1 1 1 1 1 0 0 1 1 1 1 1
1 0 0 0 0 1 0 1 0 1 1 1
1 1 0 0 1 1 0 0 0 0 1 1

Entrada

Su programa o función tomará la matriz binaria como entrada. El formato de matriz es muy flexible, pero debe describirse claramente en su respuesta.

Por ejemplo:

• Una sola cadena binaria, con o sin separadores entre las filas:

  "111001111110 110100100000..."

  o:

  "111001111110110100100000..."

• una matriz de cadenas binarias:

  ["111001111110", "110100100000", ...]

• una matriz de números (cada número que describe una fila una vez convertida de nuevo a binario y rellena con ceros a la izquierda):

  [3710, 3360, ...]

Salida

Las coordenadas (X, Y)de la 'carne', (0, 0)siendo la esquina superior izquierda del bollo.

Alternativamente, puede usar coordenadas basadas en 1 (pero no una combinación de ambos formatos, como 0 para X y 1 para Y).

Para el ejemplo anterior, la respuesta esperada es (3, 4)(basada en 0) o (4, 5)(basada en 1):

   00 01 02 03 04 05 06 07 08 09 10 11 
00  1  1  1  0  0  1  1  1  1  1  1  0
01  1  1  0  1  0  0  1  0  0  0  0  0
02  0  1  0  0  0  1  1  1  1  1  0  1
03  1  0  0  1  0  0  1  0  0  1  0  0
04  1  0  0 [1  0  1  1] 0  0  1  1  1
05  1  1  1 [1  1  1  0] 0  0  0  1  0
06  1  1  0 [1  1  1  0] 0  0  0  0  1
07  1  0  0 [1  1  1  1] 0  0  0  0  1
08  1  0  0  1  1  1  0  1  1  1  1  1
09  1  1  1  1  1  0  0  1  1  1  1  1
10  1  0  0  0  0  1  0  1  0  1  1  1
11  1  1  0  0  1  1  0  0  0  0  1  1

Una vez más, cualquier formato razonable funcionaría siempre que se especifique en su respuesta. Mencione también si está utilizando coordenadas basadas en 0 o en 1.

Reglas

• Puede asumir con seguridad que siempre hay exactamente una 'carne' en el pan. No se requiere su código para admitir casos con más de una carne o sin carne.
• El patrón de carne siempre aparecerá como se describe. Nunca se rotará ni reflejará de ninguna manera.
• Este es el código de golf, por lo que gana la respuesta más corta en bytes. Las lagunas estándar están prohibidas.

Casos de prueba

En los siguientes casos de prueba, cada fila de la matriz se expresa como su representación decimal.

Input : [ 3710, 3360, 1149, 2340, 2407, 4034, 3521, 2529, 2527, 3999, 2135, 3267 ]
Output: [ 3, 4 ]

Input : [ 1222, 3107, 1508, 3997, 1906, 379, 2874, 2926, 1480, 1487, 3565, 633 ]
Output: [ 3, 7 ]

Input : [ 2796, 206, 148, 763, 429, 1274, 2170, 2495, 42, 1646, 363, 1145 ]
Output: [ 6, 4 ]

Input : [ 3486, 3502, 1882, 1886, 2003, 1442, 2383, 2808, 1416, 1923, 2613, 519 ]
Output: [ 1, 1 ]

Input : [ 3661, 2382, 2208, 1583, 1865, 3969, 2864, 3074, 475, 2382, 1838, 127 ]
Output: [ 8, 8 ]

Input : [ 361, 1275, 3304, 2878, 3733, 3833, 3971, 3405, 2886, 448, 3101, 22 ]
Output: [ 0, 3 ]

Input : [ 3674, 2852, 1571, 3582, 1402, 3331, 1741, 2678, 2076, 2685, 734, 261 ]
Output: [ 7, 7 ]

Jalea , 20 17 16 bytes

ṡ€4ḄZw€“¿ÇÇБĖUṀ

La entrada está en forma de una matriz booleana, la salida es el par de índice basado en 1 (Y, X) .

Pruébalo en línea! o verificar todos los casos de prueba .

Cómo funciona

ṡ€4ḄZw€“¿ÇÇБĖUṀ  Main link. Argument: M (2D array of Booleans)

ṡ€4               Split each row into 9 chunks of length 4.
   Ḅ              Convert these chunks from base 2 to integer.
    Z             Zip/transpose. This places the columns of generated integers
                  into the rows of the matrix to comb through them.
       “¿ÇÇБ     Push the array of code points (in Jelly's code page) of these
                  characters, i.e., 0xB, 0xE, 0xE, and 0xF.
     w€           Window-index each; in each row, find the index of the contiguous
                  subarray [0xB, 0xE, 0xE, 0xF] (0 if not found).
                  Since the matrix contains on one BEEF, this will yield an array
                  of zeroes, with a single non-zero Y at index X.
             Ė    Enumerate; prefix each integer with its index.
              U   Upend; reverse the pairs to brings the zeroes to the beginning.
               Ṁ  Take the maximum. This yields the only element with positive
                  first coordinate, i.e., the pair [Y, X].

vim, 126 80 77 76

/\v1011\_.{9}(1110\_.{9}){2}1111<cr>:exe'norm Go'.join(getpos('.'))<cr>xxdawhPXXd{

Espera entrada en el formulario

111001111110
110100100000
010001111101
100100100100
100101100111
111111000010
110111000001
100111100001
100111011111
111110011111
100001010111
110011000011

Y salidas (con índices basados ​​en 1) como

4 5

/                      regex search for...
\v                     enable "very magic" mode (less escaping)
1011\_.{9}             find the first line ("B"), followed by 8 chars + 1 \n
(1110\_.{9}){2}        find the second and third lines ("EE")
1111<cr>               find the fourth line ("F")
:exe'norm Go'.         insert at the beginning of the file...
join(getpos('.'))<cr>  the current position of the cursor
xxdawhPXX              do some finagling to put the numbers in the right order
d{                     delete the input

Gracias a Jörg Hülsermann por guardar indirectamente 46 bytes al darme cuenta de que mi expresión regular era súper tonta, y a DJMcMayhem por 3 bytes más.

JavaScript (ES6), 63 60 56 bytes

s=>[(i=s.search(/1011.{9}(1110.{9}){2}1111/))%13,i/13|0]

Toma la entrada como una cadena delimitada por espacios de 155 caracteres de 12 cadenas binarias de 12 dígitos, devuelve valores indexados a cero. Editar: Guardado 3 bytes gracias a @ JörgHülsermann. Guardado 4 bytes gracias a @ETHproductions.

C, 146 177 173 163 bytes

Gracias a Numberknot por arreglar el código (desplazando las tres filas inferiores).

Ahorrando 4 bytes reemplazando >>=1con /=2en 4 lugares. Ahorrando 10 bytes más al permitir xy yser global y predeterminado intgracias a MD XF

#define T(i,n)(A[y+i]&15)==n
x,y;b(int A[12]){for(x=9;x--;){for(y=0;++y<9;A[y]/=2)if(T(0,11)&&T(1,14)&&T(2,14)&&T(3,15))return(x<<4)+y;A[9]/=2;A[10]/=2;A[11]/=2;}}

Sin golf:

int b(int A[12]) {
 for (int x=8; x>=0; --x) {
  for (int y=0; y<9; ++y) {
   if ((A[y]&15)==11 && (A[y+1]&15)==14 && (A[y+2]&15)==14 && (A[y+3]&15)==15) { 
    return (x<<4) + y; 
   }
   A[y]/=2;
  }
  A[9]/=2; A[10]/=2; A[11]/=2;
 }
}

Devuelve x, y (basado en 0) en el mordisco alto y bajo de un byte.

Uso:

int temp=b(array_to_solve);
int x=temp>>4;
int y=temp&15;
printf("%d %d\n",x,y);

MATL , 22 21 bytes

Eq[ODDH]B~EqZ+16=&fhq

La entrada es una matriz binaria, con un ;separador de filas. La salida es 1-basa en el orden inverso: Y X.

Pruébalo en línea! O verifique todos los casos de prueba con formato de entrada decimal.

Explicación

El patrón se detecta mediante convolución 2D. Para esto,

• La matriz y el patrón deben estar en forma bipolar, es decir, en 1, -1lugar de 1, 0. Como el patrón tiene un tamaño de 4 × 4, su aparición se detecta mediante una entrada igual a 16la salida de convolución.
• El núcleo de convolución debe definirse como el patrón buscado invertido en ambas dimensiones.

Además, dado que la convolución introduce un desplazamiento en los índices detectados, esto debe corregirse en la salida.

Eq      % Implicitly input binary matrix. Convert to bipolar form (0 becomes -1)
[ODDH]  % Push array [0 8 8 2]
B       % Convert to binary. Each number gives a row
~Eq     % Negate and convert to bipolar. Gives [1 1 1 1; 0 1 1 1; 0 1 1 1; 1 1 0 1]
        % This is the "BEEF" pattern reversed in the two dimensions. Reversal is
        % needed because a convolution will be used to detect that patter
Z+      % 2D convolution, keeping original size
16=&f   % Find row and column indices of 16 in the above matrix
h       % Concatenate horizontally
q       % Subtract 1. Implicitly display

Mathematica, 62 bytes

BlockMap[Fold[#+##&,Join@@#]==48879&,#,{4,4},1]~Position~True&

Devuelve todas las posiciones de la matriz BEEF, indexadas en 1. La entrada debe ser una matriz de dígitos binarios. Sin embargo, las x e y en la salida se cambian.

Slip , 28 bytes

27 bytes de código, +1 para la popción.

(?|1011)(\(?|1110)){2}\1111

Requiere entrada como un rectángulo multilínea de 1 y 0 sin espacios. Pruébelo aquí (con el tercer caso de prueba como entrada).

Explicación

Slip es un lenguaje del desafío 2D-Match Matching . Sp3000 podría decir mucho más al respecto que yo, pero básicamente es una forma extendida de expresiones regulares con algunos comandos direccionales que te permiten combinar en dos dimensiones. El código anterior usa el comando homónimo "slip" \, que no cambia la dirección del puntero de coincidencia, sino que lo mueve de lado por un carácter. También utiliza "grupo estacionario" (?|...), que coincide con algo y luego restablece el puntero a su ubicación anterior.

El código se descompone de la siguiente manera:

(?|1011)                     Match 1011; reset pointer to beginning of match
        (         ){2}       Do the following twice:
         \                     Slip (moves pointer down one row)
          (?|1110)             Match 1110; reset pointer to beginning of match
                      \1111  Slip and match 1111

Esto coincide con el 0xBEEFcuadrado. La popción genera las coordenadas del partido, indexadas en 0.

PHP, 87 bytes

cadena binaria como entrada sin separadores, devuelve valores indexados a cero.

preg_match("#1011(.{8}1110){2}.{8}1111#",$argv[1],$c,256);echo($s=$c[0][1])%12,$s/12^0;

matriz de números como entrada 128 Bytes

<?foreach($_GET[a]as$a)$b.=sprintf("%012b",$a);preg_match("#1011(.{8}1110){2}.{8}1111#",$b,$c,256);echo($s=$c[0][1])%12,$s/12^0;

14 Bytes guardados por @Titus Gracias

Java 7182 177 bytes

Porté la respuesta de Karl Napf C a JAVA y gracias a Karl Napf por guardar 5 bytes recordándome Bit magic. (Por cierto, también se me ocurrió esta idea, pero la idea de la parte de devolución de @KarlNapf era tuya, no mía). Lo siento si te disguste.

(Basado en 0)

int f(int[]a){int x=9,y,z=0;for(;x-->0;){for(y=0;y<9;a[y++]/=2) if((a[y]&15)==11&(a[y+1]&15)==14&(a[y+2]&15)==14&(a[y+3]&15)==15)z=(x<<4)+y;a[y]/=2;a[10]/=2;a[11]/=2;}return z;}

Sin golf

class Beef {

    public static void main(String[] args) {
        int x = f(new int[] { 1222, 3107, 1508, 3997, 1906, 379, 2874, 2926, 1480, 1487, 3565, 633 });
        System.out.println(x >> 4);
        System.out.println(x & 15);
    }

    static int f(int[] a) {
        int x = 9,
            y,
            z = 0;

        for (; x-- > 0; ) {
            for (y = 0; y < 9; a[y++] /= 2)
                if ((a[y] & 15) == 11 
                  & (a[y + 1] & 15) == 14
                  & (a[y + 2] & 15) == 14 
                  & (a[y + 3] & 15) == 15)
                    z = (x << 4) + y;

            a[y] /= 2;
            a[10] /= 2;
            a[11] /= 2;
        }
        return z;
    }

}

Retina, 47 bytes

Me gustaría presentar esto con una disculpa. Creo que esto es probablemente terrible y un mal ejemplo de cómo usar el lenguaje, pero como usé un Regex para mi respuesta de Perl, pensé en probar Retina. No soy muy bueno. :( Sin embargo, los fragmentos en github me ayudaron mucho.

¡Gracias a @ wullzx por su comentario sobre mi respuesta de Perl para -3 bytes y a @ Taemyr por señalar un problema con mi método!

Espera la entrada como una cadena binaria separada por espacios y las salidas coordina el espacio separado.

(.{13})*(.)*1011(.{9}1110){2}.{9}1111.*
$#2 $#1

Pruébalo en línea!

Verifique todas las pruebas a la vez.

Scala, 90 bytes

("1011.{8}(1110.{8}){2}1111".r.findAllMatchIn(_:String).next.start)andThen(i=>(i/12,i%12))

Explicación:

(
  "1011.{8}(1110.{8}){2}1111" //The regex we're using to find the beef
  .r                          //as a regex object
  .findAllMatchIn(_:String)   //find all the matches in the argument thats going to be passed here
  .next                       //get the first one
  .start                      //get its start index
)                             //this is a (String -> Int) function
andThen                       //
(i=>                          //with the found index
  (i/12,i%12)                 //convert it to 2d values
)                             

(a -> b) andThen (b -> c)da como resultado una (a -> c)función, es como el reverso de componer, pero requiere menos anotaciones de tipo en scala. En este caso, toma una cadena de dígitos binarios como entrada y devuelve una tupla de índices basados ​​en cero.

J, 31 29 bytes

[:($#:I.@,)48879=4 4#.@,;._3]

La entrada está formateada como una matriz 2D de valores binarios, y la salida son las coordenadas basadas en cero como una matriz [y, x].

El aplanamiento y la conversión de base para encontrar el índice es algo que aprendí de este comentario de Dennis.

Uso

   f =: [:($#:I.@,)48879=4 4#.@,;._3]
   ] m =: _12 ]\ 1 1 1 0 0 1 1 1 1 1 1 0 1 1 0 1 0 0 1 0 0 0 0 0 0 1 0 0 0 1 1 1 1 1 0 1 1 0 0 1 0 0 1 0 0 1 0 0 1 0 0 1 0 1 1 0 0 1 1 1 1 1 1 1 1 1 0 0 0 0 1 0 1 1 0 1 1 1 0 0 0 0 0 1 1 0 0 1 1 1 1 0 0 0 0 1 1 0 0 1 1 1 0 1 1 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 0 0 0 0 1 0 1 0 1 1 1 1 1 0 0 1 1 0 0 0 0 1 1
1 1 1 0 0 1 1 1 1 1 1 0
1 1 0 1 0 0 1 0 0 0 0 0
0 1 0 0 0 1 1 1 1 1 0 1
1 0 0 1 0 0 1 0 0 1 0 0
1 0 0 1 0 1 1 0 0 1 1 1
1 1 1 1 1 1 0 0 0 0 1 0
1 1 0 1 1 1 0 0 0 0 0 1
1 0 0 1 1 1 1 0 0 0 0 1
1 0 0 1 1 1 0 1 1 1 1 1
1 1 1 1 1 0 0 1 1 1 1 1
1 0 0 0 0 1 0 1 0 1 1 1
1 1 0 0 1 1 0 0 0 0 1 1
   f m
4 3
   f (#:~2#~#) 3710 3360 1149 2340 2407 4034 3521 2529 2527 3999 2135 3267
4 3
   f (#:~2#~#) 1222 3107 1508 3997 1906 379 2874 2926 1480 1487 3565 633
7 3
   f (#:~2#~#) 2796 206 148 763 429 1274 2170 2495 42 1646 363 1145
4 6
   f (#:~2#~#) 3486 3502 1882 1886 2003 1442 2383 2808 1416 1923 2613 519
1 1
   f (#:~2#~#) 3661 2382 2208 1583 1865 3969 2864 3074 475 2382 1838 127
8 8
   f (#:~2#~#) 361 1275 3304 2878 3733 3833 3971 3405 2886 448 3101 22
3 0
   f (#:~2#~#) 3674 2852 1571 3582 1402 3331 1741 2678 2076 2685 734 261
7 7

Explicación

[:($#:I.@,)48879=4 4#.@,;._3]  Input: 2d array M
                            ]  Identity. Get M
                 4 4    ;._3   For each 4x4 subarray of M
                       ,         Flatten it
                    #.@          Convert it to decimal from binary
           48879=              Test if equal to 48879 (decimal value of beef)
[:(       )                    Operate on the resulting array
         ,                       Flatten it
      I.@                        Find the indices where true
    #:                           Convert from decimal to radix based on
   $                               The shape of that array
                               Returns the result as coordinates [y, x]

Python 2, 98 95 92 bytes

lambda x:'%x'%(`[''.join('%x'%int(s[i:i+4],2)for s in x)for i in range(9)]`.find('beef')+15)

La entrada es una lista de cadenas, la salida es la cadena XY (índices basados ​​en 1).

Pruébalo en Ideone .

Perl, 54 bytes

Código de 53 bytes + 1 para -n. Usos -Esin costo adicional.

Utiliza índices basados ​​en 0. Espera de entrada como una cadena de 1s y 0s y salidas separadas por espacios coordenadas.

¡Gracias a @ wullxz y @ GabrielBenamy por ayudarme a ahorrar 9 bytes, y al comentario de @ Taemyr sobre mi respuesta de Retina por señalar un problema!

/1011.{9}(1110.{9}){2}1111/;say$-[0]%13,$",$-[0]/13|0

Uso

perl -nE '/1011.{9}(1110.{9}){2}1111/;say$-[0]%13,$",$-[0]/13|0' <<< '111001111110 110100100000 010001111101 100100100100 100101100111 111111000010 110111000001 100111100001 100111011111 111110011111 100001010111 110011000011
010011000110 110000100011 010111100100 111110011101 011101110010 000101111011 101100111010 101101101110 010111001000 010111001111 110111101101 001001111001
101011101100 000011001110 000010010100 001011111011 000110101101 010011111010 100001111010 100110111111 000000101010 011001101110 000101101011 010001111001
110110011110 110110101110 011101011010 011101011110 011111010011 010110100010 100101001111 101011111000 010110001000 011110000011 101000110101 001000000111
111001001101 100101001110 100010100000 011000101111 011101001001 111110000001 101100110000 110000000010 000111011011 100101001110 011100101110 000001111111
000101101001 010011111011 110011101000 101100111110 111010010101 111011111001 111110000011 110101001101 101101000110 000111000000 110000011101 000000010110
111001011010 101100100100 011000100011 110111111110 010101111010 110100000011 011011001101 101001110110 100000011100 101001111101 001011011110 000100000101'
3 4
3 7
6 4
1 1
8 8
0 3
7 7

Scala, 318 bytes

Esta solución podría mejorarse aún más ... pero la mantuve legible y permití que la entrada fuera la matriz espaciada de varias líneas.

Solución real si matriz de cadena binaria

def has(s: String, t: String): Int = s.indexOf(t)
val beef = List("1011", "1110", "1110", "1111")
l.zipWithIndex.map{case(e,i)=>l.drop(i).take(4)}.map{_.zip(beef)}.map{_.collect{case e=>has(e._1,e._2)}}.zipWithIndex.filterNot{e => e._1.contains(-1) ||  e._1.distinct.length > 1}.map{e=>s"(${e._1.head},${e._2})"}.head

Muestra de Trabajo

val bun = 
"""1 1 1 0 0 1 1 1 1 1 1 0
1 1 0 1 0 0 1 0 0 0 0 0
0 1 0 0 0 1 1 1 1 1 0 1
1 0 0 1 0 0 1 0 0 1 0 0
1 0 0 1 0 1 1 0 0 1 1 1
1 1 1 1 1 1 0 0 0 0 1 0
1 1 0 1 1 1 0 0 0 0 0 1
1 0 0 1 1 1 1 0 0 0 0 1
1 0 0 1 1 1 0 1 1 1 1 1
1 1 1 1 1 0 0 1 1 1 1 1
1 0 0 0 0 1 0 1 0 1 1 1
1 1 0 0 1 1 0 0 0 0 1 1
""".replaceAll(" ","")
def has(s: String, t: String): Int = s.indexOf(t)
val beef = List("1011", "1110", "1110", "1111")
val l = bun.split("\n").toList
l.zipWithIndex.map{case(e,i)=>l.drop(i).take(4)}
.map{_.zip(beef)}
.map{_.collect{case e=>has(e._1,e._2)}}.zipWithIndex
.filterNot{e => e._1.contains(-1) ||  e._1.distinct.length > 1}
.map{e=>s"(${e._1.head},${e._2})"}.head

Python, 137 bytes (según Linux (gracias ElPedro))

def f(s,q=0):import re
 i=s.index(re.findall('1011.{8}1110.{8}1110.{8}1111',s)[q])+1
 x=i%12
 y=(i-x)/12
 if x>8:x,y=f(s,q+1)
 return x,y

No es exactamente un bytecount competitivo, pero el algoritmo es un poco interesante. Toma la entrada como una cadena de valores binarios.

Ruby , 62 bytes

def f(a);a=~/1011(.{8}1110){2}.{8}1111/;$`.size.divmod(12);end 

Espera una cadena de 0y 1y devuelve una matriz de Y y X, basada en cero.

Prueba con ideone .

F # - 260 bytes

Programa completo, incluido el designador EntryPoint requerido (así que cuente menos si lo desea, supongo).

Entrada: cada fila como cadena separada: "111001111110" "110100100000" "010001111101" "100100100100" "100101100111" "111111000010" "110111000001" "100111100001" "100111011111" "111110011111" "100001010111" "110011000011"

Código:

[<EntryPoint>]
let main a=
 let rec f r:int=
  let b=a.[r].IndexOf"1011"
  if(b>0)then if(a.[r+1].[b..b+3].Equals"1110"&&a.[r+2].[b..b+3].Equals"1110"&&a.[r+3].[b..b+3].Equals"1111")then r else f(r+1)
  else f(r+1)
 printfn"%d%d"(a.[f 0].IndexOf"1011")(f 0);0

No es la solución más elegante, pero quería seguir con las cadenas, así es como lo hice. Casi conseguí que fuera una línea simple y más pequeña usando tuberías, pero hay algo con el bloque doble if que me estaba causando que no pude resolver. Entonces, bueno!

También pensé en portar la respuesta de Karl a F #, ya que es buena, y aún puedo hacerlo por diversión como otro enfoque, pero quería seguir con esta para ser diferente.

Dyalog APL, 29 27 bytes

Toma una matriz binaria de 12x12 como entrada del usuario y devuelve las coordenadas en orden inverso, los índices comienzan en 1.

Gracias a @ Adám por guardar muchos bytes. -2 Bytes porque soy tonto y dejé todo en una función sin ninguna razón.

0~⍨∊{⍵×⍳⍴⍵}⎕⍷⍨~0 8 0 6⊤⍨4/2

Elemento , 130 bytes

_144'{)"1-+2:';}144'["1-+19:~?1+~?!2+~?3+~?12+~?13+~?14+~?15+~?!24+~?25+~?26+~?27+~?!36+~?37+~?38+~?39+~?16'[&][12%2:`\ `-+12/`]']

Pruébalo en línea!

Toma la entrada como una cadena larga de 1s y 0s sin delimitadores. Salidas como 3 4(indexación basada en 0).

Esto funciona colocando los datos de entrada en una "matriz" (básicamente un diccionario con teclas enteras) y luego, para cada posible valor inicial, prueba los bits en desplazamientos particulares (los 16 en un proceso muy laborioso).