_{In caso di dubbi: Nan = Non-numeric datatypeai fini di questa sfida.}

Scrivi un programma o una funzione che accetta una matrice / matrice come input, nonché un elenco di indici di colonna.

La sfida è rimuovere le righe in cui si trovano tutti gli elementi nelle colonne specificate Nan. Non importa se altri elementi nella riga sono numerici o meno. Si spera che i seguenti esempi lo chiariscano (è un indice):

Input array:
    16   NaN     3    13
     5    11   NaN     8
   NaN     7   NaN    12
     4    14   -15     1

Input column index: [1 3]

Output array:
16   NaN     3    13
 5    11   NaN     8
 4    14   -15     1

----

Input array:
    16   NaN     3    13
     5    11   NaN     8
   NaN     7   NaN    12
     4    14   -15     1

Input column index: 3

Output array =
    16   NaN     3    13
     4    14   -15     1

----

Input array:
   NaN   NaN   NaN   NaN
   NaN   NaN   NaN   NaN
   NaN   NaN   NaN   NaN
   NaN   NaN   NaN   NaN

Input column index: 1 2 4

Output array:
 []

Regole e chiarimenti:

• La matrice sarà sempre non vuota
• I valori numerici saranno finiti, ma non necessariamente numeri interi o positivi
• Il vettore dell'indice di colonna può essere vuoto (nel qual caso nessuna riga verrà rimossa)
• L'indice di colonna non avrà mai valori che superano le dimensioni della matrice
• Puoi presumere che non ci saranno duplicati nell'elenco dell'indice delle colonne
• Puoi scegliere se vuoi usare valori zero o uno-indicizzati (specificare)
• Puoi prendere l'input in qualsiasi formato conveniente
  • La matrice come elenco di elenchi è OK. Gli indici di colonna possono essere argomenti separati
• ans = e simili sono accettati in uscita
• Sei libero di scegliere quale tipo di tipo di dati non numerico desideri utilizzare
  • Dovrebbe essere impossibile eseguire operazioni aritmetiche con questo tipo di dati o convertirlo in un numero finito usando funzioni come float(x).

Questo è il codice golf, quindi vince il codice più breve in byte.

Pyth, 16 19 10 9 7 10 byte

Gli indici di colonna iniziano da zero. L'input è un elenco di elenchi. Utilizza una stringa vuota come valore non numerico. Prende un elenco di indici di colonna sulla prima riga e Matrix con i valori sulla seconda riga.

?Qf-QxkTEE

Provalo online!

Spiegazione

?Qf-QxkTEE       # Implicit: Q=column indices, E=Matrix

?Q       E       # If column list is empty no rows get removed
  f     E        # filter the given matrix by each row T
     xkT         # Get the indices of all occurences of an emtpy string (k) 
   -Q            # If the indices match with the given column indices, remove the row

Aggiornamento: la mia prima soluzione ha gestito erroneamente un elenco vuoto di indici di colonna. Risolto il problema (abbastanza brutto) al costo di 3 byte. Proverò a farlo meglio dopo il lavoro ...

Aggiornamento 2: ridotto a 10 9 7 byte, con l'aiuto di @FryAmTheEggman e migliorando significativamente l'algoritmo.

Aggiornamento 3: corretto un bug scoperto da @ThomasKwa. La sua soluzione a 7 byte proposta non gestiva correttamente gli indici di colonna vuoti, quindi ho appena preso quel caso con un ternario qui. Non vedo come posso accorciare questo bancomat.

JavaScript (ES6), 48 46 byte

(a,l)=>a.filter(r=>l.some(c=>r[a=0,c]<1/0)||a)

Spiegazione

Si aspetta una matrice di righe come matrici e una matrice di numeri con indice 0 per il controllo delle colonne. Restituisce una matrice di matrici.

Semplice filtere some. Verifica NaNutilizzando n < Infinity( trueper numeri finiti, falseper NaNs).

var solution =

(a,l)=>
  a.filter(r=>     // for each row r
    l.some(c=>     // for each column to check c
      r[a=0,       // set a to false so we know the some was executed
        c]<1/0     // if any are not NaN, do not remove the row
    )
    ||a            // default to a because if l is of length 0, some returns false but
  )                //     we must return true

<textarea id="matrix" rows="5" cols="40">16 NaN 3 13
5 11 NaN 8
NaN 7 NaN 12
4 14 -15 1</textarea><br />
<input type="text" id="columns" value="0 2" />
<button onclick="result.textContent=solution(matrix.value.split('\n').map(l=>l.split(' ').map(n=>+n)),(columns.value.match(/\d+/g)||[]).map(n=>+n)).join('\n')">Go</button>
<pre id="result"></pre>

CJam, 18 byte

{{1$\f=_!\se|},\;}

Un blocco senza nome (funzione) che prevede la matrice e gli indici di colonna a base zero sulla pila (la matrice in alto), che lascia la matrice filtrata sulla pila. Sto usando l'array vuoto ""come valore non numerico.

Provalo qui.

Spiegazione

{     e# Filter the matrix rows based on the result of this block...
  1$  e#   Copy the column indices.
  \f= e#   Map them to the corresponding cell in the current row.
  _!  e#   Duplicate, logical NOT. Gives 1 for empty column list, 0 otherwise.
  \s  e#   Convert other copy to string. If the array contained only empty arrays, this 
      e#   will be an empty string which is falsy. Otherwise it will contain the numbers 
      e#   that were left after filtering, so it's non-empty and truthy.
  e|  e#   Logical OR.
},
\;    e# Discard the column indices.

APL, 19 byte

{⍵⌿⍨∨/⍬∘≡¨0↑¨⍵[;⍺]}

L'argomento sinistro dovrebbe essere un elenco di indici (e deve essere un elenco, non uno scalare), l'argomento giusto è la matrice. APL ha due tipi di dati, numeri e caratteri, quindi questo filtra i tipi di caratteri.

test:

      m1 m2
   16  NaN    3  13   NaN  NaN  NaN  NaN  
    5   11  NaN   8   NaN  NaN  NaN  NaN  
  NaN    7  NaN  12   NaN  NaN  NaN  NaN  
    4   14  ¯15   1   NaN  NaN  NaN  NaN  
      1 3 {⍵⌿⍨∨/⍬∘≡¨0↑¨⍵[;⍺]} m1
16  NaN    3  13
 5   11  NaN   8
 4   14  ¯15   1
      (,3) {⍵⌿⍨∨/⍬∘≡¨0↑¨⍵[;⍺]} m1
16  NaN    3 13
 4   14  ¯15  1
      1 2 4 {⍵⌿⍨∨/⍬∘≡¨0↑¨⍵[;⍺]} m2 ⍝ this shows nothing
      ⍴1 2 4 {⍵⌿⍨∨/⍬∘≡¨0↑¨⍵[;⍺]} m2 ⍝ the nothing is in fact a 0-by-4 matrix
0 4

Spiegazione:

• ⍵[;⍺]: seleziona le colonne indicate dalla matrice
• 0↑¨: prende i primi 0elementi dall'inizio di ogni elemento
• ⍬∘≡¨: confronta con l'elenco vuoto numerico
• ∨/: vedi in quale delle righe corrisponde almeno un elemento
• ⍵⌿⍨: seleziona quelle righe dalla matrice

MATLAB, 32 28 byte

Risponderò alla mia domanda per una volta. Il meglio che posso fare in MATLAB è di 28 byte. Speravo di evitare di usare entrambi alle in isnanqualche modo, ma non ho ancora trovato un modo.

@(A,c)A(any(A(:,c)<inf,2),:)

Test:

A =
    35     1   NaN   NaN   NaN    24
     3    32   NaN    21    23    25
    31   NaN   NaN   NaN    27    20
   NaN    28   NaN    17   NaN    15
    30     5   NaN    12    14   NaN
     4    36   NaN    13    18    11

f(A,[3,5])
ans =
     3    32   NaN    21    23    25
    31   NaN   NaN   NaN    27    20
    30     5   NaN    12    14   NaN
     4    36   NaN    13    18    11

Questa è una funzione anonima senza nome che accetta la matrice di input come prima variabile di input e un elenco di indici di colonna come seconda.

In MATLAB, NaN < Infrestituisce false. Si può presumere che tutti i valori siano finiti, quindi verificare se i valori sono inferiori a infè equivalente a verificare se non sono numerici. any(...,2)controlla se ci sono valori veri lungo la seconda dimensione (righe). In tal caso, verranno restituite tali righe.

Vecchia versione:

@(A,c)A(~all(isnan(A(:,c)),2),:)

isnan(A(:,c))restituisce un array con valori booleani per le colonne specificate. ~all(isnan(A(:,c)),2)controlla se tutti i valori lungo la seconda dimensione (righe) sono non numerici e lo annulla. Ciò si traduce in un vettore booleano con quelli nelle posizioni che vogliamo mantenere. A(~all(isnan(A(:,c)),2),:)usa l'indicizzazione logica per estrarre l'intera riga A.

La seguente soluzione a 24 byte funzionerebbe se i valori fossero garantiti diversi da zero:

@(A,c)A(any(A(:,c),2),:)

Rubino, 48 byte

->a,c{a.select{|r|c.map{|i|Fixnum===r[i]}.any?}}

L'input è costituito da indici basati su 0 ¹ .

Abbastanza autoesplicativo, in realtà. selectelementi dell'array in cui any?gli indici mappassano sulla riga sono Fixnums.

Esecuzione di esempio:

irb(main):010:0> (->a,c{a.select{|r|c.map{|i|Fixnum===r[i]}.any?}})[[[16,'',3,13],[5,11,'',8],['',7,'',12],[4,14,-15,1]],[0,2]]
=> [[16, "", 3, 13], [5, 11, "", 8], [4, 14, -15, 1]]

^{1: ho finalmente scritto correttamente questa parola al primo tentativo! \ o /}

K5, 15 byte

Questo utilizza colonne indicizzate 0 e la rappresentazione della matrice elenco naturale di liste di K:

{x@&~&/'^x[;y]}

Indicizza nella matrice ( x@) le righe in cui ( &) non tutte ( ~&/') sono null ( ^).

In azione:

  m: (16 0N 3 13;5 11 0N 8;0N 7 0N 12;4 14 -15 1);
  f: {x@&~&/'^x[;y]};

  f[m;0 2]
(16 0N 3 13
 5 11 0N 8
 4 14 -15 1)

  f[m;2]
(16 0N 3 13
 4 14 -15 1)

MATL , 15 16 byte

tiZ)tn?ZN!XA~Y)

NaNè rappresentato nell'input come N. L'indicizzazione è basata su 1. Ad esempio, nel primo caso di test l'ingresso è

[16 N 3 13; 5 11 N 8; N 7 N 12; 4 14 -15 1]
[1 3]

Provalo online!

Spiegazione

t       % implicitly input matrix, M. Duplicate
i       % input vector specifying columns
Z)      % matrix N containing those columns of M
tn?     % duplicate matrix N. If non-empty ...
  ZN    %   true for NaN values in matrix N
  !     %   transpose
  XA    %   "all" within each column: gives true for rows of N that contained all NaN's
  ~     %   logical negate
  Y)    %   apply this logical index as a row index into the copy of M that was left
        %   at the bottom of the stack
        % ... implicitly end if
        % implictly display stack contents. If the input vector was empty, the stack
        % contains the original matrix M and an empty matrix. The latter produces no
        % displayed output. If the input vector was non-empty, the stack contains the
        % resulting matrix N

R, 49 byte

function(m,j)m[!!rowSums(!is.nan(m[,j,drop=F])),]

L'input è basato su 1. La funzione accetta una matrice ( m) e un vettore di indici di colonna ( j) che potrebbero mancare.

Due casi di test:

> f <- function(m,j)m[!!rowSums(!is.nan(m[,j,drop=F])),]
> f(m)   
      V1  V2  V3 V4
[1,]  16 NaN   3 13
[2,]   5  11 NaN  8
[3,] NaN   7 NaN 12
[4,]   4  14 -15  1

> f(m, c(1,3))
     V1  V2  V3 V4
[1,] 16 NaN   3 13
[2,]  5  11 NaN  8
[3,]  4  14 -15  1

Lua, 148 byte

Una funzione che accetta una matrice e una matrice come input e genera una matrice con le righe corrispondenti in nil. Dato che le matrici sono quasi le stesse delle matrici di C, il nichilante è come free()se non fosse molto lontano.

Le matrici sono 1-indicizzate in Lua e uso la stringa "NaN"come elemento non-nomber.

function f(m,l)c=1 while(c<#m)do x=0 for j=1,#l do x=x+((type(m[c][l[j]])=="number")and 0 or 1)end m[c]=(x<#l and m[c] or nil)c=c+1 end return m end

Puoi provare Lua online e copiare / incollare il seguente esempio di codice per provare questo invio:

-- The function that does the stuff
function f(m,l)
  c=1 
  while(c<#m)
  do 
    x=0 
    for j=1,#l 
    do 
      x=x+((type(m[c][l[j]])=="number")and 0 or 1)
    end
    m[c]=(x<#l and m[c] or nil)
    c=c+1 
   end 
   return m 
end
-- A function to format matrixes into "readable" strings
function printMatrix(matrix,len)
  s="{"
  for v=1,len
  do
    if matrix[v]~=nil
    then
      s=s.."{"..table.concat(matrix[v],",").."}"..(v<len and",\n "or"")
    end
  end
  s=s.."}"
  print(s)
end

nan="NaN"
-- Datas in, indexed as matrices[testCase][row][column]
matrices={{{7,nan,5,3},{5,4,nan,4},{nan,4,nan,9},{5,7,9,8}},
{{16,nan,3,13},{5,11,nan,8},{nan,7,nan,12},{4,14,-15,1}},
{{nan,nan,nan,nan},{nan,nan,nan,nan},{nan,nan,nan,nan},{nan,nan,nan,nan}}}
indexes={{1,3},{3},{1,2,4}}

-- looping so we can test lots of things at once :)
for i=1,#matrices
do
  print("\ninput: "..table.concat(indexes[i]," "))
  printMatrix(matrices[i],4)
  print("output:")
  printMatrix(f(matrices[i],indexes[i]),4)
end

Mathematica, 52 51 49 46 byte

Delete[#,Extract[#,{;;,#2}]~Position~{NaN..}]&

L'input è [matrice come elenco di elenchi, vettore di colonne]

Haskell, 39 byte

m#[]=m
m#r=[l|l<-m,any(<1/0)$map(l!!)r]

Questo utilizza indici basati su 0. Esempio di utilizzo (sto usando sqrt(-1)per creare NaN):

*Main> [[16,sqrt(-1),3,13], [5,11,sqrt(-1),8], [sqrt(-1),7,sqrt(-1),12], [4,14,-15,1]] # [0,2]
[[16.0,NaN,3.0,13.0],[5.0,11.0,NaN,8.0],[4.0,14.0,-15.0,1.0]]

È solo un semplice filtro visto in altre risposte tramite la comprensione dell'elenco. Il caso speciale di un elenco di indici vuoto viene preso separatamente.