Thử thách:

Đưa ra một đầu vào ma trận, xác định số lượng đường chéo và đường chéo với số lượng trùng lặp.
Vì vậy, nếu chúng ta có một ma trận như thế này:

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

Tất cả các đường chéo và đường chéo sẽ là:

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

Thí dụ:

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

Tất cả các đường chéo và đường chéo sẽ là:

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

Xóa tất cả các đường chéo và đường chéo chỉ chứa các số duy nhất:

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

Vì vậy, đầu ra là số lượng đường chéo và đường chéo chứa các số trùng lặp:

6

Quy tắc thử thách:

• Nếu ma trận đầu vào trống, chỉ chứa 1 số hoặc chỉ chứa các số duy nhất trên toàn bộ ma trận, đầu ra luôn luôn 0.
• Đầu vào được đảm bảo chỉ chứa các chữ số dương [1,9](trừ khi nó hoàn toàn trống).
• Ma trận sẽ luôn là hình chữ nhật (tức là tất cả các hàng có cùng độ dài).
• I / O là linh hoạt. Đầu vào có thể được lấy dưới dạng danh sách các số nguyên hoặc mảng số nguyên 2D hoặc đối tượng Ma trận, dưới dạng chuỗi, v.v. Bạn cũng được phép lấy một hoặc cả hai kích thước của ma trận làm đầu vào bổ sung nếu nó sẽ lưu byte trong ngôn ngữ của bạn lựa chọn.

Quy tắc chung:

• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng.
  Đừng để ngôn ngữ mã-golf ngăn cản bạn đăng câu trả lời với các ngôn ngữ không mã hóa. Cố gắng đưa ra một câu trả lời càng ngắn càng tốt cho ngôn ngữ lập trình 'bất kỳ'.
• Quy tắc chuẩn áp dụng cho câu trả lời của bạn với quy tắc I / O mặc định , vì vậy bạn được phép sử dụng STDIN / STDOUT, các hàm / phương thức với các tham số thích hợp và kiểu trả về, chương trình đầy đủ. Cuộc gọi của bạn.
• Lỗ hổng mặc định bị cấm.
• Nếu có thể, vui lòng thêm một liên kết với một bài kiểm tra cho mã của bạn (ví dụ TIO ).
• Ngoài ra, thêm một lời giải thích cho câu trả lời của bạn rất được khuyến khích.

Các trường hợp thử nghiệm:

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]]

Thạch , 10 byte

ŒD;ŒdQƑÐḟL

Hãy thử trực tuyến! hoặc Kiểm tra bộ thử nghiệm!

Lựa chọn thay thế:

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

Làm thế nào nó hoạt động?

Œ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).

R , 92 86 82 78 byte

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

Hãy thử trực tuyến!

Giải trình

$x$$y$

$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

Bây giờ split(m, x-y)và split(m, x+y)tạo ra các danh sách thực tế của các đường chéo và chống chéo, mà chúng ta kết hợp với nhau.

Cuối cùng, chúng tôi đếm các mục của danh sách kết quả có mặt trùng lặp.

Cảm ơn các byte đã lưu:

-4 bởi CriminallyVulgar
-4 bởi digEmAll

J , 21 20 byte

-1 byte nhờ Jonah!

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

Hãy thử trực tuyến!

Giải trình:

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 

Japt , 31 byte

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

Hãy thử tất cả các trường hợp thử nghiệm

Giải trình:

Ë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

Tôi cũng đã thử một phiên bản dựa trên câu trả lời Haskell của Kirill L., nhưng không thể tìm ra cách hay để "nhóm theo chức năng của các chỉ số X và Y" và phương án tôi thấy không đủ tốt.

JavaScript (ES6),  107 105 101  98 byte

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

Hãy thử trực tuyến!

Ghi chú

Cách mã này được đánh gôn, chống chéo bao gồm các ô dưới cùng bên trái không bao giờ được kiểm tra. Điều đó ổn vì nó không thể chứa các giá trị trùng lặp.

Đã bình luận

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

05AB1E , 25 byte

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

Hãy thử trực tuyến! hoặc như một bộ thử nghiệm

Giải trình

í                          # 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

Tôi cảm thấy như tôi đã bỏ lỡ điều gì đó ở đây.
Cần phải cố gắng và chơi golf này sau này.

Python 2 , 144 136 byte

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

Hãy thử trực tuyến!

Octave , 98 byte

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

Hãy thử trực tuyến!

Haskell, 118 112 byte

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)

Hãy thử trực tuyến!

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

Than , 61 56 53 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

Ｆ²

Vòng qua các đường chéo về phía trước và ngược lại; i=0đại diện cho các đường chéo phía trước trong khi i=1đại diện cho các đường chéo ngược.

ＦＬθ

Vòng lặp trên mỗi chỉ số hàng. Điều này đại diện cho chỉ số bắt đầu của đường chéo.

ＦＬ§θ⁰«

Lặp lại trên mỗi chỉ số cột.

Ｆ⟦⁻κ×⊖⊗ιλ⟧

Tính chỉ số hàng của đường chéo tại chỉ số cột này. Tôi sử dụng một forvòng lặp trên một mảng phần tử đơn thay vì một phép gán vì điều này tránh việc phải bọc phép gán thành một khối bằng câu lệnh sau, do đó tiết kiệm được một byte.

⎇∧λ﹪⁺μιＬθ

Kiểm tra xem đây là cột đầu tiên hay đường chéo sắp quấn quanh giữa đáy và đỉnh.

⊟υ

Nếu không thì hãy bật danh sách cuối cùng từ danh sách danh sách.

⟦⟧

nếu có thì bắt đầu một danh sách trống mới.

⊞Ｏ...§§θμλ

Thêm mục nhập đường chéo hiện tại vào danh sách đó.

⊞υ

Và đẩy danh sách đó (trở lại) vào danh sách danh sách.

ＩＬΦυ⊙ι‹⌕ιλμ

Đếm số lượng danh sách có chứa trùng lặp.

Hãy lấy một ví dụ khi i=0và k=1. Điều này có nghĩa là chúng tôi đã thu thập hai đường chéo , [[1,1,5,2],[9,4,3,5]]. Đây là đầu vào của chúng tôi:

 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

Chúng tôi sau đó lặp ltừ 0đến 7. Điều này tiến bộ cả hàng và cột thêm 1 lần:

 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

Danh sách bây giờ [[1,1,5,2],[9,4,3,5],[5,4,4]]. Tuy nhiên khi llà 3, chúng tôi có k+l=4, một bội số của chiều cao của mảng. Điều này có nghĩa là chúng ta cần bắt đầu một danh sách mới : [[1,1,5,2],[9,4,3,5],[5,4,4],[]]. Sau đó chúng tôi tiếp tục thu thập các yếu tố đường chéo:

 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

Danh sách bây giờ [[1,1,5,2],[9,4,3,5],[5,4,4],[2,7,2,1]]. Bây giờ khi llà 7, chúng tôi có k+l=8, một bội số của chiều cao của mảng. Điều này có nghĩa là chúng ta cần bắt đầu một danh sách mới, kết thúc bằng phần tử cuối cùng của đường chéo đó : [[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

Bằng cách thu thập các đường chéo gói bắt đầu từ phần tử đầu tiên của mỗi hàng, cuối cùng chúng ta tích lũy tất cả các đường chéo của mảng.

Ngôn ngữ Wolfram (Mathicala) , 99 98 96 94 83 byte

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

Hãy thử trực tuyến!

• Function[a,a~Diagonal~#&/@Range[t=-#~Total~2,-t]]được tất cả các đường chéo của a- hoạt động vì #~Total~2lớn hơn bất kỳ kích thước nào của a.

APL + THẮNG, 69 byte

Nhắc nhở cho ma trận 2d có dạng 4 6⍴1 2 1 2 1 2 1 2 3 4 5 6 6 5 4 3 2 1 2 1 2 1 2 1

Sản lượng này:

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

Hãy thử trực tuyến! Lịch sự của Dyalog Classic

Giải trình:

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

Sản lượng:

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

Perl 5, 89 82 byte

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

TIO

TSQL, 140 128 byte

Tìm thấy một cách để golf 12 ký tự. Đây không còn là giải pháp dài nhất.

Chơi gôn

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

Ung dung:

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

Dùng thử