मैट्रिक्स ए को पॉजिटिव पूर्णांकों से युक्त करें, और इनपुट के रूप में एकल पॉजिटिव पूर्णांक एन , और यह निर्धारित करें कि मैट्रिक्स में किसी भी पंक्ति या कॉलम में एक ही नंबर की कम से कम एन लगातार घटनाएं हैं या नहीं।

आपको केवल क्षैतिज और लंबवत परीक्षण करना होगा।

परीक्षण के मामलों

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

स्पष्टीकरण हमेशा एक अच्छी बात है :)

— स्टीवी ग्रिफिन
स्रोत

5

आप मैट्रिक्स से प्यार करने लगते हैं।

— ओकेक्स

4

खैर, मैं एक MATLAB आदमी हूँ ... मैट रिक्स लैब वक्तृत्व =)

— ग्रिफिन

क्या एक सत्य / मिथ्या मूल्य वापस करने के लिए पर्याप्त है?

— डेनिस

@ निश्चित रूप से :)

— स्टीवी ग्रिफिन

5

अनायास, क्योंकि आप एक मतलबी आदमी हैं, आप ऐसी चुनौतियाँ बनाते हैं जो MATLAB में आसान लगती हैं, लेकिन एक हल्का सा मोड़ है जो स्पष्ट समाधान को

— नियंत्रित करता है

7

भूसी , 9 बाइट्स

≤▲mLṁgS+T

एक 2 डी सरणी और एक संख्या लेता है, 0मिथ्या उदाहरणों के लिए और सत्य उदाहरणों के लिए एक सकारात्मक संख्या देता है। इसे ऑनलाइन आज़माएं!

व्याख्या

भूसी एक कार्यात्मक भाषा है, इसलिए कार्यक्रम कई कार्यों की एक रचना है।

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

— Zgarb
स्रोत

5

दिल्लोग एपीएल, 27 25 23 बाइट्स

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

यह ऑनलाइन की कोशिश करो!

-2 बाइट्स के लिए @MartinEnder और @Zgarb के लिए धन्यवाद (रचना का उपयोग करने 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

— जाकारी
स्रोत

4

पर्ल 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-मेंट स्लाइस के अनुक्रम में बदल देता है । उदाहरण के लिए, यदि $^n3 और एक पंक्ति है <1 2 2 2 3>, तो यह मूल्यांकन करता है (<1 2 2>, <2 2 2>, <2 2 3>)।
.map({ [==] $_ })प्रत्येक स्लाइस को एक बूलियन में बदल देता है जो इंगित करता है कि स्लाइस के सभी तत्व समान हैं या नहीं। पिछले उदाहरण को जारी रखते हुए, यह बन जाता है (False, True, False)।
.any बूलियन्स के उस क्रम को एक-जंक्शन में बदल देता है जो सच है अगर कोई भी बूलियन सत्य है।

आउटपुट एक सत्य या जंक्शन वैल्यू है जो कि इनपुट मैट्रिक्स या इसके ट्रांसफ़ॉर्म की किसी भी पंक्ति की सत्य है, जहाँ $^nलगातार मान बराबर हैं।

— शॉन
स्रोत

4

MATL , 12 बाइट्स

t!YdY'wg)>~a

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

एक गैर-वर्ग मैट्रिक्स को उसके स्थानान्तरण के लिए ठीक से समतल नहीं किया जा सकता है, या तो लंबवत या क्षैतिज रूप से। इसलिए कोड ब्लॉक-विकर्ण मैट्रिक्स बनाकर, उन्हें तिरछे रूप से व्यवस्थित करता है।

परिणामी मैट्रिक्स कॉलम-प्रमुख क्रम और रन-लंबाई एन्कोडेड में रैखिक है। ब्लॉक-विकर्ण संघटन से उत्पन्न शून्य वास्तविक मूल्यों के रनों को अलग करने का काम करते हैं।

रन-लंबाई एन्कोडिंग से परिणाम मानों की एक सरणी और रन-लंबाई की एक सरणी है। गैर-शून्य मानों के अनुरूप रन-लंबाई रखी जाती है। आउटपुट 1अगर उन लंबाई में से कुछ इनपुट संख्या से अधिक या बराबर है, और 0अन्यथा।

आइए इसे साफ करने के लिए मध्यवर्ती परिणाम देखें। इनपुट पर विचार करें

[10 10 10;
 20 20 30]

तथा

ब्लॉक विकर्ण मैट्रिक्स जिसमें इनपुट मैट्रिक्स होता है और इसका स्थानान्तरण (कोड 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(जैसा दिखाया गया है 1) यदि उपरोक्त वेक्टर में कम से कम एक trueप्रविष्टि (कोड a) हो। इस मामले में परिणाम है

— लुइस मेंडो
स्रोत

4

ऑक्टेव, 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

— rahnema1
स्रोत

3

मुझे वास्तव में आपके समाधान पसंद हैं (न केवल यह एक), लेकिन वे निश्चित रूप से कुछ स्पष्टीकरणों से लाभ उठा सकते हैं! :) मुझे नहीं पता था कि ऑक्टेव था runlength... रोज कुछ नया सीखें ...

— स्टिव ग्रिफिन

मुझे याद दिलाने के लिए धन्यवाद runlength! मतलाब पर अधिक ध्यान केंद्रित होने के कारण, मुझे याद नहीं था कि

— लुइस मेंडो

@StewieGriffin धन्यवाद, जागने के बाद अद्यतन जवाब!

— rahnema1

@LuisMendo आपके एक पोस्ट के बाद मुझे एक फ़ंक्शन के बारे में पता चला runlength।

— rahnema1

4

जेली , ९ by बाइट्स

;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

— डेनिस
स्रोत

मेरे पास एक ही विचार था ;Z, हालांकि जेली में जेली के बजाय ...

— ETHproductions

अब मैं देखता हूं कि आपने सत्य / झूठे मूल्यों के बारे में क्यों पूछा । जेली में यह परिभाषा MATLAB (या MATL) से प्रेरित थी?

— स्टीवी ग्रिफिन

नहीं, जेली आंतरिक रूप से पायथन की स्थिति का उपयोग करती है। Ȧपरमाणु हालांकि Matl से प्रेरित था।

— डेनिस

ओह, मेरा रास्ता बहुत लंबा था> <सही, Eबिल्टिन इसे करने का तरीका था। नाइस :)

— हाइपरनेत्रिनो

3

पायथन 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,()))

इसे ऑनलाइन आज़माएं!

— छड़ी
स्रोत

मुझे लगता है कि यह मल्टीडिजिट नंबरों के साथ झूठी सकारात्मकता दे सकता है।

— xnor

@xnor वहाँ, तय

— रॉड

3

ऑक्टेव , 59 बाइट्स

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

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

यह मेरे MATL उत्तर (वहाँ स्पष्टीकरण देखें) के समान दृष्टिकोण का उपयोग करता है ।

— लुइस मेंडो
स्रोत

1

blkdiag(A,A')। बहुत अच्छा!

— rahnema1

3

जाप , 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.

— झबरा
स्रोत

1

अरे वाह, मेरा पोस्ट करने से पहले मैंने यह नहीं देखा। आप के साथ 2 बाइट्स बचा सकता है cUy)®ò¦ d_l ¨V\nd, और एक और के साथ cUy)d_ò¦ d_l ¨V, और फिर आप व्यावहारिक रूप से मेरे (हटाए गए) समाधान है।

— 18

हा हा; महान दिमाग ..., @ETHproductions :) मैं हैरान हूं कि मैं आज पूरे दिन ओबारकॉन की पिटाई करने के बाद सबसे तेज उंगली था! उन युक्तियों के लिए धन्यवाद, एक पहले से ही देखा गया था, लेकिन दूसरा अभी तक नहीं।

— शैगी

2

सीजेएम , 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.

— मार्टिन एंडर
स्रोत

मुझे हमेशा आश्चर्य होता है कि सीजेएम के आरएलई रन-लेंथ को क्यों महत्व देते हैं। खैर, यह यहाँ उपयोगी हो जाता है :-)

— लुइस मेंडो

@LuisMendo मुझे लगता है कि इस तरह से आप इसे "3 ए, 5 बी, 2 सी" कहेंगे। मैं वास्तव में इस आदेश को अक्सर उपयोगी पाता हूं।

— मार्टिन एंडर

दरअसल, ऑक्टेव का runlengthकार्य उस क्रम में भी आउटपुट देता है। लेकिन किसी तरह मैं आदेश को value, lengthअधिक स्वाभाविक महसूस करता हूं

— लुइस मेंडो

2

पायथन 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

इसे ऑनलाइन आज़माएं!

— irapsaged
स्रोत

आप के बीच एक रिक्ति की जरूरत नहीं है 1और if।

— ज़ाचरी

की जगह चार बाइट्स सहेजें a=b;b=0;c=0के साथa=b=c=0

— श्री Xcoder

(मुझे यकीन नहीं है) लेकिन मुझे लगता है कि आप m+zip(*m)इसके बजाय m4 वीं पंक्ति पर उपयोग कर सकते हैं , और पूरी तरह से 1 पंक्ति को छोड़ सकते हैं, n<=max()अंतिम पंक्ति तक ले जा सकते हैंn<=c

— रॉड

120 बाइट्स

— बिलकुल अमानवीय

b=b+1उपयोग के बजाय b+=1... आह, निन्जा ने @StewieGriffin

— Mr. Xcoder

2

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

— रिले
स्रोत

1

@MagicOctopusUrn मुझे यकीन नहीं है कि आपका क्या मतलब है। उस उदाहरण में 0दूसरी पंक्ति में लगातार 3 एस हैं, इसलिए यह सच होना चाहिए।

— रिले

@MagicOctopusUrn यदि आप उस रन (TIO) को तोड़ते हैं तो यह गलत हो जाता है।

— रिले

क्या तीसरी कमांड मूल पंक्तियों को ट्रांसपोज़्ड पंक्तियों को समतल नहीं करती है?

— मैजिक ऑक्टोपस Urn

इसके अलावा, मैंने सोचा था कि यह केवल 3 के लिए सच लौटना चाहिए था जब वहाँ है [3,3,3]। मैंने उस मामले में चुनौती को गलत बताया, इसलिए मुझे लगता है कि मैं यहां गलत हूं।

— मैजिक ऑक्टोपस Urn

@MagicOctopusUrn पहले 3 कमांड में एक सरणी बनाई जाएगी जिसमें प्रत्येक पंक्ति और प्रत्येक कॉलम में व्यक्तिगत तत्व होंगे।

— रिले

1

जेली , 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झूठे के लिए रिटर्न और सत्य के लिए एक गैर-शून्य पूर्णांक।

ईव, यह बुरा है। और बहुत लंबा है। गोल्फ युक्तियाँ की सराहना की जाएगी :)

— HyperNeutrino
स्रोत

1

जावास्क्रिप्ट (ईएस 6), 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} एल -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))

स्निपेट का विस्तार करें

— Arnauld
स्रोत

0

पायथन 2 , 64 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— XNOR
स्रोत

0

क्लोजर, 77 बाइट्स

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

pलंबाई N(प्रतीक %2) के सभी लगातार विभाजन बनाता है और मायने रखता है कि इसके कितने अलग-अलग मूल्य हैं। फिर यह इन लंबाई का सेट बनाता है और 1अगर यह सेट से पाया जाता है और वापस आ nilजाता है। forनिर्माण इस के लिए एकदम सही था, मेरा मूल प्रयास flatten, concatया उस छोटे से कुछ का उपयोग किया गया था ।

— NikoNyrh
स्रोत

क्या मैट्रिक्स में एक पंक्ति / स्तंभ में संख्या की लगातार घटनाएं होती हैं?

परीक्षण के मामलों

भूसी , 9 बाइट्स

व्याख्या

दिल्लोग एपीएल, 27 25 23 बाइट्स

पर्ल 6 , 60 बाइट्स

MATL , 12 बाइट्स

व्याख्या

ऑक्टेव, 77 70 बाइट्स

जेली , ९ by बाइट्स

यह काम किस प्रकार करता है

उदाहरण चलाते हैं

पायथन 2 , 60 92 91 बाइट्स

ऑक्टेव , 59 बाइट्स

जाप , 18 15 14 बाइट्स

व्याख्या

सीजेएम , 16 बाइट्स

व्याख्या

पायथन 3 , 129 128 125 120 104 101 बाइट्स

05AB1E , 16 14 12 बाइट्स

जेली , 18 बाइट्स

जावास्क्रिप्ट (ईएस 6), 99 बाइट्स

कैसे?

परीक्षण के मामलों

पायथन 2 , 64 बाइट्स

क्लोजर, 77 बाइट्स