Este es simple: tome una matriz de enteros como entrada y envíe el índice de la fila con la mayoría de los elementos distintos de cero. Puede suponer que solo habrá una fila con la mayoría de los elementos distintos de cero.

Casos de prueba:

Estos están indexados en 1, puede elegir si desea 0 o 1 indexado.

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>

La entrada es una matriz, con un ;separador de filas.

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación

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

Pruébalo en línea!

-2 Bytes gracias a Erik the Outgolfer

Explicación

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

devuelve una función anónima que toma una matriz:

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

rowSumssuma las filas, con la !mtransformación de 0 a 1 y todo lo demás a 0. which.mindevuelve el índice basado en 1 de la primera fila que contiene la suma mínima (es decir, qué fila tiene la menor cantidad de ceros).

Pruébalo en línea!

Haskell, 46 42 41 bytes

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

Pruébalo en línea!

Cómo 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())

Toma a List<int[]>como entrada y devuelve el resultado indexado 0.

En realidad , 9 bytes

0@♀cñ♂RmN

Pruébalo en línea!

Explicación:

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

Afeitado de 6 bytes. Vieja solución:

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

APL (Dyalog) , 11 bytes

(⊢⍳⌈/)+/0≠⎕

Pruébalo en línea!

0≠⎕ Matriz booleana donde no es cero

+/ suma de filas

( aplicar la siguiente función tácita a la lista de sumas

 ⌈/ el máximo

 ⍳ índice

 ⊢ en la lista de argumentos

)

Brachylog , 17 bytes

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

Pruébalo en línea!

05AB1E , 5 bytes

€ĀOZk

Pruébalo en línea!

0 indexado.

Jalea , 5 bytes

TL$€M

Pruébalo en línea!

1 indexado.

Tantas versiones 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

¡Salvado un byte gracias a Siracusa!

Las filas están indexadas a cero

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

Pruébalo en línea!

Clojure, 64 bytes

Este también funciona con números negativos en la entrada, afortunadamente la misma longitud que el 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

Solución:

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

Ejemplo:

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

Explicación:

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:

El problema es bastante sencillo, esta solución se siente demasiado complicada.Tan pronto como presioné enviar, me di cuenta del error de mis formas.

Prima:

Aquí hay una solución k que pesa 16 10 9 bytes, casi exactamente lo mismo pero 7 bytes más cortos debido al hecho de que no necesitamos corchetes al usar los k incorporados, y como resultado algunos se vuelven más cortos que las palabras clave q ( por ejemplo +/para sum(estaría (+/)en q)).

*<+/+0=/:

CJam , 11 bytes

{0fe=_:e<#}

Pruébalo en línea!

-2 gracias a Challenger5 .

PHP , 58 bytes

0-indexado

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

Pruébalo en línea!

V , 18 bytes

òø0
jòÚDuu/"
dGؾ

Pruébalo en línea!

A diferencia de la mayoría de las respuestas V, esta está indexada en 0.

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

¡No está mal para un idioma sin soporte numérico! ;P

También he descubierto que la variante en mayúsculas del comando de conteo , es decir Ø, está horriblemente rota.

Python 3 , 92 bytes

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

Primero ordene cada fila de modo que las entradas sean [0,0,..,0,x,x,x]luego la matriz completa, de modo que la última entrada ysea ​​la fila que estamos buscando. La copia y=x[:]es necesaria, ya que .sort()funciona en el lugar, por lo tanto, no conocemos el índice original después de la clasificación.

Agradezco cualquier ayuda sobre cómo golf esta solución más. La mayoría de los bytes se pierden debido a los espacios en blanco en cada línea. El código en sí solo tiene 68 bytes de longitud.

Pruébalo en línea!

Python 2 , 64 55 52 48 bytes

• ¡Gracias a @Rod por afeitar 9 bytes! : cuenta 0sy usa en min()lugar demax()
• @Rod guardó otros 3 bytes más: use en input()lugar dedef
• @ovs guardó 4 bytes : uso de lambday hash-map

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

Pruébalo en línea!

JavaScript (ES6), 62 bytes

0 indexado. Toma una matriz 2D como entrada.

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

Jalea , 7 bytes

ċ0$ÞḢi@

Pruébalo en línea!

ċ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

Demostración

En lugar de encontrar la fila con la mayor cantidad de elementos distintos de cero, encuentro la fila con la menor cantidad de elementos cero.

/D0: Ordenar ( D) por cuenta ( /) de ceros ( 0). Aplicado implícitamente aQ la entrada.

h: Tome el primer elemento y el mínimo.

xQ: Encuentre el índice ( x) en la entrada ( Q) de ese elemento.

Retina , 46 bytes

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

Pruébalo en línea!

0 indexado. Funciona con enteros positivos y negativos (y 0). Asume que no hay ceros a la izquierda.

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

Feo, pero funciona ..

Explicación:

Pruébalo aquí

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) , 119101 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;}

Pruébalo en línea!

Java, ese dulce lenguaje detallado :)

Gracias por guardar 18 bytes, @KevinCruijssen;)

JavaScript (ES6), 51 bytes

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

donde mes una matriz 2D y el índice devuelto está indexado a 0

Casos de prueba:

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

Explicación

El poder de las listas y corrientes! (y sin las importaciones, para arrancar!)

Dividamos esta pequeña lambda en trozos:

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

Convertimos nuestra Lista de Listas (la matriz en la pregunta) en una Corriente y revisamos cada elemento, eliminando todos esos molestos ceros de cada sublista. Necesitamos devolver explícitamente la sublista cada vez aquí, porque Stream.map()convierte cada objeto en el flujo a lo que devuelve el mapeo, y no queremos cambiarlos.

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

Revisamos nuestras sublistas recién descalificadas, y simplemente verificamos qué tan grandes son una al lado de la otra, consiguiendo la sublista más grande. Esto .get()se debe a que Stream.max()devuelve un Opcional, que requiere esa llamada de función adicional.

m.indexOf()

¡Tomamos esa sublista más grande y encontramos dónde está en la Lista principal, dándonos nuestro resultado!

Notas

Esto se rompe si la lista externa está vacía, pero estoy tomando

Puede suponer que solo habrá una fila con la mayoría de los elementos distintos de cero.

para implicar que siempre habrá al menos una fila. Corrígeme si me equivoco.

Python 2 , 51 bytes

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

Pruébalo en línea!

Esta versión elimina 0s progresivamente a través de las matrices, imprime el índice actual y se bloquea cuando no hay más ceros para eliminar. El último índice impreso es la respuesta.

Python 2 , 57 bytes

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

Pruébalo en línea!

Quería probar un enfoque diferente de lo que ya está aquí. Así que aquí itero recursivamente sobre la matriz eliminando un 0 a la vez hasta que la matriz actual ya no tenga ceros, y luego obtengo el índice de esa matriz.

Japt , 7 bytes

0 indexado. Toma entrada como una matriz de matrices.

mè
bUrw

Pruébalo

Explicación

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

mè

Map ( m) sobre la Udevolución del recuento de elementos verdaderos (distintos de cero) en cada subconjunto. Asigna implícitamente esta nueva matriz a U.
[2,1,3,2,0]

Urw

Reduce la rmatriz ( ) Uobteniendo el mayor valor actual y el elemento actual.
3

b

Obtenga el primer índice Udonde el elemento es igual a ese valor y genera el resultado implícitamente.
2