Tanım

Bir matris verilen olmayan negatif tamsayı ve negatif olmayan bir tam sayı ve , tanımladığımızı "pirzola-off" fonksiyonu tüm satır ve tüm sütunları kaldırır içeren . $M$ $k$ $F_k$ $M$ $k$

Örnek:

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

Senin görevin

Verilen $M$ ve bir hedef toplamı $S$ , görev tüm olası değerleri bulmak için $k$ kalan unsurların toplamı öyle ki $F_k(M)$ eşittir $S$ .

Örnek:

Yukarıdaki matris $M$ ve verildiğinde $S=9$ :

$k=5$ bir çözümdür, çünkü $F_5(M)=\pmatrix{1&2\\6&0}$ ve $1+2+6+0=9$
$k=1$ diğer olası çözümdür: $F_1(M)=\pmatrix{5\\4}$ ve $5+4=9$

Dolayısıyla beklenen çıktı $\{1,5\}$ .

Açıklamalar ve kurallar

Girişin, en az bir çözümü kabul etmesi garanti edilir.
Orijinal matristeki elementlerin toplamının büyük olması garanti edilir $S$ .
olduğunu varsayabilirsiniz $S>0$ . Boş bir matrisin hiçbir zaman bir çözüme yol açmayacağı anlamına gelir.
Değerleri $k$ basılı veya herhangi bir sırada ve herhangi bir uygun, açık bir biçimde döndürülebilir.
Çıktıyı tekilleştirmemenize izin verilir (örneğin veya yukarıdaki örnek için geçerli cevaplar olarak kabul edilir). $[1,1,5,5]$ $[1,5,1,5]$
Bu kod golfü .

Test durumları

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
kaynak

Giriş dizisinin orijinal yapısını korumak (örneğin, [[1,5],[1],[5],[]]ilk test durumu için) geçerli bir çıktı aracı olur mu?

— Shaggy

@Shaggy Evet. Bu makul görünüyor.

— Arnauld

10

K (ngn / k) , 39 bayt

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

Çevrimiçi deneyin!

Bu açıklama için teşekkürler @ Adám :

{... }fonksiyonu, xbir M ve ybir S

,/x dümdüz M (bunlar k adaylarıdır)

a: atamak a

x{… Sabit sol argüman ( ) olarak M}/: kullanılırken her birine aşağıdaki işlevi uygulayın :x

x=yM elemanlarının o anki k adaya eşit olduğunu gösteren Boole matrisi

~ bunu reddet

b: onu ata b

&/ VE azaltma (bu olmadan bulur sütunlar k )

(… )&\: VE aşağıdakilerden her biri ile:

&/'b VE her azaltılması (yani olmadan satırları bulur k )

x*M ile çarp

+// büyük meblağ

y=S'nin bu toplamlara eşit olduğunu gösteren Boole'lerin listesi

& Trues endeksleri

a@ bunu elementlere endekslemek için kullanın ( k adayları)

— ngn
kaynak

Açıklamayı düzeltmek için çekinmeyin.

— Ad'm

Kopyala-yapıştır açıklamasının tehlikeleri…

— 1918'de

6

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

-7 ngn sayesinde.

Anonim infix lambda. Alır S sol argüman gibi M sağ argüman olarak.

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

Çevrimiçi deneyin!

{… } "Dfn" ⍺ve ⍵sırasıyla sol ve sağ argümanlardır ( S ve M ):

⍵[… Aşağıdaki koordinatlara sahip M] dizini :

⊂⍵tek bir eleman olarak ele almak için M'yi içine alın

⍵= Her bir eleman (yani, karşılaştırma k aday) M olduğu tüm için M

(… )¨ Her birine aşağıdaki yapışkan işlevi uygulayın:

∧⌿ dikey VE azaltma (bu k adayı olmayan sütunları bulur )

… ∘.∧ Kartezyen Boolean ürünü:

∧/ yatay VE azaltma (bu k adayı olmayan satırları bulur )

⍵× çarpın M o maske ile

+/∘, düzleştirilmiş matrisin toplanması

⍺=S'nin bu toplamlara eşit olduğunu gösteren Boole

⍸ bunun doğru olduğu göstergeler

— Adem
kaynak

1

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

— ngn

@ ngn Teşekkürler. Bununla birlikte, genel olarak değerlendirmeyi kafa karıştırıcı hale getirdiği için kullanmayacağım: - MHenüz oluşturulmadığında nasıl dizin oluşturabilirsiniz?

— 10’da

iç dfn'de olduğu ⍵gibi geçmek de ⍺benim için eşit derecede kafa karıştırıcı

— ngn

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

— ngn

@ Evet, böyle bir şey yapmak istedim. Teşekkürler!

— Ad

6

R , 78 73 bayt

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

Çevrimiçi deneyin!

Çıktıyı sıralamaz ya da tekilleştirmez.

-5 bayt için J.Doe ve Giuseppe'ye teşekkür ederiz.

— Kirill L.
kaynak

4

76 bayt

— J.Doe

4

@ J.Doe 73 bayt

— Giuseppe,

5

Jelly , 20 19 17 15 14 bayt

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

Bu, M'yi argüman olarak alan ve S'yi STDIN'den alan monadik bir bağlantıdır .

Çevrimiçi deneyin!

Nasıl çalışır

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
kaynak

Sözlerimi lol işaretleyin :) Güzel cevap, +1

— Bay Xcoder

5

Haskell , 88 86 84 77 bayt

BWO sayesinde -2 bayt
Tesseract sayesinde -7 bayt

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

Tüm test durumlarını doğrulayın .

açıklama

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
kaynak

Bu "f işlevi" demeli mi?

— Quintec

1

@Quintec Gerçekten de olması gerekiyordu, ama onu "işlev" olarak değiştirdim BWO

— kazanır

5

Pyth , 27 23 22 21 20 bayt

fqvzss.DRsxLTQ-I#TQs

Test odası!

Tekilleştirmez.

Nasıl çalışır?

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.

— Bay Xcoder
kaynak

4

Python 2 , 114 108 bayt

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

Çevrimiçi deneyin!

— TFeld
kaynak

4

Perl 6 , 80 74 bayt

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

Çevrimiçi deneyin!

açıklama

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

3

05AB1E , 21 bayt

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

Çevrimiçi deneyin!

Sadece bu cevabı yazdıktan sonra Kevin'inkileri gördüm . Bunun oldukça farklı olduğuna inanıyorum, bu yüzden ayrı olarak gönderiyorum. Sezgim, en uygun bayt sayısının 18 civarında olduğunu söylüyor, bu yüzden bunu tekrar gözden geçirip başka ne yapabilirim bakmam gerekecek. Geçerli kodla, bir test takımı yazmak imkansız ancak tüm test durumlarını kendim doğruladım ve sonuçlar doğru.

Kırpma Algoritması

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

Bundan sonra elde edilen matrisin toplamı hesaplanır.

— Bay Xcoder
kaynak

1

Güzel cevap! Benimkinin kesinlikle golf oynayabileceğini biliyordum. Çalışmam için yeterince mutlu oldum, [[1,1,0,1],[2,0,0,2],[2,0,1,0]]beni rahatsız eden sayısız numarayı 1(her sütunu çıkarıyordu) da dahil olmak üzere canımı sıkıyordum. Ne yazık ki, son zamanlarda eklenen ürünlere rağmen, matrisler için neredeyse hiç yapılamadı. Gelince 1|2( 1 2~05AB1E synthax olarak) 3 sonuçlanan bu çünkü logical ORbir gibi davranır binary ORdışındaki sayılar zaman 0/ 1katılmaktadırlar (Sanırım / varsayıyorum).

— Kevin Cruijssen

@KevinCruijssen Oh haklısın! O zaman, dokümanlar bitsel VEYA yazmalı , mantıklı değil . Yakında düzeltmek zorunda kalacağım. Neyse, bitsin ya da sanırım çalışmalı. Her +halükarda yerini alabilir sanırım, bu yüzden umarım onunla bir sorun

— çıkmaz

2

05AB1E (eski) , 27 26 bayt

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

Sonuçları sıralamaz ya da benzersizleştirmez.
Yalnızca eskilerde çalışır (şimdilik), çünkü toplam-iç listelerin bir kısmı tamsayılar, diğeri listeler olduğunda bazı garip şeyler yapıyor gibi görünmektedir.

Çevrimiçi deneyin veya tüm test durumlarını doğrulayın .

Açıklama:

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

1

Jöle , 22 bayt

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

Çevrimiçi deneyin!

-Bay Xcoder'ın 05AB1E cevabındaki genel yaklaşımı kullanarak 6 bayt.

— HyperNeutrino
kaynak

1

Kömür , 33 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı sürümünü vermektir ve veri tekilleştirmeyi içerir. Açıklama:

ＦθＦι⊞υκ

İlk giriş dizisini qönceden tanımlanmış listeye düzleştirin 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

Listenin her öğesi için, diziyi toplayın, ancak satır öğesi içeriyorsa, o 0zaman toplama yerine kullanın ve öğeyi içermeyen satırları toplarken, sütun, öğeyi içeriyorsa 0, sütunun değeri yerine kullanın. . Kömür boş bir liste toplayamadığından, bu öğelerin filtrelenmesinden çok biraz daha golfur.

— Neil
kaynak

1

Temiz , 92 bayt

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]

Çevrimiçi deneyin!

Açıklaması:

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

1

MATLAB - 80 bayt

( Düzeltilmiş ve ) Sıkıştırılmış:

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

Ve tamamen geliştirilmiş bir versiyonda:

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

İlk hatamı vurgulamak için yapılan yorumlar sayesinde. Bu sürümün çıktının çoğaltılmadığını unutmayın.

Çıktıyı 5 bayt ile tekilleştirmek mümkündür:

% 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
kaynak

1

k , matrisin herhangi bir elemanı olabilir.

— Dennis,

@Dennis, doğru mu ... Kötü, bugün daha sonra düzelteceğim. Gösterdiğin için teşekkürler.

— Hoki

1

@Arnauld. Üzgünüm tatillerde oldum, şimdi düzeldi.

— Hoki

İstenilen toplamı elde etmek için matrisi kesin

Tanım

Senin görevin

Açıklamalar ve kurallar

Test durumları

K (ngn / k) , 39 bayt

APL (Dyalog Unicode) , 35 33 28 bayt SBCS

R , 78 73 bayt

Jelly , 20 19 17 15 14 bayt

Nasıl çalışır

Haskell , 88 86 84 77 bayt

açıklama

Pyth , 27 23 22 21 20 bayt

Nasıl çalışır?

Python 2 , 114 108 bayt

Perl 6 , 80 74 bayt

açıklama

05AB1E , 21 bayt

Kırpma Algoritması

05AB1E (eski) , 27 26 bayt

Jöle , 22 bayt

Kömür , 33 bayt

Temiz , 92 bayt

MATLAB - 80 bayt

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