Это просто: возьмите матрицу целых чисел в качестве входных данных и выведите индекс строки с большинством ненулевых элементов. Вы можете предположить, что будет только одна строка с большинством ненулевых элементов.

Тестовые случаи:

Это 1-индексированные, вы можете выбрать, хотите ли вы 0 или 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 байтов

!gs&X>

Ввод - это матрица с ;разделителем строк.

Попробуйте онлайн! Или проверьте все тестовые случаи .

объяснение

!     % 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 байта

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

05AB1E , 8 6 байт

ΣĀO}θk

Попробуйте онлайн!

-2 байта благодаря Эрику Аутгольферу

объяснение

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

R , 31 байт

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

возвращает анонимную функцию, которая принимает матрицу:

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

rowSumsсуммирует строки с !mпреобразованием 0 в 1 и всего остального в 0. which.minвозвращает основанный на 1 индекс первой строки, которая содержит минимальную сумму (т. е. какая строка имеет наименьшее количество нулей).

Попробуйте онлайн!

Haskell, 46 42 41 байт

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

Попробуйте онлайн!

Как это работает

    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 байт

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

Принимает в List<int[]>качестве входных данных и возвращает 0-индексированный результат.

На самом деле , 9 байтов

0@♀cñ♂RmN

Попробуйте онлайн!

Объяснение:

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 байт

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

Сбрил 6 байтов. Старое решение:

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

APL (Дьялог) , 11 байт

(⊢⍳⌈/)+/0≠⎕

Попробуйте онлайн!

0≠⎕ Булева матрица, где ненулевой

+/ сумма строк

( применить следующую молчаливую функцию к списку сумм

 ⌈/ максимум

 ⍳ показатель

 ⊢ в списке аргументов

)

Брахилог , 17 байт

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

Попробуйте онлайн!

05AB1E , 5 байтов

€ĀOZk

Попробуйте онлайн!

0 индексированные.

Желе , 5 байт

TL$€M

Попробуйте онлайн!

1-индексироваться.

Так много 5-байтовых версий ...

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

Haskell - 69 68 байт

Спасенный один байт благодаря Сиракузе!

Строки с нулевой индексацией

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

использование

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

Попробуйте онлайн!

Clojure, 64 байта

Этот работает также с отрицательными числами на входе, к счастью, такой же длины, что и оригинал:

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

Оригинал:

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

q / kdb +, 25 17 16 байт

Решение:

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

Пример:

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

Объяснение:

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

Заметки:

Проблема довольно проста, это решение кажется слишком сложным. Как только я нажал на кнопку «Отправить», я понял, в чем заключается моя ошибка.

Бонус:

Вот ak-решение, которое весит 16 10 9 байт - почти то же самое, но на 7 байт короче, потому что нам не нужны скобки при использовании k встроенных модулей, и в результате некоторые становятся короче, чем ключевые слова q ( например, +/для sum(будет (+/)в q)).

*<+/+0=/:

CJam , 11 байт

{0fe=_:e<#}

Попробуйте онлайн!

-2 благодаря Challenger5 .

PHP , 58 байт

0-индексированные

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

Попробуйте онлайн!

V , 18 байт

òø0
jòÚDuu/"
dGؾ

Попробуйте онлайн!

В отличие от большинства ответов V, это 0-индексированный.

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

Неплохо для языка без числовой поддержки! ;P

Я также обнаружил, что верхний регистр команды count , то Øесть ужасно сломан.

Python 3 , 92 байта

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

Сначала отсортируйте каждую строку так, чтобы записи [0,0,..,0,x,x,x] сортировали всю матрицу, чтобы последняя запись в yстроке была . Копия y=x[:]необходима, так как .sort()работает на месте, поэтому мы не знаем исходный индекс после сортировки.

Я ценю любую помощь, как продвигать это решение дальше. Большинство байтов теряется из-за пробелов в каждой строке. Сам код имеет длину всего 68 байт.

Попробуйте онлайн!

Python 2 , 64 55 52 48 байт

• Спасибо @Rod за бритье 9 байт !! : считать 0и использовать min()вместоmax()
• @Rod сохранил еще 3 байта: используйте input()вместоdef
• @ovs сохранил 4 байта : использование lambdaи hash-map

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

Попробуйте онлайн!

JavaScript (ES6), 62 байта

0 индексированные. Принимает 2D массив в качестве входных данных.

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

Желе , 7 байт

ċ0$ÞḢi@

Попробуйте онлайн!

ċ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 байт

xQh/D0

демонстрация

Вместо того, чтобы найти строку с наибольшим количеством ненулевых элементов, я нахожу строку с наименьшим нулевым элементом.

/D0: Порядок ( D) по count ( /) из нулей ( 0). Неявно применяется к Q, вход.

h: Возьмите первый и минимальный элемент.

xQНайти индекс ( x) в input ( Q) этого элемента.

Сетчатка , 46 байт

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

Попробуйте онлайн!

0 индексированные. Работает с положительными и отрицательными целыми числами (и 0). Предполагает отсутствие ведущих нулей.

Java 8, 145 байт

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

Уродливо, но это работает ..

Объяснение:

Попробуй это здесь.

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 байт

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

Попробуйте онлайн!

Ява, этот сладкий многословный язык :)

Спасибо за сохранение 18 байт, @KevinCruijssen;)

JavaScript (ES6), 51 байт

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

где m2D-массив, а возвращаемый индекс 0-indexed

Тестовые случаи:

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 байт

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

объяснение

Сила списков и потоков! (и без импорта, для загрузки!)

Давайте разберем эту маленькую лямбду на куски:

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

Мы превращаем наш список списков (матрицу в вопросе) в поток и проходим через каждый элемент, удаляя все эти надоедливые нули из каждого подсписка. Мы должны явно возвращать подсписок каждый раз здесь, потому чтоStream.map() преобразует каждый объект в потоке в то, что возвращает отображение, и мы не хотим их изменять.

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

Мы просматриваем наши недавно обнуленные подсписки и просто проверяем, насколько они велики рядом, получая нам самый большой подсписок. Это .get()потому, что Stream.max()возвращает Optional, требующий дополнительного вызова функции.

m.indexOf()

Мы берем этот самый большой подсписок и находим его в основном списке, давая нам наш результат!

Заметки

Это ломается, если внешний список пуст, но я беру

Вы можете предположить, что будет только одна строка с большинством ненулевых элементов.

подразумевать, что всегда будет хотя бы один ряд. Поправьте меня если я ошибаюсь.

Python 2 , 51 байт

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

Попробуйте онлайн!

Эта версия постепенно удаляет 0 в массивах, печатая текущий индекс, и вылетает, когда больше нет нулей для удаления. Последний напечатанный индекс является ответом.

Python 2 , 57 байт

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

Попробуйте онлайн!

Хотел попробовать другой подход от того, что уже здесь. Итак, здесь я рекурсивно перебираю массив, удаляя по одному 0 за раз, пока в текущем массиве больше не будет нулей - и затем выводю индекс этого массива.

Japt , 7 байт

0 индексированные. Принимает ввод в виде массива массивов.

mè
bUrw

Попробуй это

объяснение

Неявный ввод массива U.
[[0,4,1,0],[0,0,-6,0],[0,1,4,-3],[2,0,0,8],[0,0,0,0]]

mè

Map ( m) Uвозвращает количество истинных (ненулевых) элементов в каждом подмассиве. Неявно назначьте этот новый массив U.
[2,1,3,2,0]

Urw

rМассив Reduce ( ) U, получая большее из текущего значения и текущего элемента.
3

b

Получите первый индекс, в Uкотором элемент равен этому значению, и неявно выведите результат.
2