_{Im Zweifelsfall: Nan = Non-numeric datatypeim Sinne dieser Herausforderung.}

Schreiben Sie ein Programm oder eine Funktion, die eine Matrix / ein Array als Eingabe verwendet, sowie eine Liste von Spaltenindizes.

Die Herausforderung besteht darin, die Zeilen zu entfernen, in denen sich alle Elemente in den angegebenen Spalten befinden Nan. Es spielt keine Rolle, ob andere Elemente in der Zeile numerisch sind oder nicht. Die folgenden Beispiele werden dies hoffentlich klarer machen (es ist einseitig indiziert):

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

Regeln und Erläuterungen:

• Die Matrix ist immer nicht leer
• Die numerischen Werte sind endlich, aber nicht unbedingt ganze oder positive Werte
• Der Spaltenindexvektor kann leer sein (in diesem Fall werden keine Zeilen entfernt).
• Der Spaltenindex enthält niemals Werte, die die Matrixdimensionen überschreiten
• Sie können davon ausgehen, dass die Spaltenindexliste keine Duplikate enthält
• Sie können wählen, ob Sie Werte ohne oder mit einem Index verwenden möchten (bitte angeben).
• Sie können die Eingabe in einem beliebigen Format vornehmen
  • Array als Liste von Listen ist OK. Die Spaltenindizes können separate Argumente sein
• ans = und ähnliches wird in der Ausgabe akzeptiert
• Sie können frei wählen, welchen nicht numerischen Datentyp Sie verwenden möchten
  • Es sollte unmöglich sein, mit diesem Datentyp arithmetische Operationen durchzuführen oder ihn mit Funktionen wie in eine endliche Zahl umzuwandeln float(x).

Dies ist Codegolf, also gewinnt der kürzeste Code in Bytes.

Pyth, 16 19 10 9 7 10 Bytes

Spaltenindizes beginnen bei Null. Die Eingabe ist eine Liste von Listen. Verwendet eine leere Zeichenfolge als nicht numerischen Wert. Übernimmt die Liste der Spaltenindizes in der ersten Zeile und die Matrix mit den Werten in der zweiten Zeile.

?Qf-QxkTEE

Probieren Sie es online!

Erläuterung

?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

Update: Meine erste Lösung behandelte eine leere Liste von Spaltenindizes falsch. Behoben (ziemlich hässlich) auf Kosten von 3 Bytes. Ich werde versuchen, es nach der Arbeit besser zu machen ...

Update 2: Mit Hilfe von @FryAmTheEggman und durch signifikante Verbesserung des Algorithmus wurde es auf 10 9 7 Bytes reduziert.

Update3: Bug @ThomasKwa behoben. Seine vorgeschlagene 7-Byte-Lösung handhabte leere Spaltenindizes nicht richtig, daher fange ich diesen Fall hier nur mit einem Ternär ein. Ich verstehe nicht, wie ich diesen Geldautomaten verkürzen kann.

JavaScript (ES6), 48 46 Bytes

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

Erläuterung

Erwartet ein Array von Zeilen als Arrays und ein Array von 0-indizierten Zahlen für die zu überprüfenden Spalten. Gibt ein Array von Arrays zurück.

Unkompliziert filterund some. Prüft NaNmit n < Infinity( truefür endliche Zahlen, falsefür 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|},\;}

Ein unbenannter Block (Funktion), der die Matrix und die auf Null basierenden Spaltenindizes auf dem Stapel erwartet (die Matrix oben), wodurch die gefilterte Matrix auf dem Stapel verbleibt. Ich verwende das leere Array ""als nicht-numerischen Wert.

Teste es hier.

Erläuterung

{     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↑¨⍵[;⍺]}

Das linke Argument sollte eine Liste von Indizes sein (und es muss eine Liste sein, kein Skalar), das rechte Argument ist die Matrix. APL verfügt über zwei Datentypen, Zahlen und Zeichen. Dadurch werden die Zeichentypen herausgefiltert.

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

Erläuterung:

• ⍵[;⍺]: Wählen Sie die angegebenen Spalten aus der Matrix aus
• 0↑¨: Nimm die ersten 0Elemente vom Anfang jedes Gegenstandes
• ⍬∘≡¨: Vergleiche mit der numerischen leeren Liste
• ∨/: Sehen Sie, in welcher der Zeilen mindestens ein Element übereinstimmt
• ⍵⌿⍨: Wählen Sie diese Zeilen aus der Matrix aus

MATLAB, 32 28 Bytes

Ich werde meine eigene Frage einmal beantworten. Das Beste, was ich in MATLAB machen kann, sind 28 Bytes. Ich hatte gehofft, beides allund isnanirgendwie zu vermeiden , habe aber noch keinen Weg gefunden.

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

Prüfung:

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

Dies ist eine unbenannte anonyme Funktion, die die Eingabematrix als erste Eingabevariable und eine Liste von Spaltenindizes als zweite verwendet.

Wird in MATLAB NaN < Infmit false ausgewertet. Es kann davon ausgegangen werden, dass alle Werte endlich sind, sodass überprüft wird, ob die Werte kleiner als infsind. Dies entspricht der Überprüfung, ob sie nicht numerisch sind. any(...,2)prüft, ob es in der zweiten Dimension (Zeilen) wahre Werte gibt. In diesem Fall werden diese Zeilen zurückgegeben.

Alte Version:

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

isnan(A(:,c))Gibt ein Array mit Booleschen Werten für die angegebenen Spalten zurück. ~all(isnan(A(:,c)),2)prüft, ob alle Werte in der zweiten Dimension (Zeilen) nicht numerisch sind und negiert sie. Dies führt zu einem booleschen Vektor mit Einsen an den Positionen, die wir beibehalten möchten. A(~all(isnan(A(:,c)),2),:)verwendet die logische Indizierung, um die gesamten Zeilen für zu extrahieren A.

Die folgende 24-Byte-Lösung würde funktionieren, wenn die Werte garantiert ungleich Null wären:

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

Ruby, 48 Bytes

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

Eingabe ist 0-basierte Indizes ¹ .

Eigentlich ziemlich selbsterklärend. selectElemente aus dem Array, bei denen any?der mapIndex über die Zeile geht, sind Fixnums.

Probelauf:

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: Ich schließlich Dinkel dieses Wort richtig beim ersten Versuch! \Ö/}

K5, 15 Bytes

Dies verwendet 0-indizierte Spalten und die natürliche List-of-List-Matrixdarstellung von K:

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

Indizieren Sie in der Matrix ( x@) die Zeilen, in denen ( &) nicht alle von jedem ( ~&/') null ( ^) sind.

In Aktion:

  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 bis 16 Bytes

tiZ)tn?ZN!XA~Y)

NaNwird in der Eingabe als dargestellt N. Die Indizierung basiert auf 1. Zum Beispiel ist im ersten Testfall die Eingabe

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

Probieren Sie es online!

Erläuterung

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

Die Eingabe ist 1-basiert. Die Funktion verwendet eine Matrix ( m) und einen Vektor von Spaltenindizes ( j), die möglicherweise fehlen.

Zwei Testfälle:

> 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

Eine Funktion, die eine Matrix und ein Array als Eingabe verwendet und eine Matrix mit den entsprechenden Zeilen an ausgibt nil. Da Arrays den Arrays von C ziemlich ähnlich sind, ist das Vernichten wie das Löschen free(), da der Garbage Collector nicht weit entfernt ist.

Arrays sind in Lua 1-indiziert, und ich verwende den String "NaN"als Nicht-Nomber-Element.

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

Sie können Lua online testen und das folgende Codebeispiel kopieren / einfügen, um diese Übermittlung zu testen:

-- 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..}]&

Eingabe ist [Matrix als Liste von Listen, Vektor von Spalten]

Haskell, 39 Bytes

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

Dies verwendet 0-basierte Indizes. Verwendungsbeispiel (ich verwende s sqrt(-1)zum erstellen 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]]

Es ist nur ein einfacher Filter, wie er in anderen Antworten über das Listenverständnis angezeigt wird. Der Sonderfall einer leeren Indexliste wird separat erfasst.