To jest proste: weź macierz liczb całkowitych jako dane wejściowe i wyślij indeks wiersza z najbardziej niezerowymi elementami. Możesz założyć, że będzie tylko jeden wiersz z najbardziej niezerowymi elementami.
Są to indeksy 1, możesz wybrać, czy chcesz indeksować 0 czy 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
Odpowiedzi:
!gs&X>
Dane wejściowe to macierz z ;separatorem wierszy.
Wypróbuj online! Lub sprawdź wszystkie przypadki testowe .
! % 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
Ordering[Count@0/@#,1]&
ΣĀO}θk
-2 bajty dzięki Erikowi Outgolfer
ΣĀO}θk
Σ } # Sort input by following code
Ā # Is element not 0? (vectorized)
O # Sum
θk # Get index of "largest" element
# Implicit print
pryr::f(which.min(rowSums(!m)))zwraca anonimową funkcję, która przyjmuje macierz:
function(m)which.min(rowSums(!m))rowSumssumuje wiersze, !mprzekształcając 0 na 1, a wszystko inne na 0. which.minzwraca indeks pierwszego wiersza oparty na 1, który zawiera sumę minimalną (tj. który wiersz ma najmniej zer).
which.min()ponieważ niezerowe elementy staną się NIEPOPRAWNE !m.
snd.minimum.(`zip`[1..]).map(filter(==0))
Jak to działa
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
using System.Linq;m=>m.IndexOf(m.OrderBy(r=>r.Count(n=>n!=0)).Last())Pobiera List<int[]>dane wejściowe i zwraca wynik z indeksem 0.
0@♀cñ♂RmN
Wyjaśnienie:
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)
lambda a:a.index(min(a,key=lambda r:r.count(0)))Ogolono 6 bajtów. Stare rozwiązanie:
lambda a:min(range(len(a)),key=lambda i:a[i].count(0))(⊢⍳⌈/)+/0≠⎕0≠⎕ Macierz boolowska gdzie niezerowa
+/ suma wierszy
( zastosuj następującą ukrytą funkcję do listy sum
⌈/ maksimum
⍳ indeks
⊢ na liście argumentów
)
TL$€M
1-indeksowany.
Tak wiele wersji 5-bajtowych ...
TL$€M, T€L€M, TJ$€M, T€J€M, ¬¬Ṣ€M, ṠAṢ€M, ṠAS€M, AṠṢ€M, AṠS€M, ¬ċ€0M, ...
Oszczędność jednego bajtu dzięki Siracusa!
Rzędy są indeksowane zerowo
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]]
g=filteroszczędza jeden bajt
m y=length$takeWhile(<maximum y)yi skrócić lengthzamiastfilter
Ten działa również z liczbami ujemnymi na wejściu, na szczęście takiej samej długości jak oryginał:
#(nth(sort-by(fn[i](count(filter #{0}(% i))))(range(count %)))0)
Oryginalny:
#(last(sort-by(fn[i](count(filter pos?(% i))))(range(count %))))
pos?nie jest poprawne
Rozwiązanie:
(*)(<)sum(+)0=/:
Przykład:
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
Wyjaśnienie:
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
Uwagi:
Problem jest dość prosty, rozwiązanie to wydaje się zbyt skomplikowane. Gdy tylko kliknąłem przycisk Prześlij, zdałem sobie sprawę z błędu moich działań.
Premia:
Oto rozwiązanie ak że ciężary w na 16 10 9 bajtów - niemal dokładnie takie same, ale 7 bajtów krótsze ze względu na fakt, że nie trzeba wsporniki przy użyciu k Zabudowy, aw rezultacie niektóre stają się krótsze niż słowa kluczowe Q ( np. +/dla sum(byłoby (+/)w q)).
*<+/+0=/:
{0fe=_:e>#}
>powinien <zamiast tego ... dzięki i tak. :)
òø0
jòÚDuu/"
dGؾ
W przeciwieństwie do większości odpowiedzi V jest on indeksowany na 0.
00000000: f2f8 300a 6af2 da44 7575 2f12 220a 6447 ..0.j..Duu/.".dG
00000010: d8be ..
Nieźle jak na język bez obsługi numerycznej! ;P
Odkryłem również, że wariant polecenia liczenia , który jest pisany wielkimi literami Ø, jest strasznie zepsuty.
def f(x):
for e in x:
e.sort()
y=x[:]
y.sort()
return x.index(y[-1])Najpierw posortuj każdy wiersz w taki sposób, aby wpisy były [0,0,..,0,x,x,x]następnie posortowane przez całą macierz, tak aby ostatni wpis ybył wierszem, którego szukamy. Kopiowanie y=x[:]jest konieczne, ponieważ .sort()działa w miejscu, dlatego nie znamy oryginalnego indeksu po posortowaniu.
Doceniam wszelką pomoc, jak dalej grać w golfa w tym rozwiązaniu. Większość bajtów jest traconych z powodu białych znaków w każdej linii. Sam kod ma tylko 68 bajtów.
def f(a):b=list(map(sorted,a));return b.index(sorted(b)[-1])
0s i użyj min()zamiastmax()input()zamiastdeflambdai hash-map lambda x:x.index(min(x,key=lambda n:n.count(0)))minz keyparametru
0-indeksowane. Pobiera tablicę 2D jako dane wejściowe.
a=>(a=a.map(x=>x.filter(y=>y).length)).indexOf(Math.max(...a))
filterniejawnie „filtruje” zera?
filterwłaśnie było, tylko upewniłem się.
ċ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
xQh/D0
Zamiast znajdować wiersz z najbardziej niezerowymi elementami, znajduję wiersz z najmniej zerowymi elementami.
/D0: Kolejność ( D) według liczby ( /) zer ( 0). Domyślnie zastosowane do Qdanych wejściowych.
h: Weź pierwszy i minimalny element.
xQ: Znajdź indeks ( x) na wejściu ( Q) tego elementu.
%M`\b0
m`(?<=(¶.+)*)$
;$#1
O#`.+
!`(?<=^.+;).+
0-indeksowane. Działa z dodatnimi i ujemnymi liczbami całkowitymi (i 0). Nie zakłada zer wiodących.
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;}
Brzydkie, ale działa ...
Wyjaśnienie:
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
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;}Java, ten słodki, pełny język :)
Dzięki za uratowanie 18 bajtów, @KevinCruijssen;)
ji inne dłuższe części jak j=m[i].length,i m[i][j]tak: 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;}( 101 bajtów )
m=>m.reduce((a,e,i)=>e.filter(x=>x).length>a?i:a,0)
gdzie mjest tablica 2D, a zwrócony indeks ma indeks 0
Przypadki testowe:
m->m.indexOf(m.stream().map(z->{z.removeIf(x->x==0);return z;}).max((q,r)->q.size()-r.size()).get())
Moc list i strumieni! (i bez importu, aby uruchomić!)
Podzielmy tę małą lambda na części:
m.stream().map(z->{z.removeIf(x->x==0);return z;}
Przekształcamy naszą listę list (macierz w pytaniu) w strumień i przeglądamy każdy element, usuwając wszystkie te nieznośne zera z każdej podlisty. Za każdym razem musimy jawnie zwrócić listę podrzędną, ponieważ Stream.map()konwertuje każdy obiekt w strumieniu na wszystko, co zwraca mapowanie, i nie chcemy ich zmieniać.
.max((q,r)->q.size()-r.size()).get()
Przeglądamy nasze nowo wyzerowane podlisty i po prostu sprawdzamy, jak duże są obok siebie, co daje nam największą podlistę. Jest .get()tak, ponieważ Stream.max()zwraca wartość Opcjonalne, wymagającą wywołania dodatkowej funkcji.
m.indexOf()
Bierzemy tę największą podlistę i znajdujemy ją na głównej liście, dając nam nasz wynik!
To się psuje, jeśli zewnętrzna lista jest pusta, ale biorę
Możesz założyć, że będzie tylko jeden wiersz z najbardziej niezerowymi elementami.
sugerować, że zawsze będzie co najmniej jeden rząd. Popraw mnie, jeśli się mylę.
def f(x,i=0):print i;x[i].remove(0);f(x,-~i%len(x))Ta wersja usuwa zera stopniowo przez tablice, drukując bieżący indeks i ulega awarii, gdy nie ma już zer do usunięcia. Ostatni wydrukowany indeks jest odpowiedzią.
lambda x,i=0:0in x[i]>x[i].remove(0)and f(x,-~i%len(x))|iChciałem wypróbować inne podejście niż już tutaj. Więc tutaj powtarzam iteracyjnie iterację po tablicy, usuwając po jednym 0, aż bieżąca tablica nie będzie miała już żadnych zer - a następnie wypisuje indeks tej tablicy.
0-indeksowane. Pobiera dane wejściowe jako tablicę tablic.
mè
bUrw
Domniemane wejście tablicy U.[[0,4,1,0],[0,0,-6,0],[0,1,4,-3],[2,0,0,8],[0,0,0,0]]
mè
Map ( m) po Uzwróceniu liczby prawdziwych (niezerowych) elementów w każdej pod-macierzy. Niejawnie przypisz tę nową tablicę do U.[2,1,3,2,0]
Urw
Zredukuj rtablicę U, uzyskując większą z bieżącej wartości i bieżącego elementu.3
b
Uzyskaj pierwszy indeks, w Uktórym element równa się tej wartości, i domyślnie wyślij wynik.2
ĀzamiastÄ0›dla -2.