ความท้าทายนี้ได้รับแรงบันดาลใจจากโฆษณาของเวนดี้ในปี 1984

_{ภาพประกอบโดย TS Rogers}

งานของคุณคือการหา 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 (แต่ไม่ใช่ทั้งสองรูปแบบเช่นแบบอิง 0 สำหรับ X และ 1 สำหรับ Y)

สำหรับตัวอย่างข้างต้นคำตอบที่คาดหวังคือ(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

กฎระเบียบ

• คุณสามารถสรุปได้อย่างปลอดภัยว่ามี 'เนื้อ' หนึ่งเดียวบนขนมปัง ไม่จำเป็นต้องใช้รหัสของคุณเพื่อรองรับกรณีที่มีมากกว่าหนึ่งเนื้อวัวหรือไม่มีเนื้อวัวเลย
• ลวดลายเนื้อจะปรากฏขึ้นตามที่อธิบายไว้เสมอ มันจะไม่ถูกหมุนหรือสะท้อนในทางใดทางหนึ่ง
• นี่คือรหัสกอล์ฟดังนั้นคำตอบที่สั้นที่สุดในหน่วยไบต์ชนะ ช่องโหว่มาตรฐานเป็นสิ่งต้องห้าม

กรณีทดสอบ

ในกรณีทดสอบต่อไปนี้แต่ละแถวของเมทริกซ์จะแสดงแทนทศนิยม

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-based (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].

เป็นกลุ่ม, 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

ขอขอบคุณJörgHülsermannที่ช่วยประหยัด 46 ไบต์โดยอ้อมด้วยการทำให้ฉันรู้ว่า regex ของฉันนั้นโง่มากและDJMcMayhemอีก 3 ไบต์

JavaScript (ES6), 63 60 56 ไบต์

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

รับอินพุตเป็นสตริงที่คั่นด้วยช่องว่าง 155 อักขระของ 12 สตริงตัวเลข 12 หลักส่งคืนค่าศูนย์ที่จัดทำดัชนี แก้ไข: บันทึกแล้ว 3 ไบต์ขอบคุณ @ JörgHülsermann บันทึกแล้ว 4 ไบต์ด้วย @ETHproductions

C, 146 177 173 163 ไบต์

ขอบคุณNumberknotสำหรับการแก้ไขรหัส (เลื่อนสามแถวด้านล่าง)

ประหยัด 4 ไบต์โดยแทนที่>>=1ด้วย/=2ใน 4 แห่ง ประหยัด 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;}}

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

ส่งคืน 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ตามลำดับ:

ลองออนไลน์! หรือตรวจสอบกรณีทดสอบทั้งหมดด้วยรูปแบบอินพุตทศนิยม

คำอธิบาย

ตรวจพบรูปแบบโดยใช้การบิดแบบ 2 มิติ สำหรับสิ่งนี้,

• เมทริกซ์และรูปแบบจะต้องอยู่ในรูปแบบสองขั้วที่เป็นแทน1, -1 1, 0เนื่องจากรูปแบบมีขนาด 4 × 4 การตรวจจับการเกิดขึ้นของรายการจะเท่ากับ16ในเอาต์พุตของการแปลง
• เคอร์เนล convolution จะต้องกำหนดเป็นรูปแบบที่ต้องการกลับในทั้งสองมิติ

นอกจากนี้เนื่องจาก convolution แนะนำ offset ในดัชนีที่ตรวจพบสิ่งนี้จะต้องได้รับการแก้ไขในผลลัพธ์

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&

ส่งคืนตำแหน่งทั้งหมดของเมทริกซ์ BEEF ซึ่งสร้างดัชนี 1 ตำแหน่ง อินพุตต้องเป็นเมทริกซ์ของเลขฐานสอง แม้ว่า x และ y ในเอาต์พุตจะถูกสลับอย่างไรก็ตาม

สลิป 28 ไบต์

27 ไบต์ของรหัส +1 สำหรับpตัวเลือก

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

ต้องป้อนข้อมูลเป็นสี่เหลี่ยมหลายบรรทัดของ 1 และ 0 โดยไม่มีช่องว่าง ลองที่นี่ (โดยมีส่วนทดสอบที่สามเป็นอินพุต)

คำอธิบาย

สลิปเป็นภาษาจากที่2 มิติรูปแบบการจับคู่ความท้าทาย Sp3000 สามารถพูดได้มากกว่าที่ฉันสามารถทำได้ แต่โดยทั่วไปแล้วมันเป็นรูปแบบขยายของ regex ที่มีคำสั่งทิศทางที่ให้คุณจับคู่ในสองมิติ โค้ดด้านบนใช้คำสั่ง eponymous "สลิป" \ซึ่งไม่เปลี่ยนทิศทางของตัวชี้การจับคู่ แต่จะย้ายไปด้านข้างด้วยอักขระหนึ่งตัว นอกจากนี้ยังใช้ "กลุ่มที่อยู่กับที่" (?|...)ซึ่งจับคู่บางอย่างจากนั้นรีเซ็ตตัวชี้ไปยังตำแหน่งก่อนหน้า

รหัสแบ่งออกเป็นดังนี้:

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

บันทึก 14 ไบต์โดย@Titus Thank You

Java 7182 177 ไบต์

ฉันย้าย Karl Napf CตอบJAVAและขอบคุณKarl Napf ที่ช่วยประหยัด 5 ไบต์ด้วยการเตือนฉัน Bit magic (Btw ฉันมาพร้อมกับความคิดนี้เช่นกัน แต่ @KarlNapf ความคิดในการส่งคืนส่วนที่ไม่ใช่ของคุณ) ขอบคุณถ้าฉันไม่พอใจ

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

}

เรติน่า 47 ไบต์

ฉันต้องการคำนำนี้ด้วยคำขอโทษ ฉันคิดว่านี่น่ากลัวและเป็นตัวอย่างที่ดีของวิธีใช้ภาษา แต่เนื่องจากฉันใช้ Regex สำหรับคำตอบ Perl ของฉันฉันคิดว่าฉันลองใช้ Retina ฉันไม่ค่อยดี :( ตัวอย่างบน githubช่วยฉันอย่างมากแม้ว่า!

ขอบคุณ @ wullzxสำหรับความคิดเห็นของเขาเกี่ยวกับคำตอบ Perl ของฉันสำหรับ -3 ไบต์และ @ Taemyrสำหรับการชี้ปัญหาด้วยวิธีการของฉัน!

คาดว่าอินพุตเป็นสตริงไบนารีคั่นด้วยช่องว่างและเอาต์พุตประสานพื้นที่ที่คั่นด้วย

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

ลองออนไลน์!

ตรวจสอบการทดสอบทั้งหมดในครั้งเดียว

สกาลา, 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)ฟังก์ชั่นเหมือนกลับด้านเขียน แต่ต้องใช้คำอธิบายประกอบประเภทน้อยลงในสกาล่า ในกรณีนี้มันจะใช้สตริงของเลขฐานสองเป็นอินพุตและส่งกลับค่า tuple ของดัชนี zero-based

J, 31 29 ไบต์

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

การป้อนข้อมูลที่ถูกจัดรูปแบบเป็น array 2d ของค่าไบนารีและส่งออกเป็นพิกัด zero-based [y, x]เป็นอาร์เรย์

การแปลงฐานและแบนเพื่อค้นหาดัชนีเป็นสิ่งที่ฉันเรียนรู้จากความคิดเห็นนี้โดย Dennis

การใช้

   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 ไบต์รหัสเมือง + 1 -nสำหรับ ใช้-Eโดยไม่มีค่าใช้จ่ายเพิ่มเติม

ใช้ดัชนีที่อิง 0 คาดว่าอินพุตเป็นสตริงของ1s และ0s และเอาท์พุทที่คั่นด้วยช่องว่างพิกัด

ขอบคุณ @ wullxzและ @ GabrielBenamy ที่ช่วยฉันประหยัดได้ 9 ไบต์และความเห็นของ@ 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

สกาลา, 318 ไบต์

โซลูชันนี้สามารถปรับปรุงเพิ่มเติม ... แต่ฉันเก็บไว้อ่านได้และอนุญาตให้ป้อนเป็นเมทริกซ์ระยะห่างหลายบรรทัด

ทางออกที่แท้จริงถ้า Array ของไบนารีสตริง

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

ไม่ใช่ว่าเป็นจำนวนคู่แข่งขัน แต่อัลกอริทึมนั้นค่อนข้างน่าสนใจ รับอินพุตเป็นสตริงของค่าไบนารี

Ruby , 62 ไบต์

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

มันคาดว่าสตริง0และ1และส่งกลับอาร์เรย์ของ Y และ X ตามศูนย์

ลองที่ ideone

F # - 260 ไบต์

โปรแกรมเต็มรูปแบบรวมถึงผู้ออกแบบ EntryPoint ที่ต้องการ (นับน้อยลงถ้าคุณต้องการฉันสมมติ)

อินพุต: แต่ละแถวเป็นสตริงที่แยกจากกัน: "111001111110" "110100100000000" "010001111101" "100100100100100" "100101100111" "111111000010" "111111000011" "1101110011111" "100111011111" "111110011111" "

รหัส:

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

ไม่ใช่วิธีที่สง่างามที่สุดน่าจะเป็นไปได้ แต่ฉันต้องการที่จะรักษาสตริงไว้ดังนั้นนี่คือวิธีที่ฉันทำ ฉันเกือบจะเป็นบรรทัดเดียวและเล็กกว่าโดยใช้ท่อ แต่มีบางอย่างที่เป็นสองเท่าถ้าบล็อกที่ทำให้ฉันไม่สามารถแก้ไขได้ โอ้ดี!

ฉันคิดเช่นกันเกี่ยวกับการตอบคาร์ลลงใน F # เพราะมันเป็นคำตอบที่ดีและอาจจะทำเช่นนั้นเพื่อความสนุกสนานเป็นแนวทางอื่น แต่ต้องการที่จะยึดติดอยู่กับสิ่งนี้

Dyalog APL, 29 27 ไบต์

รับอาร์เรย์ไบนารีขนาด 12x12 เป็นอินพุตผู้ใช้และส่งคืนพิกัดในลำดับย้อนกลับดัชนีเริ่มต้นที่ 1

ขอบคุณ @ Adámสำหรับการบันทึกจำนวนมาก -2 Bytes เพราะฉันโง่และทิ้งทุกอย่างไว้ในฟังก์ชั่นโดยไม่มีเหตุผล

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 โดยไม่มีตัวคั่นใด ๆ ผลลัพธ์เช่น3 4(การจัดทำดัชนีตาม 0)

สิ่งนี้ทำงานได้โดยการใส่ข้อมูลเข้าใน "อาร์เรย์" (โดยพื้นฐานแล้วพจนานุกรมที่มีคีย์จำนวนเต็ม) จากนั้นสำหรับค่าเริ่มต้นแต่ละค่าที่เป็นไปได้ทดสอบบิตที่ออฟเซ็ตพิเศษ (ทั้งหมด 16 รายการในกระบวนการที่ลำบาก)