Wo ist das 0xBEEF?

92

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

Wo ist das Rindfleisch?

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 ]
Arnauld
quelle
Ist die Verwendung von 1-basierten Indizes erlaubt (wo oben links steht (1,1))?
Türklinke
@Doorknob Ja, wenn es das gleiche Format für X und Y ist (Frage entsprechend aktualisiert).
Arnauld
35
Bonuspunkte, wenn wir auch ausgeben, ob 0xBEEF 0xDEAD ist? : P
TuxCrafting
10
Diese Herausforderung ist wirklich zufällig und irgendwie albern. Aber es ist immer noch eine ziemlich große Herausforderung. +1
DJMcMayhem
Kann ich Ausgang y, x(dh umgekehrte Reihenfolge)?
Luis Mendo

Antworten:

30

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].
Dennis
quelle
14
Ich verstehe nicht ... wie kann man etwas codieren, das nicht von Menschen lesbar ist?
L3n
12
Gelee ist bei weitem einfacher zu schreiben als zu lesen. : P
Dennis
45
@ 13n Sie scheinen zu implizieren, dass Dennis ein Mensch ist. Während es eine Möglichkeit ist, würde ich angesichts der Art von Tricks, die routinemäßig herausgezogen werden, andere nicht rabattieren ... sagen wir mehr Cyberpunk-Alternativen ;-)
Francesco
1
Sie könnten (x, y) mitṡ4Z€Ḅw€“Ье‘ĖUṀ
Jonathan Allan
2
@ JonathanAllan Schön. Es gibt auch eine ṡ€4ḄZjw“¿ÇÇБ’d240-basierte Indizierung, die jedoch leider ein Byte länger ist.
Dennis
40

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.

Türknauf
quelle
1
Ein paar Tipps: 1) Ypist besser als yyp(obwohl ich weiß, dass Sie dagegen sind Y: P) 2) das Leerzeichen in exec 'norm Go'ist unnötig. Und 3) kd{ist kürzer als kdgg. (Hab das aber nicht getestet)
DJMcMayhem
1
@DJMcMayhem Oh, ich vergesse es immer, Yweil ich es in meinem vimrc zurückprallen lasse. : P Tatsächlich war das kdgggleichbedeutend mit just d{, was die aktuelle Zeile überraschenderweise nicht löscht.
Türklinke
Oh, interessant. Wie praktisch!
DJMcMayhem
Ich bin immer verwirrt, wenn sich Dinge wie {eine Charakterbewegung herausstellen; also muss ich sowas {d''stattdessen machen um ganze zeilen zu löschen.
Neil
1
Sie könnten Echo verwenden, anstatt in den Puffer zu drucken. Ich glaube, dass nichts dies in der Herausforderung verhindert. Das würde etwa 10 Bytes abschneiden.
Christian Rondeau
22

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.

Neil
quelle
Könnten Sie möglicherweise s.search(r)anstelle von verwenden r.exec(s).index?
ETHproductions
1
@ETHproductions Natürlich könnte ich. Ich muss gestern halb geschlafen haben ...
Neil
Für mich mit NodeJS auszuführen, ist es nicht , wenn ich nicht arbeiten ändern s=>[zu (s,i)=>[, weil Sie mich brauchen irgendwo zu definieren: /
Mijago
@Mijago Seltsam, es hat in Node 4 funktioniert, als ich es ausprobiert habe (ich verwende normalerweise die Spidermonkey JS-Shell). Wohlgemerkt, ein Tippfehler hatte sich in den Code eingeschlichen, so dass einiges Gutes dabei herauskam!
Neil
Ich denke, dass dies für 000010110010110011100011100011100011100011110011000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
Taemyr 26.10.16
14

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);
Karl Napf
quelle
1
Sie können Ihre Definition in #define T(i,n)if((A[y+i]&15)==n)und den if-Abschnitt in ändern T(0,11)T(1,14)T(2,14)T(3,15)return, um 6 Bytes zu sparen. Ändern Sie auch die Funktionssignatur int b(int*A)in weitere 4 Bytes, die gespeichert werden.
Lince Assassino
163 Bytes
MD XF
9

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
Luis Mendo
quelle
8

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.

JungHwan min
quelle
Keine Sorge um xund ygeschaltet zu werden.
Arnauld
7

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.

DLosc
quelle
1
Nizza :) Seltsamerweise ist es für Blockmuster manchmal Golfspieler, einfach spiralförmig 1011>001>1(11>){3}1>1
herumzulaufen
@ Sp3000 Ha! Spiral war die kürzeste Methode in SnakeEx, aber ich dachte nicht daran, es in Slip zu versuchen. Wirklich schöner Trick mit dem 1(11>){3}.
DLosc
7

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

Jörg Hülsermann
quelle
Verwenden Sie ,statt .im echound können Sie die Klammern entfernen. (-4)
Titus
In den Kommentaren erlaubt Arnauld die Ausgabe ohne Trennzeichen. (-4)
Titus
Use flag PREG_OFFSET_CAPTURE: ,256an die preg_matchParameter anhängen , ^(.*)aus der Regex entfernen , $c[0][1]statt strlen($c[1])(-6)
Titus
@Titus schön und fertig
Jörg
5

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

}
Zahlenknoten
quelle
2
Was sind die vier Räume zwischen a[y++]>>=1)und if((a[y]&15)==. Übrigens zähle ich 182 Bytes statt 183? : S
Kevin Cruijssen
@ KevinCruijssen behoben.
Numberknot
1
Alles in Ordnung ;-)
Karl Napf
1
Sie können das Leerzeichen zwischen ...a[y++]/=2)und trotzdem entfernen if((a[y]&15)==....
Kevin Cruijssen
5

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.

Dom Hastings
quelle
1
(.) Nicht für '000010110010110011100011100011100011100011110011110000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000' Ihre * sein muss {0,8} (.)
Taemyr
Wird dem entgegengewirkt You can safely assume that there is always exactly one 'beef' on the bun. Your code is not required to support cases with more than one beef or no beef at all.? Sie kann jedoch bei Bedarf mit ungrauten Modifikatoren aufgelöst werden (.{12})*?(.)*?.
Dom Hastings
1
Schauen Sie noch einmal, es gibt nur ein Rindfleisch in dieser Eingabe - und es ist nicht an dem Punkt, an dem Ihr Programm angibt. Das Problem würde nicht durch die Verwendung von eifrigen Modifikatoren gelöst, da ich das gefälschte Rindfleisch durch das echte Rindfleisch ersetzen kann. Das Problem ist, dass Ihre Regex mit einem "Rind" übereinstimmt, das weniger als 4 Bit vom Ende einer Matrixzeile entfernt beginnt.
Taemyr
Sie können dieses Problem auch beheben, indem Sie die {8} in {9} ändern und die Zeilen in der Eingabe nach einem Null-Byte-Kostenfix trennen.
Taemyr
@ Taemyr Ahhh! Aha! Ich habe Ihren Standpunkt falsch verstanden ... Sie haben in der Tat Recht. Meine Perl-Lösung ist möglicherweise auch davon betroffen. Werde das so schnell wie möglich ändern. Vielen Dank für Ihre Kommentare und Anregungen!
Dom Hastings
4

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.

corvus_192
quelle
4

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]
Meilen
quelle
4

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 .

Dennis
quelle
Könnte dies fälschlicherweise ein "Rindfleisch" über die Grenze finden, wo zwei Linien verkettet sind?
Xnor
Ja ich glaube schon. Ich werde die Bearbeitung zurücksetzen, bis ich sie richtig testen kann.
Dennis
2
Das ist, was passiert, wenn Sie ein toroidales Brötchen verwenden.
mbomb007
4

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
Dom Hastings
quelle
1
Sie können 3 Zeichen speichern, indem Sie den (.{8}1110){2}.{8}1110.{8}1110
regulären Ausdruck
1
Sie können auch weitere 3 Bytes speichern, indem Sie length$`auf$-[0]
Gabriel Benamy 24.10.16
Natürlich! Ich habe es versucht \1, hatte aber kein Glück, habe nicht daran gedacht, es zu versuchen {2}! Vielen Dank!
Dom Hastings
@ GabrielBenamy Erstaunlich, vielen Dank! Aktualisiert!
Dom Hastings
2
@ User112638726 " $-[0]ist der Versatz des Starts der letzten erfolgreichen Übereinstimmung. Ist der Versatz des Starts der $-[n]Teilzeichenfolge, auf die das n-te Teilmuster zutrifft, oder undefwenn das Teilmuster nicht zutrifft." von: perldoc.perl.org/perlvar.html (suchen Sie nach @-)
Dom Hastings
1

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
Trevor Sibanda
quelle
1

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.

penalosa
quelle
Wenn Sie anstelle von 4 einzelne Leerzeichen verklagen und unter Linux überprüfen, ist es 137
ElPedro,
1
Ich denke, Sie brauchen eine neue Zeile und Leerzeichen vor dem Import (ich bekomme einen IndentError in Python 2 ohne es), die 2 Bytes kostet, aber Sie können dann i = ..., x = ... und y = ... auf die gleiche Zeile wie und getrennt mit; 1 Byte für 136 zu verlieren
ElPedro
@elpedro Ich verwende Python 3 und es ist in Ordnung, wenn sich der Import in derselben Zeile befindet.
Penalosa
Vollständig verstanden :)
ElPedro
Meine Güte, lies noch einmal meine Kommentare und ich mache heute Abend so viele Tippfehler. Gut, dass ich nicht versuche, Code zu schreiben ...
ElPedro
1

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 .

undur_gongor
quelle
1

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.

magumbasauce
quelle
1

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
Zacharý
quelle
Sparen Sie 2 durch Ersatz ~2 8 12∊⍨4 4⍴⍳16mit 15 7 15 9⊤⍨4/2. Beachten Sie, dass 0~⍨∊{⍵×⍳⍴⍵}dies durch Version 16.0 ersetzt werden kann (Ihr Code funktioniert nur in Dyalog APL).
Adám
Ja, Dyalog hat Charaktere, die sich von GNU unterscheiden. Oder ist es etwas anderes?
Zacharý
Nun, seit Version 16 konnte ich keine Liste von GNUAPL-Grundelementen finden.
Adám
Ich habe GNU APL am Laufen, es sind meist nur Codepoint-Unterschiede.
Zacharý
Soweit mir aufgefallen ist.
Zacharý
0

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).

PhiNotPi
quelle