# Index of the row with most non-zero elements

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

# MATL, 6 bytes

!gs&X>

Input is a matrix, with ; as row separator.

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

# Mathematica, 23 bytes

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

# 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
• Use Ā instead of Ä0› for -2. Jun 26 '17 at 16:31
• Yee just realized there is probably a better way to do that part than what I had. Damn I feel like I'm learning a new 05AB1E command every day ^^ Jun 26 '17 at 16:32

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

• You need which.min() since non-zero elements will become FALSE with !m. Jun 26 '17 at 16:09
• @user2390246 oh, wow, I completely misread the question. Fixed, thank you. Jun 26 '17 at 16:33

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
• Nice! Better than mine, good to learn something. Jun 27 '17 at 3:42

# 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.

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

## 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))
• Just noticed it matches directly with the changes to the python 2 answer now. Jun 26 '17 at 16:49

# 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

)

# Brachylog, 17 bytes

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

Try it online!

€ĀOZk

Try it online!

0-indexed.

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, ... • Why do they all look like words? Jun 26 '17 at 22:33 # 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!

• Defining g=filter saves you one byte Jun 26 '17 at 17:54

Try it online!

# 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.

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

• I don't know Python but can't you remove most of the whitespace from this? Jun 26 '17 at 16:09
• @TheLethalCoder Python uses indentation instead of brackets for codeblocks, instead of brackets or keywords (e.g. for .. end). Jun 26 '17 at 16:12
• Even then python can be golfed a fair amount. The following is equivalent to your original code: def f(a):b=list(map(sorted,a));return b.index(sorted(b)[-1]) Jun 26 '17 at 16:13
• This answer uses a for loop and a function but with no newlines so I assume you can remove a lot of them although it is Python 2 the whitespace restrictions should be similar. Jun 26 '17 at 16:14
• Don't works for lists with negative numbers
– Rod
Jun 26 '17 at 16: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!

• 48 bytes
– ovs
Jun 26 '17 at 16:28
• Thanks @ovs. I didn't exactly understand how it works though. Jun 26 '17 at 16:36
• It's more or less the same logic that you had on your answer, but using min with the key parameter
– Rod
Jun 26 '17 at 18:54

# 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))
• Can you add an explanation for this one? Does filter implicitly "filter" zeroes? Jun 26 '17 at 16:10
• You're supposed to return the index of the row...
– Neil
Jun 26 '17 at 16:10
• Still trying to golf some more off it, @TheLethalCoder, will be adding a demo and an explanation when I'm done. In the meantime, see here for more info on filter, keeping in mind that 0 is falsey. Jun 26 '17 at 16:28
• @Neil: Fixed now. Jun 26 '17 at 16:29
• @Shaggy I assumed that was the case with filter was just making sure. Jun 26 '17 at 16:30

# 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 # 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. • This was exactly what I had a well. It felt clunky and like I was missing something, but it seems like there's just not a clean way to do it :( Jun 27 '17 at 1:29 # 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.

# 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

# 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 ;)

• +1 nice answer. Was about to post an even more verbose answer myself.. Was doubting whether to post it, and it's a good thing I hadn't since it's 145 bytes and ugly.. ;) Here it is... EDIT: Hmm, btw, your last two test cases fail.. Jun 27 '17 at 8:46
• Checking your code just made me realize there's a bug in my answer! o_O I don't even know how my test cases pass... Jun 27 '17 at 8:49
• Good to go, I fixed it! Jun 27 '17 at 8:51
• Nice! Btw, you can golf it by using a for-each inner loop to get rid of j and other longer parts like j=m[i].length, and m[i][j] like this: 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;} (101 bytes) Jun 27 '17 at 9:01

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

# 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.

# 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.

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

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