겹치지 않는 행렬 합계

길이가 n 인 k 개의 배열이 주어지면 두 개의 요소가 같은 인덱스에 있지 않도록 각 배열에서 하나의 요소를 사용하여 가능한 최대 합계를 출력하십시오. k <= n임을 보장합니다.

입력

비어 있지 않은 정수 배열 목록.

산출

최대 합을 나타내는 정수입니다.

예

Input -> Output
[[1]] -> 1
[[1, 3], [1, 3]] -> 4
[[1, 4, 2], [5, 6, 1]] -> 9
[[-2, -21],[18, 2]] -> 0
[[1, 2, 3], [4, 5, 6], [7, 8, 9]] -> 15
[[1, 2, 3, 4], [5, 4, 3, 2], [6, 2, 7, 1]] -> 16
[[-2, -1], [-1, -2]] -> -2

젤리 , 10 6 바이트

ZŒ!ÆṭṀ

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

(@Dennis가 저장 한 4 바이트는 젤리에 "주된 대각선의 합"이 내장되어 있다고 지적했다. 나는 그 중 하나 가 없을 것으로 예상했다. 이전 솔루션은 내장을 사용하지 않고 연산을 구현했다. Æṭ,는 "추적"으로 정의되지만 추적은 정사각 행렬에 대해서만 정의됩니다. Jelly는 직사각형 행렬에 대한 일반화도 구현합니다.)

다른 답변보다 개선 된 것은 대부분 더 간단한 (따라서 표현하기 쉬운) 알고리즘에서 비롯된 것입니다. 이 프로그램은 원래 Brachylog v2로 작성되었습니다 ({\p\iᶠ∋₎ᵐ+}ᶠot )로 작성되었지만 Jelly는 Brachylog에서 철자를 써야하는 프로그램의 일부를위한 내장 기능을 제공하므로 더 짧아졌습니다.

설명

ZŒ!ÆṭṀ
Z            Swap rows and columns
 Œ!          Find all permutations of rows (thus columns of the original)
   Æṭ        {For each permutation}, take the sum of the main diagonal
     Ṁ       Take the maximum

문제에 대한 해결책에 대해서는 원래 행렬의 열을 치환하여 그 해결책을 주 대각선에 놓을 수 있음을 분명히해야합니다. 따라서이 솔루션은 간단히 그 반대로하여 순열의 가능한 모든 주요 대각선을 찾습니다.

"열 바꾸기"조작은 다시 바꾸지 않고 "행 바꾸기, 행 바꾸기"로 수행됩니다. 나머지 알고리즘은 주 대각선에 대해 대칭이되므로 조옮김을 취소 할 필요가 없으므로 바이트를 절약 할 수 있습니다.

J , 28 바이트

>./@({.+1$:@|:\.|:@}.)@[^:]#

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

 >./ @  (   {.   +         1 $:@|:\. |:@}.       )       @[^:] #
(max of (1st row + recursive call on each "minor")) or count of arg if 0

여기서 재귀 호출은이를 $:포함하는 가장 큰 익명 함수를 나타냅니다. 우리는 원시를 가지고 J에서 운이 x u\. y적용되는, u의 연속 "outfixes"에 y길이의 연속 infixes 억제하여 얻을 수 x있는 항목을 y; 여기서 우리는 "미성년자"를 얻기 위해 연속적인 열을 억압하고 싶기 때문에 |:의 아래쪽 열 (또는 꼬리 }.)을 y바꾼 다음 접두어의 전치를 반복합니다.

파이썬 3 , 94 90 89 84 80 바이트

^{xnor 덕분에 -4 바이트 (목록 대신 세트 사용)!}

f=lambda x,y={-1}:x>[]and max(e+f(x[1:],y|{i})for(i,e)in enumerate(x[0])if{i}-y)

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

껍질 , 12 11 9 바이트

▲mȯΣ►L∂PT

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

ais523의 답변 포트 와 2 바이트 저장 을 제안한 BMO 덕분 에 더 향상시킬 수 있었고 BMO는 2 바이트를 더 줄였습니다.

이전 솔루션 (14 바이트)

▲moΣz!¹fS=uΠmŀ

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

이 답변은 첫 번째 명령 줄 인수를 사용하기 때문에 테스트 스위트를 만들 수 없었습니다. 명령을 명시 적으로 . 그러나 Husk는 STDIN을 전혀 사용하지 않으므로 모든 테스트 사례를 포함 시켰으므로 인수 필드에 붙여 넣기를 복사하여 확인할 수 있습니다. Husk의 배열은 입력되는 동안 요소 사이에 공백을 포함하지 않을 수 있습니다.

어떻게 작동합니까?

코드 분석

▲moΣz!¹fS=uΠmŀ     Full program. Takes a 2D list from CLA 1 and outputs to STDOUT.
            mŀ     Length range of each list. 
           Π       Cartesian product.
       fS=u        Discard those combinations which have at least 1 non-unique element.
 mo                Map over the combinations with the following predicate:
    z!¹            Zip the 2D list input with the current combination and index accordingly.
   Σ               Sum the resulting elements.
▲                  Finally, pick the maximum.

예

두 지수가 일치하지 않도록 각각에서 정확히 하나의 지수를 선택해야합니다. 따라서 행의 길이 범위를 생성하고 중복되지 않은 행만 유지하여 다음 조합을 생성합니다 (각 조합은 공간을 절약하기 위해 행 대신 열입니다).

그런 다음 프로그램은 입력 목록에서 조합의 각 요소를 색인화하여 다음을 리턴합니다.

$9$

자바 스크립트 (ES6),  74  71 바이트

버그를 수정하는 데 사용 된 2 개의 쓸모없는 바이트를 식별 한 @tsh에게
감사합니다. @tsh 덕분에 3 바이트가 절약되었습니다.

f=([a,...r],k,i=1)=>a?Math.max(...a.map(n=>k&(i+=i)?-1/0:n+f(r,k|i))):0

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

젤리 , 13 12 바이트

ẈŒpQƑƇị"€¹§Ṁ

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

대체 버전, 11 바이트

ZLœ!Lị"€¹§Ṁ

새로 추가 된 œ!내장 기능을 사용하여 주어진 길이의 모든 순열을 생성합니다.

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

작동 원리

ẈŒpQƑƇị"€¹§Ṁ  Main link. Argument: M (matrix)

Ẉ             Widths; compute the length of each row.
              For an n×m matrix, this yields an array m copies of n.
 Œp           Cartesian product; promote each n to [1, ..., n], then form all arrays
              that pick one k out of all m copies of [1, ..., n].
   QƑƇ        Comb by fixed unique; keep only arrays that do not change by
              deduplicating their entries.
         ¹    Identity; yield M.
      ị"€     For each of the arrays of unique elements, use its m entries to index
              into the m rows of M.
          §   Take the sums of all resulting vectors.
           Ṁ  Take the maximum.

하스켈 , 65 바이트

f(u:v)=maximum[e+f(take i<>drop(i+1)<$>v)|(i,e)<-zip[0..]u]
f _=0

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

설명 및 언 골프

이 함수 take i<>drop(i+1)는 목록을 가져와 위치에서 요소를 제거합니다 i.

이 함수 f는 가능한 각 요소 e를 position에서 가져오고 나머지 요소 i에서 위치의 요소를 제거 하고 재귀 적으로 계산 된 최적을 i추가 e합니다.

f(u:v)=maximum[e+f(removeElementAt i<$>v)|(i,e)<-zip[0..]u]

빈 목록의 기본 사례는 다음과 0같습니다.

f _=0

근접 , 18 바이트

{hl⟦kp;?z₀∋₍ᵐ+}ᶠot

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

설명

                ot      The output is the biggest result of…
{             }ᶠ        …finding all outputs to the following predicate:
 hl⟦k                     Construct the range [0, …, n-1]
     p                    Take a permutation of that range
      ;?z₀                Zip that permutation with the Input, stopping when all elements of
                            the input are used (important because the range is possibly
                            bigger than the length of the input)
          ∋₍ᵐ             In each element of the zip, take the head'th element of the tail
             +            Sum the result

펄 6 , 50 49 바이트

{max map *.map({.[$++]}).sum,permutations [Z] $_}

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

긴에도 불구하고 상당히 짧음 permutations 전화 . 목록의 목록을 가져와 숫자를 반환하는 익명의 코드 블록입니다.

설명:

{                                               } # Anonymous code block
 max                                              # Finds the maximum
                             permutations         # Of all permutations
                                          [Z] $_  # Of the transposed input
     map                                          # When mapped to
                        .sum # The sum of
         *.map({.[$++]})     # The diagonal of the matrix

K (oK) , 40, 32, 28, 19 바이트

ngn 덕분에 -13 바이트!

{|/+/(prm'x)@''!#x}

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

초기 해결책 :

{|/+/'x./:/:(*t),'/:t:{x~?x}#+!(#x)##*x}

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

참고 : 첫 번째 테스트 사례에서는 작동하지 않습니다. [[1]]

설명:

{ } -인수 기능 x

                                   #     - creata a list
                               (#x)      - with length number of rows of x
                                    #*x  - of the length of the first row
                              !          - odometer (ranged permutations)
                             +           - transpose
                            #            - filter out the rows
                      {x~?x}             - that have duplicates
                    t:                   - save it to t 
                ,'/:                     - pair up each number in each row with
            (*t)                         - a number from the first row
      x./:/:                             - index x with each of the above
   +/'                                   - find the sum of each row
 |/                                      - reduce by max

하스켈 , 65 바이트

([]%)
p%(h:t)=maximum[x+(i:p)%t|(i,x)<-zip[0..]h,all(/=i)p]
p%_=0

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

71 바이트

f m=maximum[sum b|(a,b)<-unzip<$>mapM(zip[0..])m,[x|x<-a,y<-a,x==y]==a]

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

의 [x|x<-a,y<-a,x==y]==a요소 a가 다른지 확인합니다 . 이것은 놀라운 수의 문자를 사용하지만 더 짧은 방법은 보지 못했습니다.

Pyth, 15 12 바이트

eSms@VQd.plh

여기에서 온라인으로 사용해보십시오 .

eSms@VQd.plhQ   Implicit: Q=eval(input())
                Trailing Q inferred
          lhQ   Length of first element of Q
        .p      Generate all permutaions of 0 to the above
  m             Map the elements of the above, as d, using:
    @VQd          Vectorised index into Q using d
                    For i in [0-length(Q)), yield Q[i][d[i]]
   s              Take the sum of the above
 S              Sort the result of the map
e               Take the last element of the above, implicit print

편집 : issacg의 3 바이트 저장

05AB1E , 18 13 바이트

нgLœε‚øε`è]OZ

나는이 긴 지나치게의 느낌,하지만 확실 05AB1E에 갇힌 인덱싱 바이트 효율적으로 수행하는 방법을 모르겠어요 .. 그리고 나는 그것이 너무 오래 ... -5 덕분에 바이트이었다 바로 것을 참이었다 @Emigna .

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 .

설명:

н                # Take the first inner list (of the implicit input list of lists)
 g               # Pop and take its length
  L              # Create a list in the range [1, inner-length]
   œ             # Create each possible permutation of this range-list
    ε            # Map each permutation to:
     ‚           #  Pair it with the (implicit) input
      ø          #  Transpose; swap rows/columns
       ε         #  Map each to:
        `        #   Push both to the stack
         è       #   Index the permutation-nr into the inner list of the input
    ]            # Close both maps
     O           # Take the sum of each inner list
      à          # Pop and push the maximum (and output implicitly)

예제 실행 :

• 입력: [[1,4,2],[5,6,1]]
• 1 단계 ( нgL) 후 :[1,2,3]
• 2 단계 ( œ) 후 :[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
• 3 단계 ( ε‚) 후 :[[[[1,4,2],[5,6,1]],[1,2,3]],[[[1,4,2],[5,6,1]],[1,3,2]],[[[1,4,2],[5,6,1]],[2,1,3]],[[[1,4,2],[5,6,1]],[2,3,1]],[[[1,4,2],[5,6,1]],[3,1,2]],[[[1,4,2],[5,6,1]],[3,2,1]]]
• 4 단계 ( ø) 후 :[[[[1,4,2],1],[[5,6,1],2]],[[[1,4,2],1],[[5,6,1],3]],[[[1,4,2],2],[[5,6,1],1]],[[[1,4,2],2],[[5,6,1],3]],[[[1,4,2],3],[[5,6,1],1]],[[[1,4,2],3],[[5,6,1],2]]]
• 단계 5 (이후 ε`è]:) [[4,1],[4,5],[2,6],[2,5],[1,6],[1,1]](주 : 05AB1E는 0 인덱스 () 자동 순환이 때문에 인덱싱 3으로 [5,6,1]결과5 .)
• 6 단계 ( O) 후 :[5,9,8,7,7,2]
• 7 단계 후 출력 / ( à) :9

하스켈, 84 바이트

import Data.List
h l=maximum[sum$snd<$>r|r<-mapM id$zip[1..]<$>l,(==)=<<nub$fst<$>r]

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

루비 , 74 72 69 바이트

->a{[*0...a[0].size].permutation.map{|x|a.zip(x).sum{|y,z|y[z]}}.max}

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

05AB1E , 7 바이트

øœ€Å\Oà

@ ais523 포트 의 Jelly CW 답변 , 그래서 그것을 upvote해야합니다!

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 .

설명:

ø          # Transpose the (implicit) input; swapping row/columns
 œ         # Get all permutations
  ہ\      # Take the main diagonal of each
     O     # Sum each
      à    # Pop and push the maximum (which is output implicitly)