Dies ist eine einfache Methode: Nehmen Sie eine Ganzzahlmatrix als Eingabe und geben Sie den Index der Zeile mit den meisten Nicht-Null-Elementen aus. Sie können davon ausgehen, dass es nur eine Zeile mit den meisten Nicht-Null-Elementen gibt.

Testfälle:

Diese sind 1-indiziert. Sie können wählen, ob Sie 0 oder 1-indiziert möchten.

1
0
row = 1
---
0  -1
0   0
row = 1
---
1   1   0   0   0
0   0   5   0   0
2   3   0   0   0
0   5   6   2   2
row = 4
---
0   4   1   0
0   0  -6   0
0   1   4  -3
2   0   0   8
0   0   0   0
row = 3

MATL , 6 Bytes

!gs&X>

Die Eingabe ist eine Matrix mit einem ;Zeilentrennzeichen.

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Erläuterung

!     % Transpose
g     % Logical: convert non-zeros to 1
s     % Sum of each column, or sum of row if there's a single row
&X>   % Arg max. Implicitly display

Mathematica, 23 Bytes

Ordering[Count@0/@#,1]&

05AB1E , 8 6 Bytes

ΣĀO}θk

Probieren Sie es online!

-2 Bytes dank Erik dem Outgolfer

Erläuterung

ΣĀO}θk
Σ  }   # Sort input by following code
 Ā      # Is element not 0? (vectorized)
  O     # Sum
    θk # Get index of "largest" element
       # Implicit print

R , 31 Bytes

pryr::f(which.min(rowSums(!m)))

gibt eine anonyme Funktion zurück, die eine Matrix annimmt:

function(m)which.min(rowSums(!m))

rowSumssummiert die Zeilen, wobei !m0 in 1 und alles andere in 0 umgewandelt wird.which.min Gibt den 1-basierten Index der ersten Zeile zurück, die die Min-Summe enthält (dh welche Zeile die wenigsten Nullen hat).

Probieren Sie es online!

Haskell, 46 42 41 Bytes

snd.minimum.(`zip`[1..]).map(filter(==0))

Probieren Sie es online!

Wie es funktioniert

    map                    -- for each row
        (filter(==0))      -- collect the 0s
    (`zip`[1..])           -- pair with row index  (<#0s>, <index>)
  minimum                  -- find the minimum
snd                        -- extract index from pair

C #, 69 Bytes

using System.Linq;m=>m.IndexOf(m.OrderBy(r=>r.Count(n=>n!=0)).Last())

Nimmt a List<int[]>als Eingabe und gibt das 0-indizierte Ergebnis zurück.

Eigentlich 9 Bytes

0@♀cñ♂RmN

Probieren Sie es online!

Erläuterung:

0@♀cñ♂RmN
0@♀c       count zeroes in each row
    ñ♂R    enumerate and reverse each row (each row becomes [count, index] pair)
       m   minimum
        N  last element (the index)

Python 3, 54 48 Bytes

lambda a:a.index(min(a,key=lambda r:r.count(0)))

6 Bytes abgeschabt. Alte Lösung:

lambda a:min(range(len(a)),key=lambda i:a[i].count(0))

APL (Dyalog) , 11 Bytes

(⊢⍳⌈/)+/0≠⎕

Probieren Sie es online!

0≠⎕ Boolesche Matrix, die nicht Null ist

+/ Summenzeilen

( Wenden Sie die folgende implizite Funktion auf die Liste der Summen an

 ⌈/ das Maximum ist

 ⍳ Index

 ⊢ in der Argumentliste

)

Brachylog , 17 Bytes

{{∋0}ᶜ}ᵐA;.∋₎~⌋A∧

Probieren Sie es online!

05AB1E , 5 Bytes

€ĀOZk

Probieren Sie es online!

0-indiziert.

Gelee , 5 Bytes

TL$€M

Probieren Sie es online!

1-indiziert.

So viele 5-Byte-Versionen ...

TL$€M, T€L€M, TJ$€M, T€J€M, ¬¬Ṣ€M, ṠAṢ€M, ṠAS€M, AṠṢ€M, AṠS€M, ¬ċ€0M, ...

Haskell - 69 68 Bytes

Dank Siracusa ein Byte gespart!

Zeilen sind mit Null indiziert

g=filter
m y=head$g((==maximum y).(y!!))[0..]
f=m.map(length.g(0/=))

Verwendung

f [[1,1,0,0,0],[2,3,0,0,0],[0,5,6,2,2],[1,1,1,1,1]]

Probieren Sie es online!

Clojure, 64 Bytes

Dieser funktioniert auch mit negativen Zahlen in der Eingabe, zum Glück in der gleichen Länge wie das Original:

#(nth(sort-by(fn[i](count(filter #{0}(% i))))(range(count %)))0)

Original:

#(last(sort-by(fn[i](count(filter pos?(% i))))(range(count %))))

q / kdb +, 25 17 16 Bytes

Lösung:

(*)(<)sum(+)0=/:

Beispiel:

q)(*)(<)sum(+)0=/:enlist(1;0)
0
q)(*)(<)sum(+)0=/:(0 -1;0 0)
0
q)(*)(<)sum(+)0=/:(1 1 0 0 0;0 0 5 0 0;2 3 0 0 0;0 5 6 2 2)
3
q)(*)(<)sum(+)0=/:(0 4 1 0;0 0 -6 0;0 1 4 -3;2 0 0 8;0 0 0 0)
2

Erläuterung:

first iasc sum flip 0=/:  / ungolfed
                      /:  / each right, apply a function to each item to the right
                    0=    / returns boolean 1b or 0b if item in each list is equal to zero
               flip       / flip (rotate) the output
           sum            / sum these up
      iasc                / return indices if we were to sort ascending
first                     / take the first one

Anmerkungen:

Das Problem ist ziemlich einfach, diese Lösung fühlt sich zu kompliziert an. Sobald ich Submit drückte, bemerkte ich den Fehler meiner Wege.

Bonus:

Hier ist eine Lösung, die mit 16 10 9 Bytes gewichtet wird - fast genau das gleiche, aber 7 Bytes kürzer, da bei Verwendung der k integrierten Funktionen keine eckigen Klammern erforderlich sind und einige davon kürzer werden als die q Schlüsselwörter ( zB +/für sum(wäre (+/)in q)).

*<+/+0=/:

CJam , 11 Bytes

{0fe=_:e<#}

Probieren Sie es online!

-2 dank Challenger5 .

PHP , 58 Bytes

0-indiziert

<?=array_search(max($a=array_map(array_filter,$_GET)),$a);

Probieren Sie es online!

V , 18 Bytes

òø0
jòÚDuu/"
dGؾ

Probieren Sie es online!

Im Gegensatz zu den meisten V-Antworten ist dies 0-indiziert.

00000000: f2f8 300a 6af2 da44 7575 2f12 220a 6447  ..0.j..Duu/.".dG
00000010: d8be                                     ..

Nicht schlecht für eine Sprache ohne numerische Unterstützung! ;P

Ich habe auch , dass die Groß Variante des entdeckte Zählung Befehls, das ist Ø, ist schrecklich gebrochen.

Python 3 , 92 Bytes

def f(x):
    for e in x:
        e.sort()
    y=x[:]
    y.sort()
    return x.index(y[-1])

Sortieren Sie zuerst jede Zeile so, dass die Einträge [0,0,..,0,x,x,x]dann die gesamte Matrix sortieren, sodass der letzte Eintrag in yder Zeile ist, nach der wir suchen. Die Kopiey=x[:] ist notwendig, da sie an Ort und Stelle .sort()funktioniert. Daher kennen wir den ursprünglichen Index nach dem Sortieren nicht.

Ich freue mich über jede Hilfe, um diese Lösung weiter zu verbessern. Die meisten Bytes gehen aufgrund der Leerzeichen in jeder Zeile verloren. Der Code selbst ist nur 68 Byte lang.

Probieren Sie es online!

Python 2 , 64 55 52 48 Bytes

• Danke an @Rod für das Rasieren von 9 Bytes !! : zähle 0s und benutze min()stattmax()
• @Rod hat noch 3 Bytes gespeichert: benutze input()stattdef
• @ovs sparte 4 Bytes : Verwendung von lambdaund Hash-Map

lambda x:x.index(min(x,key=lambda n:n.count(0)))

Probieren Sie es online!

JavaScript (ES6), 62 Byte

0-indiziert. Nimmt ein 2D-Array als Eingabe.

a=>(a=a.map(x=>x.filter(y=>y).length)).indexOf(Math.max(...a))

Gelee , 7 Bytes

ċ0$ÞḢi@

Probieren Sie es online!

ċ0$ÞḢi@  Main link
   Þ     Sort by
ċ0$              the number of occurences of 0
    Ḣ    Take the first element
     i@  Index in the original array

Pyth, 6 Bytes

xQh/D0

Demonstration

Anstatt die Zeile mit den meisten Nicht-Null-Elementen zu finden, finde ich die Zeile mit den niedrigsten Null-Elementen.

/D0: Reihenfolge ( D) nach Anzahl ( /) der Nullen ( 0). Implizit angewendet auf Qdie Eingabe.

h: Nehmen Sie das erste und minimale Element.

xQ: Finden Sie den Index ( x) in der Eingabe ( Q) dieses Elements.

Netzhaut , 46 Bytes

%M`\b0
m`(?<=(¶.+)*)$
;$#1
O#`.+
!`(?<=^.+;).+

Probieren Sie es online!

0-indiziert. Funktioniert mit positiven und negativen ganzen Zahlen (und 0). Nimmt keine führenden Nullen an.

Java 8, 145 Bytes

import java.util.*;m->{int t=0,s=0,i=0,r=0;for(;i<m.size();i++){List l=(List)m.get(i);for(;l.remove(0L););s=l.size();if(s>t){t=s;r=i;}}return r;}

Hässlich, aber es funktioniert ..

Erläuterung:

Probieren Sie es hier aus.

import java.util.*;         // Required import for List

m->{                        // Method with List parameter and integer return-type
  int t=0,s=0,i=0,          //  Temp integers
      r=0;                  //  Result integer
  for(;i<m.size();i++){     //  Loop over the List of Lists
    List l=(List)m.get(i);  //   Get the inner List
    for(;l.remove(0L););    //   Remove all zeros
    s=l.size();             //   Get the size of the List
    if(s>t){                //   If this size is larger than the previous
      t=s;                  //    Set `t` to this size
      r=i;                  //    And set the result to the index of this row
    }
  }                         //  End of loop
  return r;                 //  Return result-integer
}                           // End of method

Java (OpenJDK 8) , 119 101 Bytes

m->{int i=m.length,M=0,I=0,c;for(;i-->0;){c=0;for(int x:m[i])if(x!=0)c++;if(c>M){M=c;I=i;}}return I;}

Probieren Sie es online!

Java, diese süße, ausführliche Sprache :)

Danke, dass du 18 Bytes gespart hast, @KevinCruijssen;)

JavaScript (ES6), 51 Bytes

m=>m.reduce((a,e,i)=>e.filter(x=>x).length>a?i:a,0)

Dabei mist ein 2D-Array und der zurückgegebene Index ist 0-indiziert

Testfälle:

f=
m=>m.reduce((a,e,i)=>e.filter(x=>x).length>a?i:a,0)

console.log(f([[1], [0]]))
console.log(f([[0,-1], [0,0]]))
console.log(f([[1,1,0,0,0], [0,0,5,0,0], [2,3,0,0,0], [0,5,6,2,2]]))
console.log(f([[0,4,1,0], [0,0,-6,0], [0,1,4,-3], [2,0,0,8], [0,0,0,0]]))

Java 8, 100 Bytes

m->m.indexOf(m.stream().map(z->{z.removeIf(x->x==0);return z;}).max((q,r)->q.size()-r.size()).get())

Erläuterung

Die Kraft der Listen und Streams! (Und ohne die Importe, um zu booten!)

Brechen wir dieses kleine Lambda in Stücke:

m.stream().map(z->{z.removeIf(x->x==0);return z;}

Wir wandeln unsere Liste der Listen (die Matrix in der Frage) in einen Stream um und gehen jedes Element durch, wobei wir alle diese nervigen Nullen aus jeder Unterliste entfernen. Wir müssen die Unterliste jedes Mal hier explizit zurückgeben, da Stream.map()jedes Objekt im Stream in das konvertiert wird, was auch immer die Zuordnung zurückgibt, und wir möchten sie nicht ändern.

.max((q,r)->q.size()-r.size()).get()

Wir gehen unsere neu entnullten Unterlisten durch und überprüfen einfach, wie groß sie nebeneinander sind, um die größte Unterliste zu erhalten. Das .get()liegt daran, dass dasStream.max() eine Optional gibt, erfordern , dass zusätzliche Funktionsaufruf.

m.indexOf()

Wir nehmen diese größte Unterliste und finden heraus, wo sie sich in der Hauptliste befindet. So erhalten wir unser Ergebnis!

Anmerkungen

Dies bricht, wenn die äußere Liste leer ist, aber ich nehme

Sie können davon ausgehen, dass es nur eine Zeile mit den meisten Nicht-Null-Elementen gibt.

zu implizieren, dass es immer mindestens eine Zeile geben wird. Korrigiere mich, wenn ich falsch liege.

Python 2 , 51 Bytes

def f(x,i=0):print i;x[i].remove(0);f(x,-~i%len(x))

Probieren Sie es online!

Diese Version entfernt schrittweise Nullen durch die Arrays, druckt den aktuellen Index und stürzt ab, wenn keine Nullen mehr entfernt werden müssen. Der zuletzt gedruckte Index ist die Antwort.

Python 2 , 57 Bytes

lambda x,i=0:0in x[i]>x[i].remove(0)and f(x,-~i%len(x))|i

Probieren Sie es online!

Wollte eine andere Herangehensweise ausprobieren als die, die bereits hier ist. Also iteriere ich hier rekursiv über das Array und entferne jeweils eine 0, bis das aktuelle Array keine Nullen mehr hat - und gebe dann den Index dieses Arrays aus.

Japt , 7 Bytes

0-indiziert. Übernimmt die Eingabe als Array von Arrays.

mè
bUrw

Probier es aus

Erläuterung

Implizite Eingabe eines Arrays U.
[[0,4,1,0],[0,0,-6,0],[0,1,4,-3],[2,0,0,8],[0,0,0,0]]

mè

Map ( m) über die URückgabe der Anzahl der wahrheitsgemäßen (von Null verschiedenen) Elemente in jedem Unterarray. Ordnen Sie dieses neue Array implizit zu U.
[2,1,3,2,0]

Urw

Reduzieren Sie das rArray ( ), Uindem Sie den aktuellen Wert und das aktuelle Element auf den höchsten Wert bringen.
3

b

Rufen Sie den ersten Index ab, in Udem das Element diesem Wert entspricht, und geben Sie das Ergebnis implizit aus.
2