Este desafio foi inspirado no comercial deste Wendy de 1984.

_{Ilustração de TS Rogers}

Sua tarefa é encontrar um 0xBEEF hexadecimal em um bun binário.

A 'carne' consiste no seguinte padrão:

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

E o 'bun' consiste em uma matriz binária 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

Seu programa ou função terá a matriz binária como entrada. O formato da matriz é muito flexível, mas deve ser claramente descrito em sua resposta.

Por exemplo:

• uma única cadeia binária, com ou sem separadores entre as linhas:

  "111001111110 110100100000..."

  ou:

  "111001111110110100100000..."

• uma matriz de cadeias binárias:

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

• uma matriz de números (cada número que descreve uma linha uma vez convertida novamente em binário e preenchida à esquerda com zeros):

  [3710, 3360, ...]

Resultado

As coordenadas (X, Y)da 'carne', (0, 0)sendo o canto superior esquerdo do pão.

Como alternativa, você pode usar coordenadas com base em 1 (mas não uma mistura dos dois formatos, como com base em 0 para X e em 1 para Y).

Para o exemplo acima, a resposta esperada é (3, 4)(com base em 0) ou (4, 5)(com base em 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

Novamente, qualquer formato razoável funcionaria desde que especificado em sua resposta. Mencione também se você estiver usando coordenadas com base em 0 ou em 1.

Regras

• Você pode assumir com segurança que sempre há exatamente uma 'carne' no pão. Seu código não é necessário para suportar casos com mais de uma carne ou sem carne.
• O padrão de carne sempre aparecerá como descrito. Nunca será girado ou espelhado de forma alguma.
• Isso é código-golfe, então a resposta mais curta em bytes vence. As brechas padrão são proibidas.

Casos de teste

Nos seguintes casos de teste, cada linha da matriz é expressa como sua representação 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 ]

Geléia , 20 17 16 bytes

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

A entrada está na forma de uma matriz booleana, a saída é o par de índices com base em 1 (Y, X) .

Experimente online! ou verifique todos os casos de teste .

Como 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 no formulário

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

E saídas (com índices baseados em 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

Agradeço a Jörg Hülsermann por salvar indiretamente 46 bytes, fazendo-me perceber que meu regex era super burro, e a DJMcMayhem por mais 3 bytes.

JavaScript (ES6), 63 60 56 bytes

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

Recebe a entrada como uma sequência delimitada por espaço de 155 caracteres, com 12 sequências binárias de 12 dígitos, retorna valores indexados a zero. Editar: salvou 3 bytes graças a @ JörgHülsermann. Economizou 4 bytes graças a @ETHproductions.

C, 146 177 173 163 bytes

Agradecimentos ao Numberknot por corrigir o código (deslocando as três linhas inferiores).

Salvando 4 bytes substituindo >>=1por /=2em 4 lugares. Economizando mais 10 bytes ao permitir xe yser global e padrão, intgraças ao 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;}}

Ungolfed:

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

Retorna x, y (com base em 0) na mordidela alta e baixa de um 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

Entrada é uma matriz binária, com ;como separador de linhas. A saída é uma baseada em ordem inversa: Y X.

Experimente online! Ou verifique todos os casos de teste com o formato de entrada decimal.

Explicação

O padrão é detectado usando convolução 2D. Por esta,

• A matriz e o padrão precisam estar na forma bipolar, ou seja, em 1, -1vez de 1, 0. Como o padrão possui tamanho 4 × 4, sua ocorrência é detectada por uma entrada igual a 16na saída da convolução.
• O kernel de convolução precisa ser definido como o padrão procurado revertido em ambas as dimensões.

Além disso, como a convolução introduz um deslocamento nos índices detectados, isso precisa ser corrigido na saída.

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&

Retorna todas as posições da matriz BEEF, indexadas em 1. A entrada deve ser uma matriz de dígitos binários. Os x e y na saída são alterados, no entanto.

Deslizamento , 28 bytes

27 bytes de código, +1 para a popção.

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

Requer entrada como um retângulo multilinha de 1 e 0 sem espaços. Experimente aqui (com o terceiro caso de teste como entrada).

Explicação

Deslizamento é um idioma do desafio de correspondência de padrões 2-D . O Sp3000 poderia dizer muito mais sobre isso do que eu, mas basicamente é uma forma estendida de regex com alguns comandos direcionais que permitem combinar em duas dimensões. O código acima usa o comando "slip" de mesmo nome \, que não altera a direção do ponteiro de correspondência, mas o move lateralmente por um caractere. Ele também usa "grupo estacionário" (?|...), que corresponde a algo e redefine o ponteiro para o local anterior.

O código é dividido da seguinte maneira:

(?|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

Isso corresponde ao 0xBEEFquadrado. A popção gera as coordenadas da partida, indexadas em 0.

PHP, 87 bytes

string binária como entrada sem separadores, retorna valores indexados a zero.

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 salvos por @Titus Thank You

Java 7,182 177 bytes

Eu enviei Karl Napf C para JAVA e agradeço a Karl Napf por salvar 5 bytes, lembrando-me de Bit Magic. (Eu também tive essa ideia, mas a @KarlNapf retornou parte da idéia que não era minha).

(Com base em 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;}

Ungolfed

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

Eu gostaria de anteceder isso com um pedido de desculpas. Acho que isso é provavelmente terrível e um péssimo exemplo de como usar a linguagem, mas como usei um Regex para minha resposta em Perl, pensei em experimentar o Retina. Não sou muito bom. :( Os trechos no github me ajudaram bastante!

Obrigado a @ wullzx por seu comentário na minha resposta Perl por -3 bytes e a @ Taemyr por apontar um problema com meu método!

Espera a entrada como uma sequência binária separada por espaço e as saídas coordenam o espaço separado.

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

Experimente online!

Verifique todos os testes de uma só vez.

Scala, 90 bytes

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

Explicação:

(
  "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)resulta em uma (a -> c)função, é como o reverso da composição, mas requer menos anotações de tipo na escala. Nesse caso, ele recebe uma sequência de dígitos binários como entrada e retorna uma tupla de índices baseados em zero.

J, 31 29 bytes

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

A entrada é formatada como uma matriz 2D de valores binários e a saída são as coordenadas baseadas em zero como uma matriz [y, x].

A conversão de achatamento e base para encontrar o índice é algo que aprendi com este comentário 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

Explicação

[:($#: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)

Entrada é uma lista de cadeias, saída é a cadeia XY (índices baseados em 1).

Teste em Ideone .

Perl, 54 bytes

Código de 53 bytes + 1 para -n. Usa -Esem custo extra.

Usa índices baseados em 0. Espera de entrada como uma série de 1s e 0s e saídas separadas por espaço co-ordenadas.

Agradeço a @ wullxz e @ GabrielBenamy por me ajudarem a salvar 9 bytes, e ao comentário de @ Taemyr na minha resposta Retina por apontar um 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

Essa solução poderia ser melhorada ainda mais ... mas eu a mantive legível e permiti que a entrada fosse a matriz espaçada de várias linhas.

Solução real se matriz de seqüência de caracteres binária

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

Trabalho da amostra

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 (de acordo com o Linux (obrigado 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

Não é exatamente um número competitivo, mas o algoritmo é um pouco interessante. Recebe entrada como uma sequência de valores binários.

Ruby , 62 bytes

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

Ele espera uma sequência de 0e 1retorna uma matriz de Y e X, com base em zero.

Tente ideone .

F # - 260 bytes

Programa completo, incluindo o designador EntryPoint necessário (portanto, conte menos se desejar).

Entrada: cada linha como seqüência de caracteres separada: "111001111110" "110100100000" "010001111101" "100100100100" "100101100111" "111111000010" "110111000001" "100111100001" "100111011111" "111110011111" "100001010111" "11001111111" "100001010111" "11001111111" "11001111111" "

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

Provavelmente não é a solução mais elegante, mas eu queria continuar com as strings, então foi assim que fiz. Eu quase consegui ser uma linha única e menor usando tubos, mas há algo com o bloco duplo se que estava me pegando que eu não conseguia resolver. Então, tudo bem!

Pensei muito em incluir a resposta de Karl no F #, pois ela é boa, e ainda posso fazer isso por diversão como outra abordagem, mas queria continuar com essa para ser diferente.

Dyalog APL, 29 27 bytes

Pega um array binário de 12x12 como entrada do usuário e retorna as coordenadas na ordem inversa; os índices começam em 1.

Obrigado a @ Adám por salvar muitos bytes. -2 bytes porque sou burro e deixei tudo em uma função sem motivo.

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/`]']

Experimente online!

Recebe a entrada como uma sequência longa de 1s e 0s sem nenhum delimitador. Saídas como 3 4(indexação baseada em 0).

Isso funciona colocando os dados de entrada em uma "matriz" (basicamente um dicionário com chaves inteiras) e, em seguida, para cada valor inicial possível, testa os bits com desvios específicos (todos os 16 em um processo muito trabalhoso).