# 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. Commented Jun 26, 2017 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 ^^ Commented Jun 26, 2017 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. Commented Jun 26, 2017 at 16:09
• @user2390246 oh, wow, I completely misread the question. Fixed, thank you. Commented Jun 26, 2017 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. Commented Jun 27, 2017 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. Commented Jun 26, 2017 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!

# 05AB1E, 5 bytes

€Ā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? Commented Jun 26, 2017 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 Commented Jun 26, 2017 at 17:54
• You can even remove a few bytes more with m y=length$takeWhile(<maximum y)y and shortening length instead of filter Commented Jun 26, 2017 at 19:13 ## 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 %))))  • numbers in matrix are integers. so pos? isn't correct Commented Jun 27, 2017 at 9:29 • True, I forgot to account for negative integers. Fixed now. Commented Jun 27, 2017 at 10:22 # q/kdb+, 2517 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=/:  # CJam, 11 bytes {0fe=_:e<#}  Try it online! -2 thanks to Challenger5. • 11: {0fe=_:e>#} Commented Jun 30, 2017 at 4:46 • @Challenger5 > should be < instead...thanks anyways. :) Commented Jun 30, 2017 at 7:27 # Python 2, 62 bytes lambda m:max(range(len(m)),key=lambda n:len(filter(abs,m[n])))  Try it online! # PHP, 58 bytes 0-Indexed <?=array_search(max($a=array_map(array_filter,$_GET)),$a);


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? Commented Jun 26, 2017 at 16:09
• @TheLethalCoder Python uses indentation instead of brackets for codeblocks, instead of brackets or keywords (e.g. for .. end). Commented Jun 26, 2017 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]) Commented Jun 26, 2017 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. Commented Jun 26, 2017 at 16:14
• Don't works for lists with negative numbers
– Rod
Commented Jun 26, 2017 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
Commented Jun 26, 2017 at 16:28
• Thanks @ovs. I didn't exactly understand how it works though. Commented Jun 26, 2017 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
Commented Jun 26, 2017 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? Commented Jun 26, 2017 at 16:10
• You're supposed to return the index of the row...
– Neil
Commented Jun 26, 2017 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. Commented Jun 26, 2017 at 16:28
• @Neil: Fixed now. Commented Jun 26, 2017 at 16:29
• @Shaggy I assumed that was the case with filter was just making sure. Commented Jun 26, 2017 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 :( Commented Jun 27, 2017 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.

# J, 16 bytes

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


Try it online!

• 0{&\:1#.|@* for 11: Try it online! Commented Nov 14, 2023 at 2:34

# 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.. Commented Jun 27, 2017 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... Commented Jun 27, 2017 at 8:49
• Good to go, I fixed it! Commented Jun 27, 2017 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) Commented Jun 27, 2017 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.