Де 0xBEEF?


92

Цей виклик був натхнен рекламним роликом Венді з 1984 року.

Де яловичина?

Ілюстрація Т.С. Роджерса

Ваше завдання - знайти шістнадцятковий 0xBEEF на двійковій булочці.

"Яловичина" складається з наступного шаблону:

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

А «булочка» складається з двійкової матриці 12х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

Вхідні дані

Ваша програма або функція буде приймати двійкову матрицю як вхід. Формат матриці дуже гнучкий, але він повинен бути чітко описаний у вашій відповіді.

Наприклад:

  • один двійковий рядок, з роздільниками між рядками або без них:

    "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 ]

Чи дозволено використання індексів на основі 1 (де вгорі ліворуч (1,1))?
Дверна ручка

@Doorknob Так, якщо це однаковий формат для X і Y (питання оновлено відповідно).
Арнольд

35
Бонусні бали, якщо ми також виведемо, якщо 0xBEEF буде 0xDEAD? : P
TuxCrafting

10
Цей виклик справді випадковий і дещо дурний. Але насправді це все ще досить великий виклик. +1
DJMcMayhem

Можу чи я вихід y, x(тобто в зворотному порядку)?
Луїс Мендо

Відповіді:


30

Желе , 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].

14
Я не розумію ... як ви можете кодувати щось, що не читається людиною ??
L3n

12
Желе набагато простіше писати, ніж читати. : P
Денніс

45
@ l3n ти, мабуть, натякаєш, що Денніс - людина. Незважаючи на те, що це є можливим, враховуючи види хитрощів, які зазвичай виконуються, я не знижуватимуть інші ... скажімо, інші альтернативи кіберпанку ;-)
Франческо

1
Ви можете вивести (x, y) за допомогоюṡ4Z€Ḅw€“Ье‘ĖUṀ
Джонатан Аллан

2
@JonathanAllan Nice. Існує також ṡ€4ḄZjw“¿ÇÇБ’d24індексація на основі 0, але це, на жаль, на один байт довше.
Денніс

40

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

Дякую Йоргу Гюльсерману за те, що він опосередковано заощадив 46 байт, змусивши мене зрозуміти, що мій регекс був дуже німим, а DJMcMayhem - ще 3 байти.


1
Пара порад: 1) Ypкраще, ніж yyp(хоча я знаю, що ви заперечуєте проти Y: P) 2) пробіл у ньому exec 'norm Go'не потрібен. І 3) kd{коротше, ніж kdgg. (Не перевіряли, хоча)
DJMcMayhem

1
@DJMcMayhem О, я завжди забуваю про це, Yтому що у мене він відскочив у моєму vimrc. : P Насправді, значення kdggбуло еквівалентно справедливому d{, що, на диво, не видаляє поточний рядок.
Дверна ручка

О цікаво. Як зручно!
DJMcMayhem

Я завжди плутаюся, коли такі речі, як, наприклад, {виявляються рухом персонажа; тож я {d''замість цього видаляю цілі рядки.
Ніл

1
Ви можете використовувати ехо замість друку в буфері, я не думаю, що щось не заважає цьому у виклику. Це б погіршилося близько 10 байт.
Крістіан Рондо

22

JavaScript (ES6), 63 60 56 байт

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

Приймає вхід у вигляді рядка з обмеженим пробілом символом 155 символів з 12-значних двійкових рядків, повертає нульові значення. Редагувати: Збережено 3 байти завдяки @ JörgHülsermann. Збережено 4 байти завдяки @ETHproductions.


Чи можете ви s.search(r)замість цього використати r.exec(s).index?
ETHproductions

1
@ETHproductions Звичайно, я міг. Я, мабуть, вчора був напівзаспаний ...
Ніл

Для мене, використовуючи nodejs виконати, він не працює , якщо я не змінити , s=>[щоб (s,i)=>[, тому що вам потрібно визначити , я де - то: /
Mijago

@ Mijago Незнайко, він працював у вузлі 4, коли я його спробував (я зазвичай використовую оболонку Spidermonkey JS). Пам’ятайте, що помилка друку прокралася до коду, тому з нього вийшло щось хороше!
Ніл

Я думаю, що це не вдалося 00001011001011001110001110001110001110001111001111000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
Taemyr

14

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

Безголовки:

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

Повертає х, у (на основі 0) у високому та нижньому кулі байта.

Використання:

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

1
ви можете змінити свій параметр "визначення" #define T(i,n)if((A[y+i]&15)==n)та "if", T(0,11)T(1,14)T(2,14)T(3,15)returnщоб зберегти 6 байт. Також змініть підпис функції int b(int*A)на 4 збережені байти.
Lince Assassino


9

MATL , 22 21 байт

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

Вхід - це двійкова матриця з ;роздільником рядків. Вихід 1-основі в зворотному порядку: Y X.

Спробуйте в Інтернеті! Або перевірити всі тестові випадки з десятковою формою введення.

Пояснення

Шаблон виявляється за допомогою 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

8

Математика, 62 байти

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

Повертає всі положення матриці BEEF, 1-індексовану. Вхід повинен бути матрицею двійкових цифр. Хоча x і y на виході перемикаються.


Не хвилюйся xі yперемикаючись.
Арнольд

7

Ковзання , 28 байт

27 байт коду, +1 за pопцією.

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

Потрібен введення у вигляді багаторядкового прямокутника 1 і 0 без пробілів. Спробуйте тут (з третьою тестовою скринькою як вхід).

Пояснення

Ковзання - це мова із виклику 2-D узгодження шаблону . Sp3000 міг би сказати про це набагато більше, ніж я можу, але в основному це розширена форма регулярного вираження з деякими командами спрямованості, які дозволяють вам відповідати в двох вимірах. У наведеному вище коді використовується однойменна команда "ковзання" \, яка не змінює напрямок вказівника відповідності, але переміщує його набік одним символом. Він також використовує "стаціонарну групу" (?|...), яка щось відповідає, а потім скидає вказівник на попереднє місце розташування.

Код розбивається так:

(?|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-індексовані.


1
Приємно :) Дивно, що для моделей блоків іноді гольфіст просто ходити по спіралі:1011>001>1(11>){3}1>1
Sp3000

@ Sp3000 Га! Спіраль була найкоротшим методом у SnakeEx, але я не думав пробувати це у Slip. Дійсно приємний трюк з 1(11>){3}.
DLosc

7

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 Дякую


Використовуйте ,замість .в echoі ви можете видалити дужки. (-4)
Тіт

У коментарях Арнальд дозволяє виводити без роздільника. (-4)
Тіт

Використовуйте прапор PREG_OFFSET_CAPTURE: додайте ,256до preg_matchпараметрів, видаліть ^(.*)з регулярного виразу, $c[0][1]замість strlen($c[1])(-6)
Titus

@Titus приємно і готово
Йорг Гюльсерманн

5

Java 7,182 177 байт

Я переніс відповідь Karl Napf C на JAVA. І завдяки Карлу Napf за збереження 5 байт, нагадуючи мені Біт магія. (Btw, я придумав і цю ідею, але ідея повернення частини @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;
    }

}

2
Які там чотири проміжки між a[y++]>>=1)і if((a[y]&15)==. До речі, я рахую 182 байти замість 183? : S
Кевін Круїссен

@KevinCruijssen виправлено.
Numberknot

1
Все гаразд ;-)
Карл Напф

1
Ви все одно можете видалити пробіл між ...a[y++]/=2)і if((a[y]&15)==....
Kevin Cruijssen

5

Сітківка, 47 байт

Я б хотів передмовити це з вибаченням. Я думаю, що це, мабуть, страшний і поганий приклад того, як користуватися мовою, але оскільки я використовував Regex для своєї відповіді на Perl, я подумав, що спробую Retina. Я не дуже хороший. :( Фрагменти на Github мені дуже допомогли!

Дякую @ wullzx за коментар до моєї відповіді Perl на -3 байти та @ Taemyr за вказівку на проблему з моїм методом!

Очікує введення у вигляді двійкового рядка, розділеного пробілом, і виводить координати пробілу.

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

Спробуйте в Інтернеті!

Перевірте відразу всі тести.


1
Помилки для '00001011001011001110001110001110001110001111001111000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000' 'Ваш (.) * Повинен бути (.) {0,8}
Taemyr

Це протидіє 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.? Якщо це необхідно, це може бути вирішено за допомогою невідомих модифікаторів (.{12})*?(.)*?.
Дом Гастінгс

1
Подивіться ще раз, у цьому вкладі є лише одна яловичина - і це не в тому місці, де ваша програма вказує. Проблему не вирішити, використовуючи нетерплячі модифікатори, оскільки я можу переключити підроблену яловичину з реальною яловичиною. проблема полягає в тому, що ваш регулярний вираз відповідає «яловичині», яка починається менше ніж 4 біти з кінця рядка матриці.
Taemyr

Ви також можете вирішити це, змінивши {8} на {9} і попросивши, щоб рядки на вході були відокремлені пробілом, для виправлення нульових байтів.
Taemyr

@Taemyr Ahhh! Я бачу! Я неправильно зрозумів вашу думку ... Ви дійсно правильні. Моє рішення Perl також потенційно може прийти до цього. Буде змінено якнайшвидше. Дякуємо за ваші коментарі та пропозиції!
Дом Гастінгс

4

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)функції, вона нагадує зворотній склад композиції, але вимагає меншої кількості анотацій типу в масштабі. У цьому випадку він бере рядок двійкових цифр як вхідний і повертає кордону нульових індексів.


4

J, 31 29 байт

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

Вхід форматується у вигляді 2d масиву двійкових значень, а вихід - нульових координат у вигляді масиву [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]

4

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 .


Чи може це помилково знайти «яловичину» через межу, де є два рядки?
xnor

Так, я так думаю. Я відкатую редагування назад, поки не зможу перевірити його належним чином.
Денніс

2
Ось що відбувається, коли ви використовуєте тороїдальну булочку.
mbomb007

4

Perl, 54 байти

53 байти код + 1 для -n. Використовується -Eбез зайвих витрат.

Використовує індекси на основі 0. Очікує введення у вигляді рядків 1s і 0s та виводить координати, розділені пробілом.

Дякую @ wullxz та @ GabrielBenamy за те, що вони допомогли мені зберегти 9 байтів, а також коментар @ Taemyr до моєї відповіді Retina за вказівку на проблему!

/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

1
Ви можете зберегти 3 символи, поєднавши регулярний вираз для двійкового EE: (.{8}1110){2}замість.{8}1110.{8}1110
wullxz

1
Ви також можете зберегти ще 3 байти, змінивши length$`в$-[0]
Габріель Бенамі

@wullxz Звичайно! Я намагався, \1але не пощастило, не думав спробувати {2}! Дякую!
Дом Гастінгс

@GabrielBenamy Дивовижно, дуже дякую! Оновлено!
Дом Гастінгс

2
@ User112638726 " $-[0]- це зсув початку останнього успішного матчу. $-[n]Це зсув початку початку підрядки, узгодженого з n-м субпаттером, або undefякщо субпатерн не збігався." від: perldoc.perl.org/perlvar.html (шукайте @-)
Дом Гастінгс

1

Скала, 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

1

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

Не зовсім конкурентоспроможний рахунок, але алгоритм трохи цікавий. Приймає введення як рядок двійкових значень.


Якщо ви пред'являєте позов на пробіли замість 4 і перевіряєте це в Linux, це 137
ElPedro

1
Я думаю, що вам потрібен новий рядок і пробіл перед імпортом (я отримую IndentError в Python 2 без нього), який коштує 2 байти, але ви можете потім поставити i = ..., x = ... і y = ... на той самий рядок, що і відокремлений; втратити 1 байт за 136
ElPedro

@elpedro Я використовую Python 3, і це добре, коли імпорт знаходиться в одному рядку.
пеналоса

Повністю зрозумів :)
ElPedro

Боже, просто перечитай мої коментарі, і я роблю стільки друкарських помилок сьогодні. Добре, що я не намагаюся писати жодного коду ...
ElPedro


1

F # - 260 байт

Повна програма, включаючи необхідний позначок EntryPoint (тому я думаю, що менше, якщо ви хочете).

Введення: кожен рядок як окремий рядок: "111001111110" "110100100000" "010001111101" „100100100100" „100101100111" „111111000010" „110111000001" „100111100001" „100111011111" „111110011111" „100001010111" „11001110111" „11001110111" „

Код:

[<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 #, оскільки це хороший варіант, і, можливо, все ще робити це для розваги як інший підхід, але хотів дотримуватися цього, щоб бути іншим.


1

Діялог APL, 29 27 байт

Займає бінарний масив 12x12 як введення користувача та повертає координати у зворотному порядку, індекси починаються з 1.

Завдяки @ Adám за збереження багатьох байтів. -2 байти, тому що я німий і без всякої причини залишив усе у функції.

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

Збережіть 2, замінивши ~2 8 12∊⍨4 4⍴⍳16на 15 7 15 9⊤⍨4/2. Зауважте, що 0~⍨∊{⍵×⍳⍴⍵}його можна замінити на версію 16.0 (ваш код працює лише у програмі Dyalog APL).
Адама

Так, у Dyalog є символи, які відрізняються від GNU. Або це щось інше?
Zacharý

Ну, додається з v16, я не зміг знайти список примітивів GNUAPL.
Адам

У мене працює GNU APL, в основному це лише різниці в кодових точках.
Zacharý

З того, що я помітив.
Zacharý

0

Елемент , 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/`]']

Спробуйте в Інтернеті!

Вводиться як один довгий рядок 1s і 0s без обмежувачів. Виходи типу 3 4(індексація на основі 0).

Це працює, розміщуючи вхідні дані в "масив" (в основному словник з цілими клавішами), а потім для кожного можливого початкового значення тестує біти при конкретних зміщеннях (усі 16 з них в дуже трудомісткому процесі).

Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.