Thử thách này được lấy cảm hứng từ quảng cáo này của Wendy từ năm 1984.

_{Minh họa bởi TS Rogers}

Nhiệm vụ của bạn là tìm 0xBEEF thập lục phân trên búi nhị phân.

'Thịt bò' bao gồm các mẫu sau:

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

Và 'bun' bao gồm ma trận nhị phân 12x12, chẳng hạn như:

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

Đầu vào

Chương trình hoặc chức năng của bạn sẽ lấy ma trận nhị phân làm đầu vào. Định dạng ma trận rất linh hoạt, nhưng nó phải được mô tả rõ ràng trong câu trả lời của bạn.

Ví dụ:

• một chuỗi nhị phân đơn, có hoặc không có dấu phân cách giữa các hàng:

  "111001111110 110100100000..."

  hoặc là:

  "111001111110110100100000..."

• một mảng các chuỗi nhị phân:

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

• một mảng các số (mỗi số mô tả một hàng một lần được chuyển đổi thành nhị phân và được đệm trái bằng số không):

  [3710, 3360, ...]

Đầu ra

Các tọa độ (X, Y)của 'thịt bò', (0, 0)là góc trên cùng bên trái của búi tóc.

Ngoài ra, bạn có thể sử dụng tọa độ dựa trên 1 (nhưng không kết hợp cả hai định dạng, như dựa trên 0 cho X và 1 dựa trên Y).

Đối với ví dụ trên, câu trả lời dự kiến ​​là (3, 4)(dựa trên 0) hoặc (4, 5)(dựa trên 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

Một lần nữa, bất kỳ định dạng hợp lý sẽ hoạt động miễn là nó được chỉ định trong câu trả lời của bạn. Cũng vui lòng đề cập nếu bạn đang sử dụng tọa độ dựa trên 0 hoặc dựa trên 1.

Quy tắc

• Bạn có thể an toàn cho rằng luôn có chính xác một "thịt bò" trên bánh. Mã của bạn không bắt buộc phải hỗ trợ các trường hợp có nhiều hơn một thịt bò hoặc không có thịt bò nào cả.
• Các mô hình thịt bò sẽ luôn luôn xuất hiện như mô tả. Nó sẽ không bao giờ được xoay hoặc nhân đôi theo bất kỳ cách nào.
• Đây là môn đánh gôn, vì vậy câu trả lời ngắn nhất bằng byte sẽ thắng. Sơ hở tiêu chuẩn bị cấm.

Các trường hợp thử nghiệm

Trong các trường hợp thử nghiệm sau đây, mỗi hàng của ma trận được biểu thị dưới dạng biểu diễn thập phân của nó.

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 ]

Thạch , 20 17 16 byte

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

Đầu vào ở dạng ma trận Boolean, đầu ra là cặp chỉ số dựa trên 1 (Y, X) .

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

Làm thế nào nó hoạt động

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

Mong đợi đầu vào trong mẫu

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

Và đầu ra (với các chỉ số dựa trên 1) là

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

Cảm ơn Jörg Hülsermann đã gián tiếp tiết kiệm 46 byte bằng cách khiến tôi nhận ra regex của mình cực kỳ ngớ ngẩn và để DJMcMayhem có thêm 3 byte.

JavaScript (ES6), 63 60 56 byte

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

Đưa đầu vào dưới dạng một chuỗi được phân tách bằng dấu cách không gian gồm 155 ký tự gồm 12 chuỗi nhị phân 12 chữ số, trả về các giá trị được lập chỉ mục bằng không. Chỉnh sửa: Đã lưu 3 byte nhờ @ JörgHülsermann. Đã lưu 4 byte nhờ @ETHproductions.

C, 146 177 173 163 byte

Cảm ơn Numberjack vì đã sửa mã (chuyển ba hàng thấp hơn).

Tiết kiệm 4 byte bằng cách thay thế >>=1bằng /=24 vị trí. Tiết kiệm thêm 10 byte bằng cách cho phép xvà ytoàn cầu và mặc định intnhờ 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;}}

Ung dung:

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

Trả về x, y (dựa trên 0) ở mức cao và thấp của một byte.

Sử dụng:

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

Đầu vào là một ma trận nhị phân, với ;dấu phân cách hàng. Đầu ra là 1 dựa trên thứ tự ngược lại : Y X.

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm với định dạng đầu vào thập phân.

Giải trình

Mẫu được phát hiện bằng cách sử dụng tích chập 2D. Đối với điều này,

• Ma trận và mô hình cần phải ở dạng lưỡng cực, nghĩa là 1, -1thay vì 1, 0. Vì mẫu có kích thước 4 × 4, sự xuất hiện của nó được phát hiện bởi một mục bằng với 16đầu ra tích chập.
• Hạt nhân chập cần được định nghĩa là mẫu tìm kiếm được đảo ngược theo cả hai chiều.

Ngoài ra, do tích chập giới thiệu một phần bù trong các chỉ số được phát hiện, điều này cần được sửa trong đầu ra.

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

Toán học, 62 byte

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

Trả về tất cả các vị trí của ma trận BEEF, được lập chỉ mục 1. Đầu vào phải là một ma trận các chữ số nhị phân. Tuy nhiên, x và y trong đầu ra được chuyển đổi.

Trượt , 28 byte

27 byte mã, +1 cho ptùy chọn.

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

Yêu cầu đầu vào dưới dạng hình chữ nhật đa chiều 1 và 0 không có dấu cách. Hãy thử nó ở đây (với testcase thứ ba là đầu vào).

Giải trình

Trượt là một ngôn ngữ từ thử thách Kết hợp mẫu 2 chiều . Sp3000 có thể nói nhiều hơn về nó so với tôi có thể, nhưng về cơ bản, đây là một dạng regex mở rộng với một số lệnh định hướng cho phép bạn khớp theo hai chiều. Đoạn mã trên sử dụng lệnh "trượt" cùng tên \, không thay đổi hướng của con trỏ khớp mà di chuyển nó sang một bên bởi một ký tự. Nó cũng sử dụng "nhóm đứng yên" (?|...), khớp với thứ gì đó và sau đó đặt lại con trỏ đến vị trí trước đó.

Mã bị hỏng như sau:

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

Điều này phù hợp với 0xBEEFhình vuông. Các ptùy chọn kết quả đầu ra tọa độ của trận đấu, 0-lập chỉ mục.

PHP, 87 byte

chuỗi nhị phân làm đầu vào không có dấu phân cách, trả về các giá trị không có chỉ mục.

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

mảng số như đầu vào 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 được lưu bởi @Titus Cảm ơn bạn

Java 7,182 177 byte

Tôi đã chuyển câu trả lời của Karl Napf C cho JAVA Và cảm ơn Karl Napf vì đã tiết kiệm 5 byte bằng cách nhắc nhở tôi về phép thuật Bit.

(Dựa trên 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;}

Bị đánh cắp

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

}

Võng mạc, 47 byte

Tôi muốn mở đầu điều này bằng một lời xin lỗi. Tôi nghĩ rằng điều này có lẽ là khủng khiếp và là một ví dụ tồi về cách sử dụng ngôn ngữ, nhưng vì tôi đã sử dụng Regex cho câu trả lời Perl của mình, tôi nghĩ tôi sẽ thử Retina. Tôi không tốt lắm. :( Các đoạn trên github đã giúp tôi rất nhiều!

Cảm ơn @ wullzx đã nhận xét về câu trả lời Perl của tôi cho -3 byte và @ Taemyr vì đã chỉ ra một vấn đề với phương pháp của tôi!

Yêu cầu đầu vào dưới dạng một chuỗi nhị phân được phân tách bằng dấu cách và đầu ra phối hợp không gian được phân tách.

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

Hãy thử trực tuyến!

Xác nhận tất cả các xét nghiệm cùng một lúc.

Scala, 90 byte

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

Giải trình:

(
  "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)dẫn đến một (a -> c)chức năng, nó giống như sự đảo ngược của sáng tác, nhưng yêu cầu ít chú thích kiểu hơn trong scala. Trong trường hợp này, nó lấy một chuỗi các chữ số nhị phân làm đầu vào và trả về một bộ chỉ số dựa trên số không.

J, 31 29 byte

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

Đầu vào được định dạng là một mảng 2d của các giá trị nhị phân và đầu ra là tọa độ dựa trên số 0 dưới dạng một mảng [y, x].

Việc làm phẳng và chuyển đổi cơ sở để tìm chỉ mục là điều tôi học được từ nhận xét này của Dennis.

Sử dụng

   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

Giải trình

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

Đầu vào là danh sách các chuỗi, đầu ra là chuỗi XY (chỉ số dựa trên 1).

Kiểm tra nó trên Ideone .

Perl, 54 byte

Mã 53 byte + 1 cho -n. Sử dụng -Emà không mất thêm chi phí.

Sử dụng các chỉ số dựa trên 0. Yêu cầu đầu vào dưới dạng một chuỗi 1s và 0s và đầu ra tọa độ không gian được phân tách.

Cảm ơn @ wullxz và @ GabrielBenamy đã giúp tôi tiết kiệm 9 byte và nhận xét của @ Taemyr về câu trả lời Retina của tôi vì đã chỉ ra một vấn đề!

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

Sử dụng

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

Giải pháp này có thể được cải thiện hơn nữa ... nhưng tôi giữ cho nó có thể đọc được và cho phép đầu vào là ma trận cách dòng nhiều dòng.

Giải pháp thực tế nếu Mảng của chuỗi nhị phân

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

Mẫu làm việc

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 (theo Linux (cảm ơn 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

Không chính xác là một bytecount cạnh tranh, nhưng thuật toán là một chút thú vị. Lấy đầu vào là một chuỗi các giá trị nhị phân.

Ruby , 62 byte

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

Nó mong đợi một chuỗi 0và 1và trả về một mảng Y và X, dựa trên zero.

Hãy thử tại ideone .

F # - 260 byte

Chương trình đầy đủ, bao gồm cả người chỉ định Entrypoint bắt buộc (vì vậy hãy tính ít hơn nếu bạn muốn tôi cho rằng).

Dữ liệu vào

Mã số:

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

Không phải là giải pháp tao nhã nhất, nhưng tôi muốn giữ chuỗi, vì vậy đây là cách tôi đã làm. Tôi gần như đã có được nó là một dòng đơn và nhỏ hơn bằng cách sử dụng các đường ống, nhưng có một cái gì đó với khối kép nếu nó khiến tôi không thể giải quyết. Vậy thì tốt quá!

Tôi cũng nghĩ về việc đưa câu trả lời của Karl vào F # vì đây là một câu hỏi hay, và vẫn có thể làm điều đó để giải trí như một cách tiếp cận khác, nhưng muốn gắn bó với câu trả lời này để khác đi.

APL Dyalog, 29 27 byte

Lấy một mảng nhị phân 12x12 làm đầu vào của người dùng và trả về tọa độ theo thứ tự ngược lại, các chỉ mục bắt đầu từ 1.

Cảm ơn @ Adám đã lưu nhiều byte. -2 Byte vì tôi bị câm và bỏ lại mọi thứ trong một chức năng mà không có lý do.

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

Phần tử , 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/`]']

Hãy thử trực tuyến!

Đưa đầu vào thành một chuỗi dài 1 và 0 mà không có dấu phân cách. Đầu ra như 3 4(lập chỉ mục dựa trên 0).

Điều này hoạt động bằng cách đặt dữ liệu đầu vào vào một "mảng" (về cơ bản là một từ điển với các khóa nguyên) và sau đó, với mỗi giá trị bắt đầu có thể, kiểm tra các bit tại các độ lệch cụ thể (tất cả 16 trong số chúng trong một quá trình rất tốn công).