Bu zorluk, bu Wendy'nin 1984'teki reklamından esinlenmiştir .

_{TS Rogers tarafından İllüstrasyon}

Senin görevin bir ikili topuz onaltılık bir 0xBEEF bulmaktır.

'Sığır eti' aşağıdaki düzenden oluşur:

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

Ve 'topuz', 12x12'lik ikili bir matristen oluşur, örneğin:

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

Giriş

Programınız veya fonksiyonunuz ikili matrisi girdi olarak alır. Matris formatı çok esnektir, ancak cevabınızda açıkça belirtilmesi gerekir.

Örneğin:

• satırlar arasında ayırıcı olan veya olmayan tek bir ikili dize:

  "111001111110 110100100000..."

  veya:

  "111001111110110100100000..."

• İkili dizelerin bir dizi:

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

• bir sayılar dizisi (bir kez ikiliye dönüştürülen ve sıfırlarla sola yaslanmış bir satırı tanımlayan her sayı):

  [3710, 3360, ...]

Çıktı

(X, Y)'Sığırların' koordinatları (0, 0), topuzun sol üst köşesidir.

Alternatif olarak, 1 tabanlı koordinatlar kullanabilirsiniz (ancak X için 0 tabanlı ve Y için 1 tabanlı gibi her iki formatın karışımı değil).

Yukarıdaki örnekte beklenen cevap (3, 4)(0 tabanlı) veya (4, 5)(1 tabanlı):

   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

Yine, makul herhangi bir format cevabında belirtildiği sürece işe yarar. Lütfen 0 veya 1 tabanlı koordinatları kullanıyorsanız bahsedin.

kurallar

• Çörekte her zaman tam olarak bir 'sığır' olduğunu güvenli bir şekilde kabul edebilirsiniz. Birden fazla sığır eti veya hiç sığır eti olmayan vakaları desteklemek için kodunuz gerekmez.
• Sığır eti deseni her zaman açıklandığı gibi görünecektir. Asla döndürülmez veya yansıtılmaz.
• Bu kod golf, yani bayt cinsinden en kısa cevap kazanır. Standart boşluklar yasaktır.

Test durumları

Aşağıdaki test durumlarında, matrisin her satırı ondalık gösterimi olarak ifade edilir.

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 ]

Jöle , 20 17 16 bayt

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

Giriş, bir Boolean matrisi şeklinde, çıkış 1 tabanlı dizin çiftidir (Y, X) .

Çevrimiçi deneyin! veya tüm test durumlarını doğrulayın .

Nasıl çalışır

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

Formdaki girişi bekliyor

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

Ve çıktıları (1 tabanlı endekslerle) olarak

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

Sayesinde Jörg Hülsermann dolaylı benim regex süper dilsiz olduğunu fark ve hiç yaparak 46 bayt kaydetmek için DJMcMayhem 3 daha byte için.

JavaScript (ES6), 63 60 56 bayt

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

Girdiyi, 12 karakterli, 12 karakterli, 12 karakterli bir karakter dizisi olarak, 155 karakterlik boşluk bırakılmış bir dizge olarak alır. Düzenleme: @ JörgHülsermann sayesinde 3 bayt kaydedildi. @ETHproductions sayesinde 4 byte kurtarıldı.

C, 146 177 173 163 bayt

Kodu düzeltmek için Sayı notu sayesinde (alt üç sırayı değiştirerek).

4 yer >>=1ile değiştirerek 4 bayttan tasarruf edin /=2. Sağlayarak 10 daha bayt kaydetme xve yküresel ve varsayılan olmasını intsayesinde 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;
 }
}

Bir baytın en yüksek ve en düşük ucundaki x, y (0 temelli) değerini döndürür.

Kullanımı:

int temp=b(array_to_solve);
int x=temp>>4;
int y=temp&15;
printf("%d %d\n",x,y);

MATL , 22 21 bayt

Eq[ODDH]B~EqZ+16=&fhq

Giriş, ;satır ayırıcı olarak ikili bir matristir . Çıkış ters sırayla 1-dayanmaktadır: Y X.

Çevrimiçi deneyin! Veya tüm test durumlarını ondalık giriş biçiminde doğrulayın .

açıklama

Desen 2B evrişim kullanılarak algılanır. Bunun için,

• Matris ve desen, 1, -1bunun yerine , bipolar formda olmalıdır 1, 0. Desenin boyutu 4 × 4 olduğundan, oluşumu 16evrişim çıkışına eşit bir giriş tarafından tespit edilir .
• Konvolüsyon çekirdeğinin her iki boyutta da tersine çevrilen aranan kalıp olarak tanımlanması gerekir.

Ayrıca, evrişim algılanan endekslerde bir ofset getirdiğinden, bunun çıktıda düzeltilmesi gerekir.

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 bayt

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

1 indeksli BEEF matrisinin tüm pozisyonlarını döndürür. Girdi, ikili rakamlardan oluşan bir matris olmalıdır. Yine de çıkıştaki x ve y değiştirilir.

Kayma , 28 bayt

27 bayt kod, pseçenek için +1 .

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

Boşluksuz 1'lerin ve 0'ların çok satırlı bir dikdörtgeni olarak giriş gerektirir. Burada deneyin (giriş olarak üçüncü test çantasıyla).

açıklama

Kayma, 2 Boyutlu Desen Eşleştirme mücadelesinden bir dildir . Sp3000, benden çok daha fazla şey söyleyebilirdi, ancak temelde, iki boyutta eşleştirmenize izin veren bazı yön komutlarıyla genişletilmiş bir regex biçimi. Yukarıdaki kod \, eşleme işaretçisinin yönünü değiştirmeyen ancak bir karakter yana doğru hareket ettiren "slip" komutunu kullanır . Ayrıca (?|...), bir şeyle eşleşen ve ardından işaretçiyi önceki konumuna sıfırlayan "sabit grup" kullanır .

Kod aşağıdaki gibi bozuluyor:

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

Bu 0xBEEFkare ile eşleşir . pSeçenek maç koordinatlarını çıktı olarak 0 endeksli.

PHP, 87 Bayt

ayırıcı olmadan giriş olarak ikili dize, sıfır dizinli değerleri döndürür.

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

128 Bayt girişi olarak sayı dizisi

<?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 tarafından kaydedilen 14 Bayt Thank You

Java 7,182 177 bayt

Karl Napf taşıdık C cevabını JAVA Ve Teşekkür Karl Napf bana Bit sihirli hatırlatarak 5 bayt kaydetmek için. (Btw ben de bu fikir geldi ama seninki benim değil kısım fikir iade @KarlNapf) sana hoşuna gitmedi eğer .Sorry.

(0 bazlı)

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

}

Retina, 47 bayt

Bunun için özür dilemek istiyorum. Bunun muhtemelen korkunç ve dilin nasıl kullanılacağına dair kötü bir örnek olduğunu düşünüyorum, ancak Perl cevabım için Regex kullandığımdan Retina'yı deneyeceğimi düşündüm. Çok iyi değilim. :( Github'daki snippet'ler bana çok yardımcı oldu!

@ Sayesinde wullzx -3 bayt için ve @ benim Perl cevap üzerine yorum için Taemyr benim yöntemi ile bir sorunu işaret için!

Girdiyi boşlukla ayrılmış bir ikili dize olarak bekler ve çıkarılan alanı koordine eder.

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

Çevrimiçi deneyin!

Tüm testleri bir kerede doğrulayın.

Scala, 90 bayt

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

Açıklama:

(
  "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)bir (a -> c)fonksiyonla sonuçlanır , bu kompozisyonun tersi gibidir, ancak skalada daha az tip açıklama gerektirir. Bu durumda, ikili basamakların bir girişini girdi olarak alır ve sıfır tabanlı endekslerin bir demetini döndürür.

J, 31 29 bayt

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

Giriş, 2d'lik ikili değer dizisi olarak biçimlendirilir ve çıktı, dizi olarak sıfır temelli koordinatlardır [y, x].

Dizini bulmak için yapılan yassılaştırma ve temel dönüşüm, bu yorumdan Dennis tarafından öğrendiğim bir şey .

kullanım

   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

açıklama

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

lambda x:'%x'%(`[''.join('%x'%int(s[i:i+4],2)for s in x)for i in range(9)]`.find('beef')+15)

Giriş, dizelerin bir listesidir, çıktı ise XY dizesidir (1 tabanlı dizinler).

İdeone üzerinde test et .

Perl, 54 bayt

İçin 53 bayt kodu + 1 -n. -EEk ücret ödemeden kullanır .

0 tabanlı endeksler kullanır. Girdiyi 1s ve 0s dizisi olarak bekler ve boşlukla ayrılmış koordinatlar çıkarır.

9 bayt'ı kurtarmama yardım ettiği için @ wullxz ve @ GabrielBenamy'e ve @ Taemyr'in Retina cevabımdaki bir konuyu işaret ettiği konusundaki yorumuna teşekkürler !

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

kullanım

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 Bayt

Bu çözüm daha da geliştirilebilirdi ... ama onu okunaklı tuttum ve girişin çok satırlı aralıklı matris olmasına izin verdim.

İkili Dize Dizilimi Gerçek Çözüm

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

Örnek çalışma

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 bayt (Linux'a göre (teşekkürler 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

Tam olarak rekabetçi bir bytecount değil, algoritma biraz ilginç. Girdiyi bir ikili değer dizisi olarak alır.

Ruby , 62 bayt

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

Bu bir dizi bekler 0ve 1ve Y ve X, bir dizi döner sıfır tabanlı.

İdeone de dene .

F # - 260 bayt

Gerekli EntryPoint belirteçleri de dahil olmak üzere tam program.

Giriş: her satır ayrı dize olarak: "111001111110" "110100100000" "010001111101" "100100100100" "100101100111" "111111000010" "110111000001" "100111100111" "100111011111" "111110011111" "10000101111" "111110011111"

Kod:

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

Büyük olasılıkla en zarif çözüm değil, ancak dizelerle devam etmek istedim, bu yüzden böyle yaptım. Neredeyse tek bir hatta daha küçük borular kullanmaya başlamıştım, ama eğer çözemediğim beni engelleyen double if ile ilgili bir şey var. Yani oh iyi!

Ben de Karl'ın cevabını F # 'ya vermeyi iyi bir cevap olarak vermeyi düşündüm, ve yine de eğlence için bunu başka bir yaklaşım olarak yapabilirim, ama bununla farklı olmak için buna bağlı kalmak istedim.

Dyalog APL, 29 27 bayt

Kullanıcı girişi olarak 12x12 ikili diziyi alır ve koordinatları ters sırada döndürür, dizinler 1'den başlar.

Çok sayıda baytı kurtardığınız için @ Adám'a teşekkür ederiz. -2 Bayt çünkü aptalım ve hiçbir şeyi sebepsiz yere bir fonksiyonda bıraktım.

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

Öğe , 130 bayt

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

Çevrimiçi deneyin!

Girdiyi, sınırlayıcı olmadan uzun bir 1s ve 0s dizisi olarak alır. Gibi çıkışlar 3 4(0 tabanlı indeksleme).

Bu, giriş verilerini bir "dizi" (temelde tamsayı tuşlarına sahip bir sözlük) içine yerleştirerek çalışır ve ardından olası her başlangıç ​​değeri için, bitleri belirli ofsetlerde test eder (16'sı çok zahmetli bir süreçte).