Index of the row with most non-zero elements

Question

This is a simple one: Take a matrix of integers as input, and output the index of the row with the most non-zero elements. You may assume that there will only be one row with the most non-zero elements.

Test cases:

These are 1-indexed, you may choose if you want 0 or 1-indexed.

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

Answer 1

MATL, 6 bytes

!gs&X>

Input is a matrix, with ; as row separator.

Try it online! Or verify all test cases.

Explanation

!     % 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

Answer 2

Mathematica, 23 bytes

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

Answer 3

R, 31 bytes

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

returns an anonymous function which takes a matrix:

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

rowSums sums the rows, with !m transforming 0 to 1 and everything else to 0. which.min returns the 1-based index of the first row which contains the min sum (i.e., which row has the fewest zeros).

Try it online!

Answer 4

05AB1E, 8 6 bytes

ΣĀO}θk

Try it online!

-2 Bytes thanks to Erik the Outgolfer

Explanation

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

Answer 5

Haskell, 46 42 41 bytes

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

Try it online!

How it works

    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

Answer 6

C#, 69 bytes

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

Takes a List<int[]> as input and returns the 0-indexed result.

Answer 7

Python 3, 54 48 bytes

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

Shaved off 6 bytes. Old solution:

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

Answer 8

Actually, 9 bytes

0@♀cñ♂RmN

Try it online!

Explanation:

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)

Answer 9

APL (Dyalog), 11 bytes

(⊢⍳⌈/)+/0≠⎕

Try it online!

0≠⎕ Boolean matrix where non-zero

+/ sum rows

( apply the following tacit function to the list of sums

 ⌈/ the maximum's

 ⍳ index

 ⊢ in the argument list

)

Answer 10

Brachylog, 17 bytes

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

Try it online!

Answer 11

Jelly, 5 bytes

TL$€M

Try it online!

1-indexed.

So many 5-byte versions...

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

Answer 12

Clojure, 64 bytes

This one works also with negative numbers in the input, luckily the same length as the 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 %))))

Answer 13

05AB1E, 5 bytes

€ĀOZk

Try it online!

0-indexed.

Answer 14

Haskell - 69 68 Bytes

Saved one byte thanks to Siracusa!

Rows are zero indexed

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

Usage

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

Try it online!

Answer 15

CJam, 11 bytes

{0fe=_:e<#}

Try it online!

-2 thanks to Challenger5.

Answer 16

q/kdb+, 25 17 16 bytes

Solution:

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

Example:

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

Explanation:

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

Notes:

The problem is fairly straightforward, this solution feels overly complicated. As soon as I hit submit I realised the error of my ways.

Bonus:

Here's a k solution that weights in at 16 10 9 bytes - almost exactly the same but 7 bytes shorter due to the fact we don't need brackets when using the k built-ins, and as a result some become shorter than the q keywords (e.g. +/ for sum (would be (+/) in q)).

*<+/+0=/:

Answer 17

Jelly, 7 bytes

ċ0$ÞḢi@

Try it online!

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

Answer 18

Python 2, 64 55 52 48 bytes

• Thanks to @Rod for shaving 9 bytes!!: count 0s and use min() instead of max()
• @Rod saved yet another 3 bytes: use input() instead of def
• @ovs saved 4 bytes: use of lambda and hash-map

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

Try it online!

Answer 19

JavaScript (ES6), 62 bytes

0-indexed. Takes a 2D array as input.

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

Answer 20

PHP, 58 bytes

0-Indexed

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

Try it online!

Answer 21

V, 18 bytes

òø0
jòÚDuu/"
dGؾ

Try it online!

Unlike most V answers, this is 0-indexed.

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

Not bad for a language with no numeric support! ;P

I also have discovered that the uppercase variant of the count command, that is Ø, is horribly broken.

Answer 22

Python 3, 92 bytes

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

First sort each row such that the entrys are [0,0,..,0,x,x,x] then sort the whole matrix, so that the last entry in y is the row we are looking for. The copy y=x[:] is necessary, since .sort() works inplace, hence we don't know the original index after sorting.

I appreciate any help how to golf this solution further. Most bytes are lost because of the whitespaces in each line. The code itself is only 68 bytes long.

Try it online!

Answer 23

Pyth, 6 bytes

xQh/D0

Demonstration

Instead of finding the row with the most non-zero elements, I find the row with the least zero elements.

/D0: Order (D) by count (/) of zeros (0). Implicitly applied to Q, the input.

h: Take the first, and minimum, element.

xQ: Find the index (x) in the input (Q) of that element.

Answer 24

Retina, 46 bytes

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

Try it online!

0-indexed. Works with positive and negative integers (and 0). Assumes no leading zeros.

Answer 25

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;}

Try it online!

Java, that sweet verbose language :)

Thanks for saving 18 bytes, @KevinCruijssen ;)

Answer 26

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;}

Ugly, but it works..

Explanation:

Try it here.

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

Answer 27

JavaScript (ES6), 51 Bytes

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

where m is a 2D array and the index returned is 0-indexed

Test cases:

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

Answer 28

Python 2, 51 bytes

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

Try it online!

This version removes 0s progressively through the arrays, printing the current index, and crashes when there are no more zeros to remove. Last printed index is the answer.

Python 2, 57 bytes

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

Try it online!

Wanted to try a different approach from what's already here. So here I recursively iterate over the array removing one 0 at a time until the current array no longer has any zeroes - and then output the index of that array.

Answer 29

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())

Explanation

The power of Lists and Streams! (and without the imports, to boot!)

Let's break this little lambda down into chunks:

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

We turn our List of Lists (the matrix in the question) into a Stream and go through each element, removing all of those pesky zeroes from each sub-List. We need to explicitly return the sublist each time here, because Stream.map() converts each object in the Stream to whatever the mapping returns, and we don't want to change them.

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

We go through our newly de-zeroed sublists, and simply check how big they are next to each other, getting us the biggest sublist. The .get() is because the Stream.max() returns an Optional, requiring that extra function call.

m.indexOf()

We take that biggest sublist, and find where it is in the main List, giving us our result!

Notes

This breaks if the outer list is empty, but I'm taking

You may assume that there will only be one row with the most non-zero elements.

to imply that there will always be at least one row. Correct me if I'm wrong.

Answer 30

Japt, 7 bytes

0-indexed. Takes input as an array of arrays.

mè
bUrw

Test it

---

Explanation

Implicit input of array U.
[[0,4,1,0],[0,0,-6,0],[0,1,4,-3],[2,0,0,8],[0,0,0,0]]

mè

Map (m) over U returning the count of truthy (non-zero) elements in each sub-array. Implicitly assign this new array to U.
[2,1,3,2,0]

Urw

Reduce (r) array U by getting the greater of the current value and the current element.
3

b

Get the first index in U where the element equals that value and implicitly output the result.
2

Answer 31

Python 2, 62 bytes

lambda m:max(range(len(m)),key=lambda n:len(filter(abs,m[n])))

Try it online!

Answer 32

J, 16 bytes

0{[:/:@:+/@|:0=]

Try it online!