पर्ल में हैश से उच्चतम मूल्य के साथ कुंजी प्राप्त करने का सबसे आसान तरीका क्या है?

Question

पर्ल में हैश से उच्चतम मूल्य के साथ कुंजी प्राप्त करने का सबसे आसान तरीका क्या है?

Answer 1

जबकि तरह से समाधान:

(sort {$hash{$a} <=> $hash{$b}} keys %hash)[0] 

अन्य उत्तर में से कुछ में पाया काफी सुंदर है, यह के रूप में अच्छी तरह से के रूप में यह लग रहा है प्रदर्शन नहीं करता। सबसे पहले, इस प्रकार O(n) खोज खोज ऑपरेशन को O(n log n) में बदल देता है। दूसरा, सॉर्ट समाधान में n log n हैश लुक-अप है। हैश लुक-अप कुछ परिचालनों के लिए बहुत अच्छे हैं, लेकिन पूरे हैश के साथ काम करते समय, each, keys, या values का उपयोग डेटा संरचना के माध्यम से करने के लिए लुक-अप धीमा हो जाएगा। ऐसा इसलिए है क्योंकि इटरेटर्स को चाबियों के हैंश की गणना करने की आवश्यकता नहीं होती है, न ही उन्हें मूल्यों को खोजने के लिए बार-बार चलने की आवश्यकता होती है। और ऊपरी भाग स्थिर नहीं है, लेकिन हैश बढ़ने के साथ बढ़ रहा है।

sub largest_value (\%) { 
    my $hash = shift; 
    keys %$hash;  # reset the each iterator 

    my ($large_key, $large_val) = each %$hash; 

    while (my ($key, $val) = each %$hash) { 
     if ($val > $large_val) { 
      $large_val = $val; 
      $large_key = $key; 
     } 
    } 
    $large_key 
} 

print largest_value %hash; # prints 'largest' 

या एक तेज संस्करण के लिए स्मृति कारोबार:

use strict; 
use warnings; 

my %hash = (
    small => 1, 
    medium => 5, 
    largest => 10, 
    large => 8, 
    tiny => 0.1, 
); 

यहाँ एक समाधान each इटरेटर का उपयोग कर (एक O(1) आपरेशन n बार किया) है:

यहाँ कुछ तेजी से समाधान कर रहे हैं गति (यह हैश की एक प्रति बनाता है):

sub largest_value_mem (\%) { 
    my $hash = shift; 
    my ($key, @keys) = keys %$hash; 
    my ($big, @vals) = values %$hash; 

    for (0 .. $#keys) { 
     if ($vals[$_] > $big) { 
      $big = $vals[$_]; 
      $key = $keys[$_]; 
     } 
    } 
    $key 
} 

print largest_value_mem %hash; # prints 'largest' 

यहाँ विभिन्न हैश आकारों के साथ प्रदर्शन है:

10 keys:    Rate largest_with_sort largest_value largest_value_mem 
largest_with_sort 111565/s    --   -8%    -13% 
largest_value  121743/s    9%   --    -5% 
largest_value_mem 127783/s    15%   5%    -- 

50 keys:    Rate largest_with_sort largest_value largest_value_mem 
largest_with_sort 24912/s     --   -37%    -40% 
largest_value  39361/s    58%   --    -6% 
largest_value_mem 41810/s    68%   6%    -- 

100 keys:   Rate largest_with_sort largest_value largest_value_mem 
largest_with_sort 9894/s     --   -50%    -56% 
largest_value  19680/s    99%   --    -12% 
largest_value_mem 22371/s    126%   14%    -- 

1,000 keys:   Rate largest_with_sort largest_value largest_value_mem 
largest_with_sort 668/s     --   -69%    -71% 
largest_value  2183/s    227%   --    -7% 
largest_value_mem 2341/s    250%   7%    -- 

10,000 keys:  Rate largest_with_sort largest_value largest_value_mem 
largest_with_sort 46.5/s     --   -79%    -81% 
largest_value  216/s    365%   --    -11% 
largest_value_mem 242/s    421%   12%    -- 

आप देख सकते हैं, अगर स्मृति एक मुद्दे के ज्यादा नहीं है, आंतरिक सरणियों के साथ संस्करण सबसे तेज, है बारीकी से each इटरेटर द्वारा पीछा किया, और में तीसरे स्थान ... sort

Answer 2

my $highest_val = (keys {$hash{$b} <=> $hash{$a}} keys %hash)[0]; 

Answer 3

कुंजी सबसे कम से उच्चतम करने के लिए, मूल्य के अनुसार क्रमबद्ध:

sort { $hash{$a} <=> $hash{$b} } keys %hash 

चाबियाँ, मूल्य के अनुसार क्रमबद्ध उच्चतम से न्यूनतम:

reverse sort { $hash{$a} <=> $hash{$b} } keys %hash 

और पहला तत्व

(reverse sort { $hash{$a} <=> $hash{$b} } keys %hash)[0] 

स्पेसशिप को 012 के साथ बदलें स्वाद के लिए।

Answer 4

my $highest_val = (sort { $hash{$a} <=> $hash{$b} } keys %hash)[0]; 

आप जो चाहते हैं वह होने की संभावना है।

my @array = map {[$hash{$_},$_]} keys %hash; 
my $key_with_highest_value = (sort { $a->[0] <=> $b->[0] } @array)[0]->[1] 

Answer 5

निम्नलिखित अधिक स्थान-कुशल है और हे (एन) में चलेंगे हे के बजाय (एन:

आप एक बहुत बड़े हैश है, तो आप को बदलने के लिए एक Schwartzian की तरह कुछ का उपयोग करना चाहें लॉग एन) हैश को सॉर्ट करने वाले अन्य उत्तरों की तुलना में। यह मानता है कि मान 0 से अधिक पूर्णांक हैं और हैश खाली नहीं है, लेकिन आपके मामले के लिए आसानी से बढ़ाया जाना चाहिए।

my $key_for_max_value; 
my $max_value = -1; 
while ((my $key, my $value) = each %hash) { 
    if ($value > $max_value) { 
    $max_value = $value; 
    $max_key = $key; 
    } 
} 

$ key_for_max_value अब उच्चतम मूल्य के अनुरूप कुंजी होगी।

Answer 6

my ($max_key, $max_val) = each %hash or die "hash is empty"; 
while (my ($key, $val) = each %hash) { 
    $max_key = $key, $max_val = $val if $val > $max_val; 
} 

Answer 7

नहीं

यकीन है कि क्यों हर कोई हाथ से यह कर रहा है ...

use List::Util qw(reduce); 
my $max_val_key = reduce { $hash{$a} > $hash{$b} ? $a : $b } keys %hash;