Diese Herausforderung wurde von der Werbung dieser Wendy aus dem Jahr 1984 inspiriert .

_{Illustration von TS Rogers}

Ihre Aufgabe ist es, ein hexadezimales 0xBEEF auf einem binären Brötchen zu finden.

Das Rindfleisch besteht aus folgendem Muster:

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

Und das 'Brötchen' besteht aus einer 12x12-Binärmatrix, wie zum Beispiel:

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

Eingang

Ihr Programm oder Ihre Funktion nimmt die binäre Matrix als Eingabe. Das Matrixformat ist sehr flexibel, muss aber in Ihrer Antwort klar beschrieben werden.

Zum Beispiel:

• eine einzelne Binärzeichenfolge mit oder ohne Trennzeichen zwischen den Zeilen:

  "111001111110 110100100000..."

  oder:

  "111001111110110100100000..."

• ein Array von binären Strings:

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

• ein Array von Zahlen (jede Zahl beschreibt eine Zeile, die einmal in binäre Zahlen umgewandelt und mit Nullen aufgefüllt wurde):

  [3710, 3360, ...]

Ausgabe

Die Koordinaten (X, Y)des 'Rindfleisches', (0, 0)wobei es sich um die obere linke Ecke des Brötchens handelt.

Alternativ können Sie 1-basierte Koordinaten verwenden (jedoch keine Mischung aus beiden Formaten, z. B. 0-basierte für X und 1-basierte für Y).

Für das obige Beispiel lautet die erwartete Antwort (3, 4)(0-basiert) oder (4, 5)(1-basiert):

   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

Auch hier würde jedes vernünftige Format funktionieren, solange es in Ihrer Antwort angegeben ist. Bitte erwähnen Sie auch, ob Sie 0-basierte oder 1-basierte Koordinaten verwenden.

Regeln

• Sie können davon ausgehen, dass sich immer genau ein Rindfleisch auf dem Brötchen befindet. Ihr Code ist nicht erforderlich, um Fälle mit mehr als einem Rindfleisch oder gar keinem Rindfleisch zu unterstützen.
• Das Rindfleischmuster wird immer wie beschrieben angezeigt. Es wird niemals gedreht oder gespiegelt.
• Das ist Code-Golf, also gewinnt die kürzeste Antwort in Bytes. Standardlücken sind verboten.

Testfälle

In den folgenden Testfällen wird jede Zeile der Matrix als ihre Dezimaldarstellung ausgedrückt.

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 ]

Jelly , 20 17 16 Bytes

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

Die Eingabe erfolgt in Form einer Booleschen Matrix, die Ausgabe erfolgt als 1-basiertes Indexpaar (Y, X) .

Probieren Sie es online! oder überprüfen Sie alle Testfälle .

Wie es funktioniert

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

Erwartet Eingaben in das Formular

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

Und Ausgänge (mit 1-basierten Indizes) als

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

Vielen Dank an Jörg Hülsermann für die indirekte Einsparung von 46 Bytes, indem er mir klar machte, dass mein Regex super doof war, und an DJMcMayhem für 3 weitere Bytes.

JavaScript (ES6), 63 60 56 Bytes

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

Nimmt die Eingabe als durch Leerzeichen getrennte 155-stellige Zeichenfolge von 12 12-stelligen Binärzeichenfolgen an und gibt mit Nullen indizierte Werte zurück. Edit: 3 Bytes gespeichert dank @ JörgHülsermann. 4 Bytes gespart dank @ETHproductions.

C 146 177 173 163 Bytes

Danke an Numberknot für das Fixieren des Codes (Verschieben der unteren drei Zeilen).

Speichern von 4 Bytes durch Ersetzen >>=1durch /=2an 4 Stellen. Speicher 10 mehr Bytes , indem sie xund yglobal sein und Standard intdank 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;
 }
}

Gibt x, y (0-basiert) im High- und Low-Halbbyte eines Bytes zurück.

Verwendungszweck:

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

Die Eingabe ist eine binäre Matrix mit einem ;Zeilentrennzeichen. Die Ausgabe wird mit Basis 1 in umgekehrter Reihenfolge: Y X.

Probieren Sie es online! Oder überprüfen Sie alle Testfälle mit dezimalem Eingabeformat.

Erläuterung

Das Muster wird unter Verwendung einer 2D-Faltung erfasst. Dafür,

• Die Matrix und das Muster müssen in bipolarer Form vorliegen, dh 1, -1statt 1, 0. Da das Muster die Größe 4 × 4 hat, wird sein Auftreten durch einen Eintrag gleich 16der Faltungsausgabe erfasst .
• Der Faltungskern muss als das gesuchte Muster definiert werden, das in beiden Dimensionen umgekehrt ist.

Da die Faltung einen Versatz in die erfassten Indizes einführt, muss dies in der Ausgabe korrigiert werden.

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&

Gibt alle Positionen der BEEF-Matrix 1-indiziert zurück. Die Eingabe muss eine Matrix aus Binärziffern sein. Die x und y in der Ausgabe werden jedoch umgeschaltet.

Unterhose , 28 Bytes

27 Byte Code, +1 für pOption.

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

Erfordert die Eingabe als mehrzeiliges Rechteck aus Einsen und Nullen ohne Leerzeichen. Probieren Sie es hier aus (mit drittem Testfall als Eingabe).

Erläuterung

Slip ist eine Sprache aus dem 2-D Pattern Matching . Sp3000 könnte viel mehr darüber sagen als ich, aber im Grunde ist es eine erweiterte Form von Regex mit einigen Richtungsbefehlen, mit denen Sie in zwei Dimensionen übereinstimmen können. Der obige Code verwendet den gleichnamigen "Slip" -Befehl \, der die Richtung des Übereinstimmungszeigers nicht ändert, sondern ihn seitwärts um ein Zeichen verschiebt. Es wird auch "stationäre Gruppe" verwendet (?|...), die mit etwas übereinstimmt und dann den Zeiger auf seine vorherige Position zurücksetzt.

Der Code setzt sich wie folgt zusammen:

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

Das passt zum 0xBEEFQuadrat. Die pOption gibt die Koordinaten der Übereinstimmung 0-indiziert aus.

PHP, 87 Bytes

Binärzeichenfolge als Eingabe ohne Trennzeichen, gibt mit Null indizierte Werte zurück.

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

Array von Zahlen als Eingabe 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 von @Titus gespeichert Vielen Dank

Java 7,182 177 Bytes

Ich portiert Karl Napf C Antwort auf JAVA Und Dank Karl Napf für 5 Byte Speichern von mir erinnert Bit Magie. (Btw ich auch mit dieser Idee kam aber @KarlNapf Teil Idee Rückkehr war Ihr nicht meine) .Sorry wenn ich Ihnen mißfallen.

(0-basiert)

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

}

Netzhaut, 47 Bytes

Ich möchte dies mit einer Entschuldigung voranstellen. Ich denke, das ist wahrscheinlich schrecklich und ein schlechtes Beispiel für die Verwendung der Sprache, aber da ich für meine Perl-Antwort einen Regex verwendet habe, dachte ich, ich würde es mit Retina versuchen. Ich bin nicht sehr gut. :( Die Schnipsel auf Github haben mir sehr geholfen!

Vielen Dank an @ wullzx für seinen Kommentar zu meiner Perl-Antwort für -3 Bytes und an @ Taemyr für den Hinweis auf ein Problem mit meiner Methode!

Erwartet die Eingabe als durch Leerzeichen getrennte Binärzeichenfolge und gibt durch Leerzeichen getrennte Koordinaten aus.

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

Probieren Sie es online!

Überprüfen Sie alle Tests auf einmal.

Scala, 90 Bytes

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

Erläuterung:

(
  "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)Das Ergebnis ist eine (a -> c)Funktion, die der Umkehrung des Komponierens ähnelt, jedoch weniger Typanmerkungen in Scala erfordert. In diesem Fall wird eine Zeichenfolge der Binärziffern als Eingabe verwendet und ein Tupel von auf Null basierenden Indizes zurückgegeben.

J 31 29 Bytes

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

Die Eingabe ist als 2d-Array von Binärwerten formatiert, und die Ausgabe sind die auf Null basierenden Koordinaten als Array [y, x] .

Aus diesem Kommentar habe ich gelernt, wie der Index abgeflacht und umgerechnet wird von Dennis .

Verwendungszweck

   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

Erläuterung

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

Eingabe ist eine Liste von Zeichenfolgen, Ausgabe ist die Zeichenfolge XY (1-basierte Indizes).

Teste es auf Ideone .

Perl, 54 Bytes

53 Byte Code + 1 für -n. Verwendet-E ohne zusätzliche Kosten.

Verwendet 0-basierte Indizes. Erwartet die Eingabe als Zeichenfolge von 1s und 0s und gibt durch Leerzeichen getrennte Koordinaten aus.

Vielen Dank an @ wullxz und @ GabrielBenamy, die mir beim Sparen von 9 Bytes geholfen haben, und an @ Taemyrs Kommentar zu meiner Retina-Antwort für den Hinweis auf ein Problem!

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

Verwendungszweck

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

Diese Lösung könnte weiter verbessert werden ... aber ich habe sie lesbar gehalten und zugelassen, dass die Eingabe die Matrix mit mehreren Zeilenabständen ist.

Tatsächliche Lösung, wenn Array der Binärzeichenfolge

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

Beispielarbeit

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 (laut Linux (danke 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

Nicht gerade ein konkurrenzfähiger Bytecount, aber der Algorithmus ist ein bisschen interessant. Übernimmt die Eingabe als eine Folge von Binärwerten.

Ruby , 62 Bytes

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

Es erwartet eine Zeichenfolge von 0und 1und gibt ein Array von Y und X auf der Basis von Null zurück.

Versuche es bei ideone .

F # - 260 Bytes

Vollständiges Programm, einschließlich des erforderlichen EntryPoint-Bezeichners (ich nehme an, zählen Sie weniger, wenn Sie dies wünschen).

Eingabe: jede Zeile als separate Zeichenfolge: 111001111110 110100100000 010001111101 100100100100 100101100111 111111000010 110111000001 100111100001 10011101111111 1100

Code:

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

Wahrscheinlich nicht die eleganteste Lösung, aber ich wollte bei Streichern bleiben, also habe ich es so gemacht. Ich hätte es beinahe zu einer einzelnen Linie und zu einer kleineren mit Pipes gemacht, aber es gibt etwas mit dem double if Block, das mich dazu brachte, dass ich es nicht auflösen konnte. Also gut!

Ich habe auch darüber nachgedacht, Karls Antwort in F # zu portieren, da es eine gute Antwort ist, und das vielleicht noch zum Spaß als eine andere Herangehensweise, aber ich wollte bei dieser bleiben, um anders zu sein.

Dyalog APL, 29 27 Bytes

Nimmt ein 12x12-Binärarray als Benutzereingabe und gibt die Koordinaten in umgekehrter Reihenfolge zurück, die Indizes beginnen bei 1.

Vielen Dank an @ Adám für das Speichern vieler Bytes. -2 Bytes, weil ich dumm bin und alles grundlos in einer Funktion belassen habe.

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

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

Probieren Sie es online!

Nimmt die Eingabe als eine lange Zeichenfolge mit 1 und 0 ohne Begrenzer. Ausgaben wie 3 4(0-basierte Indizierung).

Dies funktioniert, indem die Eingabedaten in ein "Array" (im Grunde genommen ein Wörterbuch mit ganzzahligen Schlüsseln) gestellt werden und dann für jeden möglichen Startwert die Bits an bestimmten Offsets getestet werden (alle 16 in einem sehr mühsamen Prozess).