이 도전은 1984 년 이 Wendy의 광고 에서 영감을 얻었습니다 .

_{TS Rogers의 일러스트레이션}

당신의 작업은 이진 롤빵에서 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", ...]

• 숫자 배열 (각 숫자는 한 번 이진으로 다시 변환되고 왼쪽으로 0으로 채워짐) :

  [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 기반 좌표를 사용하는 경우에도 언급하십시오.

규칙

• 롤빵에 항상 정확히 하나의 '쇠고기'가 있다고 가정 할 수 있습니다. 귀하의 코드는 쇠고기가 두 개 이상이거나 쇠고기가없는 경우를 지원할 필요는 없습니다.
• 쇠고기 패턴은 항상 설명대로 나타납니다. 어떤 식 으로든 회전하거나 미러링하지 않습니다.
• 이것은 코드 골프이므로 바이트 단위의 최단 답변이 이깁니다. 표준 허점은 금지되어 있습니다.

테스트 사례

다음 테스트 사례에서 행렬의 각 행은 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].

정력, 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 개 바이트.

자바 스크립트 (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하여 4 바이트 저장 /=2시키는 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

수학, 62 바이트

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

BEEF 매트릭스의 모든 위치를 1- 인덱스로 반환합니다. 입력은 이진수의 행렬이어야합니다. 그러나 출력의 x와 y는 전환됩니다.

슬립 , 28 바이트

27 바이트의 코드, p옵션의 경우 +1

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

공백없이 1과 0의 여러 줄 직사각형으로 입력해야합니다. 여기 에서 입력 하십시오 (세 번째 테스트 케이스를 입력으로 사용).

설명

슬립은 2D 패턴 일치 챌린지 의 언어입니다 . Sp3000은 내가 할 수있는 것보다 훨씬 더 많은 것을 말할 수 있지만 기본적으로 2 차원으로 일치시킬 수있는 방향 명령이있는 확장 된 형태의 정규식입니다. 위의 코드는 시선 "slip"명령을 사용합니다.이 명령 \은 일치 포인터의 방향을 변경하지 않지만 한 문자 씩 옆으로 이동합니다. 또한 "stationary group"을 사용하여 (?|...)무언가를 일치시킨 다음 포인터를 이전 위치로 재설정합니다.

코드는 다음과 같이 분류됩니다.

(?|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는 감사

자바 7,182 177 바이트

나는 Karl Napf C 답변을 JAVA 로 포팅 했으며 5 비트를 절약 해 준 Karl Napf 에게 Bit magic을 상기시켜주었습니다.

(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 의 스 니펫 은 나를 크게 도와주었습니다!

-3 바이트에 대한 내 Perl 답변에 대한 의견에 @ wullzx 와 내 방법의 문제를 지적 한 @ 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)함수의 결과 는 작성의 역순과 같지만 스칼라에서 더 적은 유형 주석이 필요합니다. 이 경우 이진수의 문자열을 입력으로 받아 0부터 시작하는 인덱스의 튜플을 반환합니다.

J, 31 29 바이트

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

입력은 이진 값으로 구성된 2 차원 배열로 형식화되며 출력은 배열로 0부터 시작하는 좌표 [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]

파이썬 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에서 테스트하십시오 .

펄, 54 바이트

53 바이트 코드 + 1 -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

스칼라, 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 

그것은 문자열 기대 0와 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

가장 우아한 해결책은 아니지만 문자열로 유지하고 싶었으므로 이것이 내가 한 일입니다. 파이프를 사용하여 거의 한 줄로 작게 만들었지 만 double if 블록으로 해결할 수없는 것이 있습니다. 잘 오!

Karl의 답변을 F #으로 포팅하는 것에 대해 너무 생각했지만 다른 접근법으로 재미있게 사용할 수는 있지만이 방법을달라고하고 싶었습니다.

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의 하나의 긴 문자열로 입력을받습니다. 3 4(0 기반 색인) 과 같은 출력 .

입력 데이터를 "배열"(기본적으로 정수 키가있는 사전)에 배치 한 다음 가능한 각 시작 값에 대해 특정 오프셋 (비트 16 개 모두 매우 힘든 프로세스)에서 비트를 테스트합니다.