Questo è semplice: prendi una matrice di numeri interi come input e genera l'indice della riga con il maggior numero di elementi diversi da zero. Si può presumere che ci sarà solo una riga con il maggior numero di elementi diversi da zero.

Casi test:

Questi sono 1 indicizzati, puoi scegliere se vuoi 0 o 1 indicizzato.

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 byte

!gs&X>

L'input è una matrice, con ;come separatore di riga.

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

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

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

05AB1E , 8 6 byte

ΣĀO}θk

Provalo online!

-2 byte grazie a Erik the Outgolfer

Spiegazione

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

R , 31 byte

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

restituisce una funzione anonima che accetta una matrice:

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

rowSumssomma le righe, !mtrasformando 0 in 1 e tutto il resto in 0. which.minrestituisce l'indice in base 1 della prima riga che contiene la somma minima (ovvero, quale riga ha il minor numero di zeri).

Provalo online!

Haskell, 46 42 41 byte

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

Provalo online!

Come funziona

    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 byte

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

Prende un List<int[]>input e restituisce il risultato indicizzato 0.

In realtà , 9 byte

0@♀cñ♂RmN

Provalo online!

Spiegazione:

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 byte

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

Rimozione di 6 byte. Vecchia soluzione:

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

APL (Dyalog) , 11 byte

(⊢⍳⌈/)+/0≠⎕

Provalo online!

0≠⎕ Matrice booleana dove diversa da zero

+/ somma righe

( applica la seguente funzione tacita all'elenco delle somme

 ⌈/ il massimo

 ⍳ indice

 ⊢ nell'elenco degli argomenti

)

Brachylog , 17 byte

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

Provalo online!

05AB1E , 5 byte

€ĀOZk

Provalo online!

0-indicizzati.

Gelatina , 5 byte

TL$€M

Provalo online!

1-indicizzati.

Tante versioni a 5 byte ...

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

Haskell - 69 68 byte

Salvato un byte grazie a Siracusa!

Le righe sono indicizzate zero

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

Provalo online!

Clojure, 64 byte

Questo funziona anche con numeri negativi nell'input, per fortuna della stessa lunghezza dell'originale:

#(nth(sort-by(fn[i](count(filter #{0}(% i))))(range(count %)))0)

Originale:

#(last(sort-by(fn[i](count(filter pos?(% i))))(range(count %))))

q / kdb +, 25 17 16 byte

Soluzione:

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

Esempio:

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

Spiegazione:

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

Gli appunti:

Il problema è abbastanza semplice, questa soluzione sembra eccessivamente complicata. Non appena premo invio mi sono reso conto dell'errore dei miei modi.

Bonus:

Ecco una soluzione ak che pesa a 16 10 9 byte - quasi esattamente la stessa ma 7 byte più corti a causa del fatto che non abbiamo bisogno di parentesi quando si usano i built-in k, e di conseguenza alcuni diventano più brevi delle parole chiave q ( ad es. +/per sum(sarebbe (+/)in q)).

*<+/+0=/:

CJam , 11 byte

{0fe=_:e<#}

Provalo online!

-2 grazie a Challenger5 .

PHP , 58 byte

0-indicizzato

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

Provalo online!

V , 18 byte

òø0
jòÚDuu/"
dGؾ

Provalo online!

A differenza della maggior parte delle risposte V, questo è indicizzato 0.

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

Non male per una lingua senza supporto numerico! ;P

Ho anche scoperto che la variante maiuscola del comando count , cioè Ø, è terribilmente rotta.

Python 3 , 92 byte

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

Prima ordina ogni riga in modo tale che le voci siano [0,0,..,0,x,x,x]quindi ordinate l'intera matrice, in modo che l'ultima voce ysia la riga che stiamo cercando. La copia y=x[:]è necessaria, poiché .sort()funziona sul posto, quindi non conosciamo l'indice originale dopo l'ordinamento.

Apprezzo qualsiasi aiuto su come golf ulteriormente questa soluzione. La maggior parte dei byte viene persa a causa degli spazi bianchi in ciascuna riga. Il codice stesso è lungo solo 68 byte.

Provalo online!

Python 2 , 64 55 52 48 byte

• Grazie a @Rod per la rasatura di 9 byte !! : conta se 0usa min()invece dimax()
• @Rod ha salvato ancora altri 3 byte: usare input()invece didef
• @ovs ha salvato 4 byte : uso di lambdae hash-map

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

Provalo online!

JavaScript (ES6), 62 byte

0-indicizzati. Accetta un array 2D come input.

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

Gelatina , 7 byte

ċ0$ÞḢi@

Provalo 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 byte

xQh/D0

Dimostrazione

Invece di trovare la riga con il maggior numero di elementi diversi da zero, trovo la riga con il minor numero di elementi zero.

/D0: Order ( D) per count ( /) di zeri ( 0). Applicato implicitamente a Q, l'input.

h: Prende il primo e minimo elemento.

xQ: Trova l'indice ( x) nell'input ( Q) di quell'elemento.

Retina , 46 byte

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

Provalo online!

0-indicizzati. Funziona con numeri interi positivi e negativi (e 0). Non presuppone zero iniziali.

Java 8, 145 byte

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

Brutto, ma funziona ..

Spiegazione:

Provalo qui.

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 byte

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

Provalo online!

Java, quel dolce linguaggio verboso :)

Grazie per aver salvato 18 byte, @KevinCruijssen;)

JavaScript (ES6), 51 byte

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

dove mè un array 2D e l'indice restituito è indicizzato 0

Casi 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 byte

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

Spiegazione

Il potere di elenchi e stream! (e senza le importazioni, per l'avvio!)

Dividiamo questa piccola lambda in pezzi:

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

Trasformiamo il nostro Elenco di elenchi (la matrice nella domanda) in un flusso e analizziamo ogni elemento, rimuovendo tutti quei fastidiosi zero da ciascun elenco secondario. Dobbiamo restituire esplicitamente la lista secondaria ogni volta qui, perché Stream.map()converte ogni oggetto nello Stream in qualunque cosa restituisca la mappatura e non vogliamo cambiarli.

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

Esaminiamo le nostre liste secondarie appena azzerate e controlliamo semplicemente quanto sono grandi l'una accanto all'altra, ottenendo la più grande lista secondaria. Il .get()perché Stream.max()restituisce un Opzionale, che richiede quella chiamata di funzione aggiuntiva.

m.indexOf()

Prendiamo quella più grande lista e troviamo dove si trova nella lista principale, dandoci il nostro risultato!

Gli appunti

Questo si interrompe se l'elenco esterno è vuoto, ma sto prendendo

Si può presumere che ci sarà solo una riga con il maggior numero di elementi diversi da zero.

implicare che ci sarà sempre almeno una riga. Correggimi se sbaglio.

Python 2 , 51 byte

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

Provalo online!

Questa versione rimuove progressivamente gli 0 attraverso gli array, stampa l'indice corrente e si arresta in modo anomalo quando non ci sono più zeri da rimuovere. L'ultimo indice stampato è la risposta.

Python 2 , 57 byte

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

Provalo online!

Volevo provare un approccio diverso da quello che è già qui. Quindi qui ricerco ripetutamente l'array rimuovendo uno 0 alla volta fino a quando l'array corrente non ha più zero - e quindi restituisco l'indice di tale array.

Japt , 7 byte

0-indicizzati. Accetta l'input come una matrice di array.

mè
bUrw

Provalo

Spiegazione

Input implicito di array U.
[[0,4,1,0],[0,0,-6,0],[0,1,4,-3],[2,0,0,8],[0,0,0,0]]

mè

Mappa ( m) Urestituendo il conteggio degli elementi di verità (diversi da zero) in ciascun sotto-array. Assegnare implicitamente questo nuovo array a U.
[2,1,3,2,0]

Urw

Reduce ( r) array Uottenendo il maggiore tra il valore corrente e l'elemento corrente.
3

b

Ottieni il primo indice in Ucui l'elemento è uguale a quel valore e genera implicitamente il risultato.
2