Essa é simples: use uma matriz de números inteiros como entrada e faça a saída do índice da linha com o maior número de elementos diferentes de zero. Você pode supor que haverá apenas uma linha com mais elementos diferentes de zero.

Casos de teste:

Estes são indexados em 1, você pode escolher se deseja indexar 0 ou 1.

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>

A entrada é uma matriz, com o ;separador de linhas.

Experimente online! Ou verifique todos os casos de teste .

Explicação

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

Experimente online!

-2 Bytes graças a Erik, o Outgolfer

Explicação

ΣĀ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)))

retorna uma função anônima que leva uma matriz:

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

rowSumssoma as linhas, !mtransformando 0 em 1 e todo o resto em 0. which.minretorna o índice baseado em 1 da primeira linha que contém a soma mínima (ou seja, qual linha possui o menor número de zeros).

Experimente online!

Haskell, 46 42 41 bytes

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

Experimente online!

Como funciona

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

Pega a List<int[]>como entrada e retorna o resultado indexado em 0.

Na verdade , 9 bytes

0@♀cñ♂RmN

Experimente online!

Explicação:

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

Raspou 6 bytes. Solução antiga:

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

APL (Dyalog) , 11 bytes

(⊢⍳⌈/)+/0≠⎕

Experimente online!

0≠⎕ Matriz booleana onde diferente de zero

+/ soma de linhas

( aplique a seguinte função tácita à lista de somas

 ⌈/ o máximo

 ⍳ índice

 ⊢ na lista de argumentos

)

Braquilog , 17 bytes

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

Experimente online!

05AB1E , 5 bytes

€ĀOZk

Experimente online!

Indexado a 0.

Gelatina , 5 bytes

TL$€M

Experimente online!

1 indexado.

Tantas versões de 5 bytes ...

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

Guardado um byte graças a Siracusa!

As linhas são zero indexadas

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

Uso

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

Experimente online!

Clojure, 64 bytes

Este também funciona com números negativos na entrada, felizmente o mesmo tamanho que o 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

Solução:

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

Exemplo:

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

Explicação:

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

Notas:

O problema é bastante direto, essa solução parece excessivamente complicada. Assim que apertei enviar, percebi o erro dos meus caminhos.

Bônus:

Aqui está uma solução que pesa 16 10 9 bytes - quase exatamente o mesmo, mas 7 bytes mais curto devido ao fato de não precisarmos de colchetes ao usar os k built-ins e, como resultado, alguns ficam mais curtos que as palavras-chave q ( por exemplo, +/para sum(estaria (+/)em q)).

*<+/+0=/:

CJam , 11 bytes

{0fe=_:e<#}

Experimente online!

-2 graças a Challenger5 .

PHP , 58 bytes

0-Indexado

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

Experimente online!

V , 18 bytes

òø0
jòÚDuu/"
dGؾ

Experimente online!

Diferentemente da maioria das respostas em V, isso é indexado em 0.

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

Nada mal para um idioma sem suporte numérico! ;P

Também descobri que a variante maiúscula do comando count , ou seja Ø, está terrivelmente quebrada.

Python 3 , 92 bytes

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

Primeiro, classifique cada linha de [0,0,..,0,x,x,x]modo que as entradas classifiquem toda a matriz, para que a última entrada yseja a linha que estamos procurando. A cópia y=x[:]é necessária, pois .sort()funciona no local, portanto, não sabemos o índice original após a classificação.

Agradeço qualquer ajuda como jogar esta solução ainda mais. A maioria dos bytes é perdida devido aos espaços em branco em cada linha. O código em si tem apenas 68 bytes.

Experimente online!

Python 2 , 64 55 52 48 bytes

• Graças a @Rod para barbear 9 bytes !! : conte se 0use em min()vez demax()
• O @Rod salvou outros 3 bytes: use em input()vez dedef
• @ovs salvou 4 bytes : uso lambdae mapa de hash

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

Experimente online!

JavaScript (ES6), 62 bytes

Indexado a 0. Toma uma matriz 2D como entrada.

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

Geléia , 7 bytes

ċ0$ÞḢi@

Experimente online!

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

Pitão, 6 bytes

xQh/D0

Demonstração

Em vez de encontrar a linha com mais elementos diferentes de zero, encontro a linha com menos elementos.

/D0: Ordene ( D) pela contagem ( /) de zeros ( 0). Aplicado implicitamente aQ entrada.

h: Pegue o primeiro e o mínimo elemento.

xQ: Encontre o índice ( x) na entrada ( Q) desse elemento.

Retina , 46 bytes

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

Experimente online!

Indexado a 0. Funciona com números inteiros positivos e negativos (e 0). Não assume zeros à esquerda.

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

Feio, mas funciona ..

Explicação:

Experimente aqui.

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

Experimente online!

Java, essa doce linguagem detalhada :)

Obrigado por salvar 18 bytes, @KevinCruijssen;)

JavaScript (ES6), 51 bytes

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

onde mé uma matriz 2D e o índice retornado é indexado em 0

Casos de teste:

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

Explicação

O poder das listas e córregos! (e sem as importações, para inicializar!)

Vamos dividir esse pequeno lambda em pedaços:

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

Transformamos nossa lista de listas (a matriz na pergunta) em um fluxo e analisamos cada elemento, removendo todos os zeros traquinas de cada sub-lista. Precisamos retornar explicitamente a sublist cada vez aqui, porque Stream.map()converte cada objeto no Stream para o que o mapeamento retornar, e não queremos alterá-los.

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

Examinamos nossas sublistas recém-zeradas e simplesmente verificamos quão grandes elas são próximas uma da outra, obtendo para nós a maior sub-lista. O .get()é porque o Stream.max()retorna um opcional, exigindo que chamada de função extra.

m.indexOf()

Nós pegamos a maior sublist e descobrimos onde ela está na lista principal, nos dando o nosso resultado!

Notas

Isso quebra se a lista externa estiver vazia, mas eu estou pegando

Você pode supor que haverá apenas uma linha com mais elementos diferentes de zero.

implicar que sempre haverá pelo menos uma linha. Corrija-me se eu estiver errado.

Python 2 , 51 bytes

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

Experimente online!

Essa versão remove os 0s progressivamente pelas matrizes, imprimindo o índice atual e trava quando não há mais zeros a serem removidos. O último índice impresso é a resposta.

Python 2 , 57 bytes

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

Experimente online!

Queria tentar uma abordagem diferente do que já está aqui. Então, aqui, eu iteramos recursivamente sobre a matriz, removendo um 0 de cada vez, até que a matriz atual não tenha mais zeros - e depois produzo o índice dessa matriz.

Japonês , 7 bytes

Indexado a 0. Recebe a entrada como uma matriz de matrizes.

mè
bUrw

Teste-o

Explicação

Entrada implícita da matriz U.
[[0,4,1,0],[0,0,-6,0],[0,1,4,-3],[2,0,0,8],[0,0,0,0]]

mè

Mapeie ( m) Uretornando a contagem de elementos verdadeiros (diferentes de zero) em cada sub-matriz. Atribua implicitamente essa nova matriz a U.
[2,1,3,2,0]

Urw

Reduza ( r) a matriz U, obtendo o maior valor atual e o elemento atual.
3

b

Obtenha o primeiro índice em Uque o elemento é igual a esse valor e produz implicitamente o resultado.
2