चुनौती:

मैट्रिक्स इनपुट को देखते हुए, डुप्लिकेट संख्या के साथ विकर्णों और विरोधी-विकर्णों की मात्रा निर्धारित करें।
तो अगर हम इस तरह एक मैट्रिक्स है:

[[aa,ab,ac,ad,ae,af],
 [ba,bb,bc,bd,be,bf],
 [ca,cb,cc,cd,ce,cf],
 [da,db,dc,dd,de,df]]

सभी विकर्ण और विरोधी विकर्ण होंगे:

[[aa],[ab,ba],[ac,bb,ca],[ad,bc,cb,da],[ae,bd,cc,db],[af,be,cd,dc],[bf,ce,dd],[cf,de],[df],
 [af],[ae,bf],[ad,be,cf],[ac,bd,ce,df],[ab,bc,cd,de],[aa,bb,cc,dd],[ba,cb,dc],[ca,db],[da]]

उदाहरण:

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

सभी विकर्ण और विरोधी विकर्ण होंगे:

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

सभी विकर्णों और विरोधी-विकारों को हटाने में केवल अद्वितीय संख्याएँ होती हैं:

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

तो आउटपुट विकर्ण और विरोधी-विकर्ण की मात्रा है जिसमें डुप्लिकेट संख्या होती है:

चुनौती नियम:

यदि इनपुट मैट्रिक्स खाली है, तो केवल 1 नंबर होता है, या पूरे मैट्रिक्स में केवल अनन्य नंबर होते हैं, आउटपुट हमेशा होता है 0 ।
इनपुट की गारंटी केवल सकारात्मक अंक रखने की है [1,9] (जब तक कि यह पूरी तरह से खाली न हो)।
मैट्रिक्स हमेशा आयताकार होगा (यानी सभी पंक्तियाँ समान लंबाई हैं)।
I / O लचीला है। इनपुट को पूर्णांकों की सूची की सूची के रूप में लिया जा सकता है, या पूर्णांक के 2 डी सरणी, या एक मैट्रिक्स-ऑब्जेक्ट, एक स्ट्रिंग, आदि के रूप में) आपको अतिरिक्त इनपुट के रूप में मैट्रिक्स के आयामों में से एक या दोनों को लेने की अनुमति है अगर यह पसंद की भाषा में बाइट्स को बचाएगा।

सामान्य नियम:

यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव संक्षिप्त उत्तर के साथ आने का प्रयास करें।
डिफ़ॉल्ट I / O नियमों के साथ आपके जवाब के लिए मानक नियम लागू होते हैं , इसलिए आपको उचित पैरामीटर और रिटर्न-प्रकार, पूर्ण कार्यक्रमों के साथ STDIN / STDOUT, फ़ंक्शन / विधि का उपयोग करने की अनुमति है। तुम्हारा फोन।
डिफ़ॉल्ट लूपोल्स निषिद्ध हैं।
यदि संभव हो, तो कृपया अपने कोड (यानी TIO ) के लिए एक परीक्षण के साथ एक लिंक जोड़ें ।
साथ ही, आपके उत्तर के लिए स्पष्टीकरण जोड़ने की अत्यधिक अनुशंसा की जाती है।

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

Input:                     Output:

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

[[]]                       0

[[1,2],                    0
 [3,4]]

[[1,1],                    2
 [1,1]]

[[9,9,9],                  6
 [9,9,9],
 [9,9,9]]

[[7,7,7,7],                8
 [7,7,7,7],
 [7,7,7,7]]

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

[[1,8,4,2,9,4,4,4],        12
 [5,1,2,7,7,4,2,3],
 [1,4,5,2,4,2,3,8],
 [8,5,4,2,3,4,1,5]]

[[1,2,3,4],                4
 [5,6,6,7],
 [8,6,6,9],
 [8,7,6,5]]

— केविन क्रूज़सेन
स्रोत

4

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

ŒD;ŒdQƑÐḟL

इसे ऑनलाइन आज़माएं! या परीक्षण सूट की जाँच करें!

विकल्प:

ŒD;ŒdQƑ€¬S
ŒD;ŒdQƑ€ċ0

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

ŒD;ŒdQƑÐḟL – Monadic link / Full program.
  ;        – Join:
ŒD           – The diagonals
             with
   Œd        – The anti-diagonals.
       Ðḟ  – Discard the lists that are not:
     QƑ      – Invariant under deduplication.
         L – Length (count them).

— मिस्टर एक्सकोडर
स्रोत

10

आर , 92 86 82 78 बाइट्स

function(m,x=row(m),y=col(m),`|`=split,`^`=Map)sum(max^table^c(m|x-y,m|x+y)>1)

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

व्याख्या

सबसे पहले, हम अतिरिक्त चर घोषित करते हैं $x$ $y$ जो क्रमशः पंक्ति और स्तंभ सूचकांकों के लिए खड़े होते हैं। फिर हम उनके अंतर और योग को लेकर विकर्णों और विरोधी-विकारों को चित्रित कर सकते हैं। जैसे, 4x4 मैट्रिक्स के लिए:

$x-y$ देता है:

0 -1 -2 -3 1 0 -1 -2 2 1 0 -1 3 2 1 0

$x+y$ देता है:

2 3 4 5 3 4 5 6 4 5 6 7 5 6 7 8

अब split(m, x-y)और split(m, x+y)विकर्णों और विरोधी-विकर्णों की वास्तविक सूचियों का उत्पादन करते हैं, जिन्हें हम एक साथ जोड़ते हैं।

अंत में, हम परिणामी सूची की प्रविष्टियों को गिनते हैं जहां डुप्लिकेट मौजूद हैं।

बाइट्स के लिए धन्यवाद बचाया:

-4 CriminallyVulgar
-4 द्वारा digEmAll द्वारा

— किरिल एल।
स्रोत

1

मुझे लगता है मैं जोड़ सकते हैं rowऔर col'अत्यंत स्थितिजन्य कार्यों' की मेरी सूची में। वास्तव में चतुर समाधान।

— क्रिमिनल

1

मुझे लगता है कि आप c(m|x-y,m|x+y)सीधे नीलम कॉल में स्थानांतरित कर सकते हैं , l=भाग को हटा सकते हैं । मैं कोई भी असफल परीक्षण नहीं देखता हूं। इसे ऑनलाइन आज़माएं!

— क्रिमिनल

हां, यह सही है, मुझे सिर्फ इतना याद आया कि मेरे पहले गोल्फ के बाद, केवल एक ही lउदाहरण शेष था।

— किरिल एल।

1

उन्होंने आज सुबह आर rowऔर columnकार्यों को जोड़ा होगा , क्योंकि मैंने उनके बारे में कभी नहीं सुना है।

— 15

5

जे , 21 20 बाइट्स

-1 बाइट जोनाह को धन्यवाद!

1#.|.,&((~:&#~.)/.)]

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

स्पष्टीकरण:

1#.                   find the sum of the  
     ,                concatenation of
       (          )   the result of the verb in the parentheses applied to
                   ]  the input
      &               and
   |.                 the reversed input
        (      )/.    for each diagonal
         ~:&#~.       check if all elements are unique and negate the result

— गैलेन इवानोव
स्रोत

1

यह पागल की तरह है कि आप (-.@-:~.)जम्मू में "अद्वितीय वस्तुओं से मेल नहीं खाते" से बेहतर नहीं कर सकते हैं, लेकिन मैंने कई बार इसका सामना किया है और मुझे नहीं लगता कि आप कर सकते हैं ... हमारे पास =और ~:एक पर हाथ, -:और <this is missing>।

— जोनाह

दरअसल, 1 और बाइट को शेव करने में कामयाब रहे 1#.|.,&((~:&#~.)/.)]:। इसे ऑनलाइन आज़माएं!

— जोनाह

@ जॉन: शांत उपयोग &, धन्यवाद!

— गालेन इवानोव

5

जाप , 31 बाइट्स

ËcUî
ËéEÃÕc¡XéYnÃÕ mf fÊk_eZâÃl

सभी परीक्षण मामलों की कोशिश करो

स्पष्टीकरण:

Ëc                            #Pad each row...
  Uî                          #With a number of 0s equal to the number of rows

ËéEÃÕ                         #Get the anti-diagonals:
ËéEÃ                          # Rotate each row right a number of times equal to the row's index
    Õ                         # Get the resulting columns
     c                        #Add to that...
      ¡XéYnÃÕ                 #The diagonals:
      ¡XéYnÃ                  # Rotate each row left a number of times equal to the row's index
            Õ                 # Get the resulting columns
              mf              #Remove the 0s from each diagonal
                 fÊ           #Remove the all-0 diagonals
                   k_   Ã     #Remove the ones where:
                     eZâ      # The list contains no duplicates
                         l    #Return the number of remaining diagonals

मैंने किरिल एल। हास्केल के उत्तर पर आधारित एक संस्करण की भी कोशिश की , लेकिन "एक्स और वाई सूचकांकों के एक समूह द्वारा" समूह के लिए एक अच्छा तरीका नहीं खोज सका और जो विकल्प मुझे मिला वह अच्छा नहीं था।

— कामिल दकरी
स्रोत

31 बाइट्स

— झबरा

4

जावास्क्रिप्ट (ईएस 6), 107 105 101 98 बाइट्स

f=(m,d=s=1)=>(m+0)[s-=~d/2]?m.some(o=(r,y)=>!r.every((v,x)=>x+d*y+m.length-s?1:o[v]^=1))+f(m,-d):0

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

ध्यान दें

इस कोड को जिस तरह से गढ़ा गया है, एंटी-विकर्ण एकमात्र तल-बाएं सेल से मिलकर कभी भी परीक्षण नहीं किया जाता है। यह ठीक है क्योंकि इसमें संभवतः डुप्लिकेट किए गए मान नहीं हो सकते।

टिप्पणी की गई

f = (                    // f = recursive function taking:
  m,                     //   m[] = input matrix
  d =                    //   d   = direction (1 for anti-diagonal or -1 for diagonal)
  s = 1                  //   s   = expected diagonal ID, which is defined as either the sum
) =>                     //         or the difference of x and y + the length of a row
  (m + 0)[               //
    s -= ~d / 2          // increment s if d = -1 or leave it unchanged otherwise
  ] ?                    // if s is less than twice the total number of cells:
    m.some(o =           //   o = object used to store encountered values in this diagonal
    (r, y) =>            //   for each row r[] at position y in m[]:
      !r.every((v, x) => //     for each cell of value v at position x in r[]:
        x + d * y +      //       x + d * y + m.length is the ID of the diagonal
        m.length - s ?   //       if it's not equal to the one we're looking for:
          1              //         yield 1
        :                //       else:
          o[v] ^= 1      //         toggle o[v]; if it's equal to 0, v is a duplicate and
                         //         every() fails which -- in turn -- makes some() succeed
      )                  //     end of every()
    )                    //   end of some()
    + f(m, -d)           //   add the result of a recursive call in the opposite direction
  :                      // else:
    0                    //   stop recursion

— Arnauld
स्रोत

4

05AB1E , 25 बाइट्स

í‚εεygÅ0«NFÁ]€ø`«ʒ0KDÙÊ}g

इसे ऑनलाइन आज़माएं! या टेस्ट सूट के रूप में

व्याख्या

í                          # reverse each row in input
 ‚                         # and pair with the input
  ε                        # for each matrix
   ε                       # for each row in the matrix
    ygÅ0«                  # append len(row) zeroes
         NFÁ               # and rotate it index(row) elements to the right
            ]              # end loops
             €ø            # transpose each matrix
               `«          # append them together
                 ʒ     }   # filter, keep only rows that
                  0K       # when zeroes are removed
                    DÙÊ    # are not equal to themselves without duplicate values                           
                        g  # push length of the result

मुझे ऐसा लगता है कि मैंने यहां कुछ याद किया है।
इसे और बाद में आजमाने की आवश्यकता है।

— Emigna
स्रोत

1

बिल्कुल मदद नहीं करता है, लेकिन अब rotate N leftहोगा N._। तो í‚εεygÅ0«N._]भी काम करता है। इस नए बदलाव के साथ चपटेपन को भी दूर कर सकते हैं ... अभी भी कोई बाइट बचत नहीं है:í‚vyεygÅ0«N._}ø}«ʒ0KDÙÊ}g

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

1

@MagicOctopusUrn: दिलचस्प है। मुझे वह आदेश याद आ गया था। हालांकि केवल एक बाएं। वह अजीब है।

— एमिग्ना

1

@Emigna मेरे अनुमान से आप सही जा सकते हैं N(._, लेकिन आपकी NFÁ}लंबाई समान है, और ]लूप और मैप्स को एक साथ बंद करने के कारण इस मामले में भी कम है । कुल मिलाकर इसका उपयोग ._केवल तभी उपयोगी होता है जब इसकी तुलना में 1 बाइट को बचाने के लिए छोड़ा जाता है NFÀ}।

— केविन क्रूज़सेन

@ केविनक्रूजसेन: आह, मस्त। हालांकि जैसा कि आप कहते हैं, बहुत उपयोगी नहीं है।

— एमिग्ना

3

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

lambda m:sum(l(set(d))<l(d)for d in[[r[i*x+o]for i,r in enumerate(m)if-1<i*x+o<l(r)]for o in range(-l(`m`),l(`m`))for x in[-1,1]])
l=len

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

— TFeld
स्रोत

3

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

@(A)nnz([(q=@(Q)arrayfun(@(n)nnz(z=diag(Q,n))-nnz(unique(z)),-([m,n]=size(Q)):n))(A),q(rot90(A))])

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

— Sanchises
स्रोत

1

क्या सरणियाँ वास्तव में मजेदार हैं? ; पी

— केविन क्रूज़सेन

और परीक्षण मामलों को ऑक्टेव प्रारूप में तैयार करने के लिए धन्यवाद!

— लुइस मेंडो

2

@ केविनक्रूजसेन न केवल सरणियाँ! आपके पास cellfunभी हो सकता है, और मसोइक के लिए structfunभी। ऑक्टेव में, यह या तो एक लूप है या है fun!

— शाम

और बी-एसएक्स-मज़ा मत भूलना!

— लुइस मेंडो

3

हास्केल, 118 112 बाइट्स

import Data.List
r#(a:b)=sum[1|(/=)=<<nub$[h|h:_<-a:r]]+[t|_:t<-a:r]#b
[]#_=0
a#_=a#[[]]
h x=[]#x+[]#(reverse x)

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

r#(a:b)                      -- function '#' calculates the ant-diagonals of a matrix
                             -- where 'a' is the first row and 'b' all the others
                             -- as we recursively walk down the rows of the matrix,
                             -- 'r' holds the rows from before with the respective
                             -- head dropped
                             --
          [h|h:_<-a:r]       -- if the heads of the the current row and the rows
                             -- before
       (/=)=<<nub$           -- contain duplicates
    [1|                ]     -- make a singleton list [1] (else the empty list)
 sum                         -- and take the sum thereof
      +                      -- and add
             #               -- a recursive call with
 [t|_:t<-a:r]                -- the tails of the current row and the rows before
              b              -- and the rows below
                             --
[]#_=0                       -- base case if there aren't any tails anymore, return 0
a#_=a#[[]]                   -- if there are tails, but no further rows below,
                             -- continue with tails

h x=[]#x+[]#(reverse x)      -- main function, call '#' with input matrix 'x'
                             -- and the reverse of it to get the number of diagonals
                             -- and anti-diagonals. Recursion starts with no
                             -- rows before the 1st row.

-- example trace of function '#'
-- input matrix:
--   [[1,2,3,4],
--    [5,6,7,8],
--    [9,9,9,9]]
--
--  | r         a          b              a:r          heads   tails (r of next call)
-- -+----------------------------------------------------------------------------------
-- 1| []        [1,2,3,4]  [[5,6,7,8],    [[1,2,3,4]]  [1]     [[2,3,4]]
--  |                       [9,9,9,9]]
--  | 
-- 2| [[2,3,4]]  [5,6,7,8]  [[9,9,9,9]]   [[5,6,7,8],  [5,2]   [[6,7,8],
--  |                                      [2,3,4  ]]           [3,4  ]]
--  |
-- 3| [[6,7,8],  [9,9,9,9]  []            [[9,9,9,9],  [9,6,3] [[9,9,9],
--  |  [3,4  ]]                            [6,7,8  ],           [7,8  ]
--  |                                      [3,4    ],           [4    ]
--  |
--  | ....

— nimi
स्रोत

2

चारकोल , 61 56 53 बाइट्स

Ｆ²ＦＬθＦＬ§θ⁰Ｆ⟦⁻κ×⊖⊗ιλ⟧⊞υ⊞Ｏ⎇∧λ﹪⁺μιＬθ⊟υ⟦⟧§§θμλＩＬΦυ⊙ι‹⌕ιλμ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

Ｆ²

आगे और विपरीत विकर्णों पर लूप; i=0आगे विकर्णों का i=1प्रतिनिधित्व करता है जबकि रिवर्स विकर्णों का प्रतिनिधित्व करता है।

ＦＬθ

प्रत्येक पंक्ति सूचकांक पर लूप। यह विकर्ण की शुरुआत के सूचकांक का प्रतिनिधित्व करता है।

ＦＬ§θ⁰«

प्रत्येक कॉलम इंडेक्स पर लूप।

Ｆ⟦⁻κ×⊖⊗ιλ⟧

इस स्तंभ सूचकांक में विकर्ण की पंक्ति सूचकांक की गणना करें। मैं forअसाइनमेंट के बजाय सिंगल-एलिमेंट ऐरे से अधिक लूप का उपयोग करता हूं क्योंकि यह असाइनमेंट को निम्न स्टेटमेंट के साथ ब्लॉक में लपेटने से बचता है, इस प्रकार एक बाइट की बचत होती है।

⎇∧λ﹪⁺μιＬθ

जांचें कि यह पहला स्तंभ है या विकर्ण नीचे और ऊपर के बीच लपेटने वाला है।

⊟υ

यदि यह सूची की सूची से अंतिम सूची पॉप नहीं है।

⟦⟧

यदि यह है तो एक नई खाली सूची शुरू करें।

⊞Ｏ...§§θμλ

उस सूची में वर्तमान विकर्ण प्रविष्टि जोड़ें।

⊞υ

और सूचियों की सूची में उस सूची (पीछे) को धक्का दें।

ＩＬΦυ⊙ι‹⌕ιλμ

उन सूचियों की संख्या गिनें जिनमें डुप्लिकेट हैं।

के एक उदाहरण लेते हैं जब करते हैं i=0और k=1। इस का मतलब है कि हम पहले से ही दो विकर्ण एकत्र किया है [[1,1,5,2],[9,4,3,5]]। यहां हमारा इनपुट है:

 1 8 4 2 9 4 4 4
[5]1 2 7 7 4 2 3
 1 4 5 2 4 2 3 8
 8 5 4 2 3 4 1 5

हम तो पाश lसे 0करने के लिए 7। यह पंक्ति और स्तंभ दोनों को 1 बार आगे बढ़ाता है:

 1 8 4 2 9 4 4 4
[5]1 2 7 7 4 2 3
 1[4]5 2 4 2 3 8
 8 5[4]2 3 4 1 5

सूची अभी है [[1,1,5,2],[9,4,3,5],[5,4,4]]। लेकिन जब lहै 3, हमारे पास है k+l=4, सरणी की ऊंचाई की एक बहु। इसका मतलब है कि हमें एक नई सूची शुरू करने की आवश्यकता है [[1,1,5,2],[9,4,3,5],[5,4,4],[]]:। हम तब विकर्ण तत्वों को इकट्ठा करना जारी रखते हैं:

 1 8 4[2]9 4 4 4
[5]1 2 7[7]4 2 3
 1[4]5 2 4[2]3 8
 8 5[4]2 3 4[1]5

सूची अभी है [[1,1,5,2],[9,4,3,5],[5,4,4],[2,7,2,1]]। अब जब lहै 7, तो हमारे पास k+l=8सरणी की ऊंचाई का एक और गुण है। इसका मतलब है कि हमें एक नई सूची शुरू करने की आवश्यकता है, जो उस विकर्ण के अंतिम तत्व के साथ समाप्त होती है [[1,1,5,2],[9,4,3,5],[5,4,4],[2,7,2,1],[4]]:।

 1 8 4[2]9 4 4[4]
[5]1 2 7[7]4 2 3
 1[4]5 2 4[2]3 8
 8 5[4]2 3 4[1]5

प्रत्येक पंक्ति के पहले तत्व से शुरू होने वाले रैपिंग विकर्णों को इकट्ठा करके हम अंततः सरणी के सभी विकर्णों को जमा करते हैं।

— नील
स्रोत

2

वोल्फ्राम भाषा (गणितज्ञ) , ९९ Language ९ Language६ ९ ४३ बाइट्स

Count[DuplicateFreeQ@Diagonal[#,i]~Table~{i,-t,t=#~Total~2}&/@{#,Reverse@#},1<0,2]&

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

Function[a,a~Diagonal~#&/@Range[t=-#~Total~2,-t]]के सभी विकर्ण मिलते हैं a- जो काम करता है क्योंकि #~Total~2किसी भी आयाम से बड़ा है a।

— lirtosiast
स्रोत

1

एपीएल + विन, 69 बाइट्स

2d मैट्रिक्स के लिए फॉर्म 4 6 21 2 1 2 1 2 1 2 3 4 5 6 6 4 4 2 2 1 2 2 2 2 के लिए संकेत

यह प्रदान करता है:

1 2 1 2 1 2
1 2 3 4 5 6
6 5 4 3 2 1
2 1 2 1 2 1

+/~(v⍳¨v)≡¨⍳¨⍴¨v←(v←⊂[1](⌽0,⍳1↓n)⌽(n⍴0),m,((n←0 ¯1+↑⍴m)⍴0),⌽m←⎕)~¨0

इसे ऑनलाइन आज़माएं! दरियाल क्लासिक के सौजन्य से

स्पष्टीकरण:

(⌽0,⍳1↓n)⌽(n⍴0),m pad m with zeros to isolate diagonals

((n←0 ¯1+↑⍴m)⍴0),⌽m pad rotated m with zeros to isolate anti-diagonals

पैदावार:

1 2 1 2 1 2 0 0 0 2 1 2 1 2 1 0 0 0
0 1 2 3 4 5 6 0 0 0 6 5 4 3 2 1 0 0
0 0 6 5 4 3 2 1 0 0 0 1 2 3 4 5 6 0
0 0 0 2 1 2 1 2 1 0 0 0 1 2 1 2 1 2

v←(v←⊂[1](.....)~¨0 enclose the diagonals as a nested vector with padded zeros removed

+/~(v⍳¨v)≡¨⍳¨⍴¨v identify diagnols with duplicate entries and sum

— ग्राहम
स्रोत

1

पर्ल 5, 89 82 बाइट्स

map{$i=0;map{$a[$x+$i].=$_;$b[@F-$x+$i++].=$_}/\d/g;$x++}@F;$_=grep/(.).*\1/,@a,@b

TIO

— नहुएल फौलीउल
स्रोत

1

टीएसक्यूएल, 140 128 बाइट्स

12 पात्रों को गोल्फ के लिए एक रास्ता मिला। यह अब सबसे लंबा समाधान नहीं है।

golfed:

SELECT sum(iif(y+x=j+i,1,0)+iif(y-x=j-i,1,0))FROM
@,(SELECT x i,y j,max(y)over()m,v w
FROM @)d WHERE(x*y=0or m=y)and v=w and x<i

Ungolfed:

DECLARE @ table(v int,x int,y int)
-- v = value
-- x = row 
-- y = column
INSERT @ values
(1,0,0),(2,0,1),(1,0,2),(2,0,3),(1,0,4),(2,0,5),
(1,1,0),(2,1,1),(3,1,2),(4,1,3),(5,1,4),(6,1,5),
(6,2,0),(5,2,1),(4,2,2),(3,2,3),(2,2,4),(1,2,5),
(2,3,0),(1,3,1),(2,3,2),(1,3,3),(2,3,4),(1,3,5)


SELECT sum(iif(y+x=j+i,1,0)+iif(y-x=j-i,1,0))
FROM @,(SELECT x i,y j,max(y)over()m,v w FROM @)d
WHERE
  (x*y=0or m=y)
  and v=w
  and x<i

कोशिश करके देखो

— t-clausen.dk
स्रोत

डुप्लिकेट मानों के साथ सभी (विरोधी) विकर्णों को स्पॉट करें

चुनौती:

चुनौती नियम:

सामान्य नियम:

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

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

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

आर , 92 86 82 78 बाइट्स

व्याख्या

जे , 21 20 बाइट्स

स्पष्टीकरण:

जाप , 31 बाइट्स

जावास्क्रिप्ट (ईएस 6), 107 105 101 98 बाइट्स

ध्यान दें

टिप्पणी की गई

05AB1E , 25 बाइट्स

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

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

हास्केल, 118 112 बाइट्स

चारकोल , 61 56 53 बाइट्स

वोल्फ्राम भाषा (गणितज्ञ) , ९९ Language ९ Language६ ९ ४३ बाइट्स

एपीएल + विन, 69 बाइट्स

पर्ल 5, 89 82 बाइट्स

टीएसक्यूएल, 140 128 बाइट्स