Ma trận tổng không chồng chéo

Cho k mảng có độ dài n , xuất tổng số tối đa có thể bằng cách sử dụng một phần tử từ mỗi mảng sao cho không có hai phần tử nào từ cùng một chỉ mục. Nó được đảm bảo rằng k <= n.

Đầu vào

Một danh sách không trống của các mảng không trống của số nguyên.

Đầu ra

Một số nguyên biểu thị tổng tối đa.

Ví dụ

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

Thạch , 10 6 byte

ZŒ!ÆṭṀ

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

(4 byte cứu bởi @Dennis, người đã chỉ ra rằng Jelly đã có một "tổng của chính chéo" BUILTIN tôi. Không mong đợi nó để có một trong những; các giải pháp trước đây thực hiện các hoạt động mà không sử dụng được xây dựng trong Các hoạt động trong câu hỏi,. Æṭ, được định nghĩa là "dấu vết", nhưng dấu vết chỉ được xác định cho ma trận vuông; Jelly cũng thực hiện khái quát hóa cho ma trận hình chữ nhật.)

Sự cải thiện so với các câu trả lời khác chủ yếu là từ thuật toán đơn giản hơn (do đó khó hiểu hơn); chương trình này ban đầu được viết bằng Brachylog v2 ( {\p\iᶠ∋₎ᵐ+}ᶠot), nhưng Jelly có một số nội dung cho các phần của chương trình phải được đánh vần trong Brachylog, vì vậy điều này xuất hiện ngắn hơn.

Giải trình

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

Cần phải rõ ràng rằng đối với bất kỳ giải pháp nào cho vấn đề, chúng ta có thể hoán vị các cột của ma trận gốc để đưa giải pháp đó lên đường chéo chính. Vì vậy, giải pháp này chỉ đơn giản là đảo ngược điều đó, tìm tất cả các đường chéo chính có thể của hoán vị.

Lưu ý rằng thao tác "hoán vị các cột" được thực hiện dưới dạng "hoán vị, hoán vị các hàng" mà không cần chuyển đổi trở lại; phần còn lại của thuật toán xảy ra đối xứng về đường chéo chính, vì vậy chúng ta không cần hoàn tác chuyển vị và do đó có thể tiết kiệm một byte.

J , 28 byte

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

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

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

Ở đây, cuộc gọi đệ quy được thực hiện bằng cách $:biểu thị hàm ẩn danh lớn nhất có chứa nó. Chúng tôi may mắn ở J có được tính nguyên thủy x u\. y, áp dụng ucho các "tiền tố" kế tiếp ycó được bằng cách triệt tiêu các phần tử liên tiếp về độ dài xcủa các mục trong y; ở đây, chúng tôi muốn thay thế các cột liên tiếp để có được "vị thành niên", vì vậy chúng tôi hoán chuyển |:các hàng thấp hơn (hoặc đuôi }.) của y, và sau đó lặp lại trên chuyển vị của các tiền tố của chúng.

Python 3 , 94 90 89 84 80 byte

^{-4 byte nhờ xnor (sử dụng bộ thay vì danh sách)!}

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

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

Husk , 12 11 9 byte

▲mȯΣ►L∂PT

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

Cảm ơn BMO đã đề xuất một cổng câu trả lời của ais523 và lưu 2 byte, mà tôi đã cố gắng cải thiện hơn nữa, và đến lượt BMO đã loại bỏ thêm 2 byte.

Giải pháp trước đó (14 byte)

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

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

Tôi không thể tạo một bộ kiểm tra vì câu trả lời này sử dụng lệnh đối số dòng lệnh đầu tiên một cách rõ ràng. Nhưng Husk hoàn toàn không sử dụng STDIN nên tôi đã bao gồm tất cả các trường hợp thử nghiệm ở đó, vì vậy bạn chỉ có thể sao chép dán vào trường đối số để kiểm tra. Cũng lưu ý rằng các mảng trong Husk có thể không chứa khoảng trắng giữa các phần tử trong khi được nhập vào.

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

Sự cố mã

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

Thí dụ

Người ta phải chọn chính xác một chỉ mục từ mỗi chỉ số sao cho không có hai chỉ số tương ứng. Vì vậy, chúng tôi tạo phạm vi độ dài của các hàng và chỉ giữ những khoảng không trùng lặp, mang lại các kết hợp sau (mỗi kết hợp là một cột thay vì một hàng để tiết kiệm không gian):

Sau đó, chương trình lập chỉ mục trong danh sách đầu vào với từng thành phần của kết hợp, trả về:

$9$

JavaScript (ES6),  74  71 byte

Cảm ơn @tsh vì đã xác định 2 byte vô dụng đã được sử dụng để sửa lỗi
Đã lưu 3 byte nhờ @tsh

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

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

Thạch , 13 12 byte

ẈŒpQƑƇị"€¹§Ṁ

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

Phiên bản thay thế, 11 byte

ZLœ!Lị"€¹§Ṁ

Điều này sử dụng tích hợp mới được thêm œ!vào, tạo ra tất cả các hoán vị có độ dài nhất định.

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

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

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

Haskell , 65 byte

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

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

Giải thích & Ungolfed

Hàm take i<>drop(i+1)lấy một danh sách và loại bỏ phần tử tại vị trí i.

Hàm flấy từng phần tử có thể etại vị trí i, loại bỏ các phần tử tại vị trí ikhỏi các phần tử còn lại và thêm evào tối ưu tính toán đệ quy:

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

Và trường hợp cơ bản cho danh sách trống chỉ là 0:

f _=0

Brachylog , 18 byte

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

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

Giải trình

                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

Perl 6 , 50 49 byte

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

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

Không lâu, thậm chí mặc dù permutationscuộc gọi dài . Đây là một khối mã ẩn danh nhận danh sách các danh sách và trả về một số.

Giải trình:

{                                               } # 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 byte

-13 byte nhờ ngn!

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

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

Giải pháp ban đầu:

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

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

Lưu ý: Không hoạt động cho trường hợp thử nghiệm đầu tiên [[1]]

Giải trình:

{ } - chức năng với đối số 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

Haskell , 65 byte

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

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

71 byte

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

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

Các [x|x<-a,y<-a,x==y]==akiểm tra rằng các yếu tố alà khác biệt. Điều này sử dụng một số lượng nhân vật đáng ngạc nhiên, nhưng tôi không thấy một cách ngắn hơn.

Bình thường, 15 12 byte

eSms@VQd.plh

Hãy thử trực tuyến tại đây .

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

Chỉnh sửa: đã lưu 3 byte lịch sự của issacg

05AB1E , 18 13 byte

нgLœε‚øε`è]OZ

Tôi có cảm giác nó quá dài, nhưng tôi không chắc làm thế nào để lập chỉ mục byte hiệu quả trong 05AB1E .. Và tôi thực sự đúng là nó quá dài .. -5 byte nhờ @Emigna .

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

н                # 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)

Chạy ví dụ:

• Đầu vào: [[1,4,2],[5,6,1]]
• Sau bước 1 ( нgL):[1,2,3]
• Sau bước 2 (œ ):[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
• Sau bước 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]]]
• Sau bước 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]]]
• Sau bước 5 ( ε`è]): [[4,1],[4,5],[2,6],[2,5],[1,6],[1,1]](LƯU Ý: 05AB1E được lập chỉ mục 0 (có tự động đóng gói), do đó, lập chỉ mục 3thành [5,6,1]kết quả trong5 .)
• Sau bước 6 ( O):[5,9,8,7,7,2]
• Đầu ra / sau bước 7 ( à):9

Haskell, 84 byte

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

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

Ruby , 74 72 69 byte

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

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

05AB1E , 7 byte

øœ€Å\Oà

Cổng của câu trả lời Jelly CW của @ ais523 , vì vậy hãy đảm bảo nâng cấp nó!

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

ø          # 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)