この課題は、1984年のウェンディのコマーシャルに触発されました。

_{TSロジャースによるイラスト}

あなたの仕事は、バイナリバンで16進数の0xBEEFを見つけることです。

「牛肉」は次のパターンで構成されています。

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

「bun」は、次のような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ベースの座標を使用することもできます（ただし、Xの場合は0ベース、Yの場合は1ベースなど、両方の形式の組み合わせは使用できません）。

上記の例では、予想される答えは(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ベースの座標を使用している場合も記載してください。

ルール

• パンには常に「ビーフ」が1つだけあると安全に想定できます。あなたのコードは、複数の牛肉がある場合や牛肉がまったくない場合をサポートする必要はありません。
• 牛肉のパターンは、常に説明どおりに表示されます。いかなる方法でも回転またはミラーリングされることはありません。
• これはコードゴルフなので、バイト単位の最短回答が勝ちです。標準的な抜け穴は禁止されています。

テストケース

次のテストケースでは、マトリックスの各行は10進表現として表されます。

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

おかげイェルクHülsermann間接的に私は私の正規表現がスーパーダムだった実現、とすることによって、46のバイトを保存するためのDJMcMayhem 3バイト以上のため。

JavaScript（ES6）、63 60 56バイト

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

12個の12桁のバイナリ文字列の155文字のスペース区切り文字列として入力を受け取り、ゼロインデックス値を返します。編集：@JörgHülsermannのおかげで3バイトを保存しました。@ETHproductionsのおかげで4バイト節約されました。

C、146の 177 173 163バイト

コードを修正してくれたNumberknotに感謝します（下の3行をシフトします）。

置換することにより4つのバイトを保存>>=1して/=24箇所に。させることで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;}}

ゴルフをしていない：

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。

オンラインでお試しください！または、10進数の入力形式ですべてのテストケースを検証します。

説明

パターンは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&

1から始まるBEEFマトリックスのすべての位置を返します。入力は2進数の行列でなければなりません。ただし、出力のxとyは切り替えられます。

スリップ、28バイト

27バイトのコード、pオプションの場合は+1 。

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

スペースなしの1と0の複数行の四角形として入力が必要です。ここで試してください（入力として3番目のテストケースを使用）。

説明

スリップは、2-Dパターンマッチングチャレンジの言語です。Sp3000は、私ができる以上に多くのことを言うことができますが、基本的には、2次元で一致させるいくつかの方向性コマンドを備えた拡張形式の正規表現です。上記のコードは、\マッチポインターの方向を変更せずに1文字だけ横に移動する、同名の「スリップ」コマンドを使用しています。また、「静止グループ」を使用します。これは(?|...)、何かに一致してから、ポインターを以前の場所にリセットします。

コードは次のように分類されます。

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

@Titus Thank Youが保存した14バイト

Java 7、182 177バイト

Karl Napf Cの回答をJAVAに移植し、ビットマジックを思い出させて5バイト節約してくれたKarl Napfに感謝します（このアイデアも思いついたのですが、@ 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;}

非ゴルフ

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バイト

これに謝罪を述べたいと思います。これは恐らく恐ろしく、言語の使い方の悪い例だと思いますが、Perlの答えにRegexを使用したので、Retinaを試してみると思いました。私はそんなに上手くないです。:( githubのスニペットは私を大いに助けてくれました！

Perlの-3バイトの回答についてのコメントを@ wullzxに、私のメソッドの問題を指摘してくれた@ Taemyrに感謝します！

入力をスペースで区切られたバイナリ文字列として期待し、スペースで区切られた座標を出力します。

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

オンラインでお試しください！

すべてのテストを一度に検証します。

Scala、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)関数になります。構成の逆に似ていますが、scalaで必要な型注釈は少なくなります。この場合、2進数の文字列を入力として受け取り、ゼロベースのインデックスのタプルを返します。

J、31 29バイト

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

入力はバイナリ値の2次元配列としてフォーマットされ、出力は配列としてのゼロベースの座標[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バイトのコード+ -n。-E追加費用なしで使用します。

0ベースのインデックスを使用します。入力を1sおよび0sの文字列として期待し、スペースで区切られた座標を出力します。

9バイトの節約を支援してくれた@ wullxzと@ GabrielBenamy、および問題を指摘してくれたRetinaの回答に対する@ Taemyrのコメントに感謝します！

/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 

0andの文字列を期待し1、ゼロから始まるYとXの配列を返します。

ideoneで試してください。

F＃-260バイト

必要なEntryPoint指定子を含む完全なプログラム（したがって、必要に応じて数を減らしてください）。

入力：各行を個別の文字列として： "111001111110" "110100100000" "010001111101" "100100100100" "100101100111" "111111000010" "110111000001" "100111100001" "100111011111" "111110011111" "100001010111" "110011000011"

コード：

[<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ブロックに何かがあります。まあまあ！

Karlの答えをF＃に移植することも考えました。これは別のアプローチとして楽しみのためにそれを行うかもしれませんが、この1つを別のものとして使い続けたいと思っていました。

Dyalog APL、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の1つの長い文字列として受け取ります。3 4（0ベースのインデックス付け）のような出力。

これは、入力データを「配列」（基本的には整数キーを持つディクショナリ）に配置し、可能な開始値ごとに特定のオフセットでビットをテストします（非常に面倒なプロセスで16個すべて）。