_{Caso haja alguma dúvida: Nan = Non-numeric datatypepara os propósitos deste desafio.}

Escreva um programa ou função que use uma matriz / matriz como entrada, bem como uma lista de índices de coluna.

O desafio é remover as linhas onde estão todos os elementos nas colunas especificadas Nan. Não importa se outros elementos na linha são numéricos ou não. Esperamos que os exemplos a seguir tornem isso mais claro (é um indexado):

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

Regras e esclarecimentos:

• A matriz sempre estará vazia
• Os valores numéricos serão finitos, mas não necessariamente inteiros ou valores positivos
• O vetor de índice da coluna pode estar vazio (nesse caso, nenhuma linha será removida)
• O índice da coluna nunca terá valores que excedam as dimensões da matriz
• Você pode assumir que não haverá duplicatas na lista de índices da coluna
• Você pode escolher se deseja usar valores indexados com zero ou um (especifique)
• Você pode levar a entrada em qualquer formato conveniente
  • A matriz como lista de listas está OK. Os índices da coluna podem ser argumentos separados
• ans = e similar é aceito na saída
• Você é livre para escolher que tipo de tipo de dados não numérico deseja usar
  • Deve ser impossível executar operações aritméticas com esse tipo de dados ou convertê-lo em um número finito usando funções como float(x).

Este é o código golf, pelo que o código mais curto em bytes vence.

Pyth, 16 19 10 9 7 10 Bytes

Os índices da coluna começam em zero. Entrada é uma lista de listas. Usa uma string vazia como valor não numérico. Leva a lista de índices de coluna na primeira linha e a matriz com os valores na segunda linha.

?Qf-QxkTEE

Experimente online!

Explicação

?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

Atualização: minha primeira solução manipulou uma lista vazia de índices de coluna incorretamente. Corrigido (muito feio) ao custo de 3 bytes. Vou tentar fazer melhor depois do trabalho ...

Atualização 2: reduziu para 10 9 7 bytes, com alguma ajuda de @FryAmTheEggman an, melhorando significativamente o algoritmo.

Update3: Foi corrigido um erro que @ThomasKwa descobriu. Sua solução proposta de 7 bytes não lidou corretamente com os índices de colunas vazias, então eu entendi esse caso com um ternário aqui. Não vejo como posso encurtar esse caixa eletrônico.

JavaScript (ES6), 48 46 bytes

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

Explicação

Espera uma matriz de linhas como matrizes e uma matriz de números indexados 0 para as colunas verificarem. Retorna uma matriz de matrizes.

Direto filtere some. Verifica NaNusando n < Infinity( truepara números finitos, falsepara 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 bytes

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

Um bloco sem nome (função) esperando a matriz e os índices da coluna com base em zero na pilha (a matriz na parte superior), que deixa a matriz filtrada na pilha. Estou usando a matriz vazia ""como o valor não numérico.

Teste aqui.

Explicação

{     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 bytes

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

O argumento da esquerda deve ser uma lista de índices (e deve ser uma lista, não uma escalar), o argumento da direita é a matriz. A APL possui dois tipos de dados, números e caracteres, portanto, isso filtra os tipos de caracteres.

Testes:

      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

Explicação:

• ⍵[;⍺]: selecione as colunas fornecidas na matriz
• 0↑¨: pegue os primeiros 0elementos desde o início de cada item
• ⍬∘≡¨: compare com a lista vazia numérica
• ∨/: veja em qual das linhas pelo menos um item corresponde
• ⍵⌿⍨: selecione essas linhas da matriz

MATLAB, 32 28 bytes

Vou responder minha própria pergunta pela primeira vez. O melhor que posso fazer no MATLAB é de 28 bytes. Eu esperava evitar usar os dois alle de isnanalguma forma, mas ainda não encontrei uma maneira.

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

Teste:

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

Essa é uma função anônima sem nome que leva a matriz de entrada como a primeira variável de entrada e uma lista de índices de coluna como a segunda.

No MATLAB, NaN < Infavalia como falso. Pode-se supor que todos os valores sejam finitos, verificando se os valores são menores que o infequivalente a verificar se são não numéricos. any(...,2)verifica se existem valores verdadeiros ao longo da segunda dimensão (linhas). Se for esse o caso, essas linhas serão retornadas.

Versão antiga:

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

isnan(A(:,c))retorna uma matriz com booleanos para as colunas especificadas. ~all(isnan(A(:,c)),2)verifica se todos os valores da segunda dimensão (linhas) são não numéricos e a nega. Isso resulta em um vetor booleano com aqueles nas posições que queremos manter. A(~all(isnan(A(:,c)),2),:)usa indexação lógica para extrair as linhas inteiras A.

A seguinte solução de 24 bytes funcionaria se fosse garantido que os valores fossem diferentes de zero:

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

Ruby, 48 bytes

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

A entrada é índices baseados em 0 ¹ .

Bastante auto-explicativo, na verdade. selectelementos da matriz onde any?os índices mapped sobre a linha sãoFixnum s.

Exemplo de execução:

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: Eu finalmente escrevi essa palavra corretamente na primeira tentativa! \ o /}

K5, 15 bytes

Isso usa colunas indexadas em 0 e a representação natural da matriz da lista de listas de K:

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

Indique na matriz ( x@) as linhas em que ( &) nem todos ( ~&/') são nulos ( ^).

Em ação:

  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 bytes

tiZ)tn?ZN!XA~Y)

NaNé representado na entrada como N. A indexação é baseada em 1. Por exemplo, no primeiro caso de teste, a entrada é

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

Experimente online!

Explicação

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 bytes

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

A entrada é baseada em 1. A função pega uma matriz ( m) e um vetor de índices de coluna ( j) que podem estar ausentes.

Dois casos de teste:

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

Uma função que recebe uma matriz e uma matriz como entrada e produz uma matriz com as linhas correspondentes em nil. Como matrizes são exatamente iguais às matrizes de C, nihilating é como ingê free()-lo, pois o coletor de lixo não está longe.

As matrizes são indexadas em 1 em Lua, e eu uso a string "NaN"como um elemento não nomeador.

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

Você pode experimentar o Lua online e copiar / colar o seguinte exemplo de código para tentar este envio:

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

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

Entrada é [matriz como lista de listas, vetor de colunas]

Haskell, 39 bytes

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

Isso usa índices baseados em 0. Exemplo de uso (estou usando sqrt(-1)para criar NaNs):

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

É apenas um filtro simples, como visto em outras respostas, através da compreensão da lista. O caso especial de uma lista de índices vazia é capturado separadamente.