以包含正整数和单个正整数N的矩阵A作为输入，并确定矩阵中的任何行或列中是否至少有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∊∊⍷∘⍵¨(⊢,⍪¨)⍺/¨⍳⌈/∊⍵}

在线尝试！

感谢@MartinEnder和@Zgarb分别提供了-2个字节（组成消除了使用w和毫无意义的括号）

如果有任何问题和/或需要打高尔夫球，请提醒我。左说法是ň，正确的说法是一个。

说明：

{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

Perl 6，60个字节

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

在线尝试！

• @^m是输入矩阵（第一个参数），$^n是要检查的连续出现的次数（第二个参数）。
• [Z,] @^m 是输入矩阵的转置。
• (@^m | [Z,] @^m)是输入矩阵及其转置的一个或多个结。map如果在倡导者的$^n任何行中出现连续的相等值，则以下结果为真实值。如果输入矩阵或其转置$^n在任何行中包含连续相等的值，则将其应用于输入矩阵或其转置，得出真值；如果转置满足该条件，则表示输入矩阵$^n在其列之一中具有连续的相等值。
• *.rotor($^n => $^n - 1)将每一行变成一系列$^n-element切片。例如，如果$^n是3，行是<1 2 2 2 3>，这个计算结果为(<1 2 2>, <2 2 2>, <2 2 3>)。
• .map({ [==] $_ })将每个切片变成一个布尔值，指示该切片的所有元素是否相等。继续前面的示例，它变为(False, True, False)。
• .any 将布尔值序列转换为or节点，如果任何布尔值为true，则为true。

输出是真实值或连接点值，如果输入矩阵或其转置具有$^n连续值相等的ANY行，则该值为true 。

MATL，12字节

t!YdY'wg)>~a

在线尝试！或验证所有测试用例。

说明

非正方形矩阵不能正确地与其垂直或水平的转置连接。因此，代码通过创建块对角矩阵将它们对角地连接起来。

所得矩阵以列优先顺序线性化，并进行游程编码。块对角串联产生的零用来隔离实际值的游程。

游程长度编码的结果是一个值数组和一个游程长度数组。保留与非零值对应的游程长度。输出是1，如果一些那些长度大于或等于输入号码，和0其它。

让我们看一下中间结果以使其更清楚。考虑输入

[10 10 10;
 20 20 30]

和

3

包含输入矩阵及其转置（代码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

游程编码（代码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

仅将对应的长度保持为非零值（代码wg)）即可

1 1 1 1 1 1 3 2 1

比较看看哪些长度大于或等于输入数字（代码>~）会产生矢量

0 0 0 0 0 0 1 0 0

最后，如果上述向量至少包含一个条目（代码），则输出应为true（显示为）。在这种情况下，结果是1truea

1

八度，77 70字节

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

在线尝试！

说明：由于tha矩阵仅包含非零整数，因此我们可以在矩阵周围添加0s边界并计算矩阵的游程长度编码（重整为矢量）

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

Python 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答案相同的方法（请参阅此处的说明）。

Japt，18 15 14字节

cUy)d_ò¦ d_ʨV

测试一下

• 在ETHproductions的帮助下节省了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.

Python 3中，129个 128 125 120 104 101字节

非常感谢@Zachary T，@ Stewie Griffin，@先生。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?

退货 0 false， true的非零整数。

哇，这很糟糕。而且很长。高尔夫技巧将不胜感激:)

JavaScript（ES6），99个字节

以currying语法获取矩阵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('|')用来将二维数组转换成字符串。这首先导致矩阵行的隐式强制转换为逗号分隔的字符串。

例如，此输入：

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

Python 2，64个字节

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

在线尝试！

Clojure，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或短的东西。