Этот вызов был вдохновлен рекламой Венди с 1984 года.

_{Иллюстрация Т.С. Роджерса}

Ваша задача - найти шестнадцатеричный 0xBEEF на двоичной булочке.

«Говядина» состоит из следующего шаблона:

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

И «плюшка» состоит из двоичной матрицы 12x12, такой как:

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

вход

Ваша программа или функция будет принимать двоичную матрицу в качестве входных данных. Формат матрицы очень гибкий, но он должен быть четко описан в вашем ответе.

Например:

• одиночная двоичная строка, с или без разделителей между строками:

  "111001111110 110100100000..."

  или же:

  "111001111110110100100000..."

• массив двоичных строк:

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

• массив чисел (каждое число, описывающее строку, однажды преобразованную обратно в двоичную и дополненную слева нулями):

  [3710, 3360, ...]

Выход

Координаты (X, Y)«говядины», (0, 0)являющейся верхним левым углом булочки.

В качестве альтернативы, вы можете использовать координаты на основе 1 (но не сочетание обоих форматов, например 0 на основе X и 1 на основе Y).

Для приведенного выше примера ожидаемый ответ (3, 4)(на основе 0) или (4, 5)(на основе 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

Опять же, любой разумный формат будет работать, если он указан в вашем ответе. Также укажите, если вы используете 0 или 1.

правила

• Вы можете смело предположить, что на булочке всегда ровно одна «говядина». Ваш код не обязан поддерживать случаи с более чем одной говядиной или вообще без говядины.
• Шаблон говядины всегда будет выглядеть так, как описано. Он никогда не будет повернут или отражен каким-либо образом.
• Это код-гольф, поэтому выигрывает самый короткий ответ в байтах. Стандартные лазейки запрещены.

Контрольные примеры

В следующих тестовых примерах каждая строка матрицы выражается в виде десятичного представления.

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 ]

Желе , 20 17 16 байт

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

Входные данные представлены в виде булевой матрицы, выходные данные - индексная пара на основе 1 (Y, X) .

Попробуйте онлайн! или проверьте все контрольные примеры .

Как это устроено

ṡ€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{

Ожидает ввода в виде

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

И выходные данные (с индексами на основе 1) как

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

Спасибо Jörg Hülsermann за косвенную экономию 46 байт, благодаря которой я понял, что мое регулярное выражение было очень глупым, и DJMcMayhem за еще 3 байта.

JavaScript (ES6), 63 60 56 байт

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

Принимает ввод в виде 155-символьной строки из 12 12-значных двоичных строк, разделенных пробелом, возвращает значения с нулевым индексом. Изменить: Сохранено 3 байта благодаря @ JörgHülsermann. Сохранено 4 байта благодаря @ETHproductions.

C 146 177 173 163 байта

Спасибо Numberknot за исправление кода (смещение трех нижних строк).

Сохранение 4 байта, заменив >>=1с /=2в 4 -х местах. Сохранение более 10 байт, позволяя xи yбыть глобальным и по умолчанию intблагодаря 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;
 }
}

Возвращает x, y (на основе 0) в верхнем и нижнем полубайтах байта.

Использование:

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

MATL , 22 21 байт

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

Ввод представляет собой двоичную матрицу с ;разделителем строк. Выход 1-основе в обратном порядке: Y X.

Попробуйте онлайн! Или проверьте все контрольные примеры с десятичным форматом ввода.

объяснение

Шаблон обнаруживается с использованием 2D свертки. За это,

• Матрица и шаблон должны быть в биполярной форме, то есть 1, -1вместо 1, 0. Поскольку шаблон имеет размер 4 × 4, его появление обнаруживается записью, равной 16на выходе свертки.
• Ядро свертки должно быть определено как искомый шаблон, обращенный в обоих измерениях.

Кроме того, поскольку свертка вносит смещение в обнаруженные индексы, это необходимо исправить в выходных данных.

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 байта

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

Возвращает все позиции матрицы BEEF, с 1 индексированием. На входе должна быть матрица двоичных цифр. Хотя x и y на выходе переключаются.

Скольжение , 28 байт

27 байт кода, +1 за pопцию.

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

Требует ввода в виде многострочного прямоугольника из 1 и 0 без пробелов. Попробуйте это здесь (с третьим тестом в качестве входных данных).

объяснение

Slip - это язык из задачи 2-D Pattern Matching . Sp3000 мог бы сказать об этом гораздо больше, чем я, но в основном это расширенная форма регулярного выражения с некоторыми командами направления, которые позволяют вам сопоставлять в двух измерениях. Приведенный выше код использует одноименную команду «slip» \, которая не меняет направление указателя совпадения, а перемещает его вбок на один символ. Он также использует «стационарную группу» (?|...), которая сопоставляет что-то, а затем сбрасывает указатель на его предыдущее местоположение.

Код разбивается следующим образом:

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

Это соответствует 0xBEEFплощади. pОпция выводит координаты матча, 0-индексированные.

PHP, 87 байт

двоичная строка в качестве ввода без разделителей, возвращает значения с нулевым индексом.

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

массив чисел в качестве входных 128 байтов

<?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 байтов сохранено @Titus Спасибо

Java 7,182 177 байт

Я портировал ответ Karl Napf C на JAVA И спасибо Karl Napf за то, что он сэкономил 5 байт, напомнив мне немного магии. (Кстати, я тоже придумал эту идею, но идея возврата части @KarlNapf была вашей, а не моей). Извините, если я вас не устраивал.

(От 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;
    }

}

Сетчатка, 47 байт

Я хотел бы предварить это извинением. Я думаю, что это, вероятно, ужасно и плохой пример того, как использовать язык, но так как я использовал Regex для своего ответа на Perl, я решил попробовать Retina. Я не очень хорош. :( Отрывки на github мне очень помогли!

Спасибо @ wullzx за комментарий к моему Perl-ответу для -3 байта и @ Taemyr за указание на проблему с моим методом!

Ожидает ввод в виде разделенной пробелами двоичной строки и выводит координаты разделенных пробелом.

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

Попробуйте онлайн!

Проверьте все тесты одновременно.

Скала, 90 байт

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

Объяснение:

(
  "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)в результате получается (a -> c)функция, аналогичная compose, но требует меньше аннотаций типов в scala. В этом случае он принимает строку двоичных цифр в качестве входных данных и возвращает набор нулевых индексов.

J, 31 29 байт

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

Входные данные отформатированы в виде двумерного массива двоичных значений, а выходные данные - это координаты, начинающиеся с нуля, в виде массива [y, x].

Сглаживание и базовое преобразование для поиска индекса - это то, что я узнал из этого комментария Денниса.

использование

   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

объяснение

[:($#: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 байта

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

Ввод - это список строк, вывод - это строка XY (индексы на основе 1).

Проверьте это на Ideone .

Perl, 54 байта

Код 53 байта + 1 для -n. Используется -Eбез каких-либо дополнительных затрат.

Использует индексы на основе 0. Ожидает ввод в виде строки 1s и 0s и выводит разделенные пробелом координаты.

Спасибо @ wullxz и @ GabrielBenamy за помощь в экономии 9 байт, а также комментарию @ Taemyr к моему ответу Retina за указание на проблему!

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

использование

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 байт

Это решение может быть улучшено в дальнейшем ... но я сохранил его читабельным и допустил, чтобы входные данные были многострочными матрицами.

Фактическое решение, если массив двоичной строки

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

Образец работы

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 байт (согласно Linux (спасибо 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

Не совсем конкурентный счет, но алгоритм немного интересен. Принимает ввод как строку двоичных значений.

Рубин , 62 байта

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

Он ожидает строку 0и 1возвращает массив Y и X, нулевой основе.

Попробуйте в идеоне .

F # - 260 байт

Полная программа, включая требуемый указатель EntryPoint (так что считайте меньше, если хотите, я полагаю).

Ввод: каждая строка в виде отдельной строки: "111001111110" "110100100000" "010001111101" "100100100100" "100101100111" "111111000010" "110111000001" "100111100001" "100111011111" "111110011111" "100001010111" "1100110111" "1100110011" "1100110011

Код:

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

Скорее всего, это не самое элегантное решение, но я хотел бы придерживаться строк, поэтому я так и сделал. Я почти сделал так, чтобы это была одна линия и меньше, использующая каналы, но есть кое-что с двойным блоком if, который заставлял меня, что я не мог разрешить. Ну да ладно!

Я тоже думал о переносе ответа Карла на F #, поскольку он хороший, и, возможно, все еще делает это ради забавы, как другой подход, но хотел придерживаться этого, чтобы быть другим.

Дьялог АПЛ, 29 27 байт

Принимает двоичный массив 12x12 в качестве пользовательского ввода и возвращает координаты в обратном порядке, индексы начинаются с 1.

Спасибо @ Adám за сохранение большого количества байтов. -2 байта, потому что я тупой и оставил все в функции без причины.

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

Элемент , 130 байт

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

Попробуйте онлайн!

Принимает ввод в виде одной длинной строки 1 и 0 без разделителей. Выходы как 3 4(индексация на основе 0).

Это работает, помещая входные данные в «массив» (в основном словарь с целочисленными ключами), а затем, для каждого возможного начального значения, проверяет биты с определенными смещениями (все 16 из них в очень трудоемком процессе).