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

मैं एक स्ट्रिंग [] सरणी के साथ सी # में काम कर रहा हूं जो फ़ंक्शन कॉल से वापस आ जाता है। मैं संभवतः एक जेनेरिक संग्रह में डाल सकता था, लेकिन मैं सोच रहा था कि ऐसा करने का एक बेहतर तरीका है, संभवतः एक temp सरणी का उपयोग करके।

सी # सरणी से डुप्लिकेट को हटाने का सबसे अच्छा तरीका क्या है?

0
ro fr bn
विशिष्ट विस्तार विधि का प्रयोग करें।
जोड़ा लेखक kokos, स्रोत
@ विटिम.स नोप। मेरे मामले में, यह एक सरणी भी नहीं है, लेकिन एक सूची है। मैं कोई जवाब स्वीकार करता हूं जो नौकरी करता है। शायद, यह कागज पर ऐसा करने का एक झटका है।
जोड़ा लेखक AngryHacker, स्रोत
वास्तव में। यह अधिक मजेदार है जब सरणी पहले ही हल हो चुकी है - उस स्थिति में यह ओ (एन) समय में जगह में किया जा सकता है।
जोड़ा लेखक David Airapetyan, स्रोत

20 उत्तर

ऐसा करने के लिए आप संभवतः LINQ क्वेरी का उपयोग कर सकते हैं:

int[] s = { 1, 2, 3, 3, 4};
int[] q = s.Distinct().ToArray();
0
जोड़ा
ध्यान दें कि आप स्ट्रिंग के मामले-असंवेदनशील विशिष्ट सेट को प्राप्त करने के लिए डिस्टिंक (स्ट्रिंग कॉम्पारेर। ऑर्डिनल इग्नोरकेस) जैसे पैरामीटर के रूप में एक IEqualityComparer का उपयोग कर सकते हैं।
जोड़ा लेखक justis, स्रोत
तत्वों का मूल सम्मान अलग सम्मान है?
जोड़ा लेखक asyrov, स्रोत

यदि आपको इसे सॉर्ट करने की आवश्यकता है, तो आप एक प्रकार को कार्यान्वित कर सकते हैं जो डुप्लीकेट को भी हटा देता है।

फिर एक पत्थर के साथ दो पक्षियों को मारता है।

0
जोड़ा
सॉर्टिंग डुप्लीकेट को कैसे हटाता है?
जोड़ा लेखक Danyal Ozair, स्रोत

निम्न परीक्षण और कार्य कोड एक सरणी से डुप्लीकेट हटा देगा। आपको सिस्टम शामिल करना होगा। चयन नामस्थान।

string[] sArray = {"a", "b", "b", "c", "c", "d", "e", "f", "f"};
var sList = new ArrayList();

for (int i = 0; i < sArray.Length; i++) {
    if (sList.Contains(sArray[i]) == false) {
        sList.Add(sArray[i]);
    }
}

var sNew = sList.ToArray();

for (int i = 0; i < sNew.Length; i++) {
    Console.Write(sNew[i]);
}

यदि आप चाहें तो आप इसे एक फ़ंक्शन में लपेट सकते हैं।

0
जोड़ा

नोट: परीक्षण नहीं किया गया!

string[] test(string[] myStringArray)
{
    List myStringList = new List();
    foreach (string s in myStringArray)
    {
        if (!myStringList.Contains(s))
        {
            myStringList.Add(s);
        }
    }
    return myStringList.ToString();
}

हो सकता है कि आपको क्या चाहिए ...

EDIT Argh!!! beaten to it by rob by under a minute!

0
जोड़ा
रोब ने आपको कुछ भी नहीं हराया। जब आप सूची का उपयोग कर रहे हैं, तो वह ऐरेलिस्ट का उपयोग कर रहा है। आपका संस्करण बेहतर है।
जोड़ा लेखक Doug S, स्रोत

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

यदि आपको अंतिम इनपुट की आवश्यकता होती है तो मूल इनपुट के समान क्रम होता है, जब आप प्रत्येक स्ट्रिंग के पहले अवसर पर विचार करते हैं, तो इसके बजाय निम्न एल्गोरिदम का उपयोग करें:

  1. एक सूची (अंतिम आउटपुट) और एक शब्दकोश (डुप्लीकेट की जांच करने के लिए)
  2. है
  3. इनपुट में प्रत्येक स्ट्रिंग के लिए, जांचें कि यह पहले से मौजूद शब्दकोश में मौजूद है या नहीं
  4. यदि नहीं, तो इसे दोनों को शब्दकोश और सूची में जोड़ें

अंत में, सूची में प्रत्येक अद्वितीय स्ट्रिंग का पहला मौका होता है।

सुनिश्चित करें कि आप अपनी शब्दकोश का निर्माण करते समय संस्कृति जैसे चीजों पर विचार करें, यह सुनिश्चित करने के लिए कि आप अक्षरों वाले अक्षरों के साथ डुप्लिकेट को सही तरीके से संभाल लें।

0
जोड़ा

Here is the HashSet approach:

public static string[] RemoveDuplicates(string[] s)
{
    HashSet set = new HashSet(s);
    string[] result = new string[set.Count];
    set.CopyTo(result);
    return result;
}

दुर्भाग्य से इस समाधान के लिए .NET Framework 3.5 या बाद में भी आवश्यकता है क्योंकि हैशसेट को उस संस्करण तक नहीं जोड़ा गया था। आप array.Distinct() का भी उपयोग कर सकते हैं , जो LINQ की एक विशेषता है।

0
जोड़ा
यह शायद मूल आदेश को सुरक्षित नहीं रखेगा।
जोड़ा लेखक Hamish Grubijan, स्रोत

यह इस बात पर निर्भर हो सकता है कि आप समाधान को कितना इंजीनियर करना चाहते हैं - यदि सरणी कभी भी बड़ी नहीं होगी और आपको सूची को सॉर्ट करने की परवाह नहीं है तो आप निम्न के जैसा कुछ प्रयास करना चाहेंगे:

    public string[] RemoveDuplicates(string[] myList) {
        System.Collections.ArrayList newList = new System.Collections.ArrayList();

        foreach (string str in myList)
            if (!newList.Contains(str))
                newList.Add(str);
        return (string[])newList.ToArray(typeof(string));
    }
0
जोड़ा
आपको ArrayList के बजाय सूची का उपयोग करना चाहिए।
जोड़ा लेखक Doug S, स्रोत
List myStringList = new List();
foreach (string s in myStringArray)
{
    if (!myStringList.Contains(s))
    {
        myStringList.Add(s);
    }
}

यह ओ (एन ^ 2) है, जो एक छोटी सूची के लिए कोई फर्क नहीं पड़ता है जो कॉम्बो में भरने जा रहा है, लेकिन बड़े संग्रह पर तेजी से समस्या हो सकती है।

0
जोड़ा

शायद हैशसेट जो डुप्लिकेट तत्वों को संग्रहीत नहीं करता है और चुपचाप जोड़ने के अनुरोधों को अनदेखा करता है डुप्लिकेट।

static void Main()
{
    string textWithDuplicates = "aaabbcccggg";     

    Console.WriteLine(textWithDuplicates.Count());  
    var letters = new HashSet(textWithDuplicates);
    Console.WriteLine(letters.Count());

    foreach (char c in letters) Console.Write(c);
    Console.WriteLine("");

    int[] array = new int[] { 12, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2 };

    Console.WriteLine(array.Count());
    var distinctArray = new HashSet(array);
    Console.WriteLine(distinctArray.Count());

    foreach (int i in distinctArray) Console.Write(i + ",");
}
0
जोड़ा

यहां ओ (एन * एन) दृष्टिकोण है जो O (1) स्थान का उपयोग करता है।

void removeDuplicates(char* strIn)
{
    int numDups = 0, prevIndex = 0;
    if(NULL != strIn && *strIn != '\0')
    {
        int len = strlen(strIn);
        for(int i = 0; i < len; i++)
        {
            bool foundDup = false;
            for(int j = 0; j < i; j++)
            {
                if(strIn[j] == strIn[i])
                {
                    foundDup = true;
                    numDups++;
                    break;
                }
            }

            if(foundDup == false)
            {
                strIn[prevIndex] = strIn[i];
                prevIndex++;
            }
        }

        strIn[len-numDups] = '\0';
    }
}

ऊपर हैश/linq दृष्टिकोण हैं जो आप आम तौर पर वास्तविक जीवन में उपयोग करेंगे। हालांकि साक्षात्कार में वे आमतौर पर कुछ बाधाओं को रखना चाहते हैं उदा। स्थिर स्थान जो हैश या कोई आंतरिक api का नियम नहीं है - जो LINQ का उपयोग करके नियम बनाता है।

0
जोड़ा
जब आप पूरी सूची को स्टोर करते हैं तो यह कभी भी ओ (1) स्पेस का उपयोग कैसे कर सकता है? एक इनस्थल प्रकार से शुरू करके, आप बहुत कम कोड के साथ ओ (nlogn) समय और ओ (एन) मेमोरी कर सकते हैं।
जोड़ा लेखक Thomas Ahle, स्रोत
आपको क्या लगता है कि यह पूरी सूची संग्रहित कर रहा है? यह वास्तव में जगह में कर रहा है। और हालांकि सवाल में कोई शर्त नहीं है, मेरा कोड मूल स्ट्रिंग में वर्णों के क्रम को बनाए रखता है। छंटनी इसे हटा देगा।
जोड़ा लेखक Sesh, स्रोत

- यह हर बार पूछे जाने वाले साक्षात्कार प्रश्न है। अब मैंने अपना कोडिंग किया है।

static void Main(string[] args)
{    
            int[] array = new int[] { 4, 8, 4, 1, 1, 4, 8 };            
            int numDups = 0, prevIndex = 0;

            for (int i = 0; i < array.Length; i++)
            {
                bool foundDup = false;
                for (int j = 0; j < i; j++)
                {
                    if (array[i] == array[j])
                    {
                        foundDup = true;
                        numDups++;//Increment means Count for Duplicate found in array.
                        break;
                    }                    
                }

                if (foundDup == false)
                {
                    array[prevIndex] = array[i];
                    prevIndex++;
                }
            }

           //Just Duplicate records replce by zero.
            for (int k = 1; k <= numDups; k++)
            {               
                array[array.Length - k] = '\0';             
            }


            Console.WriteLine("Console program for Remove duplicates from array.");
            Console.Read();
        }
0
जोड़ा
आपको इस प्रश्न के लिए ओ (एन * 2) समय जटिलता नहीं करनी चाहिए।
जोड़ा लेखक Danyal Ozair, स्रोत
आपको मर्ज सॉर्ट का उपयोग करना चाहिए
जोड़ा लेखक nfgallimore, स्रोत

कोड का निम्नलिखित भाग एक ऐरेलिस्ट से डुप्लिकेट को हटाने का प्रयास करता है हालांकि यह एक इष्टतम समाधान नहीं है। मुझे इस प्रश्न को रिकर्सन के माध्यम से डुप्लीकेट हटाने के लिए एक साक्षात्कार के दौरान पूछा गया था, और दूसरी/अस्थायी सरणी सूची का उपयोग किए बिना:

private void RemoveDuplicate() 
{

ArrayList dataArray = new ArrayList(5);

            dataArray.Add("1");
            dataArray.Add("1");
            dataArray.Add("6");
            dataArray.Add("6");
            dataArray.Add("6");
            dataArray.Add("3");
            dataArray.Add("6");
            dataArray.Add("4");
            dataArray.Add("5");
            dataArray.Add("4");
            dataArray.Add("1");

            dataArray.Sort();

            GetDistinctArrayList(dataArray, 0);
}

private void GetDistinctArrayList(ArrayList arr, int idx)

{

            int count = 0;

            if (idx >= arr.Count) return;

            string val = arr[idx].ToString();
            foreach (String s in arr)
            {
                if (s.Equals(arr[idx]))
                {
                    count++;
                }
            }

            if (count > 1)
            {
                arr.Remove(val);
                GetDistinctArrayList(arr, idx);
            }
            else
            {
                idx += 1;
                GetDistinctArrayList(arr, idx);
            }
        }
0
जोड़ा
protected void Page_Load(object sender, EventArgs e)
{
    string a = "a;b;c;d;e;v";
    string[] b = a.Split(';');
    string[] c = b.Distinct().ToArray();

    if (b.Length != c.Length)
    {
        for (int i = 0; i < b.Length; i++)
        {
            try
            {
                if (b[i].ToString() != c[i].ToString())
                {
                    Response.Write("Found duplicate " + b[i].ToString());
                    return;
                }
            }
            catch (Exception ex)
            {
                Response.Write("Found duplicate " + b[i].ToString());
                return;
            }
        }              
    }
    else
    {
        Response.Write("No duplicate ");
    }
}
0
जोड़ा

Tested the below & it works. What's cool is that it does a culture sensitive search too

class RemoveDuplicatesInString
{
    public static String RemoveDups(String origString)
    {
        String outString = null;
        int readIndex = 0;
        CompareInfo ci = CultureInfo.CurrentCulture.CompareInfo;


        if(String.IsNullOrEmpty(origString))
        {
            return outString;
        }

        foreach (var ch in origString)
        {
            if (readIndex == 0)
            {
                outString = String.Concat(ch);
                readIndex++;
                continue;
            }

            if (ci.IndexOf(origString, ch.ToString().ToLower(), 0, readIndex) == -1)
            {
                //Unique char as this char wasn't found earlier.
                outString = String.Concat(outString, ch);                   
            }

            readIndex++;

        }


        return outString;
    }


    static void Main(string[] args)
    {
        String inputString = "aAbcefc";
        String outputString;

        outputString = RemoveDups(inputString);

        Console.WriteLine(outputString);
    }

}

--AptSenSDET

0
जोड़ा

यह कोड 100% एक सरणी से डुप्लिकेट मान हटाता है [जैसा कि मैंने एक [i]] किया था ..... आप इसे किसी भी ओओ भाषा में परिवर्तित कर सकते हैं ..... :)

for(int i=0;i
0
जोड़ा

सरल समाधान:

using System.Linq;
...

public static int[] Distinct(int[] handles)
{
    return handles.ToList().Distinct().ToArray();
}
0
जोड़ा
आपको ToList() की आवश्यकता नहीं है ...
जोड़ा लेखक jHilscher, स्रोत

जब आप ArrayList के साथ काम करते हैं तो आप इस कोड का उपयोग कर सकते हैं

ArrayList arrayList;
//Add some Members :)
arrayList.Add("ali");
arrayList.Add("hadi");
arrayList.Add("ali");

//Remove duplicates from array
  for (int i = 0; i < arrayList.Count; i++)
    {
       for (int j = i + 1; j < arrayList.Count ; j++)
           if (arrayList[i].ToString() == arrayList[j].ToString())
                 arrayList.Remove(arrayList[j]);
0
जोड़ा
public static int RemoveDuplicates(ref int[] array)
{
    int size = array.Length;

   //if 0 or 1, return 0 or 1:
    if (size  < 2) {
        return size;
    }

    int current = 0;
    for (int candidate = 1; candidate < size; ++candidate) {
        if (array[current] != array[candidate]) {
            array[++current] = array[candidate];
        }
    }

   //index to count conversion:
    return ++current;
}
0
जोड़ा

नीचे जावा में एक साधारण तर्क है, आप दो बार सरणी के तत्वों को पार करते हैं और यदि आप कोई भी तत्व देखते हैं तो आप शून्य को असाइन करते हैं और आप जिस तत्व की तुलना कर रहे हैं उसके सूचकांक को स्पर्श नहीं करते हैं।

import java.util.*;
class removeDuplicate{
int [] y ;

public removeDuplicate(int[] array){
    y=array;

    for(int b=0;b
0
जोड़ा
  private static string[] distinct(string[] inputArray)
        {
            bool alreadyExists;
            string[] outputArray = new string[] {};

            for (int i = 0; i < inputArray.Length; i++)
            {
                alreadyExists = false;
                for (int j = 0; j < outputArray.Length; j++)
                {
                    if (inputArray[i] == outputArray[j])
                        alreadyExists = true;
                }
                        if (alreadyExists==false)
                        {
                            Array.Resize(ref outputArray, outputArray.Length + 1);
                            outputArray[outputArray.Length-1] = inputArray[i];
                        }
            }
            return outputArray;
        }
0
जोड़ा
कृपया अपने उत्तर की व्याख्या करें।
जोड़ा लेखक Badiparmagi, स्रोत