Escriba un fragmento para calcular el modo (número más común) de una lista de enteros positivos.

Por ejemplo, el modo de

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

es 1, porque ocurre el máximo de 5 veces.

Puede suponer que la lista se almacena en una variable como dy tiene un modo único.

por ejemplo: Python, 49

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

Este es el código de golf , por lo que gana la solución más corta en bytes.

K5, 6 bytes

*>#:'=

El primero ( *) de los elementos descendentes ( >) del recuento de cada ( #:') del grupo ( =). Paso a paso:

  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

Pruébalo en tu navegador !

Python 2 - 18

max(d,key=d.count)

Como su respuesta de Python no parece imprimirse, espero que esto sea lo que desea.

Agregue 6 bytes para printnormalmente.

Matlab / Octave, 7 5 bytes

Como era de esperar, hay una función incorporada para encontrar modos. Como una función anónima:

@mode

Esto devuelve el elemento que ocurre más comúnmente en el vector de entrada con vínculos que van al valor menor.

¡Ahorré 2 bytes gracias a Dennis!

Pyth - 6

eo/QNQ

Pruébalo en línea.

Espera entrada en stdin like [4,3,1,0,6,1,6,4,4,0,3,1,7,7,3,4,1,1,2,8]. Los empates se resuelven por última vez porque Python realiza tipos estables.

Ordena la lista por contar el valor en la lista, luego imprime el último número de la lista.

Qpodría reemplazarse dsi se inicializa dpara contener el valor antes, por ejemplo=d[4 3 1 0 6 4 4 0 1 7 7 3 4 1 1 2 8)

Seudocódigo de Python-esque:

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

Explicación completa:

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

Pyth's orderbycorre exactamente como Python sortedcon orderbyel primer argumento de ser el keyargumento.

Mathematica, 25 bytes

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

o

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

Como en el desafío, esto espera que la lista se almacene en d.

o ... 15 bytes

Por supuesto, Mathematica no sería Mathematica si no tuviera incorporado:

#&@@Commonest@d

Commonestdevuelve una lista de todos los elementos más comunes (en caso de empate) y #&@@es un campo de golf First@.

Ruby, 22 bytes

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

Básicamente un puerto de mi respuesta de Mathematica, excepto que Ruby tiene un directo, max_byasí que no necesito ordenar primero.

R, 33 25 bytes

Gracias @Hugh por la ayuda acortando:

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

El original:

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

Esto calcula la frecuencia de cada elemento en el vector d, luego devuelve el nombre de la columna que contiene el valor más grande. El valor devuelto es en realidad una cadena de caracteres que contiene el número. No decía en ninguna parte que eso no estaba bien, así que ...

¡Cualquier sugerencia para acortar esto es bienvenida!

CJam, 11 10 bytes

A{A\-,}$0=

Asume la matriz en una variable llamada A . Básicamente, esto es ordenar la matriz en función de la aparición de cada número en la matriz y luego selecciona el último elemento de la matriz.

Ejemplo de uso

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

Salida

6

¡1 byte guardado gracias a Dennis!

Pruébalo en línea aquí

Powershell 19

($d|group)[0].Count

(esto supone que la matriz ya está encendida $d)

J - 12 char

Función anónima. Ordena la lista de más a menos común, tomando el primer elemento.

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

• 0{ Primero de
• ~. Artículos únicos
• \: Desglosado por
• #/.~ Frecuencias

Pruébalo por ti mismo.

JavaScript (ES6) 51

Solo una expresión de línea simple usando la variable precargada d. Ordene la matriz por frecuencia y luego obtenga el primer elemento.
Efecto secundario desagradable, la matriz original se altera

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

Como de costumbre, usando .map en lugar de .reduce porque es 1 char más corto en general. Con .reduce es casi una solución limpia y sin golf.

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

Por fin, una solución que usa una función, sin cambiar la matriz original y sin globales (62 bytes):

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

Prueba en la consola 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]

Salida 1

La matriz d se convierte en:

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

No veo una solución de 18 caracteres en ninguna parte en el futuro para ser honesto.

EDITAR: Estoy corregido e impresionado.

JavaScript, ES6, 71 bytes

Un poco largo, se puede jugar mucho al golf.

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

Esto crea una función fque se puede llamar como f([1,1,1,2,1,2,3,4,1,5])y volverá 1.

Pruébalo en tu última consola de Firefox.

05AB1E , 3 bytes

(no competitiva - la pregunta es anterior al idioma)

.MJ

Explicación:

.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 desea almacenar la matriz en una variable en lugar de usar la entrada, simplemente empuje la matriz a la pila al inicio del programa.

Pruébalo en línea!

C # - 49

Realmente no puedo competir con C # pero bueno:

Suponiendo que des la matriz

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

bash - 29 27 caracteres

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

Utilizándolo:

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

es decir, "1" es el modo, y aparece cinco veces.

GolfScript, 10 bytes

a{a\-,}$0=

De esta respuesta escribí a Consejos para jugar golf en GolfScript . Espera la entrada en una matriz llamada a, devuelve el resultado en la pila. (Para leer la entrada de una matriz en la pila, anteponer :11 bytes; para leer la entrada de stdin (en el formato [1 2 1 3 7]), también anteponer~ 12 bytes).

Este código funciona iterando sobre la matriz de entrada, restando cada elemento de la matriz original y contando el número de elementos restantes. Esto se usa como una clave para ordenar la matriz original y se devuelve el primer elemento de la matriz ordenada.

Demo en línea.

PD. Gracias a Peter Taylor por señalarme este desafío .

Dyalog APL, 12 caracteres

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

∘.=⍨des lo mismo que d∘.=d, producto externo reflexivo de =. Crea una matriz booleana que compara cada par de elementos d.

+/ suma esa matriz a lo largo de uno de los ejes y produce un vector.

⍒califica el vector, es decir, lo ordena por índices. (Como sugieren los glifos, ⍒califica en orden descendente y ⍋calificaría en orden ascendente).

⊃toma el primer índice de la calificación, el índice del elemento más grande de d.

d[...] devuelve ese elemento

Perl 6 , 21 bytes

.Bag.invert.max.value

Ejemplo:

$_ = < 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…

Si hay un empate, imprimirá el más grande de los que lo hicieron.

El .Bagmétodo en una Lista o una Matriz crea un hash cuantificado que asocia el recuento total de cuántas veces se vio un valor dado con ese valor.

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

El .invertmétodo crea una Lista de los pares en la bolsa con la clave y el valor intercambiado. (La razón por la que llamamos a esto es para que el próximo método haga lo que queramos)

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

El .maxmétodo en una Lista de pares devuelve el par más grande que compara las claves primero y en el caso de un empate que compara los valores.
(Esto es porque así es como multi infix:<cmp>(Pair:D \a, Pair:D \b)determina cuál es más grande)

5 => 1

El .valuemétodo devuelve el valor del par. (Hubiera sido la clave que buscábamos si no fuera por la .invertllamada anterior)

1

Si desea devolver todos los valores vinculados en caso de empate:

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

los .classify método devuelve una lista de pares de donde provienen las claves llamando a la Lambda Cualquiera  *.valuecon cada uno de los Pares.

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

Entonces llamamos .max para obtener el par más grande.

"5" => [1 => 5]

Un llamado a .value obtener los pares originales de la bolsa (solo uno en este caso)

1 => 5

Luego, usamos >>.keypara llamar al .keymétodo en cada par de la lista, de modo que terminemos con una lista de los valores más vistos.

1

Java 8: 184 bytes

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

La entrada A debe ser de tipo Integer[]. Tenga en cuenta java.util.*y java.util.stream.*debe importarse, sin embargo, en el Spirit Oneliner se omiten.

Bash + herramientas unix, 62 bytes

Espera la matriz en el STDIN. El formato de entrada no cuenta, siempre que los números sean enteros no negativos.

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

Editado: comodín escapado en argumento grep. Ahora se puede ejecutar de forma segura en directorios no vacíos. Gracias a manatwork.

Perl, 27 bytes

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

Devuelve el último valor más común en caso de empate.

PHP, 53 50 bytes

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

Corre así:

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

Ajustes

• Se guardaron 3 bytes haciendo uso de la libertad de asumir que la entrada se asigna a una variable d

Java 8, 83 bytes

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

ddebe ser a Collection<Integer>.

Si Collectionsse puede importar estáticamente:
59 bytes

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 se ignoran las importaciones, son 45 .

Haskell , 42 39 bytes

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

Pruébalo en línea!

Editar: Thans a Zgarb para -3 bytes

Brachylog , 5 bytes

ọtᵒth

Pruébalo en línea!

Esto no es realmente un fragmento, pero no estoy seguro de qué sería ...

         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 bytes

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

(frequencies %)devuelve un mapa hash, que se puede usar como una función. Dada una clave, devuelve el valor correspondiente :)

Misma longitud:

#(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;

Código completo y prueba:

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