Escreva um trecho para calcular o modo (número mais comum) de uma lista de números inteiros positivos.

Por exemplo, o modo de

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

é 1, porque ocorre no máximo 5 vezes.

Você pode assumir que a lista é armazenada em uma variável como de possui um modo exclusivo.

por exemplo: Python, 49

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

Isso é código-golfe , então a solução mais curta em bytes vence.

K5, 6 bytes

*>#:'=

O primeiro ( *) dos elementos descendentes ( >) da contagem de cada ( #:') do grupo ( =). Passo a passo:

  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

experimente no seu navegador !

Python 2-18

max(d,key=d.count)

Como sua resposta em python parece não ser impressa, espero que seja isso que você deseja.

Adicione 6 bytes printnormalmente.

Matlab / Octave, 7 5 bytes

Sem surpresa, há uma função interna para encontrar modos. Como uma função anônima:

@mode

Isso retorna o elemento de ocorrência mais comum no vetor de entrada, com os vínculos indo para o valor menor.

Economizou 2 bytes graças a Dennis!

Pitão - 6

eo/QNQ

Experimente online.

Espera entrada no stdin como [4,3,1,0,6,1,6,4,4,0,3,1,7,7,3,4,1,1,2,8]. Os laços são resolvidos pela última ocorrência porque o Python executa classificações estáveis.

Classifica a lista por contar o valor na lista e, em seguida, imprime o último número da lista.

Qpode ser substituído por dse você inicializou dpara conter o valor antes, por exemplo=d[4 3 1 0 6 4 4 0 1 7 7 3 4 1 1 2 8)

Pseudo-código em estilo Python:

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

Explicação completa:

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

O Pyth é orderbyexecutado exatamente como o Python, sortedcom orderbyo primeiro argumento sendo o keyargumento.

Mathematica, 25 bytes

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

ou

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

Como no desafio, isso espera que a lista seja armazenada d.

ou ... 15 bytes

Obviamente, o Mathematica não seria o Mathematica se não tivesse um built-in:

#&@@Commonest@d

Commonestretorna uma lista de todos os elementos mais comuns (em caso de empate) e #&@@é um jogo de golfe First@.

Ruby, 22 bytes

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

Basicamente, uma porta da minha resposta do Mathematica, exceto que Ruby tem uma direta, max_byentão eu não preciso classificar primeiro.

R, 33 25 bytes

Obrigado @Hugh pela redução de ajuda:

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

O original:

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

Isso calcula a frequência de cada elemento no vetor e d, em seguida, retorna o nome da coluna que contém o maior valor. O valor retornado é na verdade uma sequência de caracteres que contém o número. Não dizia em lugar nenhum que isso não estava bem, então ...

Quaisquer sugestões para encurtar isso são bem-vindas!

CJam, 11 10 bytes

A{A\-,}$0=

Assume a matriz em uma variável chamada A. Isso basicamente classifica a matriz com base na ocorrência de cada número na matriz e, em seguida, escolhe o último elemento da matriz.

Exemplo de uso

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

Saída

6

1 byte economizado graças ao Dennis!

Experimente online aqui

Powershell 19

($d|group)[0].Count

(isso pressupõe que a matriz já está ativada $d)

J - 12 caracteres

Função anônima. Classifica a lista do mais ao menos comum, obtendo o primeiro item.

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

• 0{ O primeiro de
• ~. Itens exclusivos
• \: Ordenado por
• #/.~ Frequências

Experimente você mesmo.

JavaScript (ES6) 51

Apenas uma expressão de linha única usando a variável pré-carregada d. Classifique a matriz por frequência e obtenha o primeiro elemento.
Efeito colateral desagradável, a matriz original é alterada

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

Como de costume, use .map em vez de .reduce porque é 1 char mais curto no geral. Com o .reduce, é quase uma solução limpa e sem golfe.

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

Por fim, uma solução usando uma função, sem alterar a matriz original e sem globais (62 bytes):

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

Teste no console do 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]

Saída 1

A matriz d se torna:

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

Não veja uma solução de 18 caracteres em nenhum lugar no futuro para ser honesto.

EDIT: Eu estou corrigido, e impressionado.

JavaScript, ES6, 71 bytes

Um pouco longo, pode ser jogado muito.

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

Isso cria uma função fque pode ser chamada como f([1,1,1,2,1,2,3,4,1,5])e retornará 1.

Experimente no seu console mais recente do Firefox.

05AB1E , 3 bytes

(não concorrente - a pergunta é anterior ao idioma)

.MJ

Explicação:

.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.

Se você deseja armazenar a matriz em uma variável em vez de usar a entrada, basta empurrar a matriz para a pilha no início do programa.

Experimente online!

C # - 49

Não é possível competir usando C #, mas tudo bem:

Assumindo que dé a matriz

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

bash - 29 27 caracteres

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

Usando isso:

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

ou seja, "1" é o modo e aparece cinco vezes.

GolfScript, 10 bytes

a{a\-,}$0=

A partir desta resposta , escrevi para Dicas para jogar golfe no GolfScript . Espera a entrada em uma matriz chamada a, retorna o resultado na pilha. (Para ler a entrada de uma matriz na pilha, adicione :11 bytes; para ler a entrada de stdin (no formato [1 2 1 3 7]), também adicione ~12 bytes.)

Esse código funciona iterando sobre a matriz de entrada, subtraindo cada elemento da matriz original e contando o número de elementos restantes. Isso é usado como uma chave para classificar a matriz original e o primeiro elemento da matriz classificada é retornado.

Demonstração online.

Ps. Agradeço a Peter Taylor por apontar esse desafio para mim .

Dyalog APL, 12 caracteres

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

∘.=⍨dé o mesmo que d∘.=d, produto externo reflexivo de =. Ele cria uma matriz booleana comparando cada par de elementos d.

+/ soma essa matriz ao longo de um dos eixos e produz um vetor.

⍒classifica o vetor, ou seja, classifica-o por índices. (Como sugerem os glifos, ⍒classifica em ordem decrescente e ⍋classifica em ordem crescente.)

⊃pega o primeiro índice da classificação - o índice do maior elemento de d.

d[...] retorna esse elemento.

Perl 6 , 21 bytes

.Bag.invert.max.value

Exemplo:

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

Se houver um empate, ele imprimirá o maior dos empatados.

O .Bagmétodo em uma Lista ou Matriz cria um hash quantificado que associa a contagem total de quantas vezes um determinado valor foi visto com esse valor.

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

O .invertmétodo cria uma lista dos pares na sacola com a chave e o valor trocado. (O motivo pelo qual chamamos isso é o próximo método para fazer o que queremos)

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

O .maxmétodo em uma Lista de pares retorna o maior par comparando primeiro as chaves e, no caso de empate, comparando os valores.
(Isso ocorre porque é assim multi infix:<cmp>(Pair:D \a, Pair:D \b)que determina qual é maior)

5 => 1

O .valuemétodo retorna o valor do par. (Seria a chave que buscávamos se não fosse pela .invertligação anterior)

1

Se você deseja retornar todos os valores que empataram no caso de empate:

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

O .classifymétodo retorna uma lista de pares em que as chaves estão chamando o lambda Whatever  *.valuecom cada um dos pares.

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

Então chamamos .maxpara obter o maior par.

"5" => [1 => 5]

Uma ligação para .valueobter os pares originais do saco (apenas um neste caso)

1 => 5

Em seguida, >>.keychamamos o .keymétodo em todos os pares da lista, para que terminemos com uma lista dos valores mais 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();

A entrada A deve ser do tipo Integer[]. Observe java.util.*e java.util.stream.*precisa ser importado, no entanto, no espírito de delineamento, eles são deixados de fora.

Ferramentas Bash + unix, 62 bytes

Espera a matriz no STDIN. O formato de entrada não conta, desde que os números sejam números inteiros não negativos.

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

Editado: curinga escapada no argumento grep. Agora ele pode ser executado com segurança em diretórios não vazios. Graças à manatwork.

Perl, 27 bytes

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

Retorna o último valor mais comum em caso de empate.

PHP, 53 50 bytes

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

Execute assim:

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

• Salva 3 bytes, fazendo uso da liberdade de assumir que a entrada está atribuída a uma variável d

Java 8, 83 bytes

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

ddeve ser a Collection<Integer>.

Se Collectionspode ser importado estaticamente:
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

Se as importações são ignoradas, são 45 .

Haskell , 42 39 bytes

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

Experimente online!

Edit: Thans para Zgarb por -3 bytes

Braquilog , 5 bytes

ọtᵒth

Experimente online!

Este não é realmente um trecho, mas não tenho certeza do que seria ...

         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 %)retorna um mapa de hash, que pode ser usado como uma função. Dada uma chave, ele retorna o valor correspondente :)

Comprimento igual:

#(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 e teste completos:

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