Nicht überlappende Matrixsumme

Geben Sie bei k Arrays der Länge n die maximal mögliche Summe aus, indem Sie ein Element aus jedem Array verwenden, sodass keine zwei Elemente aus demselben Index stammen. Es ist garantiert, dass k <= n ist.

Eingang

Eine nicht leere Liste von nicht leeren Arrays mit ganzen Zahlen.

Ausgabe

Eine Ganzzahl, die die maximale Summe darstellt.

Beispiele

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

Gelee , 10 6 Bytes

ZŒ!ÆṭṀ

Probieren Sie es online!

(4 Bytes gespart von @Dennis, der darauf hinwies, dass Jelly eine "Summe der Hauptdiagonalen" eingebaut hatte. Ich hatte nicht damit gerechnet, dass es eine davon gibt. Die vorherige Lösung hat die Operation implementiert, ohne die eingebaute zu verwenden. Die fragliche Operation, Æṭ, wird als "trace" definiert, aber der Trace wird nur für quadratische Matrizen definiert; Jelly implementiert auch eine Verallgemeinerung auf rechteckige Matrizen.)

Die Verbesserung gegenüber den anderen Antworten beruht hauptsächlich auf einem einfacheren Algorithmus (der daher genauer ausgedrückt werden kann). Dieses Programm wurde ursprünglich in Brachylog v2 ( {\p\iᶠ∋₎ᵐ+}ᶠot) geschrieben, aber Jelly verfügt über einige integrierte Funktionen für Teile des Programms, die in Brachylog geschrieben werden müssen.

Erläuterung

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

Es sollte klar sein, dass wir für jede Lösung des Problems die Spalten der ursprünglichen Matrix permutieren können, um diese Lösung auf die Hauptdiagonale zu setzen. Diese Lösung kehrt das einfach um und findet alle möglichen Hauptdiagonalen von Permutationen.

Beachten Sie, dass die Operation "Spalten transponieren" als "Zeilen transponieren" ausgeführt wird, ohne sich die Mühe zu machen, zurück zu transponieren. Der Rest des Algorithmus ist zufällig symmetrisch zur Hauptdiagonale, sodass wir die Transponierung nicht rückgängig machen müssen und somit ein Byte sparen können.

J , 28 Bytes

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

Probieren Sie es online!

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

Hier wird der rekursive Aufruf ausgeführt, $:der die größte anonyme Funktion darstellt, die ihn enthält. Wir haben das Glück, in J das Primitive zu haben x u\. y, das für uaufeinanderfolgende "Outfixes" gilt , ydie durch Unterdrücken aufeinanderfolgender Infixe der Länge xder Elemente in erhalten werden y. Hier möchten wir aufeinanderfolgende Spalten unterdrücken, um "Minderjährige" zu erhalten, also transponieren wir |:die unteren Zeilen (oder Endpunkte }.) von yund greifen dann auf die Transponierung ihrer Outfixes zurück.

Python 3 , 94 90 89 84 80 Bytes

^{-4 Bytes dank xnor (mit Mengen anstelle von Listen)!}

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

Probieren Sie es online!

Schale , 12 11 9 Bytes

▲mȯΣ►L∂PT

Probieren Sie es online!

Vielen Dank an BMO , der einen Port für die Antwort von ais523 und eine 2-Byte-Speicherung vorgeschlagen hat, die ich weiter verbessert habe. BMO hat im Gegenzug 2 weitere Bytes gespart.

---

Vorherige Lösung (14 Bytes)

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

Probieren Sie es online!

Ich konnte keine Testsuite erstellen, da in dieser Antwort das erste Befehlszeilenargument explizit verwendet wird. Da Husk jedoch STDIN überhaupt nicht verwendet, habe ich alle Testfälle dort eingefügt. Sie können also zum Auschecken einfach Paste in das Argumentfeld kopieren. Beachten Sie auch, dass Arrays in Husk bei der Eingabe möglicherweise keine Leerzeichen zwischen Elementen enthalten.

Wie es funktioniert?

Code-Aufschlüsselung

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

Beispiel

$$\left(\begin{matrix}1&4&2\\5&6&1\end{matrix}\right)$$

Man muss genau einen Index aus jedem auswählen, so dass keine zwei Indizes übereinstimmen. Wir generieren also die Längenbereiche der Zeilen und behalten nur diese ohne Duplikate bei, was die folgenden Kombinationen ergibt (jede Kombination ist eine Spalte anstelle einer Zeile, um Platz zu sparen):

$$\left(\begin{matrix}\color{red}{1}&\color{blue}{2}&\color{green}{1}&\color{orange}{3}&2&\color{pink}{3}\\\color{red}{2}&\color{blue}{1}&\color{green}{3}&\color{orange}{1}&3&\color{pink}{2}\end{matrix}\right)$$

Anschließend indiziert das Programm jedes Element der Kombination in den Eingabelisten und gibt Folgendes zurück:

$$\left(\begin{matrix} \color{red}{1}&\color{blue}{4}&\color{green}{1}&\color{orange}{2}&4&\color{pink}{2}\\ \color{red}{6}&\color{blue}{5}&\color{green}{1}&\color{orange}{5}&1&\color{pink}{6} \end{matrix}\right)$$

$9$ .

JavaScript (ES6),  74 bis  71 Byte

Vielen Dank an @tsh für die Identifizierung von 2 unnötigen Bytes, mit denen ein Fehler
behoben wurde. 3 Bytes wurden dank @tsh gespeichert

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

Probieren Sie es online!

Jelly , 13-12 Bytes

ẈŒpQƑƇị"€¹§Ṁ

Probieren Sie es online!

Alternative Version, 11 Bytes

ZLœ!Lị"€¹§Ṁ

Dabei wird die neu hinzugefügte Funktion verwendet œ!, die alle Permutationen einer bestimmten Länge generiert.

Probieren Sie es online!

Wie es funktioniert

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

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

Probieren Sie es online!

Erklärung & Ungolfed

Die Funktion erstellt take i<>drop(i+1)eine Liste und entfernt das Element an der Positioni .

Die Funktion fruft jedes mögliche Element ean der Position ab i, entfernt die Elemente an der Position ivon den verbleibenden Elementen und addiert ezum rekursiv berechneten Optimum:

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

Und der Grundfall für die leere Liste ist nur 0:

f _=0

Brachylog , 18 Bytes

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

Probieren Sie es online!

Erläuterung

                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 Bytes

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

Probieren Sie es online!

Anständig kurz, trotz der langen permutations Anrufs. Dies ist ein anonymer Codeblock, der eine Liste von Listen aufnimmt und eine Zahl zurückgibt.

Erläuterung:

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

-13 bytes dank ngn!

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

Probieren Sie es online!

Anfangslösung:

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

Probieren Sie es online!

Hinweis: Funktioniert nicht für den ersten Testfall [[1]]

Erläuterung:

{ } - Funktion mit Argument 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 Bytes

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

Probieren Sie es online!

---

71 Bytes

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

Probieren Sie es online!

Die [x|x<-a,y<-a,x==y]==aÜberprüfungen, die die Elemente von aunterscheiden. Dies verbraucht überraschend viele Zeichen, aber ich habe keinen kürzeren Weg gesehen.

Pyth, 15 12 Bytes

[email protected]

Probieren Sie es hier online aus .

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

Bearbeiten: 3 Bytes mit freundlicher Genehmigung von issacg gespeichert

05AB1E , 18 13 Bytes

нgLœε‚øε`è]OZ

Ich habe das Gefühl , es ist zu lang, aber ich bin nicht sicher , wie vektorisiert Indizierung Byte-effizient in 05AB1E zu tun .. Und ich war in der Tat richtig , dass es zu lange war .. -5 Bytes dank @Emigna .

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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

Beispiellauf:

• Eingang: [[1,4,2],[5,6,1]]
• Nach Schritt 1 ( нgL):[1,2,3]
• Nach Schritt 2 ( œ):[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
• Nach Schritt 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]]]
• Nach Schritt 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]]]
• Nach Schritt 5 ( ε`è]): [[4,1],[4,5],[2,6],[2,5],[1,6],[1,1]](Anmerkung: 05AB1E 0 indexiert (mit automatischer wraparound), so Indexieren 3in [5,6,1]Ergebnisse in5 .)
• Nach Schritt 6 ( O):[5,9,8,7,7,2]
• Ausgabe / nach Schritt 7 ( à):9

Haskell, 84 Bytes

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

Probieren Sie es online!

Ruby , 74 72 69 Bytes

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

Probieren Sie es online!

05AB1E , 7 Bytes

øœ€Å\Oà

Port of @ ais523s Jelly CW-Antwort , also stelle sicher, dass du sie auch positiv bewertest!

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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