Écrivez un extrait pour calculer le mode (nombre le plus courant) d'une liste d'entiers positifs.

Par exemple, le mode de

d = [4,3,1,0,6,1,6,4,4,0,3,1,7,7,3,4,1,1,2,8]

est 1, car il se produit au maximum 5 fois.

Vous pouvez supposer que la liste est stockée dans une variable telle que det a un mode unique.

par exemple: Python, 49

max(((i,d.count(i))for i in set(d)), key=lambda x:x[1])

Il s'agit de code-golf , donc la solution la plus courte en octets l'emporte.

K5, 6 octets

*>#:'=

Le premier ( *) des éléments descendants ( >) du décompte de chacun ( #:') du groupe ( =). Pas à pas:

  i
4 3 1 0 6 1 6 4 4 0 3 1 7 7 3 4 1 1 2 8

  =i
4 3 1 0 6 7 2 8!(0 7 8 15
 1 10 14
 2 5 11 16 17
 3 9
 4 6
 12 13
 ,18
 ,19)

  #:'=i
4 3 1 0 6 7 2 8!4 3 5 2 2 2 1 1

  >#:'=i
1 4 3 7 6 0 8 2

  *>#:'=i
1

essayez-le dans votre navigateur !

Python 2-18

max(d,key=d.count)

Puisque votre réponse en python ne semble pas s'imprimer, je pense que c'est ce que vous voulez.

Ajoutez 6 octets pour printnormalement.

Matlab / Octave, 7 5 octets

Sans surprise, il existe une fonction intégrée pour trouver les modes. En tant que fonction anonyme:

@mode

Cela renvoie l'élément le plus courant dans le vecteur d'entrée avec des liens allant à la plus petite valeur.

Enregistré 2 octets grâce à Dennis!

Pyth - 6

eo/QNQ

Essayez-le en ligne.

Attend une entrée sur stdin comme [4,3,1,0,6,1,6,4,4,0,3,1,7,7,3,4,1,1,2,8]. Les liens sont résolus par la dernière occurrence car Python effectue des tris stables.

Trie la liste en comptant la valeur de la liste, puis imprime le dernier numéro de la liste.

Qpourrait être remplacé par dsi vous avez initialisé dpour contenir la valeur avant par exemple=d[4 3 1 0 6 4 4 0 1 7 7 3 4 1 1 2 8)

Pseudo-code Python-esque:

Q=eval(input());print(sorted(Q,key=Q.count)[-1])

Explication complète:

            : Q=eval(input()) (implicit)
e           : ... [-1]
 o   Q      : orderby(lambda N: ...,Q)
  /QN       : count(Q,N)

Pyth de orderbyruns exactement comme Python sortedavec le orderbypremier argument de » étant l' keyargument de .

Mathematica, 25 octets

Last@SortBy[d,d~Count~#&]

ou

#&@@SortBy[d,-d~Count~#&]

Comme dans le défi, cela attend que la liste soit stockée d.

ou ... 15 octets

Bien sûr, Mathematica ne serait pas Mathematica s'il n'avait pas de fonction intégrée:

#&@@Commonest@d

Commonestrenvoie une liste de tous les éléments les plus courants (en cas d'égalité), et #&@@est un golfé First@.

Rubis, 22 octets

d.max_by{|i|d.count i}

Fondamentalement, un port de ma réponse Mathematica, sauf que Ruby a un direct, max_bydonc je n'ai pas besoin de trier d'abord.

R, 33 25 octets

Merci @Hugh pour le raccourcissement de l'aide:

names(sort(-table(d))[1])

L'original:

v=table(d);names(v[which.max(v)])

Cela calcule la fréquence de chaque élément du vecteur d, puis renvoie le nom de la colonne contenant la plus grande valeur. La valeur renvoyée est en fait une chaîne de caractères contenant le nombre. Cela ne disait nulle part que ce n'était pas bien, alors ...

Toutes les suggestions pour raccourcir ceci sont les bienvenues!

CJam, 11 10 octets

A{A\-,}$0=

Suppose le tableau dans une variable appelée A . Il s'agit essentiellement de trier le tableau en fonction de l'occurrence de chaque numéro du tableau, puis de sélectionner le dernier élément du tableau.

Exemple d'utilisation

[1 2 3 4 4 2 6 6 6 6]:A;A{aA\/,}$W=

Sortie

6

1 octet économisé grâce à Dennis!

Essayez-le en ligne ici

Powershell 19

($d|group)[0].Count

(cela suppose que le tableau est déjà allumé $d)

J - 12 caractères

Fonction anonyme. Trie la liste du plus courant au moins courant, en prenant le premier élément.

(0{~.\:#/.~)

• 0{ D'abord
• ~. Objets uniques
• \: Trié par
• #/.~ Fréquences

Essayez-le par vous-même.

JavaScript (ES6) 51

Une seule expression de ligne utilisant la variable préchargée d. Triez le tableau par fréquence, puis récupérez le premier élément.
Effet secondaire désagréable, le tableau d'origine est modifié

d.sort((a,b)=>d.map(w=>t+=(w==b)-(w==a),t=0)&&t)[0]

Comme d'habitude, utilisez .map au lieu de .reduce car il est globalement 1 caractère plus court. Avec .reduce, c'est presque une solution propre et sans golf.

d.sort((a,b)=>d.reduce((t,w)=>t+(w==b)-(w==a),0))[0]

Enfin, une solution utilisant une fonction, ne changeant pas le tableau d'origine et sans globaux (62 octets):

F=d=>[...d].sort((a,b)=>d.reduce((t,w)=>t+(w==b)-(w==a),0))[0]

Test dans la console FireFox / FireBug

d=[4,3,1,0,6,1,6,4,4,0,3,1,7,7,3,4,1,1,2,8]
d.sort((a,b)=>x.map(w=>t+=(w==b)-(w==a),t=0)&&t)[0]

Sortie 1

Le tableau d devient:

[1, 1, 1, 1, 1, 4, 4, 4, 4, 3, 3, 3, 0, 6, 6, 0, 7, 7, 2, 8]

Python - 32

max((x.count(i),i)for i in x)[1]

Pour être honnête, ne voyez aucune solution à 18 caractères dans le futur.

EDIT: Je suis corrigé et impressionné.

JavaScript, ES6, 71 octets

Un peu long, on peut beaucoup jouer au golf.

f=a=>(c=b=[],a.map(x=>b[x]?b[x]++:b[x]=1),b.map((x,i)=>c[x]=i),c.pop())

Cela crée une fonction fqui peut être appelée comme f([1,1,1,2,1,2,3,4,1,5])et qui reviendra 1.

Essayez-le sur votre dernière console Firefox.

05AB1E , 3 octets

(non concurrentiel - la question est antérieure à la langue)

.MJ

Explication:

.M  # Gets the most frequent element in the [implicit] input
  J # Converts to a string, needed as the program would output "[1]" instead of "1" without this.

Si vous souhaitez stocker le tableau dans une variable au lieu d'utiliser l'entrée, poussez simplement le tableau vers la pile au début du programme.

Essayez-le en ligne!

C # - 49

Je ne peux pas vraiment rivaliser avec C # mais bon:

En supposant que dle tableau

d.GroupBy(i=>i).OrderBy(a=>a.Count()).Last().Key;

bash - 29 27 caractères

sort|uniq -c|sort -nr|sed q

En l'utilisant:

sort|uniq -c|sort -nr|sed q
4
3
1
0
6
1
6
4
4
0
3
1
7
7
3
4
1
1
2
8
[ctrl-D]
5 1

c'est-à-dire "1" est le mode, et il apparaît cinq fois.

GolfScript, 10 octets

a{a\-,}$0=

À partir de cette réponse, j'ai écrit à Tips for golfing in GolfScript . Attend l'entrée dans un tableau nommé a, renvoie le résultat sur la pile. (Pour lire l'entrée d'un tableau sur la pile, ajoutez :11 octets; pour lire l'entrée depuis stdin (au format [1 2 1 3 7]), ajoutez également ~12 octets.)

Ce code fonctionne en itérant sur le tableau d'entrée, en soustrayant chaque élément du tableau d'origine et en comptant le nombre d'éléments restants. Il est ensuite utilisé comme clé pour trier le tableau d'origine et le premier élément du tableau trié est renvoyé.

Démo en ligne.

Ps. Merci à Peter Taylor de m'avoir signalé ce défi .

Dyalog APL, 12 caractères

d[⊃⍒+/∘.=⍨d]

∘.=⍨dest le même que d∘.=d, produit extérieur réflexif de =. Il crée une matrice booléenne comparant chaque paire d'éléments dans d.

+/ additionne cette matrice le long d'un des axes et produit un vecteur.

⍒classe le vecteur, c'est-à-dire le trie par indices. (Comme le suggèrent les glyphes, les ⍒notes sont décroissantes et ⍋se classeraient par ordre croissant.)

⊃prend le premier indice de la notation - l'indice du plus grand élément de d.

d[...] renvoie cet élément.

Perl 6 , 21 octets

.Bag.invert.max.value

Exemple:

$_ = < 4 3 1 0 6 1 6 4 4 0 3 1 7 7 3 4 1 1 2 8 >».Int;

say .Bag.invert.max.value; # implicitly calls $_.Bag…

S'il y a une cravate, elle imprimera la plus grande de celles qui ont noué.

La .Bagméthode sur une liste ou un tableau crée un hachage quantifié qui associe le nombre total de fois où une valeur donnée a été vue à cette valeur.

bag(4(4), 3(3), 1(5), 0(2), 6(2), 7(2), 2, 8)

La .invertméthode crée une liste des paires dans le sac avec la clé et la valeur échangées. (La raison pour laquelle nous appelons cela est pour la prochaine méthode pour faire ce que nous voulons)

4 => 4,  3 => 3,  5 => 1,  2 => 0,  2 => 6,  2 => 7,  1 => 2,  1 => 8

La .maxméthode sur une liste de paires renvoie la plus grande paire en comparant les clés en premier et dans le cas d'une égalité en comparant les valeurs.
(C'est parce que c'est ainsi que multi infix:<cmp>(Pair:D \a, Pair:D \b)détermine ce qui est le plus grand)

5 => 1

La .valueméthode renvoie la valeur de la paire. (Cela aurait été la clé que nous recherchions s'il n'y avait pas eu l' .invertappel plus tôt)

1

Si vous souhaitez renvoyer toutes les valeurs liées dans le cas d'une égalité:

say @list.Bag.classify(*.value).max.value».key

La .classifyméthode retourne une liste de paires où les clés doivent appeler le lambda Quel que soit  *.valueavec chacune des paires.

1 => [2 => 1, 8 => 1],
2 => [0 => 2, 6 => 2, 7 => 2],
3 => [3 => 3],
4 => [4 => 4],
5 => [1 => 5]

Ensuite, nous appelons .maxpour obtenir la plus grande paire.

"5" => [1 => 5]

Un appel pour .valuenous obtenir les paires originales du sac (une seule dans ce cas)

1 => 5

Ensuite, nous utilisons >>.key pour appeler la .keyméthode sur chaque paire de la liste, afin de nous retrouver avec une liste des valeurs les plus vues.

1

Java 8: 184 octets

Stream.of(A).collect(Collectors.groupingBy(i -> i, Collectors.counting())).entrySet().stream().sorted(Map.Entry.comparingByValue(Comparator.reverseOrder())).findFirst().get().getKey();

L'entrée A doit être de type Integer[]. Remarque java.util.*et java.util.stream.*doivent être importés, mais dans l'esprit oneliner ils sont laissés de côté.

Outils Bash + Unix, 62 octets

Attend le tableau dans le STDIN. Le format d'entrée ne compte pas, tant que les nombres sont des entiers non négatifs.

grep -o [0-9]\*|sort|uniq -c|sort -n|awk 'END{print $2}'

Modifié: caractère générique échappé dans l'argument grep. Maintenant, il peut être exécuté en toute sécurité dans des répertoires non vides. Merci au manatwork.

Perl, 27 octets

$Q[$a{$_}++]=$_ for@F;pop@Q

Renvoie la dernière valeur la plus courante en cas d'égalité.

PHP, 53 50 octets

<?=array_flip($c=array_count_values($d))[max($c)];

Courez comme ceci:

echo '<?php $d=$argv;?><?=array_flip($c=array_count_values($d))[max($c)]; echo"\n";' | php -- 4 3 1 0 6 1 6 4 4 0 3 1 7 7 3 4 1 1 2 8

Tweaks

• Enregistré 3 octets en utilisant la liberté de supposer que l'entrée est affectée à une variable d

Java 8, 83 octets

d.stream().max((x,y)->Collections.frequency(d,x)-Collections.frequency(d,y)).get();

ddoit être un Collection<Integer>.

Si Collectionspeut être importé statiquement:
59 octets

d.stream().max((x,y)->frequency(d,x)-frequency(d,y)).get();

Haskell 78

import Data.List
import Data.Ord
g=head.maximumBy(comparing length).group.sort

Si les importations sont ignorées, c'est 45 .

Haskell , 42 39 octets

f s=snd$maximum[([1|y<-s,y==x],x)|x<-s]

Essayez-le en ligne!

Edit: Thans à Zgarb pour -3 octets

Brachylog , 5 octets

ọtᵒth

Essayez-le en ligne!

Ce n'est pas vraiment un extrait, mais je ne sais pas ce que ce serait ...

         The output is
    h    the first element of
   t     the last element of
ọ        a list of [value, number of occurrences] pairs corresponding to
         the input,
  ᵒ      sorted ascending by
 t       their last elements (the numbers of occurrences).

Clojure, 32 octets

#(apply max-key(frequencies %)%)

(frequencies %)renvoie une table de hachage, qui peut être utilisée comme fonction. Étant donné une clé, elle renvoie la valeur correspondante :)

Longueur égale:

#(last(sort-by(frequencies %)%))

Scala, 32

d.groupBy(a=>a).maxBy(_._2.size)

C ++ 119

int *a=std::max_element(x,x+n);int z=0,b=0,c=0;for(int i=0;i<=*a;i++){c=std::count(x,x+n,i);if(c>b){b=c;z=i;}}return z;

Code complet et test:

#include <iostream>
#include <algorithm>
#include <vector>

int m(int *x,int n)
{
int *a=std::max_element(x,x+n);int z=0,b=0,c=0;for(int i=0;i<=*a;i++){c=std::count(x,x+n,i);if(c>b){b=c;z=i;}}return z;
}

int main()
{
int d[] = {4,3,1,0,6,1,6,4,4,0,3,1,7,7,3,4,1,1,2,8};
std::cout<<m(d,20);
return 0;
}