Wie Sie die Gruppe durch die Zählung im array ohne Verwendung von loop

arr = [1,2,1,3,5,2,4]

Wie kann ich die Anzahl der array group-Wert mit der Sortierung? Ich brauche die folgende Ausgabe:

x[1] = 2  
x[2] = 2  
x[3] = 1  
x[4] = 1  
x[5] = 1
mögliche Duplikate von Wie zu zählen Duplikate in Ruby-Arrays
Warum, ohne eine Schleife? Es geht um eine Schleife geht irgendwo.

InformationsquelleAutor Mr. Black | 2011-03-29

  1. 106
    x = arr.inject(Hash.new(0)) { |h, e| h[e] += 1 ; h }
    Vielen Dank michael und Terw. Ich mag diese sehr kurz. Aber, kannst du bitte kurz erläutern, die über kurze Linie. :).
    inject "injiziert" ein Akkumulator in eine Zählbare, was in unserem Fall ist ein Hash, der mit einem Standard-Wert von 0. Bei jeder iteration, die wir hinzufügen, um den Wert mit dem Schlüssel des aktuellen Elements (e). Schließlich kehren wir der Akku. ruby-doc.org/core/classes/Enumerable.html#M001494
    Die "inject" - Vorgang wird oft als "Falten" in funktionalen Programmiersprachen, die ich denke, ist ein intuitiver name.
    Aber das code Sortieren nicht-hash. Also am Ende ist es mehr brauchen: Hash[#code hier#.Sortieren] oder sogar sort_by
    lieber .each_with_object über inject beim Bau hashes gegenüber arithmetischen. Siehe @sawa, die Antwort von unten.

    InformationsquelleAutor Michael Kohl

  2. 31

    Nur unter ruby 1.9

    Im Grunde das gleiche wie Michael ' s Antwort, aber einen etwas kürzeren Weg:

    x = arr.each_with_object(Hash.new(0)) {|e, h| h[e] += 1}

    In ähnlichen Situationen,

    • Wenn die Start-element ist ein veränderlich Objekt wie ein Array, Hash, String verwenden, können Sie each_with_object, wie im obigen Fall.

    • Wenn die Start-element ist ein unveränderlich Objekt wie Numeric haben, müssen Sie auf inject als unten.

      sum = (1..10).inject(0) {|sum, n| sum + n} # => 55

    Was die Charaktere angeht, es ist mehr. In Bezug auf die tokens, es ist kürzer. Danke für den Kommentar.
    Danke @sawa. Absolut, es ist sehr kürzer und schneller. Denn, meine eigentliche array ist mutable-format und enthält eine sehr große Menge von Daten. noch einmal vielen Dank.
    Obwohl ich habe bemerkt, mit diesem Ansatz, dass die Werte nicht in Reihenfolge sortiert, wie die Antwort sagte.
    Dies ist die sauberste Antwort. each_with_object wurde Hinzugefügt, um zu vermeiden h[e] += 1 ; h

    InformationsquelleAutor sawa

  3. 13

    Noch ein weiteres - ähnlich wie andere - Ansatz:

    result=Hash[arr.group_by{|x|x}.map{|k,v| [k,v.size]}]
    1. Gruppe durch jedes element der Wert.
    2. Anzeigen die Gruppierung zu einer Reihe von [Wert, counter] Paare.
    3. Drehen Sie das array von paris in Schlüssel-Werte in einem Hash, d.h. erreichbar über result[1]=2 ....

    InformationsquelleAutor lllllll

  4. 10
    x = Hash[arr.uniq.map{ |i| [i, arr.count(i)] }]
    smart 🙂 wie es
    aber performance-wise, Michael und Terv Antwort besser sind.
    Michael Kohl schlagt mich, aber er ist code sollte schneller sein. Dieser code dauert etwa doppelt so lange
    ist interessant..ich dachte, das wäre langsamer als es durchläuft und dann wieder verwenden count - Methode auf das array. Vielleicht mit Hilfe von integrierten Methoden hat Ihre Vorteile. 🙂
    Wirklich? Ich hatte ursprünglich eine version mit count, dachte aber, es wäre nicht gut skalieren mit dem array-Länge, so ersetzt es durch meine aktuelle Antwort. Können Sie führen Sie Ihre benchmark mit etwas größeren array und vergleichen wieder.

    InformationsquelleAutor rubyprince

  5. 9

    Wann immer Sie jemanden finden, der behauptet, dass etwas ist der Schnellste auf diese Art der primitive routine, ich finde immer die interessante zu bestätigen, denn ohne die Bestätigung die meisten von uns sind wirklich nur raten. Also nahm ich alle Methoden hier und getestet.

    Nahm ich ein array mit 120 links, die ich extrahiert aus einer web-Seite, die ich brauchte, um die Gruppe durch zählen und umgesetzt werden, alle diese mit einem Sekunden = Benchmark.Echtzeit-do-Schleife und hab das ganze mal.

    Angenommen links ist der name des Arrays, die ich brauchen, um count:

    #0.00077
seconds = Benchmark.realtime do
  counted_links = {}
  links.each { |e| counted_links[e] = links.count(e) if counted_links[e].nil?}
end
seconds

#0.000232
seconds = Benchmark.realtime do
  counted_links = {}
  links.sort.group_by {|x|x}.each{|x,y| counted_links[x] = y.size}
end

#0.00076
seconds = Benchmark.realtime do 
  Hash[links.uniq.map{ |i| [i, links.count(i)] }]
end

#0.000107 
seconds = Benchmark.realtime do 
  links.inject(Hash.new(0)) {|h, v| h[v] += 1; h}
end

#0.000109
seconds = Benchmark.realtime do 
  links.each_with_object(Hash.new(0)) {|e, h| h[e] += 1}
end

#0.000143
seconds = Benchmark.realtime do 
  links.inject(Hash.new(0)) { |h, e| h[e] += 1 ; h }
end

    Und dann ein wenig von ruby, um herauszufinden, die Antwort:

    times = [0.00077, 0.000232, 0.00076, 0.000107, 0.000109, 0.000143].min
==> 0.000107

    So dass die tatsächliche Schnellste Methode, ymmv, natürlich, ist:

    links.inject(Hash.new(0)) {|h, v| h[v] += 1; h}
    Ich denke, "Sprung in die Logik" es sich für Ihre Schlussfolgerung. 🙂

    InformationsquelleAutor fuzzygroup

  6. 5

    Ich bin sicher, es gibt bessere Möglichkeiten, 

    >> arr.sort.group_by {|x|x}.each{|x,y| print "#{x} #{y.size}\n"}
1 2
2 2
3 1
4 1
5 1

    zuweisen von x-und y-Werte eines hash als nötig.

    es ist nicht notwendig, um sort vor group_by. arr.group_by {...} wird das gleiche tun
    Die OP implizierten die Ergebnisse vorgestellt werden, in Ordnung. Nicht [2,1].group_by {|x|x} #=> {2=>[2], 1=>[1]} kurumi, welche Möglichkeiten sind besser?
    gibt eine Hash die hat keine Ordnung. Die Reihenfolge, in der die Einträge in einer Hash iteriert wird, ist unvorhersehbar.
    href="http://stackoverflow.com/questions/24378914/does-enumerables-group-by-preiserve-the-enumerables-order">bewahrt bestellen, zumindest in der MRT 1.9+. AFAIK, es ist nicht dokumentiert, sollte aber, da es ein Teil des spec.
    Die entsprechenden Werte für jeden Schlüssel eine Reihenfolge; Sortieren könnte relevant sein, wenn Sie sich darum gekümmert. Aber es ist keine Ordnung unter den Schlüsseln, für die Tatsache, dass der zurückgegebene Wert ist ein Hash. Also wäre es NICHT haben nichts zu tun mit [2,1].group_by {|x|x} #=> {2=>[2], 1=>[1]}

    InformationsquelleAutor kurumi

  7. 5

    Nur für das Protokoll, ich habe kürzlich gelesen, über Object#tap hier. Meine Lösung wäre:

    Hash.new(0).tap{|h| arr.each{|i| h[i] += 1}}

    Den #tap Methode übergibt der Aufrufer um den block, und dann gibt es zurück. Das ist ziemlich praktisch, wenn Sie schrittweise erstellen Sie ein array/hash.

    Vielen Dank für Ihren Eintrag!.

    InformationsquelleAutor erasing

  8. 4

    Dies sollte es tun

    arr = [1,2,1,3,5,2,4]

puts arr.inject(Hash.new(0)) {|h, v| h[v] += 1; h}
#=> {1=>2, 2=>2, 3=>1, 5=>1, 4=>1}

    InformationsquelleAutor ThoKra

  9. 4

    Gibt es eine kurze version, die in ruby-2.7 => Enumerable#tally.

    [1,2,1,3,5,2,4].tally  #=> { 1=>2, 2=>2, 3=>1, 5=>1, 4=>1 }

# Other possible usage

(1..6).tally { |i| i%3 }   #=> { 0=>2, 1=>2, 2=>2 }

    InformationsquelleAutor Mr. Black

  10. 1
    arr = [1,2,1,3,5,2,4]
r = {}
arr.each { |e| r[e] = arr.count(e) if r[e].nil?}

    Ausgänge

    p r
#==> {1=>2, 2=>2, 3=>1, 5=>1, 4=>1}
    Danke @thebugfinder

    InformationsquelleAutor thebugfinder

Schreibe einen Kommentar