Definition

Bei einer Matrix aus nicht negativen ganzen Zahlen und einer nicht negativen ganzen Zahl definieren wir als die Funktion "Abhacken", die alle Zeilen und Spalten in , die enthalten . $M$ $k$ $F_k$ $M$ $k$

Beispiel:

\begin{aligned} M = (\begin{matrix} 6 & 1 & 5 \\ 1 & 2 & 8 \\ 9 & 8 & 5 \\ 6 & 0 & 4 \end{matrix}) \\ F_{5} (M) = (\begin{matrix} 1 & 2 \\ 6 & 0 \end{matrix}) \end{aligned}

$\begin{align}M=\pmatrix{\color{red}6&\color{red}1&\color{white}{\bbox[red,1pt]{5}}\\1&2&\color{red}8\\\color{red}9&\color{red}8&\color{white}{\bbox[red,1pt]{5}}\\6&0&\color{red}4}\\\\F_5(M)=\pmatrix{1&2\\6&0}\end{align}$

Deine Aufgabe

Bei gegebenem und einer Zielsumme besteht Ihre Aufgabe darin, alle möglichen Werte von so zu finden, dass die Summe der verbleibenden Elemente in gleich . $M$ $S$ $k$ $F_k(M)$ $S$

Beispiel:

Ausgehend von der obigen Matrix und : $M$ $S=9$

$k=5$ ist eine Lösung, weil und $F_5(M)=\pmatrix{1&2\\6&0}$ $1+2+6+0=9$
$k=1$ ist die einzig mögliche Lösung: und $F_1(M)=\pmatrix{5\\4}$ $5+4=9$

Die erwartete Ausgabe wäre also $\{1,5\}$ .

Erläuterungen und Regeln

Die Eingabe lässt garantiert mindestens eine Lösung zu.
Die Summe der Elemente in der ursprünglichen Matrix gewährleistet ist als größer ist $S$ .
Sie können annehmen $S>0$ . Dies bedeutet, dass eine leere Matrix niemals zu einer Lösung führt.
Die Werte von $k$ können in beliebiger Reihenfolge und in einem angemessenen, eindeutigen Format ausgedruckt oder zurückgegeben werden.
Sie dürfen die Ausgabe nicht (zB oder gelten als gültige Antworten für das obige Beispiel). $[1,1,5,5]$ $[1,5,1,5]$
Das ist Code-Golf .

Testfälle

M = [[6,1,5],[1,2,8],[9,8,5],[6,0,4]]
S = 9
Solution = {1,5}

M = [[7,2],[1,4]]
S = 7
Solution = {4}

M = [[12,5,2,3],[17,11,18,8]]
S = 43
Solution = {5}

M = [[7,12],[10,5],[0,13]]
S = 17
Solution = {0,13}

M = [[1,1,0,1],[2,0,0,2],[2,0,1,0]]
S = 1
Solution = {2}

M = [[57,8,33,84],[84,78,19,14],[43,14,81,30]]
S = 236
Solution = {19,43,57}

M = [[2,5,8],[3,5,8],[10,8,5],[10,6,7],[10,6,4]]
S = 49
Solution = {2,3,4,7}

M = [[5,4,0],[3,0,4],[8,2,2]]
S = 8
Solution = {0,2,3,4,5,8}

code-golf array-manipulation matrix

— Arnauld
quelle

Wäre die Beibehaltung der ursprünglichen Struktur des Eingabearrays (z. B. [[1,5],[1],[5],[]]für den ersten Testfall) ein gültiges Mittel zur Ausgabe?

— Shaggy

@ Shaggy Ja. Das sieht vernünftig aus.

— Arnauld

10

K (ngn / k) , 39 Bytes

{a@&y=x{+//x*(&/'b)&\:&/b:~x=y}/:a:,/x}

Probieren Sie es online!

danke @ Adám für diese Erklärung :

{… }Funktion xist M und yist S

,/xM abflachen (das sind die k Kandidaten)

a: zuweisen a

x{... }/: gelten für jeden die folgende Funktion bei der Verwendung von M als festem linkem Argument ( x):

x=y Boolesche Matrix, die angibt, wo Elemente von M gleich dem aktuellen k- Kandidaten sind

~ negiere das

b: weise das zu b

&/ AND-Reduktion (findet Spalten ohne das k )

(… )&\: UND das mit jedem der folgenden:

&/'b UND-Reduktion von jedem (findet Zeilen ohne das k )

x* multiplizieren Sie M damit

+// Gesamtsumme

y= Liste der Booleschen Werte, die angeben, wo S diesen Summen entspricht

& Indizes der Wahrheiten

a@ benutze das, um die Elemente zu indizieren (die k Kandidaten)

— ngn
quelle

Fühlen Sie sich frei, um die Erklärung zu korrigieren.

— Adám

Die Gefahren der Copy-Paste-Erklärung…

— Adám

6

APL (Dyalog Unicode) , 35 33 28 Byte ^SBCS

-7 danke an ngn.

Anonymes Infix Lambda. Nimmt S als linkes Argument und M als rechtes Argument.

{⍵[⍸⍺=(+/∘,⍵×∧/∘.∧∧⌿)¨⍵≠⊂⍵]}

Probieren Sie es online!

{... } "dfn" ⍺und ⍵sind jeweils linke und rechte Argumente ( S und M ):

⍵[… ] Index M mit folgenden Koordinaten:

⊂⍵ Füge M hinzu , um es als einzelnes Element zu behandeln

⍵= vergleiche jedes Element (dh k Kandidat) von M mit dem gesamten M

(… )¨ Wenden auf jede folgende stillschweigende Funktion an:

∧⌿ vertikale UND-Reduktion (findet Spalten ohne diesen k Kandidaten)

… ∘.∧ Kartesisches Boolesches Produkt mit:

∧/ horizontale UND-Reduktion (findet Zeilen ohne diesen k Kandidaten)

⍵× multipliziere M mit dieser Maske

+/∘, summiere die abgeflachte Matrix

⍺= Boolescher Wert, der angibt, wo S diesen Summen entspricht

⍸ Indizes, wo das stimmt

— Adam
quelle

1

{M[⍸⍺={+/,(∧⌿d)/M⌿⍨∧/d←M≠⍵}¨M←⍵]}

— ngn

@ngn Danke. Ich werde die globale Methode jedoch nicht verwenden, da die Reihenfolge der Auswertung dadurch verwirrend wird: - Wie können Sie sie indizieren, Mwenn sie noch nicht erstellt wurde?

— Adám

vorbei ⍵wie ⍺in der inneren dfn ist für mich genauso verwirrend

— ngn

{⍵[⍸⍺=+/¨(,⍵×∧/∘.∧∧⌿)¨⍵≠⊂⍵]}

— 5.

@ngn Ja, ich wollte sowas machen. Vielen Dank!

— Adám

6

R , 78 73 Bytes

function(m,s)m[Map(function(y)sum(m[(w=-which(m==y,T))[,1],w[,2]]),m)==s]

Probieren Sie es online!

Sortiert oder dedupliziert die Ausgabe nicht.

Gutschrift an J.Doe & Giuseppe für -5 Bytes.

— Kirill L.
quelle

4

76 Bytes

— J.Doe

4

@ J.Doe 73 Bytes

— Giuseppe

5

Jelly , 20 19 17 15 14 Bytes

pZnⱮFȦ€€ḋFẹƓịF

Dies ist eine monadische Verknüpfung, die M als Argument verwendet und S aus STDIN liest .

Probieren Sie es online!

Wie es funktioniert

pZnⱮFȦ€€ḋFẹƓịF  Main link. Argument: M

 Z              Zip; transpose the rows and columns of M.
p               Take the Cartesian product of M and its transpose, yielding all pairs
                (r, c) of rows and columns of M.
    F           Flatten; yield the elements of M.
  nⱮ            Not equal map; for each element e of M, compare the elements of the
                pairs (r, c) with e.
     Ȧ€€        All each each; for each array of Booleans corresponding to an (r, c)
                pair, test if all of them are true.
         F      Flatten; yield the elements of M.
        ḋ       Take the dot product of each list of resulting Booleans and the
                elements of M.
           Ɠ    Read an integer S from STDIN.
          ẹ     Find all indices of S in the dot products.
             F  Flatten; yield the elements of M.
            ị   Retrieve the elements of the right at the indices from the left.

— Dennis
quelle

— Markieren Sie

5

Haskell , 88 86 84 77 Bytes

-2 Bytes dank BWO
-7 Bytes dank Tesseract

m!s=[k|k<-m>>=id,s==sum[x|r<-m,all(/=k)r,(i,x)<-zip[0..]r,all((/=k).(!!i))m]]

Überprüfen Sie alle Testfälle .

Erläuterung

m ! s =                                         -- function !, taking m and s as input
    [k |                                        -- the list of all k's such that
        k <- m >>= id,                          -- * k is an entry of m
        s == sum                                -- * s equals the sum of
            [x |                                --     the list of x's such that
                r <- m,                         --     * r is a row of m
                all (/= k) r,                   --     * r does not contain k
                (i, x) <- zip [0 ..] r,         --     * i is a valid column index; also let x = r[i]
                all ((/= k) . (!! i)) m         --     * none of the rows contain k at index i
            ]
    ]

— Delfad0r
quelle

Sollte das "Funktion f" sagen?

— Quintec

1

@Quintec Eigentlich hätte es gehen sollen, aber ich habe es auf "Funktion!" Geändert. 2 Bytes dank BWO

— Delfad0r

5

Pyth , 27 23 22 21 20 Bytes

fqvzss.DRsxLTQ-I#TQs

Testsuite!

Dedupliziert nicht.

Wie es funktioniert?

fqvzss.DRsxLTQ-I#TQs     Full program.
f                  s     Flatten M and keep only those elements T which satisfy:
 qvzss.DRsxLTQ-I#TQ      The filtering function. Breakdown:
              -I#TQ      Discard the rows that contain T. More elaborate explanation:
                # Q         |-> In M, keep only those elements that are...
               I            |-> Invariant under (equal to themselves after...)
              -  T          |-> Removing T.
                         Let's call the result of this expression CR (chopped rows).
          xLTQ           Map over the rows M and retrieve all indices of T.
         s               Collect indices in 1D list (flatten). Call this I.
      .DR                For each row left in CR, remove the elements at indices in I.
    ss                   Sum all the elements of this matrix flattened.
 qvz                     And then finally check whether they equal S.

— Mr. Xcoder
quelle

4

Python 2 , 114 108 Bytes

lambda m,s:{a for a in sum(m,[])if s==sum(v for l in m for i,v in enumerate(l)if{a}-set(l)-set(zip(*m)[i]))}

Probieren Sie es online!

— TFeld
quelle

4

Perl 6 , 80 74 Bytes

->\m,\s{grep {s==sum m[m.$_;[[Z](m).$_]]}o{*.grep(:k,!*.grep($_))},m[*;*]}

Probieren Sie es online!

Erläuterung

->\m,\s{...}  # Anonymous block taking arguments m and s
  grep {...}o{...},m[*;*]   # Filter matrix elements
                            # with combination of two functions
    *.grep(:k,!*.grep($_))  # (1) Whatever code returning matching rows
    s==sum m[               # (2) s equals sum of elements
      m.$_;                 #     in matched rows
      [                     #     (array supporting multiple iterations)
       [Z](m).$_            #     and matched columns (matched rows
                            #     of m transposed with [Z])
      ]
    ]

— nwellnhof
quelle

3

05AB1E , 21 Bytes

²˜ʒQεZ+}øεZ<~}ø_*OO¹Q

Probieren Sie es online!

Erst nachdem ich diese Antwort geschrieben habe, habe ich Kevin gesehen . Ich bin der Meinung, dass dies wesentlich anders ist, daher poste ich es separat. Meiner Intuition nach liegt die optimale Byteanzahl bei 18, daher muss ich das noch einmal überprüfen und sehen, was ich sonst noch tun kann. Mit dem aktuellen Code ist es nicht möglich, eine Testsuite zu schreiben, aber ich habe alle Testfälle selbst überprüft und die Ergebnisse sind korrekt.

Algorithmus zum Zuschneiden

$k=5$

M = (\begin{matrix} 6 & 1 & 5 \\ 1 & 2 & 8 \\ 9 & 8 & 5 \\ 6 & 0 & 4 \end{matrix})

$M=\left(\begin{matrix}6&1&\bbox[green,1pt]{\color{white}{5}}\\1&2&8\\9&8&\bbox[green,1pt]{\color{white}{5}}\\6&0&4\end{matrix}\right)$

$k$

(\begin{matrix} 0 & 0 & 1 \\ 0 & 0 & 0 \\ 0 & 0 & 1 \\ 0 & 0 & 0 \end{matrix})

$\left(\begin{matrix}0&0&1\\0&0&0\\0&0&1\\0&0&0\end{matrix}\right)$

$M$ $R$ $\max(R)$ $R$

(\begin{matrix} 1 & 1 & 2 \\ 0 & 0 & 0 \\ 1 & 1 & 2 \\ 0 & 0 & 0 \end{matrix})

$\left(\begin{matrix}\color{green}{1}&\color{green}{1}&\bbox[green,1pt]{\color{white}{2}}\\0&0&0\\\color{green}{1}&\color{green}{1}&\bbox[green,1pt]{\color{white}{2}}\\0&0&0\end{matrix}\right)$

$M$ $C$ $(\max(C)-1)\space ||\space c\space\forall\space c\in C\:$ $||$ ~+

(\begin{matrix} 1 & 1 & 3 \\ 0 & 0 & 1 \\ 1 & 1 & 3 \\ 0 & 0 & 1 \end{matrix})

$\left(\begin{matrix}\color{green}{1}&\color{green}{1}&\bbox[green,1pt]{\color{white}{3}}\\0&0&\color{green}{1}\\\color{green}{1}&\color{green}{1}&\bbox[green,1pt]{\color{white}{3}}\\0&0&\color{green}{1}\end{matrix}\right)$

$0$ $1$ $0$ $M$

(\begin{matrix} 0 & 0 & 0 \\ 1 & 1 & 0 \\ 0 & 0 & 0 \\ 1 & 1 & 0 \end{matrix}) ⟶ (\begin{matrix} 0 & 0 & 0 \\ 1 & 2 & 0 \\ 0 & 0 & 0 \\ 6 & 0 & 0 \end{matrix})

$\left(\begin{matrix}\color{green}{0}&\color{green}{0}&\color{green}{0}\\1&1&\color{green}{0}\\\color{green}{0}&\color{green}{0}&\color{green}{0}\\1&1&\color{green}{0}\end{matrix}\right)\:\longrightarrow\:\left(\begin{matrix}\color{green}{0}&\color{green}{0}&\color{green}{0}\\1&2&\color{green}{0}\\\color{green}{0}&\color{green}{0}&\color{green}{0}\\6&0&\color{green}{0}\end{matrix}\right)$

Danach wird die Summe der resultierenden Matrix berechnet.

— Mr. Xcoder
quelle

1

Gute Antwort! Ich wusste, dass meins mit Sicherheit Golf spielen würde. Ich war schon froh, dass es funktionierte, einschließlich des nervigen Falls, der [[1,1,0,1],[2,0,0,2],[2,0,1,0]]mich für die Nummer vermasselt hat1 (der jede Spalte entfernt ..). Ich hatte in der Tat etwas unter 20 in meinem Kopf sowie die Möglichkeit. Schade, dass es trotz der kürzlich hinzugefügten Produkte kaum eingebaute Matrizen gibt. Der Grund für die 1|2( 1 2~in 05AB1E-Synthax) resultierende 3 ist, dass sich die logical ORwie eine verhält, binary ORwenn andere Zahlen als 0/ 1beteiligt sind (ich denke / nehme an).

— Kevin Cruijssen

@ KevinCruijssen Oh du hast recht! Dann sollten die Dokumente bitweise ODER schreiben , nicht logisches ODER . Ich werde das bald korrigieren müssen. Wie auch immer, bitweises ODER sollte funktionieren, denke ich. Es kann durch +sowieso ersetzt werden, also hoffe ich, dass es keine Probleme damit gibt :)

— Mr. Xcoder

2

05AB1E (Legacy) , 27 - 26 Byte

˜ʒ©¹ε®å_}¹ζʒ®å_}ζ‚ζ€€OPOIQ

Sortiert oder vereinheitlicht das Ergebnis nicht.
Funktioniert (vorerst) nur im Legacy, da sum-each seltsame Dinge zu tun scheint, wenn ein Teil der inneren Listen Ganzzahlen und ein anderer Teil Listen sind.

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

Erläuterung:

˜              # Flatten the (implicit) matrix-input
               #  i.e. [[6,1,5],[1,2,8],[9,8,5],[6,0,4]] → [6,1,5,1,2,8,9,8,5,6,0,4]
 ʒ             # Filter this list by:
  ©            #  Store the current value in a register-variable
   ¹           #  Take the matrix-input
    ε   }      #  Map it to:
     ®å_       #   0 if the current number is in this row, 1 if not
               #    i.e. [[6,1,5],[1,2,8],[9,8,5],[6,0,4]] and 6 → [0,1,1,0]
   ¹           #  Take the matrix-input again
    ζ          #  Swap its rows and columns
               #   i.e. [[6,1,5],[1,2,8],[9,8,5],[6,0,4]] → [[6,1,9,6],[1,2,8,0],[5,8,5,4]]
     ʒ   }     #  Filter it by:
      ®å_      #   Only keep the inner lists that does not contain the current number
               #    i.e. [[6,1,9,6],[1,2,8,0],[5,8,5,4]] and 6 → [[1,2,8,0],[5,8,5,4]]
               #    i.e. [[1,2,2],[1,0,0],[0,0,1],[1,2,0]] and 1 → []
          ζ    #  After filtering, swap it's rows and columns back again
               #   i.e. [[1,2,8,0],[5,8,5,4]] → [[1,5],[2,8],[8,5],[0,4]]
   ‚ζ          #  Pair both lists together and zip them
               #   i.e. [0,1,1,0] and [[1,5],[2,8],[8,5],[0,4]]
               #    → [[0,[1,5]],[1,[2,8]],[1,[8,5]],[0,[0,4]]]
               #   i.e. [0,1,0] and [] → [[0,' '],[1,' '],[0,' ']]
     €         #  Map each inner list / value to:
      €O       #   Sum each
               #    i.e. [[0,[1,5]],[1,[2,8]],[1,[8,5]],[0,[0,4]]]
               #     → [[0,6],[1,10],[1,13],[0,4]]
               #    i.e. [[0,' '],[1,' '],[0,' ']]
               #     → [[0,0],[1,0],[0,0]]
               #  (NOTE: For most test cases just `O` instead of `€€O` would be enough,
               #   but not if we removed ALL zipped inner lists for a number, like the 
               #   second example above with input [[1,1,0,1],[2,0,0,2],[2,0,1,0]] and 1)
        P      #  Now take the product of each inner list
               #   i.e. [[0,6],[1,10],[1,13],[0,4]] → [0,10,13,0]
         O     #  Then take the sum of those
               #   i.e. [0,10,13,0] → 23
          IQ   #  And only keep those that are equal to the number-input
               #   i.e. 23 and 9 → 0 (falsey), so it's removed from the flattened input

— Kevin Cruijssen
quelle

1

Jelly , 22 Bytes

=+Ṁ$€Z$⁺’¬×⁸FS
F³ç=⁹ƲƇ

Probieren Sie es online!

-6 Bytes unter Verwendung des allgemeinen Ansatzes aus der 05AB1E-Antwort von Herrn Xcoder.

— HyperNeutrino
quelle

1

Holzkohle , 33 Bytes

ＦθＦι⊞υκＩΦυ⁼ηΣＥθ∧¬№λιΣＥλ∧¬№Ｅθ§πξιν

Probieren Sie es online!Der Link ist eine ausführliche Version des Codes und enthält die Deduplizierung. Erläuterung:

ＦθＦι⊞υκ

Reduzieren Sie das erste Eingabearray q in die vordefinierte Liste u.

  υ                          Flattened array
 Φ                           Filter elements
       θ                     Input array
      Ｅ                      Map over rows
            ι                Current element
           λ                 Current row
          №                  Count matching elements
         ¬                   Logical Not
        ∧                    Logical And
               λ             Current row
              Ｅ              Map over columns
                    θ        Input array
                   Ｅ         Map over rows
                      π      Inner row
                       ξ     Column index
                     §       Inner element
                        ι    Current element
                  №          Count matching elements
                 ¬           Logical Not
                ∧            Logical And
                         ν   Current element
             Σ               Sum
     Σ                       Sum
    η                        Second input
   ⁼                         Equals
Ｉ                            Cast to string
                             Implicitly print each result on its own line

Summieren Sie für jedes Element der Liste das Array, aber wenn die Zeile das Element enthält, verwenden Sie 0anstelle der Summe, und wenn Sie Zeilen summieren, die das Element nicht enthalten, verwenden Sie 0anstelle des Spaltenwerts , wenn die Spalte das Element enthält . Dies ist ein bisschen besser als das Herausfiltern von Elementen, da Charcoal keine leere Liste zusammenfassen kann.

— Neil
quelle

1

Sauber , 92 Bytes

import StdEnv
$m s=[c\\r<-m,c<-r|sum[b\\a<-m|all((<>)c)a,b<-a&x<-[0..]|all(\u=u!!x<>c)m]==s]

Probieren Sie es online!

Erklärt:

$ m s                       // the function $ of `m` and `s`
 = [                        // is equal to
  c                         // the value `c`
  \\ r <- m                 // for every row `r` in `m`
  , c <- r                  // for every value `c` in `r`
  | sum [                   // where the sum of
   b                        // the value `b`
   \\ a <- m                // for every row `a` in `m`
   | all ((<>)c) a          // where `c` isn't in `a`
   , b <- a                 // for every value `b` in `a`
   & x <- [0..]             // with every column index `x` from zero
   | all (\u = u!!x <> c) m // where `c` isn't in column `x`
  ] == s                    // equals `s`
 ]

— Οurous
quelle

1

MATLAB - 80 Bytes

( Korrigiert und ) Verdichtet:

function f(M,s);for k=M(:)';if sum(sum(M(~sum(M==k,2),~sum(M==k))))==s;k,end;end

Und in einer voll entwickelten Version:

function getthesum(M,s)

for k=M(:)'                         % For each element of M
    x = M==k ;                      % Index elements equal to "k"
    N = M( ~sum(x,2) , ~sum(x) ) ;  % New matrix with only the appropriate rows/columns
    if sum(sum(N))==s               % sum rows and columns and compare to "s"
        k                           % display "k" in console if "k" is valid
    end
end

Vielen Dank an die Kommentare, um meinen anfänglichen Fehler hervorzuheben. Beachten Sie, dass diese Version die Ausgabe nicht dupliziert.

Es ist möglich, die Ausgabe mit 5 weiteren Bytes zu deduplizieren:

% This will only cycle through the unique elements of 'M' (85 bytes):

function f(M,s);for k=unique(M)';if sum(sum(M(~sum(M==k,2),~sum(M==k))))==s;k,end;end

— Hoki
quelle

1

k könnte ein beliebiges Element der Matrix sein.

— Dennis

@ Tennis, hoppla, das stimmt ... Mein Schlimmes, ich korrigiere es später heute. Vielen Dank für den Hinweis.

— Hoki

1

@Arnauld. Sorry ich war im Urlaub, dass es jetzt behoben ist.

— Hoki

Schneiden Sie die Matrix ab, um die gewünschte Summe zu erhalten

Definition

Deine Aufgabe

Erläuterungen und Regeln

Testfälle

K (ngn / k) , 39 Bytes

APL (Dyalog Unicode) , 35 33 28 Byte SBCS

R , 78 73 Bytes

Jelly , 20 19 17 15 14 Bytes

Wie es funktioniert

Haskell , 88 86 84 77 Bytes

Erläuterung

Pyth , 27 23 22 21 20 Bytes

Wie es funktioniert?

Python 2 , 114 108 Bytes

Perl 6 , 80 74 Bytes

Erläuterung

05AB1E , 21 Bytes

Algorithmus zum Zuschneiden

05AB1E (Legacy) , 27 - 26 Byte

Jelly , 22 Bytes

Holzkohle , 33 Bytes

Sauber , 92 Bytes

MATLAB - 80 Bytes

APL (Dyalog Unicode) , 35 33 28 Byte ^SBCS