Definizione

Data una matrice $M$ di numeri interi non negativi e un numero intero non negativo $k$ , definiamo $F_k$ come funzione "chop-off" che rimuove tutte le righe e tutte le colonne in $M$ che contengono . $k$

Esempio:

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

Il tuo compito

Dato e una somma bersaglio , il vostro compito è quello di trovare tutti i possibili valori di tale che la somma degli elementi rimanenti è pari a . $M$ $S$ $k$ $F_k(M)$ $S$

Esempio:

Data la matrice sopra e : $M$ $S=9$

$k=5$ è una soluzione, perché e $F_5(M)=\pmatrix{1&2\\6&0}$ $1+2+6+0=9$
$k=1$ è l'unica altra soluzione possibile: e $F_1(M)=\pmatrix{5\\4}$ $5+4=9$

Quindi l'output previsto sarebbe . $\{1,5\}$

Chiarimenti e regole

L'ingresso è garantito per ammettere almeno una soluzione.
La somma degli elementi della matrice originale è garantita per essere maggiore di . $S$
Puoi assumere . Significa che una matrice vuota non porterà mai a una soluzione. $S>0$
I valori di possono essere stampati o restituiti in qualsiasi ordine e in qualsiasi formato ragionevole e inequivocabile. $k$
È consentito non deduplicare l'output (es. o sono considerati risposte valide per l'esempio sopra). $[1,1,5,5]$ $[1,5,1,5]$
Questo è code-golf .

Casi test

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
fonte

Il mantenimento della struttura originale dell'array di input (ad es. [[1,5],[1],[5],[]]Per il primo caso di test) sarebbe un valido mezzo di output?

— Shaggy

@Shaggy Sì. Sembra ragionevole.

— Arnauld,

10

K (ngn / k) , 39 byte

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

Provalo online!

grazie @Adám per questa spiegazione :

{... }funzione, xè M ed yè S

,/x appiattisci M (questi sono i k candidati)

a: assegnato a a

x{... }/: applica la seguente funzione a ciascuna mentre usi M come argomento sinistro fisso ( x):

x=y Matrice booleana che indica dove gli elementi di M equivalgono all'attuale k candidato

~ negalo

b: assegnalo a b

&/ Riduzione AND (trova colonne senza quella k )

(... )&\: E quello con ciascuno dei seguenti:

&/'b E riduzione di ciascuno (trova le righe senza quella k )

x* moltiplicare M per quello

+// grande somma

y= elenco di valori booleani che indicano dove S è uguale a tali somme

& indici di Trues

a@ usalo per indicizzare gli elementi (i k candidati)

— NGN
fonte

Sentiti libero di correggere la spiegazione.

— Adám,

I pericoli della spiegazione di copia e incolla ...

— Adám,

6

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

-7 grazie a ngn.

Infografica anonima lambda. Prende S come argomento di sinistra e M come argomento di destra.

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

Provalo online!

{... } "dfn", ⍺e ⍵sono rispettivamente argomenti sinistro e destro ( S e M ):

⍵[… ] Indice M con le seguenti coordinate:

⊂⍵ racchiudere M per trattarlo come un singolo elemento

⍵= confrontare ogni elemento (cioè k candidato) di M con quella intera M

(... )¨ applica la seguente funzione tacita a ciascuno:

∧⌿ riduzione AND verticale (trova colonne senza quel k candidato)

… ∘.∧ Prodotto booleano cartesiano con:

∧/ riduzione AND orizzontale (trova righe senza quel k candidato)

⍵× moltiplica M con quella maschera

+/∘, sommare la matrice appiattita

⍺= Booleano che indica dove S è uguale a tali somme

⍸ indici in cui è vero

— Adamo
fonte

1

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

— ngn,

@ngn Grazie. Non userò il globale, tuttavia, poiché confonde l'ordine di valutazione: - Come si può indicizzare Mquando non è stato ancora creato?

— Adám,

passare ⍵come ⍺nel dfn interiore è ugualmente confuso per me

— ngn

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

— ngn,

@ngn Sì, volevo fare qualcosa del genere. Grazie!

— Adám,

6

R , 78 73 byte

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

Provalo online!

Non ordina né deduplica l'output.

Ringraziamo J.Doe e Giuseppe per -5 byte.

— Kirill L.
fonte

4

76 byte

— J.Doe

4

@ J.Doe 73 byte

— Giuseppe

5

Gelatina , 20 19 17 15 14 byte

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

Questo è un collegamento monadico che prende M come argomento e legge S da STDIN.

Provalo online!

Come funziona

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
fonte

Segna le mie parole lol :) Bella risposta, +1

— Mr. Xcoder,

5

Haskell , 88 86 84 77 byte

-2 byte grazie a BWO
-7 byte grazie 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]]

Verifica tutti i test .

Spiegazione

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
fonte

Dovrebbe dire "funzione f"?

— Quintec,

1

@Quintec In effetti avrebbe dovuto, ma l'ho cambiato in "funzione!" per salvare 2 byte grazie a BWO

— Delfad0r

5

Pyth , 27 23 22 21 20 byte

fqvzss.DRsxLTQ-I#TQs

Suite di test!

Non deduplica.

Come funziona?

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.

— Mr. Xcoder
fonte

4

Python 2 , 114 108 byte

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

Provalo online!

— TFeld
fonte

4

Perl 6 , 80 74 byte

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

Provalo online!

Spiegazione

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

3

05AB1E , 21 byte

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

Provalo online!

Solo dopo aver scritto questa risposta ho visto Kevin . Credo che questo sia sostanzialmente diverso, quindi lo sto postando separatamente. La mia intuizione dice che il conteggio dei byte ottimale è di circa 18, quindi dovrò rivisitare questo e vedere cos'altro posso fare. Con il codice attuale, è impossibile scrivere una suite di test ma ho verificato personalmente tutti i casi di test e i risultati sono corretti.

Algoritmo di ritaglio

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

Quindi, passa attraverso la trasposizione di $M$ e per ogni colonna $C$ , esegue l'operazione $(\max(C)-1)\space ||\space c\space\forall\space c\in C\:$ (dove $||$ è OR bit per bit di 05AB1E - anche l'addizione dovrebbe funzionare, quindi sostituiscila ~con +se vuoi testare anche quella), che si traduce in:

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

Infine, mappa $0$ a $1$ e tutti gli altri numeri interi a $0$ ed esegue la moltiplicazione degli elementi con $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)$

Dopo di che viene calcolata la somma della matrice risultante.

— Mr. Xcoder
fonte

1

Bella risposta! Sapevo che il mio sarebbe stato sicuramente giocabile a golf. Ero già abbastanza felice di farlo funzionare, incluso il fastidioso caso in [[1,1,0,1],[2,0,0,2],[2,0,1,0]]cui mi ha fregato per il numero 1(che rimuove ogni colonna ..) In effetti avevo leggermente meno di 20 nella mia testa e possibilità. Peccato che non ci siano quasi nessun builtin per matrici, nonostante quelli aggiunti di recente. Per quanto riguarda il 1|2( 1 2~nel sintassi 05AB1E) risultante in 3, questo è perché si logical ORcomporta come un binary ORquando sono coinvolti numeri diversi da 0/ 1(penso / presumo).

— Kevin Cruijssen,

@KevinCruijssen Oh hai ragione! Quindi, i documenti dovrebbero scrivere OR bit per bit , non OR logico . Dovrò correggerlo presto. Ad ogni modo, penso che anche OR bit per bit dovrebbe funzionare. Può essere sostituito da +comunque suppongo, quindi spero che non ci saranno problemi :)

— Mr. Xcoder,

2

05AB1E (legacy) , 27 26 byte

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

Non ordina né unifica il risultato.
Funziona solo nell'eredità (per ora), perché la somma-ciascuno sembra fare alcune cose strane quando parte degli elenchi interni sono numeri interi e altri sono elenchi.

Provalo online o verifica tutti i casi di test .

Spiegazione:

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

1

Gelatina , 22 byte

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

Provalo online!

-6 byte usando l'approccio generale dalla risposta 05AB1E di Mr. Xcoder.

— HyperNeutrino
fonte

1

Carbone , 33 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice e include la deduplicazione. Spiegazione:

ＦθＦι⊞υκ

Appiattire il primo array di input qnell'elenco predefinito 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

Per ogni elemento dell'elenco, sommare l'array, ma se la riga contiene l'elemento, utilizzare 0invece della sua somma e quando si sommano le righe che non contengono l'elemento, se la colonna contiene l'elemento, utilizzare 0invece il valore della colonna . Questo è leggermente più golfoso del filtraggio degli elementi poiché il carbone non può sommare un elenco vuoto.

— Neil
fonte

1

Pulito , 92 byte

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]

Provalo online!

Ha spiegato:

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

1

MATLAB - 80 byte

( Corretto e ) compattato:

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

E in una versione completamente sviluppata:

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

Grazie ai commenti per evidenziare il mio errore iniziale. Si noti che questa versione non duplica l'output.

È possibile deduplicare l'output con altri 5 byte:

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

1

k potrebbe essere qualsiasi elemento della matrice.

— Dennis,

@Dennis, oops, è vero ... Mio Dio, lo correggerò più tardi oggi. Grazie per segnalarlo.

— Hoki,

1

@Arnauld. Mi dispiace che ero in vacanza, che ora è stato risolto.

— Hoki,

Taglia la matrice per ottenere la somma desiderata

Definizione

Il tuo compito

Chiarimenti e regole

Casi test

K (ngn / k) , 39 byte

APL (Dyalog Unicode) , 35 33 28 byte SBCS

R , 78 73 byte

Gelatina , 20 19 17 15 14 byte

Come funziona

Haskell , 88 86 84 77 byte

Spiegazione

Pyth , 27 23 22 21 20 byte

Come funziona?

Python 2 , 114 108 byte

Perl 6 , 80 74 byte

Spiegazione

05AB1E , 21 byte

Algoritmo di ritaglio

05AB1E (legacy) , 27 26 byte

Gelatina , 22 byte

Carbone , 33 byte

Pulito , 92 byte

MATLAB - 80 byte

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