Визначення

З огляду на матрицю невід’ємних цілих чисел та невід’ємне ціле число , ми визначаємо як функцію «відсікання», яка видаляє всі рядки та всі стовпці що містять .$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$ можуть бути надруковані або повернені в будь-якому порядку та в будь-якому розумному, однозначному форматі.
• Вам дозволяється не результат (наприклад, або вважаються правильними відповідями для вищевказаного прикладу).$[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}

К (нг / к) , 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

  &/ І скорочення (знаходить стовпці без цього k )

  (... )&\: І що з кожним із наступного:

   &/'b І зменшення кожного (знаходить рядки без цього k )

  x* помножимо M на це

  +// велика сума

 y= список булевих вказівок, де S дорівнює цим сумам

 & індекси Трусів

 a@ використовувати це для індексації до елементів ( k кандидатів)

APL (Dyalog Unicode) , 35 33 28 байт ^SBCS

-7 завдяки ngn.

Анонімна інфіксація лямбда. Приймає S як лівий аргумент і M як правий аргумент.

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

Спробуйте в Інтернеті!

{… } "Dfn", ⍺і ⍵це лівий і правий аргументи ( S і M ) відповідно:

 ⍵[… ] Індекс М із такими координатами:

  ⊂⍵ додайте М, щоб розглянути його як єдиний елемент

  ⍵= порівняйте кожен елемент (тобто k кандидат) M з цим цілим M

  (… )¨ Застосувати таку негласну функцію до кожного:

   ∧⌿ вертикальні і відновлення (знаходить стовпці без цього K кандидата)

… ∘.∧ Декартовий булевий продукт із:

    ∧/ горизонтальна і зменшення (знахідки рядки без цього K кандидата)

   ⍵× помножте М на цю маску

   +/∘, підсумовуємо сплюснуту матрицю

  ⍺= Булева вказує, де S дорівнює цим сумам

  ⍸ індекси, де це правда

R , 78 73 байт

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

Спробуйте в Інтернеті!

Не сортує та не дедублює вихід.

Зарахуйте J.Doe & Giuseppe за -5 байт.

Желе , 20 19 17 15 14 байт

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

Це монадичне посилання, яке приймає M як аргумент і читає S зі STDIN.

Спробуйте в Інтернеті!

Як це працює

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

Не сортує і не уніфікує результат.
Працює лише в спадщині (поки що), тому що сума-кожен, здається, робить деякі дивні речі, коли частина внутрішніх списків є цілими числами, а інші - списками.

Спробуйте в Інтернеті або перевірте всі тестові випадки .

Пояснення:

˜              # 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³ç=⁹ƲƇ

Спробуйте в Інтернеті!

-6 байт, використовуючи загальний підхід з відповіді містера Xcoder 05AB1E.

Вугілля деревне , 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