정의

음이 아닌 정수 의 행렬 $M$ 과 음이 아닌 정수 주어지면, 를 가 포함 된 모든 행과 모든 열을 제거하는 "잘라 내기"함수로 $k$ 정의 합니다 . $F_k$ $M$ $k$

예:

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

당신의 작업

과 목표 합계 주어지면 의 나머지 요소의 합계 가 같도록 가능한 모든 값을 찾아야합니다 . $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]$
이것은 code-golf 입니다.

테스트 사례

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

— 아르나 울드
소스

입력 배열의 원래 구조 (예 : [[1,5],[1],[5],[]]첫 번째 테스트 사례)를 유지하는 것이 유효한 출력 수단입니까?

— 얽히고 설킨

@Shaggy 예. 합리적으로 보입니다.

— Arnauld

10

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=yM의 요소가 현재 k 후보와 같은 위치를 나타내는 부울 행렬

~ 그것을 부정하다

b: 그것을 할당 b

&/ AND 축소 ( k 없이 열을 찾습니다 )

(… )&\: 그리고 그 각각은 다음과 같습니다.

&/'b 각각의 AND 감소 ( k가 없는 행 찾기 )

x*M 에 곱하기

+// 총액

y=S가 해당 합계와 같은 위치를 나타내는 부울 목록

& 참의 지수

a@이것을 요소 ( k 후보) 로 색인하기 위해 사용하십시오.

— ngn
소스

설명을 자유롭게 수정하십시오.

— Adám

복사하여 붙여 넣기 설명의 위험…

— Adám

6

APL (Dyalog Unicode) , 35 33 28 바이트 ^SBCS

ngn 덕분에 -7.

익명의 람다. 소요 S를 왼쪽 인수와 같은 M 오른쪽 인자로.

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

온라인으로 사용해보십시오!

{… } "dfn" ⍺이며 ⍵각각 왼쪽 및 오른쪽 인수 ( S 및 M )입니다.

⍵[… 다음 좌표로 M 을 ] 색인 합니다.

⊂⍵ 둘러싸 M을 단일 요소로 취급하는

⍵=M의 각 요소 (즉, k 후보) 를 전체 M과 비교

(… )¨ 다음의 암묵적 기능을 각각에 적용하십시오.

∧⌿ 수직 AND 축소 ( k 후보가 없는 열을 찾습니다 )

… 다음을 ∘.∧ 포함한 데카르트 부울 곱 :

∧/ 수평 AND 축소 ( k 후보 없이 행을 찾습니다 )

⍵×그 마스크와 M 을 곱

+/∘, 평탄화 된 행렬을 합산

⍺=S가 해당 합계와 같은 위치를 나타내는 부울

⍸ 그것이 사실 인 지수

— 아담
소스

1

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

— ngn

@ngn 감사합니다. 하지만 평가 순서가 혼란 스럽기 때문에 전역을 사용하지는 않겠습니다. — M아직 작성하지 않은 경우 어떻게 색인을 작성할 수 있습니까?

— Adám

내부 dfn에서 ⍵와 같이 전달하는 것은 ⍺나에게 똑같이 혼란스러워

— ngn

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

— ngn

@ngn 그래, 나는 그런 것을하고 싶었다. 감사!

— Adám

6

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 바이트입니다.

— 키릴 L.
소스

4

76 바이트

— J.Doe

4

@ J.Doe 73 바이트

— 주세페

5

젤리 , 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.

— 데니스
소스

내 단어를 표시해라 :) 좋은 대답, +1

— Mr. Xcoder

5

하스켈 , 88 86 84 77 바이트

BWO 덕분에 -2 바이트
Tesseract 덕분에 -7 바이트

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

— 델 파드
소스

"기능 f"라고해야합니까?

— Quintec

1

@Quintec 실제로 있어야하지만 "기능!"으로 변경했습니다. 2 바이트의 감사를 저장 BWO

— Delfad0r

5

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.

— 미스터 Xcoder
소스

4

파이썬 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]))}

온라인으로 사용해보십시오!

— TFeld
소스

4

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

— 엔웰 호프
소스

3

05AB1E , 21 바이트

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

온라인으로 사용해보십시오!

이 답변을 작성한 후에야 Kevin 's을 보았습니다 . 나는 이것이 상당히 다르다고 생각하므로 별도로 게시하고 있습니다. 내 직감에 따르면 최적의 바이트 수는 약 18이므로이를 다시 방문하여 다른 작업을 수행해야합니다. 현재 코드로는 테스트 스위트를 작성할 수 없지만 모든 테스트 사례를 직접 확인했으며 결과가 정확합니다.

자르기 알고리즘

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

그리고,의 전치 통과 및 각각의 컬럼에 대한 , 상기 동작을 수행 (여기서 05AB1E의 비트는 OR - 또한 그렇게 교체도 작동합니다 으로 당신이 어떤 결과를) 너무 테스트하려면 : $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)$

그 후 결과 행렬의 합이 계산됩니다.

— 미스터 Xcoder
소스

1

좋은 대답입니다! 나는 내 골프가 확실하다는 것을 알았다. 나는 (모든 열을 제거하는) [[1,1,0,1],[2,0,0,2],[2,0,1,0]]숫자로 나를 망쳐 놓은 성가신 경우를 포함하여 이미 작동하기에 충분히 행복했습니다 1. 나는 실제로 머리뿐만 아니라 가능성도 약간 20 미만이었습니다. 최근 추가 된 제품에도 불구하고 매트릭스에 대한 내장 기능이 거의 없습니다. 3을 초래 하는 1|2( 1 2~05AB1E synthax에서)에 관해서 는 / 이외의 숫자 가 관련되어 있을 때 logical OR와 같이 작용 하기 때문입니다 (생각 / 가정). binary OR01

— Kevin Cruijssen

@KevinCruijssen 아 맞아! 그런 다음 문서는 논리 OR이 아닌 비트 OR을 작성해야합니다 . 나는 곧 고쳐야 할 것이다. 어쨌든, 비트 OR은 잘 작동한다고 생각합니다. 그것은 어쨌든 내가 생각 하는 것으로 대체 될 수 있으므로 문제가 없기를 바랍니다 :)+

— Mr. Xcoder

2

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

— 케빈 크루이 센
소스

1

젤리 , 22 바이트

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

온라인으로 사용해보십시오!

Xcoder의 05AB1E 답변의 일반적인 접근 방식을 사용하여 -6 바이트.

— 하이퍼 뉴트리노
소스

1

숯 , 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경우 열 값 대신 사용 하십시오 . Charcoal은 빈 목록을 합할 수 없으므로 요소를 필터링하는 것보다 매우 골치가 적습니다.

— 닐
소스

1

클린 , 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`
 ]

— 뇨
소스

1

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

— 호키
소스

1

k 는 행렬의 모든 요소가 될 수 있습니다.

— Dennis

@ 데니스, 죄송합니다 ... 내 나쁜, 오늘 나중에 수정하겠습니다. 지적 해 주셔서 감사합니다.

— Hoki

1

@Arnauld. 나는 휴일에 있었는데, 지금 고쳐졌다.

— Hoki

원하는 합계를 얻기 위해 행렬을 잘라냅니다.

정의

당신의 작업

설명 및 규칙

테스트 사례

K (ngn / k) , 39 바이트

APL (Dyalog Unicode) , 35 33 28 바이트 SBCS

R , 78 73 바이트

젤리 , 20 19 17 15 14 바이트

작동 원리

하스켈 , 88 86 84 77 바이트

설명

Pyth , 27 23 22 21 20 바이트

어떻게 작동합니까?

파이썬 2 , 114 108 바이트

펄 6 , 80 74 바이트

설명

05AB1E , 21 바이트

자르기 알고리즘

05AB1E (레거시) , 27 26 바이트

젤리 , 22 바이트

숯 , 33 바이트

클린 , 92 바이트

MATLAB-80 바이트

APL (Dyalog Unicode) , 35 33 28 바이트 ^SBCS