Prenez une matrice A composée d'entiers positifs et un seul entier positif N en entrée, et déterminez s'il y a au moins N occurrences consécutives du même nombre dans une ligne ou une colonne de la matrice.

Vous avez seulement besoin de tester horizontalement et verticalement.

Cas de test

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

Les explications sont toujours une bonne chose :)

Coque , 9 octets

≤▲mLṁgS+T

Prend un tableau 2D et un nombre, renvoie 0pour les instances fausses et un nombre positif pour les instances véridiques. Essayez-le en ligne!

Explication

Husk est un langage fonctionnel, donc le programme n'est qu'une composition de plusieurs fonctions.

≤▲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 octets

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

Essayez-le en ligne!

Merci à @MartinEnder et @Zgarb pour -2 octets chacun (la composition élimine le besoin d'utiliser w parens inutiles)

Alertez-moi s'il y a des problèmes et / ou des octets au golf. L'argument de gauche est N , l'argument de droite est A .

Explication:

{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 octets

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

Essayez-le en ligne!

• @^mest la matrice d'entrée (premier argument) et $^nle nombre d'occurrences consécutives à vérifier (deuxième argument).
• [Z,] @^m est la transposition de la matrice d'entrée.
• (@^m | [Z,] @^m)est une jonction en or de la matrice d'entrée et de sa transposition. Ce qui suit mapévalue à une valeur véridique si $^ndes valeurs égales consécutives se produisent dans n'importe quelle ligne de l'invocant. Appliqué à la matrice d'entrée OU à sa transposition, il évalue à une valeur vraie si la matrice d'entrée ou sa transposition contiennent $^ndes valeurs égales consécutives dans n'importe quelle ligne; si la transposition remplit cette condition, cela signifie que la matrice d'entrée a $^ndes valeurs égales consécutives dans l'une de ses colonnes.
• *.rotor($^n => $^n - 1)transforme chaque ligne en une séquence de $^ntranches d'éléments. Par exemple, si $^nest 3 et qu'une ligne l'est <1 2 2 2 3>, cela correspond à (<1 2 2>, <2 2 2>, <2 2 3>).
• .map({ [==] $_ })transforme chaque tranche en un booléen qui indique si tous les éléments de la tranche sont égaux. Poursuivant l'exemple précédent, cela devient (False, True, False).
• .any transforme cette séquence de booléens en une jonction ou qui est vraie si l'un des booléens est vrai.

La sortie est une valeur véridique ou de jonction qui est vraie si la matrice d'entrée OU sa transposition ont TOUTE ligne où $^nles valeurs consécutives sont égales.

MATL , 12 octets

t!YdY'wg)>~a

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

Une matrice non carrée ne peut pas être correctement concaténée à sa transposition, ni verticalement ni horizontalement. Le code les concatène donc en diagonale , en créant une matrice bloc-diagonale.

La matrice résultante est linéarisée dans l'ordre des colonnes majeures et codée sur la durée. Les zéros résultant de la concaténation bloc-diagonale servent à isoler les séries de valeurs réelles.

Les résultats du codage de longueur d'exécution sont un tableau de valeurs et un tableau de longueurs d'exécution. Les longueurs d'exécution correspondant aux valeurs non nulles sont conservées. La sortie est 1si certaines de ces longueurs sont supérieures ou égales au nombre d'entrée, et 0sinon.

Voyons les résultats intermédiaires pour le rendre plus clair. Tenez compte des entrées

[10 10 10;
 20 20 30]

et

3

La matrice diagonale de bloc contenant la matrice d'entrée et sa transposition (code t!Yd ) est:

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

Cette matrice est implicitement linéarisée dans l'ordre des colonnes principales (vers le bas, puis à travers):

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

Encodage de longueur (code Y' ) donne les deux vecteurs suivants (représentés ici comme des vecteurs de ligne; en fait, ce sont des vecteurs de colonne): vecteur avec des valeurs

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

et vecteur avec des longueurs de course

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

Ne conserver que les longueurs correspondant à des valeurs non nulles (code wg)) donne

1 1 1 1 1 1 3 2 1

La comparaison pour voir quelles longueurs sont supérieures ou égales au nombre d'entrée (code >~) produit le vecteur

0 0 0 0 0 0 1 0 0

Enfin, la sortie doit être true(indiquée comme 1) si le vecteur ci-dessus contient au moins une trueentrée (code a). Dans ce cas, le résultat est

1

Octave, 77 70 octets

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

Essayez-le en ligne!

Explication: Étant donné que la matrice ne contient que des entiers non nuls, nous pouvons ajouter une bordure de 0 autour de la matrice et calculer le codage de la longueur d'exécution de la matrice (remodelé en un vecteur)

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

Gelée , 9 8 octets

;ZjṡƓE€S

Prend la matrice comme arguments et lit l'entier de STDIN.

Essayez-le en ligne!

Comment ça fonctionne

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

Exemple d'exécution

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

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

Essayez-le en ligne!

Au lieu de compter, une liste avec la taille n(pour chaque élément de la matrice) est générée et vérifiée si elle se trouve sur la matrice

Sans chaînes, 94 octets

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,()))

Essayez-le en ligne!

Octave , 59 octets

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

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Cela utilise la même approche que ma réponse MATL (voir l'explication ici).

Japt , 18 15 14 octets

cUy)d_ò¦ d_ʨV

Essaye-le

• 3 octets enregistrés avec l'aide de ETHproductions.

Explication

    :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 octets

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

Essayez-le en ligne!

Explication

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 125 120 104 101 octets

Un grand merci à @Zachary T, @Stewie Griffin, @Mr. Xcoder, @Rod, @totallyhuman pour avoir beaucoup amélioré cela.

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

Essayez-le en ligne!

05AB1E , 16 14 12 octets

Døìvyγ€gM²‹_

Essayez-le en ligne!

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

Gelée , 18 octets

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

Essayez-le en ligne!

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

Renvoie 0pour faux et un entier non nul pour véridique.

Ew, c'est mauvais. Et très longtemps. Des conseils de golf seraient appréciés :)

JavaScript (ES6), 99 octets

Prend la matrice met le nombre d'occurrences attendu ndans la syntaxe de curry (m)(n). Renvoie un booléen.

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

Comment?

Ce code n'est pas particulièrement court, mais je voulais essayer une approche purement basée sur des expressions régulières.

Conversion de la matrice en chaîne

Nous utilisons m.join('|') pour transformer le tableau 2D en une chaîne. Cela provoque d'abord une contrainte implicite des lignes de la matrice sur des chaînes séparées par des virgules.

Par exemple, cette entrée:

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

sera transformé en:

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

Correspondance de lignes

Nous recherchons des occurrences consécutives d'affilée avec:

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

Cela correspond:

• \b une limite de mot
• \d+ suivi d'un nombre
• (){n-1}suivi n-1 fois par:
  • , une virgule
  • \1 suivi de notre référence: une limite de mot + le premier nombre
• \b suivi d'une limite de mot

Correspondance de colonnes

Nous recherchons des occurrences consécutives dans une colonne avec:

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

où Lest la longueur d'une ligne.

Cela correspond:

• \b une limite de mot
• \d+ suivi d'un nombre
• (){n-1}suivi n-1 fois par:
  • (){L-1} L-1 fois:
    • . n'importe quel caractère (en effet: une virgule ou une pipe)
    • \d+? suivi d'un numéro (celui-ci doit être non gourmand)
  • . suivi par n'importe quel caractère (encore une fois: une virgule ou une pipe)
  • \1 suivi de notre référence: une limite de mot + le premier nombre
• \b suivi d'une limite de mot

Cas de test

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 octets

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

Essayez-le en ligne!

Clojure, 77 octets

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

Crée toutes les partitions consécutives pde longueur N(symbole %2) et compte le nombre de valeurs distinctes qu'il possède. Ensuite, il forme l'ensemble de ces longueurs et retourne 1s'il est trouvé à partir de l'ensemble et nilautrement. forla construction était parfaitement adaptée à cela, ma tentative originale utilisée flatten, concatou quelque chose de ce court.