C'est simple: prenez une matrice d'entiers en entrée et sortez l'index de la ligne avec le plus d'éléments non nuls. Vous pouvez supposer qu'il n'y aura qu'une seule ligne avec le plus d'éléments non nuls.

Cas de test:

Ceux-ci sont indexés 1, vous pouvez choisir si vous voulez 0 ou 1 indexé.

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 octets

!gs&X>

L'entrée est une matrice, avec ;comme séparateur de ligne.

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

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

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

05AB1E , 8 6 octets

ΣĀO}θk

Essayez-le en ligne!

-2 octets grâce à Erik l'Outgolfer

Explication

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

R , 31 octets

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

renvoie une fonction anonyme qui prend une matrice:

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

rowSumsadditionne les lignes, en !mtransformant 0 en 1 et tout le reste en 0. which.minrenvoie l'index basé sur 1 de la première ligne qui contient la somme minimale (c'est-à-dire quelle ligne a le moins de zéros).

Essayez-le en ligne!

Haskell, 46 42 41 octets

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

Essayez-le en ligne!

Comment ça marche

    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 octets

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

Prend une List<int[]>entrée et renvoie le résultat indexé 0.

En fait , 9 octets

0@♀cñ♂RmN

Essayez-le en ligne!

Explication:

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 octets

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

Rasé de 6 octets. Ancienne solution:

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

APL (Dyalog) , 11 octets

(⊢⍳⌈/)+/0≠⎕

Essayez-le en ligne!

0≠⎕ Matrice booléenne où non nul

+/ somme des lignes

( appliquer la fonction tacite suivante à la liste des sommes

 ⌈/ le maximum

 ⍳ indice

 ⊢ dans la liste des arguments

)

Brachylog , 17 octets

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

Essayez-le en ligne!

05AB1E , 5 octets

€ĀOZk

Essayez-le en ligne!

0 indexé.

Gelée , 5 octets

TL$€M

Essayez-le en ligne!

1 indexé.

Tant de versions à 5 octets ...

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

Haskell - 69 68 octets

Un octet enregistré grâce à Siracusa!

Les lignes sont indexées zéro

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

Essayez-le en ligne!

Clojure, 64 octets

Celui-ci fonctionne également avec des nombres négatifs en entrée, heureusement de la même longueur que l'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 octets

Solution:

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

Exemple:

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

Explication:

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

Remarques:

Le problème est assez simple, cette solution semble trop compliquée. Dès que j'ai appuyé sur soumettre, j'ai réalisé l'erreur de mes voies.

Prime:

Voici une solution k qui pèse 16 à 10 9 octets - presque exactement la même chose mais 7 octets plus court car nous n'avons pas besoin de crochets lors de l'utilisation des k intégrés, et par conséquent certains deviennent plus courts que les mots clés q ( par exemple +/pour sum(serait (+/)en q)).

*<+/+0=/:

CJam , 11 octets

{0fe=_:e<#}

Essayez-le en ligne!

-2 grâce à Challenger5 .

PHP , 58 octets

0 indexé

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

Essayez-le en ligne!

V , 18 octets

òø0
jòÚDuu/"
dGؾ

Essayez-le en ligne!

Contrairement à la plupart des réponses V, il s'agit d'un indice 0.

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

Pas mal pour une langue sans support numérique! ;P

J'ai également découvert que la variante majuscule de la commande count , c'est-à- Ødire est horriblement cassée.

Python 3 , 92 octets

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

Triez d'abord chaque ligne de telle sorte que les entrées [0,0,..,0,x,x,x]trient ensuite la matrice entière, de sorte que la dernière entrée de yla ligne que nous recherchons. La copie y=x[:]est nécessaire, car.sort() fonctionne sur place, donc nous ne connaissons pas l'index d'origine après le tri.

J'apprécie toute aide pour jouer au golf cette solution plus loin. La plupart des octets sont perdus en raison des espaces dans chaque ligne. Le code lui-même ne fait que 68 octets de long.

Essayez-le en ligne!

Python 2 , 64 55 52 48 octets

• Merci à @Rod pour avoir rasé 9 octets !! : compter 0s et utiliser min()au lieu demax()
• @Rod a encore enregistré 3 octets: utilisez input()au lieu dedef
• @ovs a sauvé 4 octets : utilisation lambdaet hash-map

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

Essayez-le en ligne!

JavaScript (ES6), 62 octets

0 indexé. Prend un tableau 2D en entrée.

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

Gelée , 7 octets

ċ0$ÞḢi@

Essayez-le en ligne!

ċ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 octets

xQh/D0

Manifestation

Au lieu de trouver la ligne avec le plus d'éléments non nuls, je trouve la ligne avec le moins d'éléments zéro.

/D0: Order ( D) par count ( /) de zéros ( 0). Implicitement appliqué à Ql'entrée.

h: Prenez le premier élément et le minimum.

xQ: Recherchez l'index ( x) dans l'entrée ( Q) de cet élément.

Rétine , 46 octets

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

Essayez-le en ligne!

0 indexé. Fonctionne avec des entiers positifs et négatifs (et 0). Ne suppose pas de zéros non significatifs.

Java 8, 145 octets

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

Moche, mais ça marche ..

Explication:

Essayez-le ici.

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 octets

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

Essayez-le en ligne!

Java, ce doux langage verbeux :)

Merci d'avoir économisé 18 octets, @KevinCruijssen;)

JavaScript (ES6), 51 octets

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

où mest un tableau 2D et l'index retourné est indexé 0

Cas de test:

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 octets

m->m.indexOf(m.stream().map(z->{z.removeIf(x->x==0);return z;}).max((q,r)->q.size()-r.size()).get())

Explication

La puissance des listes et des flux! (et sans les importations, pour démarrer!)

Décomposons ce petit lambda en morceaux:

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

Nous transformons notre liste de listes (la matrice de la question) en un flux et parcourons chaque élément, en supprimant tous ces zéros embêtants de chaque sous-liste. Nous devons renvoyer explicitement la sous-liste à chaque fois ici, car Stream.map()convertit chaque objet du flux en tout ce que le mappage renvoie, et nous ne voulons pas les changer.

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

Nous parcourons nos sous-listes nouvellement remises à zéro et vérifions simplement leur taille les unes à côté des autres, ce qui nous donne la plus grande sous-liste. Ceci .get()est dû au fait que Stream.max()renvoie un Facultatif, nécessitant cet appel de fonction supplémentaire.

m.indexOf()

Nous prenons cette plus grande sous-liste et trouvons où elle se trouve dans la liste principale, en nous donnant notre résultat!

Remarques

Cela casse si la liste externe est vide, mais je prends

Vous pouvez supposer qu'il n'y aura qu'une seule ligne avec le plus d'éléments non nuls.

pour impliquer qu'il y aura toujours au moins une ligne. Corrige moi si je me trompe.

Python 2 , 51 octets

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

Essayez-le en ligne!

Cette version supprime progressivement les 0 dans les tableaux, imprimant l'index en cours et se bloque lorsqu'il n'y a plus de zéros à supprimer. Le dernier index imprimé est la réponse.

Python 2 , 57 octets

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

Essayez-le en ligne!

Je voulais essayer une approche différente de ce qui est déjà là. Donc, ici, j'itère récursivement sur le tableau en supprimant un 0 à la fois jusqu'à ce que le tableau actuel ne contienne plus de zéros - puis affiche l'index de ce tableau.

Japt , 7 octets

0 indexé. Prend l'entrée comme un tableau de tableaux.

mè
bUrw

Essaye-le

Explication

Entrée implicite du tableau U.
[[0,4,1,0],[0,0,-6,0],[0,1,4,-3],[2,0,0,8],[0,0,0,0]]

mè

Map ( m) sur Urenvoyant le nombre d'éléments véridiques (non nuls) dans chaque sous-tableau. Attribuez implicitement ce nouveau tableau à U.
[2,1,3,2,0]

Urw

Tableau Reduce ( r) Uen obtenant la plus grande de la valeur actuelle et de l'élément courant.
3

b

Récupère le premier index dans Ulequel l'élément est égal à cette valeur et affiche implicitement le résultat.
2