양의 정수로 구성된 행렬 A 와 입력으로 하나의 양의 정수 N 을 취하고 행렬의 행 또는 열에 동일한 숫자의 N 개의 연속 발생 이 있는지 확인하십시오 .

수평 및 수직 테스트 만하면됩니다.

테스트 사례

N = 1
A = 
1
Result: True
----------------
N = 3
A = 
1 1 1
2 2 3
Result: True
----------------
N = 4
A = 
1 1 1
2 2 3
Result: False
----------------
N = 3
A = 
3 2 3 4 2 1
4 1 4 2 4 2
4 2 3 3 4 1
1 1 2 2 3 4
3 2 3 1 3 1
1 1 2 2 3 4
Result: True
----------------
N = 1
A = 
5 2 3 8
Result: True
----------------
N = 3
111   23  12    6
111   53   2    5
112  555   5  222
Result: False
----------------
N = 2
 4  2  6  2  1  5
 2  3  3  3  3  3
11 34  4  2  9  7
Result: True

설명은 항상 좋은 것입니다 :)

껍질 , 9 바이트

≤▲mLṁgS+T

2D 배열과 숫자 0를 취하고 허위 인스턴스에 대해서는 반환 하고 실제 인스턴스에 대해서는 양수를 반환합니다. 온라인으로 사용해보십시오!

설명

Husk는 기능적 언어이므로이 프로그램은 여러 기능으로 구성되어 있습니다.

≤▲mLṁgS+T
        T  Transpose the array
      S+   and concatenate with original.
           We get a list of the rows and columns of the input array.
    ṁ      Map and concatenate
     g     grouping of equal consecutive elements.
           This gives all consecutive runs on rows and columns.
  mL       Map length over the runs,
 ▲         take the maximum of the results
≤          and see if it's at least the second input.

Dyalog APL, 27 25 23 바이트

{1∊∊⍷∘⍵¨(⊢,⍪¨)⍺/¨⍳⌈/∊⍵}

온라인으로 사용해보십시오!

각각 -2 바이트에 대한 @MartinEnder 및 @Zgarb 덕분에 (컴포지션은 사용할 필요가 없으며 w무의미한 parens 를 제거합니다 )

골프에 문제 나 바이트가 있으면 알려주세요. 왼쪽 인수는 N 이고 오른쪽 인수는 A 입니다.

설명:

{1∊∊⍷∘⍵¨(⊢,⍪¨)⍺/¨⍳⌈/∊⍵}
                     ⍵    - Right argument
                    ∊     - Flatten the array
                 ⍳⌈/      - 1 ... the maximum (inclusive)
              ⍺/¨         - Repeat each item ⍺ (left argument) times.
        (⊢,⍪¨)            - Argument concatenated with their transposes.
    ⍷∘⍵¨                  - Do the patterns occur in ⍵?
   ∊                      - Flatten (since we have a vector of arrays)
 1∊                       - Is 1 a member?
{                     }   - Function brackets

펄 6 , 60 바이트

{(@^m|[Z,] @^m).map(*.rotor($^n=>$^n-1).map({[==] $_}).any)}

온라인으로 사용해보십시오!

• @^m입력 행렬 (첫 번째 인수)이고 $^n확인할 연속 발생 횟수 (두 번째 인수)입니다.
• [Z,] @^m 입력 행렬의 전치입니다.
• (@^m | [Z,] @^m)입력 행렬과 그 조옮김의 or-junction입니다. 다음 map은 호출자의 $^n행에서 연속적인 동일한 값이 발생하는 경우 진실한 값으로 평가됩니다 . 입력 행렬 또는 그 전치에 적용되며, 입력 행렬 또는 그 전치 중 하나 $^n가 임의의 행에서 연속적인 동일한 값을 포함하는 경우 참 값으로 평가됩니다 . 조옮김이 해당 조건을 충족하면 입력 행렬 $^n의 열 중 하나에 연속 된 동일한 값 이 있음을 의미합니다 .
• *.rotor($^n => $^n - 1)각 행을 일련의- $^n요소 슬라이스 로 바꿉니다 . 예를 들어, $^n가 3이고 행이 <1 2 2 2 3>인 경우로 평가됩니다 (<1 2 2>, <2 2 2>, <2 2 3>).
• .map({ [==] $_ })각 슬라이스를 부울로 변환하여 슬라이스의 모든 요소가 동일한 지 여부를 나타냅니다. 이전 예를 계속하면이됩니다 (False, True, False).
• .any 부울 시퀀스가 ​​부울 중 하나가 참인 경우 진실 인 or- 정션으로 바꿉니다.

입력 행렬 또는 그 전치 중 하나에 $^n연속 값이 동일한 행이 있으면 출력은 참 또는 정션 값입니다 .

MATL , 12 바이트

t!YdY'wg)>~a

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

설명

정사각형이 아닌 행렬은 수직 또는 수평으로 조옮김에 올바르게 연결할 수 없습니다. 따라서 코드 는 블록 대각선 행렬을 만들어 대각선으로 연결합니다 .

결과 행렬은 열 주요 순서로 선형화되고 실행 길이 인코딩됩니다. 블록 대각 연결로 인한 0은 실제 값의 런을 분리하는 역할을합니다.

실행 길이 인코딩의 결과는 값 배열과 실행 길이 배열입니다. 0이 아닌 값에 해당하는 실행 길이가 유지됩니다. 출력은 1해당 길이 중 일부가 입력 수보다 크거나 같은 0경우입니다.

더 명확하게하기 위해 중간 결과를 보자. 입력 고려

[10 10 10;
 20 20 30]

과

3

입력 행렬과 해당 조옮김 (code t!Yd)을 포함하는 블록 대각 행렬 은 다음과 같습니다.

10 10 10  0  0
20 20 30  0  0
 0  0  0 10 20
 0  0  0 10 20
 0  0  0 10 30

이 행렬은 열 주요 순서로 내재적으로 선형화됩니다 (아래로, 가로로).

10 20  0  0  0 10 20  0  0  0 10 30  0  0  0  0  0 10 10 10  0  0 20 20 30

런 렝스 인코딩 (code Y')은 다음 두 벡터를 제공합니다 (여기서는 행 벡터로 표시됨; 실제로는 열 벡터 임).

10 20  0 10 20  0 10 30  0 10  0 20 30

실행 길이가있는 벡터

1 1 3 1 1 3 1 1 5 3 2 2 1

0이 아닌 값 (code wg))에 해당하는 길이 만 유지 하면

1 1 1 1 1 1 3 2 1

입력 길이 (code >~) 보다 크거나 같은 길이를 비교하면 벡터가 생성됩니다.

0 0 0 0 0 0 1 0 0

마지막으로, 위의 벡터에 최소한 항목 (code )이 포함되어 있으면 출력은로 true표시 되어야합니다 . 이 경우 결과는1truea

1

옥타브, 77 70 바이트

@(A,N)any(([x y]=runlength([(p=padarray(A,[1 1]))(:);p'(:)]))(!!y)>=N)

온라인으로 사용해보십시오!

설명 : tha 행렬에는 0이 아닌 정수만 포함되므로 행렬 주위에 0의 경계를 추가하고 행렬의 런 길이 인코딩을 계산할 수 있습니다 (벡터로 모양 변경).

@(A,N)any(([x y]=runlength([(p=padarray(A,[1 1]))(:);p'(:)]))(!!y)>=N)
                             p=padarray(A,[1 1])                        % add a border of 0s around the matrix 
                            (                   )(:)                    % reshape the matrix to a column vector
                                                     p'(:)              % transpose of the matrix reshaped to a column vector
                           [                        ;     ]             % concatenate two vectors vertically
           [x y]=runlength(                                )            % runlength encoding of the vector[x=count,y=value]
          (                                                 )           % take x,counts.
                                                             (!!y)      % extrect those counts that their valuse aren't 0
      any(                                                        >=N)  % if we have at least a count that is greater than or equal to N                                                              

젤리 , 9 8 바이트

;ZjṡƓE€S

행렬을 인수로 사용하고 STDIN에서 정수를 읽습니다.

온라인으로 사용해보십시오!

작동 원리

;ZjṡƓE€S  Main link. Argument: M (matrix / row array)

 Z        Zip/transpose M.
;         Concatenate the row array with the column array.
  j       Join the rows and columns, separating by M.
    Ɠ     Read an integer n from STDIN.
   ṡ      Split the result to the left into overlapping slices of length 2.
     E€   Test the members of each resulting array for equality.
       S  Take the sum.

예제 실행

;ZjṡƓE€S  Argument: [[1, 2], [3, 2]]. STDIN: 2

 Z        [[1, 3], [2, 2]]

;         [[1, 2], [3, 2], [1, 3], [2, 2]]

  j       [1, 2, [1, 2], [3, 2], 3, 2, [1, 2], [3, 2], 1, 3, [1, 2], [3, 2], 2, 2]

    Ɠ     2

   ṡ      [[1, 2],             [2, [1, 2]],        [[1, 2], [3, 2]],   [[3, 2], 3],
           [3, 2],             [2, [1, 2]],        [[1, 2], [3, 2]],   [[3, 2], 1],
           [1, 3],             [3, [1, 2]],        [[1, 2], [3, 2]],   [[3, 2], 2],
           [2, 2]                                                                 ]

     E€   [     0,                       0,                       0,             0,
                0,                       0,                       0,             0,
                0,                       0,                       0,             0,
                1                                                                 ]

       S  1

파이썬 2 , 60 92 91 바이트

def f(n,x):x=[map(str,i)for i in x];print any(`[i]*n`[1:-1]in`x+zip(*x)`for i in sum(x,[]))

온라인으로 사용해보십시오!

계산하는 대신 n(행렬의 각 요소에 대한) 크기의 목록 이 생성되어 행렬에 있는지 확인합니다.

문자열이없는 경우 94 바이트

lambda n,x:any((e,)*n==l[i:i+n]for l in x+zip(*x)for i in range(len(l)-n+1)for e in sum(x,()))

온라인으로 사용해보십시오!

옥타브 , 59 바이트

@(A,N)any({[l,v]=runlength(blkdiag(A,A')(:)),l(v>=0)}{2}>=N)

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

이것은 내 MATL 답변 과 동일한 접근 방식을 사용합니다 (설명 참조).

apt , 18 15 14 바이트

cUy)d_ò¦ d_ʨV

그것을 테스트

• ETHproduction의 도움으로 3 바이트가 절약되었습니다.

설명

    :Implicit input of 2D array U and integer V
c   :Append to U...
Uy  :U transposed.
d   :Check if any of the elements (sub-arrays) in U return true when...
_   :Passed through a function that...
ò   :Partitions the current element by...
¦   :Checking for inequality.
d   :Check if any of the partitions return true when...
_   :Passed through a function that checks if...
Ê   :The length of the current element...
¨V  :Is greater than or equal to V.
    :Implicit output of resulting boolean.

CJam , 16 바이트

q~_z+N*e`:e>0=>!

온라인으로 사용해보십시오!

설명

q~    e# Read and eval input.
_z+   e# Append the matrix's transpose to itself.
N*    e# Join with linefeeds to flatten without causing runs across rows.
e`    e# Run-length encode.
:e>   e# Get maximum run (primarily sorted by length).
0=    e# Get its length.
>!    e# Check that it's not greater than the required maximum.

파이썬 (3) , 129 (128) 125 120 104 101 바이트

@Zachary T, @Stewie Griffin, @Mr에게 감사드립니다. Xcoder, @Rod, @totallyhuman이 기능을 많이 개선했습니다.

def f(n,m):
 a=b=c=0;m+=zip(*m)
 for r in m:
  for i in r:b,a=[1,b+1][a==i],i;c=max(c,b)
 return n<=c

온라인으로 사용해보십시오!

05AB1E , 16 14 12 바이트

Døìvyγ€gM²‹_

온라인으로 사용해보십시오!

Dø           # Duplicate the input and transpose one copy
  ì          # Combine the rows of both matrixes into one array
   vy        #   For each row...
     γ       #     Break into chunks of the same element
      €g     #     get the length of each chunk
        M    #     Get the largest length so far
         ²‹_ #     Check if that is equal to or longer than required

젤리 , 18 바이트

ŒrFUm2<⁴$ÐḟL
ZÇo³Ç

온라인으로 사용해보십시오!

ŒrFUm2<⁴$ÐḟL  Helper Link
Œr            Run-length encode
  F           Flatten the whole thing, giving the numbers in the odd indices and the lengths of the runs in the even indices
   U          Reverse
    m2        Take every other element (thus only keeping the run lengths)
         Ðḟ   Discard the elements that are
      <⁴$                                   less than the required run length
           L  And find the length
ZÇo³Ç         Main Link
Z             Zip the matrix
 Ç            Call the helper link on it
   ³Ç         Call the helper link on the original matrix
  o           Are either of these truthy?

0false를 반환 하고 true를 나타내는 0이 아닌 정수를 반환합니다.

아, 이거 나쁘다. 그리고 매우 길다. 골프 팁 감사합니다 :)

자바 스크립트 (ES6), 99 바이트

카레 구문에서 행렬 m과 예상되는 발생 횟수를 취 n합니다 (m)(n). 부울을 반환합니다.

m=>n=>[',',`(.\\d+?){${m[0].length-1}}.`].some(s=>m.join`|`.match(`(\\b\\d+)(${s}\\1){${n-1}}\\b`))

방법?

이 코드는 특별히 짧지는 않지만 정규 표현식을 기반으로 접근법을 시도하고 싶었습니다.

행렬을 문자열로 변환

m.join('|')2D 배열을 문자열로 변환하는 데 사용 합니다. 이렇게하면 행렬 행이 암시 적으로 강제 변환되어 쉼표로 구분 된 문자열이됩니다.

예를 들어이 입력은 다음과 같습니다.

[
  [ 1, 2, 3 ],
  [ 4, 5, 6 ]
]

다음으로 변환됩니다 :

"1,2,3|4,5,6"

행 매칭

우리는 다음과 함께 연속적으로 발생하는 것을 찾습니다.

/(\b\d+)(,\1){n-1}\b/

일치합니다 :

• \b 단어 경계
• \d+ 뒤에 숫자
• (){n-1}뒤에 n-1 번 :
  • , 쉼표
  • \1 우리의 참조 : 단어 경계 + 첫 번째 숫자
• \b 단어 경계 뒤에

열 일치

다음과 같은 열에서 연속적인 발생을 찾습니다.

/(\b\d+)((.\d+?){L-1}.\1){n-1}\b/

L행의 길이는 어디 입니까?

일치합니다 :

• \b 단어 경계
• \d+ 뒤에 숫자
• (){n-1}뒤에 n-1 번 :
  • (){L-1} L-1 배 :
    • . 모든 문자 (효과 : 쉼표 또는 파이프)
    • \d+? 그 뒤에 숫자가옵니다 (이것은 탐욕스럽지 않아야합니다)
  • . 뒤에 모든 문자 (쉼표 또는 파이프)
  • \1 우리의 참조 : 단어 경계 + 첫 번째 숫자
• \b 단어 경계 뒤에

테스트 사례

let f=

m=>n=>[',',`(.\\d+?){${m[0].length-1}}.`].some(s=>m.join`|`.match(`(\\b\\d+)(${s}\\1){${n-1}}\\b`))

console.log(f([
  [ 1 ]
])(1))

console.log(f([
  [ 1, 1, 1 ],
  [ 2, 2, 3 ]
])(3))

console.log(f([
  [ 1, 1, 1 ],
  [ 2, 2, 3 ]
])(4))

console.log(f([
  [ 3, 2, 3, 4, 2, 1 ],
  [ 4, 1, 4, 2, 4, 2 ],
  [ 4, 2, 3, 3, 4, 1 ],
  [ 1, 1, 2, 2, 3, 4 ],
  [ 3, 2, 3, 1, 3, 1 ],
  [ 1, 1, 2, 2, 3, 4 ]
])(3))

console.log(f([
  [ 5, 2, 3, 8 ]
])(1))

console.log(f([
  [ 111,  23,  12,   6 ],
  [ 111,  53,   2,   5 ],
  [ 112, 555,   5, 222 ]
])(3))

console.log(f([
  [  4,  2,  6,  2,  1,  5 ],
  [  2,  3,  3,  3,  3,  3 ],
  [ 11, 34,  4,  2,  9,  7 ]
])(2))

파이썬 2 , 64 바이트

lambda M,n:(', 0'*n)[5:]in`[map(cmp,l,l[1:])for l in M+zip(*M)]`

온라인으로 사용해보십시오!

클로저, 77 바이트

#((set(for[I[%(apply map vector %)]i I p(partition %2 1 i)](count(set p))))1)

p길이의 연속 된 모든 파티션 N(symbol %2)을 작성하고 고유 한 값 수를 계산합니다. 그런 다음 길이의 집합을 구성하고 집합에서 1발견되면 반환 합니다 nil. for구조는이를위한 완벽한 맞는, 내 원래의 시도가 사용했다 flatten, concat또는 짧은 무언가.