मैं पर्ल में किसी सरणी से डुप्लिकेट आइटम कैसे हटा सकता हूं?

मेरे पास पर्ल में एक सरणी है:

my @my_array = ("one","two","three","two","three");

मैं सरणी से डुप्लीकेट कैसे हटा सकता हूं?

0
ro fr bn

9 उत्तर

ऐसा करने का मेरा सामान्य तरीका है:

my %unique = ();
foreach my $item (@myarray)
{
    $unique{$item} ++;
}
my @myuniquearray = keys %unique;

यदि आप हैश का उपयोग करते हैं और आइटम हैश में जोड़ते हैं। आपके पास यह जानने का बोनस भी है कि सूची में प्रत्येक आइटम कितनी बार दिखाई देता है।

0
जोड़ा
यदि आपको इसकी आवश्यकता है, तो मूल आदेश को संरक्षित करने का नकारात्मक पक्ष है।
जोड़ा लेखक Nathan Fellman, स्रोत
foreach loop के बजाय स्लाइस का उपयोग करना बेहतर है: @unique {@myarray} =()
जोड़ा लेखक Onlyjob, स्रोत

पर्ल दस्तावेज अक्सर पूछे जाने वाले प्रश्नों के अच्छे संग्रह के साथ आता है। आपका प्रश्न अक्सर पूछा जाता है:

% perldoc -q duplicate

ऊपर दिए गए आदेश के आउटपुट से उत्तर, प्रतिलिपि और चिपकाया गया, नीचे दिखाई देता है:

Found in /usr/local/lib/perl5/5.10.0/pods/perlfaq4.pod
 How can I remove duplicate elements from a list or array?
   (contributed by brian d foy)

   Use a hash. When you think the words "unique" or "duplicated", think
   "hash keys".

   If you don't care about the order of the elements, you could just
   create the hash then extract the keys. It's not important how you
   create that hash: just that you use "keys" to get the unique elements.

       my %hash   = map { $_, 1 } @array;
       # or a hash slice: @hash{ @array } = ();
       # or a foreach: $hash{$_} = 1 foreach ( @array );

       my @unique = keys %hash;

   If you want to use a module, try the "uniq" function from
   "List::MoreUtils". In list context it returns the unique elements,
   preserving their order in the list. In scalar context, it returns the
   number of unique elements.

       use List::MoreUtils qw(uniq);

       my @unique = uniq( 1, 2, 3, 4, 4, 5, 6, 5, 7 ); # 1,2,3,4,5,6,7
       my $unique = uniq( 1, 2, 3, 4, 4, 5, 6, 5, 7 ); # 7

   You can also go through each element and skip the ones you've seen
   before. Use a hash to keep track. The first time the loop sees an
   element, that element has no key in %seen. The "next" statement creates
   the key and immediately uses its value, which is "undef", so the loop
   continues to the "push" and increments the value for that key. The next
   time the loop sees that same element, its key exists in the hash and
   the value for that key is true (since it's not 0 or "undef"), so the
   next skips that iteration and the loop goes to the next element.

       my @unique = ();
       my %seen   = ();

       foreach my $elem ( @array )
       {
         next if $seen{ $elem }++;
         push @unique, $elem;
       }

   You can write this more briefly using a grep, which does the same
   thing.

       my %seen = ();
       my @unique = grep { ! $seen{ $_ }++ } @array;
0
जोड़ा
जॉन एज़ में महार एंजर्स महल प्रतिनिधि चोरी!
जोड़ा लेखक brian d foy, स्रोत
मुझे पसंद है कि सबसे अच्छा जवाब 95% कॉपी-पेस्ट और ओसी के 3 वाक्य है। पूरी तरह से स्पष्ट होने के लिए, यह है सबसे अच्छा जवाब; मुझे बस उस तथ्य को मनोरंजक लगता है।
जोड़ा लेखक Parthian Shot, स्रोत
मुझे लगता है कि वास्तव में सवाल उठाने के लिए आपको बोनस अंक प्राप्त करना चाहिए।
जोड़ा लेखक Brad Gilbert, स्रोत
जोड़ा लेखक szabgab, स्रोत

आप perlfaq4 :

sub uniq {
    my %seen;
    grep !$seen{$_}++, @_;
}

my @array = qw(one two three two three);
my @filtered = uniq(@array);

print "@filtered\n";

आउटपुट:

one two three

If you want to use a module, try the uniq function from List::MoreUtils

0
जोड़ा
@ephemient yes, लेकिन अगर आप इस फ़ंक्शन में सॉर्टिंग जोड़ना चाहते हैं तो यह $ :: a और $ :: b को ट्रम्प करेगा, है ना?
जोड़ा लेखक vol7ron, स्रोत
उप uniq {मेरा% देखा; grep! $ देखा {$ _} ++, @_} एक बेहतर कार्यान्वयन है क्योंकि यह बिना किसी कीमत पर आदेश को सुरक्षित रखता है। या इससे भी बेहतर, सूची :: MoreUtils से एक का उपयोग करें।
जोड़ा लेखक ikegami, स्रोत
यह इस क्षेत्र में एक मेरा व्याख्यात्मक है, इसलिए यह ठीक है। कहा जा रहा है, संभवतः एक और वर्णनात्मक चर नाम चुना जा सकता है।
जोड़ा लेखक ephemient, स्रोत
@szabgab, अगर ऐसा है, तो यह गैर-स्थानीय चर का उपयोग करने के लिए sort के लिए अविश्वसनीय रूप से खराब डिज़ाइन निर्णय है।
जोड़ा लेखक Brian Vandenberg, स्रोत
@ vol7tron का अर्थ है "पिछड़ा" संगत, क्षमा करें, यह मुझे परेशान कर रहा था ;-)
जोड़ा लेखक Tyler, स्रोत
@BrianVandenberg 1 9 87 की दुनिया में आपका स्वागत है - जब यह बनाया गया था - और लगभग 100% बैकवर्ड complaility perl के लिए - तो इसे समाप्त नहीं किया जा सकता है।
जोड़ा लेखक szabgab, स्रोत
उदाहरण के लिए कृपया $ ए या $ बी का उपयोग न करें क्योंकि वे जादू के ग्लोबल हैं ()
जोड़ा लेखक szabgab, स्रोत

इसे आज़माएं, ऐसा लगता है कि यूनिक फ़ंक्शन को ठीक तरह से काम करने के लिए क्रमबद्ध सूची की आवश्यकता होती है।

use strict;

# Helper function to remove duplicates in a list.
sub uniq {
  my %seen;
  grep !$seen{$_}++, @_;
}

my @teststrings = ("one", "two", "three", "one");

my @filtered = uniq @teststrings;
print "uniq: @filtered\n";
my @sorted = sort @teststrings;
print "sort: @sorted\n";
my @sortedfiltered = uniq sort @teststrings;
print "uniq sort : @sortedfiltered\n";
0
जोड़ा

सीपीएएन से सूची :: MoreUtils इंस्टॉल करें

फिर आपके कोड में:

use strict;
use warnings;
use List::MoreUtils qw(uniq);

my @dup_list = qw(1 1 1 2 3 4 4);

my @uniq_list = uniq(@dup_list);
0
जोड़ा
@Yassinphilip सीपीएएन उन चीजों में से एक है जो पर्ल को शक्तिशाली और महान बनाते हैं। यदि आप केवल कोर मॉड्यूल पर आधारित अपनी परियोजनाओं को लिख रहे हैं, तो आप संभवतः डाले गए कोड के साथ अपने कोड पर एक बड़ी सीमा डाल रहे हैं जो कुछ मॉड्यूल का उपयोग करने से बचने के लिए कुछ बेहतर तरीके से करने का प्रयास करता है। इसके अलावा, कोर मॉड्यूल का उपयोग कुछ भी गारंटी नहीं देता है, क्योंकि अलग-अलग पर्ल संस्करण वितरण से कोर मॉड्यूल जोड़ या निकाल सकते हैं, इसलिए पोर्टेबिलिटी अभी भी उस पर निर्भर है।
जोड़ा लेखक Francisco Zarabozo, स्रोत
तथ्य यह है कि सूची :: MoreUtils को बंडल नहीं किया गया है w/perl kinda इसे उपयोग करने वाली परियोजनाओं की पोर्टेबिलिटी को नुकसान पहुंचाता है :( (मैं एक के लिए नहीं)
जोड़ा लेखक yPhil, स्रोत
यही जवाब है! लेकिन मैं केवल आपको एक बार वोट दे सकता हूं।
जोड़ा लेखक Axeman, स्रोत
@Ranguard: @dup_list uniq कॉल के अंदर होना चाहिए, नहीं @dups
जोड़ा लेखक incutonez, स्रोत

The variable @array is the list with duplicate elements

%seen=();
@unique = grep { ! $seen{$_} ++ } @array;
0
जोड़ा

एक साधारण पर्ल एक लाइनर के साथ किया जा सकता है।

my @in=qw(1 3 4  6 2 4  3 2 6  3 2 3 4 4 3 2 5 5 32 3); #Sample data 
my @out=keys %{{ map{$_=>1}@in}}; # Perform PFM
print join ' ', sort{$a<=>$b} @out;# Print data back out sorted and in order.

पीएफएम ब्लॉक यह करता है:

@in में डेटा एमएपी में खिलाया जाता है। एमएपी एक अज्ञात हैश बनाता है। कुंजी हैश से निकाली जाती है और @out में फ़ीड करती है

0
जोड़ा

अद्वितीय हैश कुंजी की अवधारणा का उपयोग करना:

my @array  = ("a","b","c","b","a","d","c","a","d");
my %hash   = map { $_ => 1 } @array;
my @unique = keys %hash;
print "@unique","\n";

आउटपुट: एक सी बी डी

0
जोड़ा

विधि 1: एक हैश का प्रयोग करें

तर्क: एक हैश में केवल अनन्य कुंजी हो सकती हैं, इसलिए सरणी पर पुनरावृत्ति करें, सरणी के प्रत्येक तत्व को कोई मान असाइन करें, तत्व को उस हैश की कुंजी के रूप में रखें। हैश की रिटर्न कुंजियां, यह आपकी अनूठी सरणी है।

my @unique = keys {map {$_ => 1} @array};

विधि 2: पुन: प्रयोज्यता के लिए विधि 1 का विस्तार

अगर हम इस कोड को हमारे कोड में कई बार उपयोग करना चाहते हैं तो सबराउटिन बनाने के लिए बेहतर है।

sub get_unique {
    my %seen;
    grep !$seen{$_}++, @_;
}
my @unique = get_unique(@array);

Method 3: Use module List::MoreUtils

use List::MoreUtils qw(uniq);
my @unique = uniq(@array);
0
जोड़ा