Schreiben Sie ein Snippet, um den Modus (die häufigste Zahl) einer Liste positiver Ganzzahlen zu berechnen.

Zum Beispiel der Modus von

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

ist 1, weil es maximal 5 mal vorkommt.

Sie können davon ausgehen, dass die Liste in einer Variablen wie dund in einem eindeutigen Modus gespeichert ist.

zB: Python, 49

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

Das ist Code-Golf , also gewinnt die kürzeste Lösung in Bytes.

K5, 6 Bytes

*>#:'=

Das erste ( *) der absteigenden Elemente ( >) der Anzahl von jedem ( #:') der Gruppe ( =). Schritt für Schritt:

  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

versuchen Sie es in Ihrem Browser !

Python 2 - 18

max(d,key=d.count)

Da Ihre Python-Antwort nicht zu drucken scheint, erwarte ich, dass dies das ist, was Sie wollen.

Addiere 6 Bytes für printnormal.

Matlab / Octave, 7 5 Bytes

Es überrascht nicht, dass es eine integrierte Funktion zum Auffinden von Modi gibt. Als anonyme Funktion:

@mode

Dies gibt das am häufigsten vorkommende Element im Eingabevektor mit Bindungen zum kleineren Wert zurück.

2 Bytes gespart dank Dennis!

Pyth - 6

eo/QNQ

Probieren Sie es online aus.

Erwartet Eingaben über stdin wie [4,3,1,0,6,1,6,4,4,0,3,1,7,7,3,4,1,1,2,8]. Bindungen werden beim letzten Auftreten aufgelöst, da Python stabile Sortierungen ausführt.

Sortiert die Liste nach dem Wert in der Liste und druckt dann die letzte Nummer der Liste.

Qkönnte durch ersetzt werden, dwenn Sie initialisiert haben d, den Wert vor z=d[4 3 1 0 6 4 4 0 1 7 7 3 4 1 1 2 8)

Python-artiger Pseudocode:

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

Vollständige Erklärung:

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

Pyth's orderbyläuft genauso wie Python's, sortedwobei orderbydas erste Argument das keyArgument ist.

Mathematica, 25 Bytes

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

oder

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

Wie bei der Challenge wird erwartet, dass die Liste in gespeichert wird d.

oder ... 15 Bytes

Natürlich wäre Mathematica nicht Mathematica, wenn es kein eingebautes Programm hätte:

#&@@Commonest@d

CommonestGibt eine Liste aller gängigen Elemente zurück (im Falle eines Gleichstands) und #&@@ist ein Golfspieler First@.

Ruby, 22 Bytes

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

Grundsätzlich eine Portierung meiner Mathematica-Antwort, außer dass Ruby eine direkte hat, max_bysodass ich nicht erst sortieren muss.

R 33 25 Bytes

Danke @Hugh für die Hilfe beim Kürzen:

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

Das Original:

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

Dadurch wird die Häufigkeit jedes Elements im Vektor berechnet dund anschließend der Name der Spalte mit dem größten Wert zurückgegeben. Der zurückgegebene Wert ist eine Zeichenfolge, die die Zahl enthält. Es wurde nirgendwo gesagt, dass das nicht in Ordnung ist, also ...

Vorschläge zur Verkürzung sind willkommen!

CJam, 11 10 Bytes

A{A\-,}$0=

Nimmt das Array in einer aufgerufenen Variablen an A. Dies sortiert das Array grundsätzlich nach dem Vorkommen jeder Zahl im Array und wählt dann das letzte Element des Arrays aus.

Anwendungsbeispiel

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

Ausgabe

6

1 Byte gespart dank Dennis!

Probieren Sie es hier online aus

Powershell 19

($d|group)[0].Count

(Dies setzt voraus, dass das Array bereits aktiviert ist. $d)

J - 12 Zeichen

Anonyme Funktion. Sortiert die Liste vom häufigsten bis zum seltensten, wobei das erste Element verwendet wird.

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

• 0{ Zuerst von
• ~. Einzigartige Gegenstände
• \: Herunter sortiert von
• #/.~ Frequenzen

Probieren Sie es aus.

JavaScript (ES6) 51

Nur ein einzeiliger Ausdruck mit der vorab geladenen Variablen d. Sortieren Sie das Array nach der Frequenz und erhalten Sie dann das erste Element.
Böser Nebeneffekt, das ursprüngliche Array wird verändert

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

Wie üblich .map anstelle von .reduce verwenden, da es insgesamt 1 Zeichen kürzer ist. Mit .reduce ist es fast eine saubere, nicht Golf spielende Lösung.

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

Endlich eine Lösung, die eine Funktion verwendet, ohne das ursprüngliche Array zu ändern und ohne Globale (62 Bytes):

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

Test In FireFox / Firebug - Konsole

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]

Ausgabe 1

Das d-Array wird zu:

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

Um ehrlich zu sein, wird es in Zukunft nirgendwo eine Lösung mit 18 Zeichen geben.

EDIT: Ich stehe korrigiert und beeindruckt.

JavaScript, ES6, 71 Byte

Ein bisschen lang, kann viel golfen.

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

Dies erzeugt eine Funktion, fdie wie f([1,1,1,2,1,2,3,4,1,5])folgt aufgerufen werden kann und zurückkehrt1 .

Probieren Sie es auf Ihrer neuesten Firefox-Konsole aus.

05AB1E , 3 Bytes

(nicht konkurrierend - Frage geht der Sprache voraus)

.MJ

Erläuterung:

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

Wenn Sie das Array in einer Variablen speichern möchten, anstatt die Eingabe zu verwenden, verschieben Sie das Array einfach zu Beginn des Programms in den Stapel.

Probieren Sie es online!

C # - 49

Kann nicht wirklich mit C # konkurrieren, aber na ja:

Angenommen, dist das Array

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

Bash - 29 27 Zeichen

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

Es benutzen:

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

dh "1" ist der Modus, und es erscheint fünfmal.

GolfScript, 10 Bytes

a{a\-,}$0=

Aus dieser Antwort schrieb ich an Tipps zum Golfen in GolfScript . Erwartet die Eingabe in einem Array mit dem Namen a, gibt das Ergebnis auf dem Stapel zurück. (Um Eingaben von einem Array auf dem Stack zu lesen, müssen Sie :11 Bytes voranstellen. Um Eingaben von stdin (im Format [1 2 1 3 7]) zu lesen , müssen Sie auch voranstellen~ 12 Bytes .)

Dieser Code iteriert über das Eingabearray, subtrahiert jedes Element vom ursprünglichen Array und zählt die Anzahl der verbleibenden Elemente. Dies wird dann als Schlüssel zum Sortieren des ursprünglichen Arrays verwendet, und das erste Element des sortierten Arrays wird zurückgegeben.

Online-Demo.

Ps. Vielen Dank an Peter Taylor , der mich auf diese Herausforderung aufmerksam gemacht hat .

Dyalog APL, 12 Zeichen

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

∘.=⍨dist dasselbe wie d∘.=d, reflexives äußeres Produkt von =. Es wird eine boolesche Matrix erstellt, in der jedes Elementpaar verglichen wird d.

+/ summiert diese Matrix entlang einer der Achsen und erzeugt einen Vektor.

⍒bewertet den Vektor, dh sortiert ihn nach Indizes. (Wie die Glyphen andeuten, werden die ⍒Noten in absteigender Reihenfolge und angezeigt⍋ die in aufsteigender Reihenfolge vergeben.)

⊃ Nimmt den ersten Index aus der Bewertung - den Index des größten Elements von d .

d[...] Gibt dieses Element zurück.

Perl 6 , 21 Bytes

.Bag.invert.max.value

Beispiel:

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

Wenn es ein Unentschieden gibt, wird das größere Unentschieden gedruckt.

Die .BagMethode für eine Liste oder ein Array erstellt einen quantifizierten Hash, der die Gesamtanzahl der Aufrufe eines bestimmten Werts mit diesem Wert verknüpft.

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

Die .invertMethode erstellt eine Liste der Paare in der Tasche mit dem Schlüssel und dem getauschten Wert. (Der Grund, warum wir dies nennen, ist, dass die nächste Methode das tut, was wir wollen.)

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

Die .maxMethode auf einer Liste von Paaren gibt das größte Paar zurück, das zuerst die Schlüssel vergleicht, und im Falle eines Gleichstands, das die Werte vergleicht.
(Dies ist, weil so multi infix:<cmp>(Pair:D \a, Pair:D \b)bestimmt wird, welche größer ist)

5 => 1

Die .valueMethode gibt den Wert aus dem Pair zurück. (Es wäre der Schlüssel gewesen, nach dem wir gesucht hätten, wenn der .invertAnruf nicht früher stattgefunden hätte.)

1

Wenn Sie alle Werte zurückgeben möchten, die bei einem Unentschieden gebunden wurden:

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

Die .classifyMethode gibt eine Liste von Paaren zurück, bei denen die Schlüssel vom Aufrufen des Whatever-Lambda  *.valuemit jedem der Paare stammen.

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

Dann rufen wir .maxan, um das größte Paar zu bekommen.

"5" => [1 => 5]

Ein Anruf, um .valueuns die originalen Paare aus der Tasche zu holen (in diesem Fall nur eines)

1 => 5

Anschließend >>.keyrufen wir die .keyMethode für jedes Paar in der Liste auf, sodass wir eine Liste der Werte erhalten, die am häufigsten gesehen wurden.

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

Eingang A muss vom Typ sein Integer[]. Beachten Sie java.util.*und java.util.stream.*müssen importiert werden, jedoch im Spirit Oneliner werden sie ausgelassen.

Bash + Unix-Tools, 62 Bytes

Erwartet das Array im STDIN. Das Eingabeformat zählt nicht, solange die Zahlen nicht negative ganze Zahlen sind.

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

Bearbeitet: Platzhalter in grep-Argumenten ausgeblendet. Jetzt kann es sicher in nicht leeren Verzeichnissen ausgeführt werden. Dank der Handarbeit.

Perl, 27 Bytes

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

Gibt den letzten am häufigsten verwendeten Wert im Falle eines Gleichstands zurück.

PHP, 53 50 Bytes

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

Laufen Sie wie folgt:

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

Optimierungen

• Einsparung von 3 Bytes durch Nutzung der Freiheit, davon auszugehen, dass der Eingang einer Variablen zugewiesen ist d

Java 8, 83 Bytes

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

dmuss ein sein Collection<Integer>.

Kann Collectionsstatisch importiert werden:
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

Wenn die Importe ignoriert werden, ist es 45 .

Haskell , 42 39 Bytes

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

Probieren Sie es online!

Edit: Als zu Zgarb für -3 Bytes

Brachylog , 5 Bytes

ọtᵒth

Probieren Sie es online!

Dies ist kein Schnipsel, aber ich bin nicht sicher, was wäre ...

         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 %)Gibt eine Hash-Map zurück, die als Funktion verwendet werden kann. Bei einem Schlüssel wird der entsprechende Wert zurückgegeben :)

Gleiche Länge:

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

Vollständiger Code und 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;
}