पर्ल

Question

में केस असंवेदनशील अनोखा ऐरे तत्व मॉड्यूल द्वारा निर्यात किए गए यूनिक फ़ंक्शन का उपयोग कर रहा हूं, सूची :: अधिक उपयोग किसी सरणी में uniq तत्वों को खोजने के लिए। हालांकि, मैं चाहता हूं कि यह असंवेदनशील तरीके से यूनिक तत्वों को ढूंढें। मैं उसे कैसे कर सकता हूँ?

#! /usr/bin/perl 

use strict; 
use warnings; 
use Data::Dumper qw(Dumper); 
use List::MoreUtils qw(uniq); 
use feature "say"; 

my @elements=<array is formed here>; 

my @words=uniq @elements; 

say Dumper \@words; 

आउटपुट::

$VAR1 = [ 
      'John', 
      'john', 
      'JohN', 
      'JOHN', 
      'JoHn', 
      'john john' 
     ]; 

अपेक्षित उत्पादन किया जाना चाहिए: जॉन, जॉन जॉन

केवल 2 तत्वों

मैं डाटा :: डम्पर का उपयोग कर सरणी के उत्पादन में फेंक दिया है , बाकी सभी को फ़िल्टर किया जाना चाहिए क्योंकि वे एक ही शब्द हैं, केवल अंतर ही है।

मैं मामले को अनदेखा कर डुप्लिकेट तत्वों को कैसे हटा सकता हूं?

Answer 1

उपयोग लोअरकेस, एक map बयान के साथ lc:

my @uniq_no_case = uniq map lc, @elements; 

---

कारण List::MoreUtils'uniq केस संवेदी है कि यह हैश की deduping विशेषताओं, जो भी केस संवेदी है पर निर्भर करता है।

sub uniq { 
    my %seen =(); 
    grep { not $seen{$_}++ } @_; 
} 

आप अपने खुद के कोड में सीधे इस उप का उपयोग करना चाहते हैं, तो आप वहाँ में lc को शामिल कर सकता है: यह कैसे काम करता की

sub uniq_no_case { 
    my %seen =(); 
    grep { not $seen{$_}++ } map lc, @_; 
} 

स्पष्टीकरण:

uniq के लिए कोड तो की तरह दिखता है

@_ में subroutine के लिए तर्क शामिल हैं, और उन्हें grep कथन में खिलाया जाता है। कोई भी तत्व जो कोड ब्लॉक के माध्यम से पारित होने पर सत्य लौटाता है उसे grep कथन द्वारा वापस कर दिया जाता है। कोड ब्लॉक में कुछ बेहतर बिंदु होते हैं:

• $seen{$_}++ पहली बार तत्व को देखा जाता है। मान अभी भी 1 तक बढ़ गया है, लेकिन इसे वापस करने के बाद (++$seen{$_} के विपरीत जो पहले इंक होगा, फिर वापस आएं)।
• वृद्धि के परिणाम को अस्वीकार कर, हम पहली कुंजी के लिए सच हो जाते हैं, और प्रत्येक निम्न कुंजी के लिए झूठी। इसलिए, सूची deduped है।
• grep उप में अंतिम विवरण के रूप में एक सूची वापस कर देगा, जो बदले में उप द्वारा वापस आ जाएगा।
• map lc, @_@_ में सभी तत्वों के लिए बस lc फ़ंक्शन लागू करता है।

Answer 2

ऊपरी/निचले मामले के लिए शब्द आप पहले से ही देखा है का ट्रैक रखने के, लेकिन यह भी सामान्य उन्हें एक हैश का उपयोग करें:

my %seen; 
my @unique; 
for my $w (@words) { 
    next if $seen{lc($w)}++; 
    push(@unique, $w); 
} 
# @unique has the unique words 

ध्यान दें कि यह मूल शब्द के मामले भी सुरक्षित रहेंगे।

अपडेट: जैसा कि टिप्पणियों में उल्लेख किया गया है, यह बिल्कुल स्पष्ट नहीं है कि ओपी को क्या चाहिए, लेकिन मैंने इस तरह के समाधान को "समानता संबंध" के तहत एक सूची से अद्वितीय प्रतिनिधियों का चयन करने के लिए एक सामान्य तकनीक को चित्रित करने के लिए लिखा। इस मामले में समानता संबंध शब्द $a शब्द $b के समतुल्य है यदि केवल lc($a) eq lc($b) है।

अधिकांश तुल्यता रिश्तों को इस तरह से व्यक्त किया जा सकता, जो है, रिश्ते एक वर्गीकारक समारोह द्वारा परिभाषित किया गया f() ऐसी है कि $a$b तभी f($a) eq f($b) के समतुल्य होता है। उदाहरण के लिए, यदि हम यह कहना चाहते हैं कि दो शब्द समान हैं तो उनके पास समान लंबाई है, तो f()length() होगा।

तो अब आप देख सकते हैं कि मैंने इस तरह एल्गोरिदम क्यों लिखा - क्लासिफायर फ़ंक्शन मूल सूची का हिस्सा नहीं मान सकता है। f = length के मामले में, हम शब्दों का चयन करना चाहते हैं, लेकिन एक शब्द के f एक संख्या है।