도전:

행렬 입력이 주어지면 숫자가 중복 된 대각선 및 대각 대각선의 양을 결정하십시오.
따라서 다음과 같은 행렬이 있다면 :

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

따라서 출력은 중복 된 숫자를 포함하는 대각선 및 대각 대각선의 양입니다.

6

도전 규칙 :

• 입력 행렬이 비어 있거나 1 개의 숫자 만 포함하거나 전체 행렬에서 고유 한 숫자 만 포함하면 출력은 항상 0 입니다.
• 입력은 양수 만 포함하도록 보장됩니다 [1,9] (완전히 비어 있지 않은 경우).
• 행렬은 항상 직사각형입니다 (즉, 모든 행의 길이는 동일 함).
• I / O는 유연합니다. 입력은 정수 목록, 정수의 2D 배열 또는 행렬 객체 등의 문자열 목록으로 사용할 수 있습니다. 추가 입력으로 행렬의 차원 중 하나 또는 둘 다를 사용할 수도 있습니다. 선택한 언어로 바이트를 저장하는 경우.

일반 규칙:

• 이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.
  코드 골프 언어가 코드 골프 언어 이외의 언어로 답변을 게시하지 못하게하지 마십시오. '모든'프로그래밍 언어에 대한 가능한 한 짧은 대답을 생각해보십시오.
• 답변에 표준 규칙이 적용됩니다. 기본 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]]

젤리 , 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).

R , 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) 우리가 함께 가입 대각선 및 안티 대각선의 실제 목록을 생성한다.

마지막으로 중복이 존재하는 결과 목록의 항목을 계산합니다.

저장된 바이트에 감사드립니다.

CriminallyVulgar의
-4-digEmAll의 -4

J , 21 20 바이트

Jonah 덕분에 -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 

Japt , 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

또한 Kirill L.의 Haskell 답변을 기반으로 한 버전 을 시도했지만 "X 및 Y 인덱스의 함수로 그룹화"하는 좋은 방법을 찾지 못했고 내가 찾은 대안이 충분하지 않았습니다.

자바 스크립트 (ES6)  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

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

여기서 뭔가를 놓친 것 같습니다.
나중에 더 시도하고 골프를 쳐야합니다.

파이썬 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

온라인으로 사용해보십시오!

옥타브 , 98 바이트

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

온라인으로 사용해보십시오!

하스켈, 118112 바이트

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

숯 , 61 56 53 바이트

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

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 설명:

Ｆ²

정방향 및 역방향 대각선을 반복합니다. i=0앞 대각선을 i=1나타내는 반면 역방향 대각선을 나타냅니다.

ＦＬθ

각 행 인덱스를 반복하십시오. 대각선의 시작 인덱스를 나타냅니다.

ＦＬ§θ⁰«

각 열 인덱스를 반복합니다.

Ｆ⟦⁻κ×⊖⊗ιλ⟧

이 열 인덱스에서 대각선의 행 인덱스를 계산하십시오. 나는for할당 대신 단일 요소 배열에 루프를 하면 다음 명령문으로 할당을 블록으로 랩핑하지 않아도되므로 바이트를 절약 할 수 있습니다.

⎇∧λ﹪⁺μιＬθ

이것이 첫 번째 열인지 아니면 대각선이 아래쪽과 위쪽을 감싸고 있는지 확인하십시오.

⊟υ

그렇지 않은 경우 목록 목록에서 마지막 목록을 팝하십시오.

⟦⟧

그렇다면 새 빈 목록을 시작하십시오.

⊞Ｏ...§§θμλ

현재 대각선 항목을 해당 목록에 추가하십시오.

⊞υ

그리고 그 목록을 목록의 목록으로 푸시하십시오.

ＩＬΦυ⊙ι‹⌕ιλμ

중복이 포함 된 목록 수를 계산하십시오.

when 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

각 행의 첫 번째 요소에서 시작하는 래핑 대각선을 수집하여 결국 배열의 모든 대각선을 누적합니다.

Wolfram Language (Mathematica) , 99 98 96 94 83 바이트

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.

APL + WIN, 69 바이트

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 형식의 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

온라인으로 사용해보십시오! Dyalog Classic 제공

설명:

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

펄 5, 89 82 바이트

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

TIO

TSQL, 140 128 바이트

12 명의 캐릭터를 골프로 치는 방법을 찾았습니다. 이것은 더 이상 가장 긴 솔루션이 아닙니다.

골프 :

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

언 골프 드 :

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

사용해보십시오