Scrivi uno snippet per calcolare la modalità (numero più comune) di un elenco di numeri interi positivi.

Ad esempio, la modalità di

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

è 1perché si verifica il massimo di 5 volte.

Si può presumere che l'elenco sia archiviato in una variabile come de abbia una modalità univoca.

ad es .: Python, 49

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

Questo è code-golf , quindi vince la soluzione più breve in byte.

K5, 6 byte

*>#:'=

Il primo ( *) degli elementi discendenti ( >) del conteggio di each ( #:') del gruppo ( =). Passo dopo 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

provalo nel tuo browser !

Python 2 - 18

max(d,key=d.count)

Dal momento che la tua risposta in Python non sembra stamparsi, mi aspetto che sia questo quello che vuoi.

Aggiungi 6 byte per printnormalmente.

Matlab / Octave, 7 5 byte

Non sorprende che ci sia una funzione integrata per trovare le modalità. Come una funzione anonima:

@mode

Ciò restituisce l'elemento che si verifica più comunemente nel vettore di input con legami che vanno al valore più piccolo.

Salvato 2 byte grazie a Dennis!

Pyth - 6

eo/QNQ

Provalo online.

Si aspetta input su stdin like [4,3,1,0,6,1,6,4,4,0,3,1,7,7,3,4,1,1,2,8]. I legami vengono risolti dall'ultima occorrenza perché Python esegue ordinamenti stabili.

Ordina l'elenco contando il valore nell'elenco, quindi stampa l'ultimo numero dell'elenco.

Qpotrebbe essere sostituito con dse inizializzato dper contenere il valore prima ad es=d[4 3 1 0 6 4 4 0 1 7 7 3 4 1 1 2 8)

Pseudo-codice Python-esque:

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

Spiegazione completa:

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

Pyth's orderbyfunziona esattamente come quello di Python sortedcon orderbyil primo argomento che è l' keyargomento.

Mathematica, 25 byte

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

o

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

Come nella sfida, ci si aspetta che la lista venga archiviata d.

o ... 15 byte

Naturalmente, Mathematica non sarebbe Mathematica se non avesse un built-in:

#&@@Commonest@d

Commonestrestituisce un elenco di tutti gli elementi più comuni (in caso di pareggio) ed #&@@è un golf First@.

Rubino, 22 byte

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

Fondamentalmente una porta della mia risposta Mathematica, tranne Ruby ha una diretta max_byquindi non ho bisogno di ordinare prima.

R, 33 25 byte

Grazie @Hugh per la riduzione dell'aiuto:

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

L'originale:

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

Questo calcola la frequenza di ciascun elemento nel vettore d, quindi restituisce il nome della colonna contenente il valore più grande. Il valore restituito è in realtà una stringa di caratteri contenente il numero. Non ha detto da nessuna parte che non andava bene, quindi ...

Eventuali suggerimenti per accorciare questo sono i benvenuti!

CJam, 11 10 byte

A{A\-,}$0=

Presuppone l'array in una variabile chiamata A. Fondamentalmente si tratta di ordinare l'array in base alla ricorrenza di ciascun numero nell'array e quindi seleziona l'ultimo elemento dell'array.

Esempio di utilizzo

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

Produzione

6

1 byte salvato grazie a Dennis!

Provalo online qui

Powershell 19

($d|group)[0].Count

(questo presuppone che l'array sia già attivo $d)

J - 12 caratteri

Funzione anonima. Ordina l'elenco dal più comune al meno comune, prendendo il primo elemento.

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

• 0{ Primo di
• ~. Oggetti unici
• \: Downsorted by
• #/.~ frequenze

Provalo tu stesso.

JavaScript (ES6) 51

Solo un'espressione a riga singola che utilizza la variabile precaricata d. Ordina la matrice per frequenza, quindi ottieni il primo elemento.
Brutto effetto collaterale, l'array originale viene modificato

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

Come al solito, usando .map invece di .reduce perché è complessivamente 1 carattere più corto. Con .reduce e 'quasi una soluzione pulita, non golfata.

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

Finalmente una soluzione che utilizza una funzione, non modificando l'array originale e senza globali (62 byte):

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

Test nella 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]

Uscita 1

La matrice d diventa:

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

Non vedo una soluzione a 18 caratteri da nessuna parte in futuro per essere onesti.

EDIT: sono corretto e impressionato.

JavaScript, ES6, 71 byte

Un po 'lungo, può essere giocato molto a golf.

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

Questo crea una funzione fche può essere chiamata come f([1,1,1,2,1,2,3,4,1,5])e tornerà 1.

Provalo sulla tua ultima console di Firefox.

05AB1E , 3 byte

(non concorrenziale - la domanda precede la lingua)

.MJ

Spiegazione:

.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 si desidera archiviare l'array in una variabile anziché utilizzare l'input, basta spingere l'array nello stack all'inizio del programma.

Provalo online!

C # - 49

Non posso davvero competere usando C # ma vabbè:

Supponendo che dsia l'array

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

bash - 29 27 caratteri

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

Usandolo:

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

vale a dire "1" è la modalità e appare cinque volte.

GolfScript, 10 byte

a{a\-,}$0=

Da questa risposta ho scritto a Tips for golfing in GolfScript . Prevede l'input in una matrice denominata a, restituisce il risultato sullo stack. (Per leggere l'input da un array nello stack, anteporre :a 11 byte; per leggere l'input da stdin (nel formato [1 2 1 3 7]), anche anteporre~ a 12 byte.)

Questo codice funziona ripetendo l'array di input, sottraendo ciascun elemento dall'array originale e contando il numero di elementi rimasti. Questo viene quindi usato come chiave per ordinare l'array originale e viene restituito il primo elemento dell'array ordinato.

Demo online.

Ps. Grazie a Peter Taylor per avermi indicato questa sfida .

Dyalog APL, 12 personaggi

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

∘.=⍨dè uguale al d∘.=dprodotto esterno riflessivo di =. Crea una matrice booleana confrontando ogni coppia di elementi in d.

+/ somma quella matrice lungo uno degli assi e produce un vettore.

⍒classifica il vettore, cioè lo ordina per indici. (Come suggeriscono i glifi, ⍒classifica in ordine decrescente e ⍋classifica in ordine crescente).

⊃prende il primo indice dalla classificazione, l'indice dell'elemento più grande di d.

d[...] restituisce quell'elemento.

Perl 6 , 21 byte

.Bag.invert.max.value

Esempio:

$_ = < 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 c'è un pareggio, verrà stampato il più grande di quelli che hanno legato.

Il .Bagmetodo su un elenco o una matrice crea un hash quantificato che associa il conteggio totale di quante volte un determinato valore è stato visto con quel valore.

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

Il .invertmetodo crea un elenco delle coppie nel sacchetto con la chiave e il valore scambiati. (Il motivo per cui lo chiamiamo è che il prossimo metodo farà quello che vogliamo)

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

Il .maxmetodo su un Elenco di coppie restituisce la coppia più grande confrontando prima le chiavi e, nel caso di un pareggio, confrontando i valori.
(Questo perché è così multi infix:<cmp>(Pair:D \a, Pair:D \b)che determina quale è più grande)

5 => 1

Il .valuemetodo restituisce il valore dalla coppia. (Sarebbe stata la chiave che stavamo cercando se non fosse stata per la .invertchiamata precedente)

1

Se si desidera restituire tutti i valori legati in caso di pareggio:

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

Il .classifymetodo restituisce un elenco di coppie in cui le chiavi provengono dal richiamo del lambda Qualunque  *.valuecon ciascuna coppia.

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

Quindi chiamiamo .maxper ottenere la coppia più grande.

"5" => [1 => 5]

Una chiamata per .valueprocurarci le coppie originali dalla borsa (solo una in questo caso)

1 => 5

Quindi usiamo >>.keyper chiamare il .keymetodo su ogni coppia nell'elenco, in modo da finire con un elenco dei valori che sono stati visti di più.

1

Java 8: 184 byte

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

L'ingresso A deve essere di tipo Integer[]. Nota java.util.*e java.util.stream.*devono essere importati, tuttavia nello spirito interno sono esclusi.

Strumenti Bash + unix, 62 byte

Si aspetta l'array in STDIN. Il formato di input non conta, purché i numeri siano numeri interi non negativi.

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

Modificato: carattere jolly di escape nell'argomento grep. Ora può essere eseguito in modo sicuro in directory non vuote. Grazie a manatwork.

Perl, 27 byte

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

Restituisce l'ultimo valore più comune in caso di pareggio.

PHP, 53 50 byte

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

Esegui in questo modo:

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

Ritocchi

• 3 byte salvati sfruttando la libertà di ritenere che l'ingresso sia assegnato a una variabile d

Java 8, 83 byte

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

ddeve essere un Collection<Integer>.

Se Collectionspuò essere importato staticamente:
59 byte

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 le importazioni vengono ignorate, è 45 .

Haskell , 42 39 byte

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

Provalo online!

Modifica: Grazie a Zgarb per -3 byte

Brachylog , 5 byte

ọtᵒth

Provalo online!

Questo non è proprio uno snippet, ma non sono sicuro di cosa sarebbe ...

         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 byte

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

(frequencies %)restituisce una mappa hash, che può essere utilizzata come funzione. Data una chiave restituisce il valore corrispondente :)

Uguale lunghezza:

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

Codice completo e 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;
}