Definición

Dada una matriz de enteros no negativos y un entero no negativo , definimos como la función de "corte" que elimina todas las filas y todas las columnas en que contienen .$M$$k$$F_k$$M$$k$

Ejemplo:

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

Tu tarea

Dada $M$ y una suma de destino $S$ , su tarea es encontrar todos los valores posibles de $k$ tal que la suma de los elementos restantes en $F_k(M)$ es igual a $S$ .

Ejemplo:

Dada la matriz anterior $M$ y $S=9$ :

• $k=5$ es una solución, porque $F_5(M)=\pmatrix{1&2\\6&0}$ y $1+2+6+0=9$
• $k=1$ es la única otra solución posible: $F_1(M)=\pmatrix{5\\4}$ y $5+4=9$

Entonces el resultado esperado sería $\{1,5\}$ .

Aclaraciones y reglas.

• La entrada está garantizada para admitir al menos una solución.
• La suma de los elementos de la matriz original se garantiza que sea mayor que $S$ .
• Puede suponer $S>0$ . Significa que una matriz vacía nunca conducirá a una solución.
• Los valores de $k$ pueden imprimirse o devolverse en cualquier orden y en cualquier formato razonable y sin ambigüedades.
• Se le permite no deduplicar la salida (por ejemplo, o se consideran respuestas válidas para el ejemplo anterior).[ 1 , 5 , 1 , 5 $[1,1,5,5]$$[1,5,1,5]$
• Este es el código de golf .

Casos de prueba

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 bytes

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

Pruébalo en línea!

gracias @ Adám por esta explicación :

{... }función, xes M y yes S

 ,/x aplanar M (estos son los k candidatos)

 a: asignar a a

 x{... }/: aplique la siguiente función a cada uno mientras usa M como argumento izquierdo fijo ( x):

  x=y Matriz booleana que indica dónde los elementos de M son iguales al candidato k actual

  ~ negar eso

  b: asignar eso a b

  &/ Reducción AND (encuentra columnas sin esa k )

  (... )&\: Y eso con cada uno de los siguientes:

   &/'b Y reducción de cada uno (encuentra filas sin esa k )

  x* multiplicar M por eso

  +// gran suma

 y= lista de booleanos que indica dónde S es igual a esas sumas

 & índices de Verdades

 a@ use eso para indexar en los elementos (los k candidatos)

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

-7 gracias a ngn.

Anónimo infijo lambda. Toma S como argumento izquierdo y M como argumento derecho.

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

Pruébalo en línea!

{... } "dfn", ⍺y ⍵son argumentos izquierdo y derecho ( S y M ) respectivamente:

 ⍵[… ] Indice M con las siguientes coordenadas:

  ⊂⍵ encierra M para tratarlo como un elemento único

  ⍵= compare cada elemento (es decir, k candidato) de M con toda esa M

  (… )¨ Aplique la siguiente función tácita a cada uno:

   ∧⌿ reducción Y vertical (encuentra columnas sin ese k candidato)

… ∘.∧ Producto booleano cartesiano con:

    ∧/ reducción horizontal Y (encuentra filas sin ese k candidato)

   ⍵× multiplica M con esa máscara

   +/∘, suma la matriz aplanada

  ⍺= Booleano que indica dónde S es igual a esas sumas

  ⍸ índices donde eso es cierto

R , 78 73 bytes

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

Pruébalo en línea!

No ordena ni deduplica la salida.

Crédito a J.Doe y Giuseppe por -5 bytes.

Jalea , 20 19 17 15 14 bytes

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

Este es un enlace monádico que toma M como argumento y lee S desde STDIN.

Pruébalo en línea!

Cómo funciona

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 bytes

• -2 bytes gracias a BWO
• -7 bytes gracias a Tesseract

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

Verifique todos los casos de prueba .

Explicación

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 bytes

fqvzss.DRsxLTQ-I#TQs

¡Banco de pruebas!

No deduplica.

¿Cómo funciona?

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

Pruébalo en línea!

Perl 6 , 80 74 bytes

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

Pruébalo en línea!

Explicación

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

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

Pruébalo en línea!

Solo después de escribir esta respuesta, vi la de Kevin . Creo que esto es sustancialmente diferente, así que lo publico por separado. Mi intuición dice que el conteo de bytes óptimo es de alrededor de 18, así que tendré que volver a visitar esto y ver qué más puedo hacer. Con el código actual, es imposible escribir un conjunto de pruebas, pero yo mismo he verificado todos los casos de prueba y los resultados son correctos.

Algoritmo de Recorte

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

Después de lo cual se calcula la suma de la matriz resultante.

05AB1E (heredado) , 27 26 bytes

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

No clasifica ni descalifica el resultado.
Solo funciona en el legado (por ahora), porque la suma de cada uno parece estar haciendo algunas cosas extrañas cuando parte de las listas internas son enteros y otras son listas ...

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

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

Jalea , 22 bytes

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

Pruébalo en línea!

-6 bytes usando el enfoque general de la respuesta 05AB1E del Sr. Xcoder.

Carbón , 33 bytes

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

Pruébalo en línea! El enlace es a una versión detallada del código e incluye deduplicación. Explicación:

ＦθＦι⊞υκ

Acoplar la primera matriz de entrada qen la lista predefinida 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

Para cada elemento de la lista, sume la matriz, pero si la fila contiene el elemento, use en 0lugar de su suma, y ​​al sumar filas que no contengan el elemento, si la columna contiene el elemento, use en 0lugar del valor de la columna . Esto es un poco más golfístico que filtrar los elementos, ya que el carbón no puede sumar una lista vacía.

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

Pruébalo en línea!

Explicado:

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

( Corregido y ) Compactado:

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

Y en una versión completamente desarrollada:

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

---

Gracias a los comentarios para resaltar mi error inicial. Tenga en cuenta que esta versión no deduplica la salida.

Es posible deduplicar la salida con 5 bytes más:

% 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