重複しない行列和

長さnのk個の配列が与えられた場合、各配列の1つの要素を使用して可能な最大合計を出力し、2つの要素が同じインデックスにないようにします。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に「メイン対角線の合計」ビルトインがあることを指摘しました。これらのいずれかがあるとは思っていませんでした。Æṭ、「トレース」として定義されていますが、トレースは正方行列に対してのみ定義されています。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適用されます。ここでは、連続する列を抑制して「マイナー」を取得するため、の下の行（またはtail ）を転置してから、それらのアウトフィックスの転置を再帰します。uyxy|:}.y

Pythonの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に感謝します。

以前のソリューション（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.

例

2つのインデックスが対応しないように、それぞれから正確に1つのインデックスを選択する必要があります。したがって、行の長さの範囲を生成し、重複のない範囲のみを保持して、次の組み合わせを生成します（各組み合わせは、スペースを節約するために行ではなく列です）。

次に、プログラムは、組み合わせの各要素を使用して入力リストのインデックスを作成し、以下を返します。

$9$

JavaScript（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.

Haskell、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)はリストを取り、positionの要素を削除しますi。

この関数fはe、位置iにある可能性のある各要素を取得iし、残りの要素から位置にある要素を削除eし、再帰的に計算された最適値に追加します。

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

そして、空のリストのベースケースはちょうど0です：

f _=0

Brachylog、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

Perl 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

Haskell、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

Haskell、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回答のポートです。必ず投票してください！

オンラインそれを試してみたり、すべてのテストケースを確認してください。

説明：

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