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

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

int[] s = { 1, 2, 3, 3, 4};
int[] q = s.Distinct().ToArray();

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

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

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

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]);
}

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

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

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!

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

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

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

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

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

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 की एक विशेषता है।

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

    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));
    }

List myStringList = new List();
foreach (string s in myStringArray)
{
    if (!myStringList.Contains(s))
    {
        myStringList.Add(s);
    }
}

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

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

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 + ",");
}

यहां ओ (एन * एन) दृष्टिकोण है जो 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 का उपयोग करके नियम बनाता है।

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

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();
        }

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

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);
            }
        }

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 ");
    }
}

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

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

for(int i=0;i

सरल समाधान:

using System.Linq;
...

public static int[] Distinct(int[] handles)
{
    return handles.ToList().Distinct().ToArray();
}

जब आप 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]);

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;
}

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

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

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

    for(int b=0;b

  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;
        }