Questa sfida è stata ispirata dalla pubblicità di questo Wendy del 1984.

_{Illustrazione di TS Rogers}

Il tuo compito è trovare un 0xBEEF esadecimale su un panino binario.

Il "manzo" è costituito dal seguente modello:

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

E il 'bun' è costituito da una matrice binaria 12x12, come ad esempio:

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

Ingresso

Il tuo programma o funzione prenderà la matrice binaria come input. Il formato matrice è molto flessibile, ma deve essere chiaramente descritto nella risposta.

Per esempio:

• una singola stringa binaria, con o senza separatori tra le righe:

  "111001111110 110100100000..."

  o:

  "111001111110110100100000..."

• una matrice di stringhe binarie:

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

• una matrice di numeri (ogni numero che descrive una riga una volta convertito in binario e riempito a sinistra con zeri):

  [3710, 3360, ...]

Produzione

Le coordinate (X, Y)del "manzo", (0, 0)essendo l'angolo in alto a sinistra del panino.

In alternativa, puoi utilizzare le coordinate basate su 1 (ma non un mix di entrambi i formati, come 0 basato su X e 1 basato su Y).

Per l'esempio sopra, la risposta prevista è (3, 4)(basata su 0) o (4, 5)(basata su 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

Ancora una volta, qualsiasi formato ragionevole funzionerebbe purché sia ​​specificato nella tua risposta. Si prega di menzionare anche se si utilizzano coordinate basate su 0 o 1.

Regole

• Puoi tranquillamente supporre che sul panino ci sia sempre esattamente un "manzo". Il tuo codice non è richiesto per supportare casi con più di un manzo o nessun manzo.
• Il modello di carne apparirà sempre come descritto. Non verrà mai ruotato o specchiato in alcun modo.
• Questo è code-golf, quindi vince la risposta più breve in byte. Sono vietate le scappatoie standard.

Casi test

Nei seguenti casi di test, ogni riga della matrice è espressa come rappresentazione decimale.

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 ]

Gelatina , 20 17 16 byte

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

L'input è in forma di matrice booleana, l'output è la coppia di indici basata su 1 (Y, X) .

Provalo online! o verifica tutti i casi di test .

Come funziona

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

Prevede input nel modulo

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

E output (con indici basati su 1) come

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

Grazie a Jörg Hülsermann per aver salvato indirettamente 46 byte facendomi capire che il mio regex era super stupido e a DJMcMayhem per altri 3 byte.

JavaScript (ES6), 63 60 56 byte

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

Accetta l'input come una stringa delimitata da spazi di 155 caratteri di 12 stringhe binarie a 12 cifre, restituisce valori indicizzati zero. Modifica: salvato 3 byte grazie a @ JörgHülsermann. Risparmiato 4 byte grazie a @ETHproductions.

C, 146 177 173 163 byte

Grazie a Numberknot per aver corretto il codice (spostando le tre righe inferiori).

Salvataggio di 4 byte sostituendolo >>=1con /=2in 4 posizioni. Risparmio di altri 10 byte lasciando xche ysia globale e predefinito intgrazie 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;}}

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

Restituisce x, y (basato su 0) nel nibble alto e basso di 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 byte

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

L'input è una matrice binaria, con ;come separatore di riga. L'uscita è 1-based in ordine inverso: Y X.

Provalo online! Oppure verifica tutti i casi di test con il formato di input decimale.

Spiegazione

Il modello viene rilevato mediante convoluzione 2D. Per questo,

• La matrice e il motivo devono essere in forma bipolare, cioè al 1, -1posto di 1, 0. Poiché il modello ha dimensioni 4 × 4, la sua occorrenza viene rilevata da una voce uguale 16all'output di convoluzione.
• Il kernel di convoluzione deve essere definito come il modello ricercato invertito in entrambe le dimensioni.

Inoltre, poiché la convoluzione introduce un offset negli indici rilevati, questo deve essere corretto nell'output.

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 byte

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

Restituisce tutte le posizioni della matrice BEEF, 1 indicizzata. L'input deve essere una matrice di cifre binarie. Tuttavia, x e y nell'output vengono commutati.

Slittamento , 28 byte

27 byte di codice, +1 per popzione.

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

Richiede input come rettangolo multilinea di 1 e 0 senza spazi. Provalo qui (con la terza testcase come input).

Spiegazione

Slip è un linguaggio della sfida 2-D Pattern Matching . Sp3000 potrebbe dire molto di più di quello che posso, ma fondamentalmente è una forma estesa di regex con alcuni comandi direzionali che ti consentono di abbinare in due dimensioni. Il codice sopra usa l'omonimo comando "slip" \, che non cambia la direzione del puntatore della partita ma lo sposta lateralmente di un carattere. Utilizza anche "gruppo stazionario" (?|...), che corrisponde a qualcosa e quindi reimposta il puntatore nella posizione precedente.

Il codice si suddivide come segue:

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

Questo corrisponde al 0xBEEFquadrato. L' popzione genera le coordinate della corrispondenza, indicizzate 0.

PHP, 87 byte

stringa binaria come input senza separatori, restituisce valori indicizzati zero.

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

matrice di numeri come input 128 byte

<?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 byte salvati da @Titus Grazie

Java 7,182 177 byte

Ho portato Karl Napf C in risposta a JAVA E grazie a Karl Napf per aver salvato 5 byte ricordandomi un po 'di magia.

(0-based)

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 byte

Vorrei prefigurarlo con delle scuse. Penso che questo sia probabilmente terribile e un cattivo esempio di come usare la lingua, ma dato che ho usato un Regex per la mia risposta al Perl, ho pensato di provare Retina. Non sono molto bravo. :( I frammenti di github mi hanno aiutato molto però!

Grazie a @ wullzx per il suo commento sulla mia risposta Perl per -3 byte e @ Taemyr per aver segnalato un problema con il mio metodo!

Si aspetta input come una stringa binaria separata dallo spazio e gli output coordina lo spazio separato.

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

Provalo online!

Verifica tutti i test contemporaneamente.

Scala, 90 byte

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

Spiegazione:

(
  "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)risulta in una (a -> c)funzione, è come il contrario di comporre, ma richiede meno annotazioni di tipo in scala. In questo caso, accetta come input una stringa di cifre binarie e restituisce una tupla di indici a base zero.

J, 31 29 byte

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

L'input è formattato come un array 2d di valori binari e l'output è le coordinate a base zero come un array [y, x].

L'appiattimento e la conversione di base per trovare l'indice sono qualcosa che ho imparato da questo commento di 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

Spiegazione

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

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

L'input è un elenco di stringhe, l'output è la stringa XY (indici basati su 1).

Provalo su Ideone .

Perl, 54 byte

53 byte codice + 1 per -n. Utilizza -Esenza costi aggiuntivi.

Utilizza indici basati su 0. Attende ingresso come una stringa di 1s e 0s ed uscite separate da uno spazio coordina.

Grazie a @ wullxz e @ GabrielBenamy per avermi aiutato a salvare 9 byte, e al commento di @ Taemyr sulla mia risposta Retina per aver segnalato 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 byte

Questa soluzione potrebbe essere ulteriormente migliorata ... ma l'ho mantenuta leggibile e ho permesso che l'input fosse la matrice spaziata su più righe.

Soluzione effettiva se array di stringhe binarie

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

Esempio di funzionamento

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 byte (secondo Linux (grazie 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

Non esattamente un conto competitivo, ma l'algoritmo è un po 'interessante. Accetta l'input come una stringa di valori binari.

Rubino , 62 byte

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

Si aspetta una stringa di 0e 1e restituisce una matrice di Y e X, a base zero.

Prova a ideone .

F # - 260 byte

Programma completo, incluso il designatore EntryPoint richiesto (quindi contane meno, se lo desideri, suppongo).

Input: ogni riga come stringa separata: "111001111110" "110100100000" "010001111101" "100100100100" "100101100111" "111111000010" "110111000001" "100111100001" "100111011111" "111110011111" "1000001110111" "11000011

Codice:

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

Probabilmente non è la soluzione più elegante, ma volevo continuare con le stringhe, quindi è così che l'ho fatto. Ho quasi capito che si trattava di una linea singola e più piccola che utilizzava pipe, ma c'è qualcosa con il doppio blocco se che mi stava procurando che non riuscivo a risolvere. Quindi vabbè!

Ho pensato anche di portare la risposta di Karl in F # perché è una buona idea, e potrei ancora farlo per divertimento come un altro approccio, ma volevo rimanere con questo per essere diverso.

Dyalog APL, 29 27 byte

Accetta un array binario 12x12 come input dell'utente e restituisce le coordinate in ordine inverso, gli indici iniziano da 1.

Grazie a @ Adám per aver salvato molti byte. -2 byte perché sono stupido e ho lasciato tutto in una funzione senza motivo.

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

Elemento , 130 byte

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

Provalo online!

Accetta l'input come una stringa lunga di 1 e 0 senza delimitatori. Output come 3 4(indicizzazione basata su 0).

Funziona posizionando i dati di input in un "array" (sostanzialmente un dizionario con chiavi intere) e quindi, per ogni possibile valore iniziale, verifica i bit in determinati offset (tutti e 16 in un processo molto laborioso).