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.
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
Réponses:
!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 .
! % 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 octets grâce à Erik l'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)))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).
which.min()car les éléments non nuls deviendront FAUX avec !m.
snd.minimum.(`zip`[1..]).map(filter(==0))
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
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.
0@♀cñ♂RmN
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)
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))(⊢⍳⌈/)+/0≠⎕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
)
TL$€M
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, ...
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/=))
f [[1,1,0,0,0],[2,3,0,0,0],[0,5,6,2,2],[1,1,1,1,1]]
g=filtervous fait gagner un octet
m y=length$takeWhile(<maximum y)yet raccourcir lengthau lieu defilter
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 %))))
pos?n'est donc pas correct
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=/:
{0fe=_:e>#}
>devrait être à la <place ... merci quand même. :)
òø0
jòÚDuu/"
dGؾ
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.
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.
def f(a):b=list(map(sorted,a));return b.index(sorted(b)[-1])
0s et utiliser min()au lieu demax()input()au lieu dedeflambdaet hash-map lambda x:x.index(min(x,key=lambda n:n.count(0)))minavec le keyparamètre
0 indexé. Prend un tableau 2D en entrée.
a=>(a=a.map(x=>x.filter(y=>y).length)).indexOf(Math.max(...a))
filterce que "filtrer" les zéros implicitement?
filterjuste s'assurer.
ċ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
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.
%M`\b0
m`(?<=(¶.+)*)$
;$#1
O#`.+
!`(?<=^.+;).+
0 indexé. Fonctionne avec des entiers positifs et négatifs (et 0). Ne suppose pas de zéros non significatifs.
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:
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, ce doux langage verbeux :)
Merci d'avoir économisé 18 octets, @KevinCruijssen;)
jautres parties plus longues comme j=m[i].length,et m[i][j]comme ceci: 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 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:
m->m.indexOf(m.stream().map(z->{z.removeIf(x->x==0);return z;}).max((q,r)->q.size()-r.size()).get())
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!
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.
def f(x,i=0):print i;x[i].remove(0);f(x,-~i%len(x))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.
lambda x,i=0:0in x[i]>x[i].remove(0)and f(x,-~i%len(x))|iJe 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.
0 indexé. Prend l'entrée comme un tableau de tableaux.
mè
bUrw
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
Āau lieu deÄ0›pour -2.