_{En cas de doute: Nan = Non-numeric datatypeaux fins de ce défi.}

Écrivez un programme ou une fonction qui prend une matrice / un tableau en entrée, ainsi qu'une liste d'index de colonnes.

Le défi consiste à supprimer les lignes où se trouvent tous les éléments des colonnes spécifiées Nan. Peu importe que les autres éléments de la ligne soient numériques ou non. Nous espérons que les exemples suivants clarifieront cela (c'est un index):

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

Règles et clarifications:

• La matrice sera toujours non vide
• Les valeurs numériques seront finies, mais pas nécessairement des entiers ou des valeurs positives
• Le vecteur d'index de colonne peut être vide (auquel cas aucune ligne ne sera supprimée)
• L'index de colonne n'aura jamais de valeurs dépassant les dimensions de la matrice
• Vous pouvez supposer qu'il n'y aura pas de doublons dans la liste d'index des colonnes
• Vous pouvez choisir si vous souhaitez utiliser des valeurs nulles ou indexées (veuillez préciser)
• Vous pouvez prendre l'entrée sur n'importe quel format pratique
  • Le tableau comme liste de listes est OK. Les indices de colonne peuvent être des arguments séparés
• ans = et similaire est accepté en sortie
• Vous êtes libre de choisir le type de type de données non numérique que vous souhaitez utiliser
  • Il devrait être impossible d'effectuer des opérations arithmétiques avec ce type de données, ou de le convertir en un nombre fini à l'aide de fonctions telles que float(x).

C'est le code golf, donc le code le plus court en octets gagne.

Pyth, 16 19 10 9 7 10 octets

Les indices de colonne commencent à zéro. L'entrée est une liste de listes. Utilise une chaîne vide comme valeur non numérique. Prend la liste des indices de colonne sur la première ligne et la matrice avec les valeurs sur la deuxième ligne.

?Qf-QxkTEE

Essayez-le en ligne!

Explication

?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

Mise à jour: ma première solution a mal géré une liste vide d'index de colonnes. Correction (assez moche) au prix de 3 octets. Je vais essayer de faire mieux après le travail ...

Mise à jour 2: il a été réduit à 10 9 7 octets, avec l'aide de @FryAmTheEggman et en améliorant considérablement l'algorithme.

Update3: Correction d'un bug découvert par @ThomasKwa. Sa solution à 7 octets proposée ne traitait pas correctement les indices de colonnes vides, donc je prends juste ce cas avec un ternaire ici. Je ne vois pas comment raccourcir cette atmosphère.

JavaScript (ES6), 48 46 octets

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

Explication

Attend un tableau de lignes en tant que tableaux et un tableau de nombres indexés 0 pour les colonnes à vérifier. Renvoie un tableau de tableaux.

Simple filteret some. Vérifie NaNen utilisant n < Infinity( truepour les nombres finis, falsepour 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 octets

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

Un bloc (fonction) sans nom qui attend la matrice et les indices de colonne de base zéro sur la pile (la matrice en haut), qui laisse la matrice filtrée sur la pile. J'utilise le tableau vide ""comme valeur non numérique.

Testez-le ici.

Explication

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

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

L'argument de gauche doit être une liste d'indices (et ce doit être une liste, pas un scalaire), l'argument de droite est la matrice. APL a deux types de données, des nombres et des caractères, donc cela filtre les types de caractères.

Tests:

      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

Explication:

• ⍵[;⍺]: sélectionnez les colonnes données dans la matrice
• 0↑¨: prendre les premiers 0éléments depuis le début de chaque élément
• ⍬∘≡¨: comparer à la liste vide numérique
• ∨/: voir dans laquelle des lignes au moins un élément correspond
• ⍵⌿⍨: sélectionnez ces lignes dans la matrice

MATLAB, 32 28 octets

Je vais répondre à ma propre question pour une fois. Le mieux que je puisse faire dans MATLAB est de 28 octets. J'espérais éviter d'utiliser les deux allet d'une isnanmanière ou d'une autre, mais je n'ai pas encore trouvé de moyen.

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

Tester:

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

Il s'agit d'une fonction anonyme sans nom qui prend la matrice d'entrée comme première variable d'entrée et une liste d'index de colonne comme seconde.

Dans MATLAB, est NaN < Infévalué à faux. On peut supposer que toutes les valeurs sont finies, vérifiant ainsi si les valeurs sont inférieures à infest équivalent à vérifier si elles ne sont pas numériques. any(...,2)vérifie s'il existe des valeurs vraies le long de la deuxième dimension (lignes). Si tel est le cas, ces lignes seront retournées.

Ancienne version:

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

isnan(A(:,c))renvoie un tableau avec des booléens pour les colonnes spécifiées. ~all(isnan(A(:,c)),2)vérifie si toutes les valeurs le long de la deuxième dimension (lignes) ne sont pas numériques et la nie. Il en résulte un vecteur booléen avec ceux dans les positions que nous voulons conserver. A(~all(isnan(A(:,c)),2),:)utilise l'indexation logique pour extraire les lignes entières pour A.

La solution suivante de 24 octets fonctionnerait si les valeurs étaient garanties non nulles:

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

Rubis, 48 ​​octets

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

L'entrée est basée sur des indices 0 ¹ .

Assez explicite, en fait. selectéléments du tableau où any?des indicesmap pédent sur la ligne sontFixnum s.

Exemple d'exécution:

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: J'ai finalement épelé ce mot correctement du premier coup! \ o /}

K5, 15 octets

Celui-ci utilise des colonnes indexées 0 et la représentation matricielle de liste de listes naturelle de K:

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

Indexez dans la matrice ( x@) les lignes où ( &) tous ( ) ne sont pas tous ~&/'nuls (^ ).

En action:

  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 octets

tiZ)tn?ZN!XA~Y)

NaNest représenté dans l'entrée comme N. L'indexation est basée sur 1. Par exemple, dans le premier cas de test, l'entrée est

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

Essayez-le en ligne!

Explication

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 octets

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

L'entrée est basée sur 1. La fonction prend une matrice ( m) et un vecteur d'indices de colonne (j ) qui peuvent être manquants.

Deux cas de 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 octets

Une fonction qui prend une matrice et un tableau en entrée et génère une matrice avec les lignes correspondantes à nil. Comme les tableaux sont assez similaires aux tableaux de C, nihiler est commefree() le faire car le garbage collector n'est pas loin.

Les tableaux sont indexés en 1 dans Lua, et j'utilise la chaîne "NaN"comme élément 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

Vous pouvez essayer Lua en ligne et copier / coller l'exemple de code suivant pour essayer cette soumission:

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

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

L'entrée est [matrice sous forme de liste de listes, vecteur de colonnes]

Haskell, 39 octets

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

Cela utilise des indices basés sur 0. Exemple d'utilisation (j'utilise sqrt(-1)pour créer des 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]]

C'est juste un simple filtre comme on le voit dans d'autres réponses via la compréhension de la liste. Le cas particulier d'une liste d'index vide est intercepté séparément.