定义

给定非负整数和非负整数的矩阵，我们将定义为“斩波”函数，该函数删除中包含k的所有行和所有列。$M$$k$$F_k$$M$$k$

例：

$$\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}$$

你的任务

鉴于$M$和目标总和$S$，你的任务是找到的所有可能值$k$使得在剩余元素的总和$F_k(M)$等于$S$。

例：

给定上述矩阵$M$和$S=9$：

• $k=5$是一个解决方案，因为$F_5(M)=\pmatrix{1&2\\6&0}$和$1+2+6+0=9$
• $k=1$是唯一可能的其他解决方案：$F_1(M)=\pmatrix{5\\4}$和$5+4=9$

因此，预期输出为$\{1,5\}$。

澄清和规则

• 确保输入至少接受一种解决方案。
• 在原始矩阵中的元素的总和被保证是大于$S$。
• 您可以假设$S>0$。这意味着空矩阵永远不会导致解决方案。
• k的值$k$可以按任何顺序以任何合理，明确的格式打印或返回。
• 你被允许不进行重复数据删除的输出（例如或对于上面的例子被认为是有效的答案）。[ 1 ，5 ，1 ，5 $[1,1,5,5]$$[1,5,1,5]$
• 这是代码高尔夫球。

测试用例

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}

K（ngn / k），39个字节

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

在线尝试！

感谢@Adám的解释：

{… }函数，x是M，y是S

 ,/x 展平M（这是k个候选对象）

 a: 分配给 a

 x{… }/: 在将M用作固定的左参数（x）时，对每个函数应用以下函数：

  x=y 布尔矩阵，表示M的元素等于当前k个候选元素的位置

  ~ 否定那个

  b: 分配给 b

  &/ AND归约（查找没有该k的列）

  (… )&\: 以及以下各项：

   &/'b 每一个的AND归并（查找没有k的行）

  x* 乘中号由

  +// 大笔款项

 y= 布尔值列表，指示S等于这些和

 & 真实指数

 a@ 用它来索引元素（k个候选对象）

APL（Dyalog Unicode），35 33 28 字节^SBCS

-7感谢ngn。

匿名中缀lambda。将S作为左参数，将M作为右参数。

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

在线尝试！

{...... } “DFN”，⍺并⍵在左，右参数（小号和中号分别对应）。

 ⍵[… 用以下坐标] 索引M：

  ⊂⍵ 将M括起来作为一个元素

  ⍵= 比较M的每个元素（即k个候选元素）与整个M

  (…… )¨ 对每个应用以下默认功能：

   ∧⌿ 垂直AND归约（查找没有该k个候选对象的列）

… ∘.∧ 具有以下特征的笛卡尔布尔积：

    ∧/ 水平AND归约（查找没有该k个候选对象的行）

   ⍵×用那个面具 乘M

   +/∘, 对扁平矩阵求和

  ⍺= 表示S等于这些和的布尔值

  ⍸ 正确的索引

R，78 73字节

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

在线尝试！

不对输出进行排序或重复数据删除。

将-5个字节记入J.Doe＆Giuseppe。

果冻，20 19 17 15 14字节

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

这是一个单调链接，以M作为参数，并从STDIN 读取S。

在线尝试！

怎么运行的

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.

Haskell，88 86 84 77字节

• -2字节归功于BWO
• -7字节归功于Tesseract

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

验证所有测试用例。

说明

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
            ]
    ]

Pyth， 27 23 22 21  20字节

fqvzss.DRsxLTQ-I#TQs

测试套件！

不重复数据删除。

怎么运行的？

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.

Python 2中，114 108个字节

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]))}

在线尝试！

Perl 6的，80 74个字节

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

在线尝试！

说明

->\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])
      ]
    ]

05AB1E，21字节

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

在线尝试！

我写完这个答案后才看到凯文的。我相信这是完全不同的，因此我将其单独发布。我的直觉说，最佳字节数约为18，因此我将不得不重新考虑一下并看看还能做什么。使用当前代码，不可能编写测试套件，但是我已经亲自验证了所有测试用例，并且结果是正确的。

裁剪算法

$k=5$

$$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$

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

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

$$\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\:$$||$~+

$$\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$

$$\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)$$

之后，计算所得矩阵的总和。

05AB1E（旧版），27 26 字节

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

不排序也不统一结果。
仅在旧版中有效（目前），因为当部分内部列表是整数而其他内部列表时，sum-each似乎在做一些奇怪的事情。

在线尝试或验证所有测试用例。

说明：

˜              # 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

果冻，22字节

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

在线尝试！

使用Xcoder先生的05AB1E回答中的一般方法来获得-6个字节。

木炭，33字节

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

在线尝试！链接是冗长的代码版本，包括重复数据删除。说明：

ＦθＦι⊞υκ

将第一个输入数组展平q到预定义列表中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

对于列表中的每个元素，对数组求和，但是如果该行包含该元素，则使用0而不是其总和；当对不包含该元素的行求和时，如果该列包含该元素，则使用0而不是该列的值。这比过滤掉元素要稍微有点高尔夫球手，因为木炭不能汇总一个空列表。

干净，92字节

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]

在线尝试！

解释：

$ 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`
 ]

MATLAB-80个字节

（已更正和）压缩：

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

在完整开发的版本中：

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

---

多亏了评论来突出我最初的错误。请注意，此版本不会删除输出重复数据。

可以使用另外5个字节对输出进行重复数据删除：

% 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