আমি কীভাবে সি # অ্যারে থেকে সদৃশগুলি সরিয়ে ফেলব?

Question

আমি string[]সি # তে একটি অ্যারের সাথে কাজ করছি যা কোনও ফাংশন কল থেকে ফিরে আসে। আমি সম্ভবত কোনও Genericসংকলনে কাস্ট করতে পারি, তবে আমি ভাবছিলাম যে এটি করার আরও ভাল উপায় আছে কিনা, সম্ভবত কোনও টেম্প অ্যারে ব্যবহার করে।

সি # অ্যারে থেকে সদৃশ অপসারণ করার সর্বোত্তম উপায় কী?

Comments

বিচ্ছিন্ন এক্সটেনশন পদ্ধতিটি ব্যবহার করুন।

— কোকোস

প্রকৃতপক্ষে. অ্যারে ইতিমধ্যে বাছাই করা হলে এটি আরও মজাদার - সেক্ষেত্রে এটি ও (এন) সময়ে স্থানে করা যায়।

— ডেভিড আইরাপেটিয়ান

@ ভিটিম.ইস না আমার ক্ষেত্রে এটি এমনকি একটি অ্যারে নয়, তবে একটি তালিকা <স্ট্রিং>। আমি কাজের যে কোনও উত্তর গ্রহণ করি। সম্ভবত, এটি কাগজে এটি করার একটি ধাক্কা।

— ক্রুদ্ধহ্যাকার

Answer 1

এটি করার জন্য আপনি সম্ভবত একটি লিনকিউ কোয়েরি ব্যবহার করতে পারেন:

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

Comments

মনে রাখবেন যে আপনি একটি আইকোয়ালিটি কম্পিউটারকে প্যারামিটার হিসাবে ব্যবহার করতে পারেন, যেমন .Distinct(StringComparer.OrdinalIgnoreCase)কেস-সংবেদনশীল স্বতন্ত্র স্ট্রিংয়ের সেট পেতে।

— justisb

পৃথক কি উপাদানগুলির মূল ক্রমকে সম্মান করে?

— asyrov

@ এ্যাসেরভ: এমএসডিএন থেকে:The Distinct() method returns an unordered sequence that contains no duplicate values.

— টাইগ্রুব

Answer 2

এখানে হ্যাশসেট <স্ট্রিং> পদ্ধতি:

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

দুর্ভাগ্যক্রমে এই সমাধানটির জন্য .NET ফ্রেমওয়ার্ক 3.5 বা তার পরেও প্রয়োজন কারণ হ্যাশসেটটি সেই সংস্করণ পর্যন্ত যুক্ত করা হয়নি। আপনি অ্যারে ব্যবহার করতে পারেন ist ডিস্টিন্ট () , যা লিনকু এর একটি বৈশিষ্ট্য।

Comments

এটি সম্ভবত মূল ক্রম সংরক্ষণ করবে না।

— হামিশ গ্রুবিজন

Answer 3

নিম্নলিখিত পরীক্ষিত এবং কার্যকারী কোডটি অ্যারে থেকে সদৃশগুলি সরিয়ে ফেলবে। আপনাকে অবশ্যই সিস্টেম.কলেকশন নেমস্পেস অন্তর্ভুক্ত করতে হবে।

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

আপনি চাইলে এটিকে কোনও কার্যে গুটিয়ে রাখতে পারেন।

Comments

এটি হে (এন ^ 2) বলে মনে হচ্ছে ... আপনি অ্যারেলিস্টের পরিবর্তে একটি গাদা ব্যবহার করতে পারেন

— নীল চৌধুরী

Answer 4

যদি আপনার এটি বাছাই করার প্রয়োজন হয়, তবে আপনি এমন একটি সারণি প্রয়োগ করতে পারেন যা নকলগুলিও সরিয়ে দেয়।

তখন একটি পাথর দিয়ে দুটি পাখি হত্যা করে।

Comments

বাছাইয়ের মাধ্যমে সদৃশগুলি কীভাবে মুছে যাবে?

— ডান 1

কে এই ভোট দিয়েছে? এটি কোনও উত্তর নয়। "আমি কীভাবে প্যানকেক তৈরি করব?" "একটি ধনুকের মধ্যে কিছু উপাদান রাখুন এবং মিশ্রিত করুন" "

— কোয়ার্কালি

Answer 5

আপনি সমাধানটি ইঞ্জিনিয়ার করতে কতটা চান তার উপর এটি নির্ভর করতে পারে - যদি অ্যারে কখনও বড় হয় না এবং আপনি তালিকাটি বাছাই করার বিষয়ে চিন্তা করেন না তবে আপনি নিম্নলিখিতটির মতো কিছু চেষ্টা করতে পারেন:

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

Comments

অ্যারেলিস্টের পরিবর্তে আপনার তালিকা ব্যবহার করা উচিত।

— ডগ এস

Answer 6

- এটি প্রতিবার জিজ্ঞাসা করা সাক্ষাত্কারের প্রশ্ন । এখন আমি এর কোডিং করেছি।

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

Comments

এই প্রশ্নের জন্য আপনার কোনও ও (এন * 2) সময় জটিলতা করা উচিত নয়।

— ডান 1

আপনার মার্জ বাছাই করা উচিত

— নিক গ্যালিমোর

Answer 7

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

এটি ও (এন ^ 2) , যা কম্বোতে ভরাট হতে চলেছে এমন একটি সংক্ষিপ্ত তালিকার পক্ষে গুরুত্বপূর্ণ নয়, তবে এটি একটি বড় সংগ্রহের ক্ষেত্রে দ্রুত সমস্যা হতে পারে।

Answer 8

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

Answer 9

এখানে একটি ও (এন * এন) পদ্ধতি যা ও (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 ।

Comments

আপনি যখন পুরো তালিকাটি সঞ্চয় করতে চান তখন এটি কীভাবে ও (1) স্পেস ব্যবহার করতে পারে? ইনপ্লেস সাজানোর মাধ্যমে শুরু করে আপনি অনেক কম কোড সহ ও (এনলগন) সময় এবং ও (এন) মেমরি করতে পারেন।

— টমাস আহলে

আপনি কী ভাবেন যে এটি পুরো তালিকাটি সংরক্ষণ করছে? এটি প্রকৃতপক্ষে জায়গায় করছে। যদিও প্রশ্নের শর্ত নয় তবে আমার কোডটি মূল স্ট্রিংয়ে অক্ষরের ক্রম বজায় রেখেছে। বাছাই করা এটি সরিয়ে ফেলবে।

— সেশ

অভ্যন্তরীণ লুপ ( strIn[j] == strIn[i]) যদি একটি স্টেপকে নিজের সাথে তুলনা করে তবে যদি কোনও if স্টেটমেন্টের সাথে হিসাব না করে।

— ব্যবহারকারী 3219

Answer 10

একটি অভিধানে সমস্ত স্ট্রিং যুক্ত করুন এবং এরপরে কীগুলির সম্পত্তি পান। এটি প্রতিটি অনন্য স্ট্রিং উত্পাদন করবে, তবে আপনার মূল ইনপুটটি একই ক্রমে প্রয়োজনীয় নয়।

আপনি যদি প্রতিটি ফলাফলের প্রথম উপস্থিতি বিবেচনা করেন তবে আপনার ফলাফলটি মূল ইনপুটের মতো একই ক্রমটির প্রয়োজন হয়, পরিবর্তে নিম্নলিখিত অ্যালগরিদম ব্যবহার করুন:

1. একটি তালিকা (চূড়ান্ত আউটপুট) এবং একটি অভিধান রয়েছে (সদৃশগুলি পরীক্ষা করার জন্য)
2. ইনপুটটিতে প্রতিটি স্ট্রিংয়ের জন্য, এটি অভিধানে ইতিমধ্যে বিদ্যমান কিনা তা পরীক্ষা করে দেখুন
3. যদি তা না হয় তবে এটি অভিধান এবং তালিকায় উভয় যুক্ত করুন

শেষে, তালিকায় প্রতিটি অনন্য স্ট্রিংয়ের প্রথম উপস্থিতি রয়েছে।

আপনি উচ্চারণযুক্ত অক্ষরগুলির সাথে সদৃশকে সঠিকভাবে পরিচালনা করেছেন কিনা তা নিশ্চিত করার জন্য আপনার অভিধানটি তৈরি করার সময় আপনি সংস্কৃতি এবং এই জাতীয় জিনিসগুলি বিবেচনা করছেন তা নিশ্চিত করুন।

Answer 11

নিম্নলিখিত কোডের টুকরোটি অ্যারেলিস্ট থেকে সদৃশগুলি সরিয়ে ফেলার চেষ্টা করে যদিও এটি কোনও অনুকূল সমাধান নয়। পুনরাবৃত্তির মাধ্যমে সদৃশগুলি সরাতে এবং দ্বিতীয় / অস্থায়ী অ্যারেলিস্ট ব্যবহার না করে আমাকে একটি সাক্ষাত্কারের সময় এই প্রশ্নটি জিজ্ঞাসা করা হয়েছিল:

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

Answer 12

সহজ সমাধান:

using System.Linq;
...

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

Answer 13

হতে পারে হ্যাশসেট যা সদৃশ উপাদান সংরক্ষণ করে না এবং নকল যুক্ত করার অনুরোধটি চুপচাপ উপেক্ষা করে।

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

    Console.WriteLine(textWithDuplicates.Count());  
    var letters = new HashSet<char>(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<int>(array);
    Console.WriteLine(distinctArray.Count());

    foreach (int i in distinctArray) Console.Write(i + ",");
}

Answer 14

দ্রষ্টব্য: পরীক্ষিত নয়!

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

আপনার যা প্রয়োজন তা করতে পারেন ...

সম্পাদনা আরগ !!! এক মিনিটের মধ্যে ডাকাতি দিয়ে মারধর!

Comments

রব তোমাকে কিছুতেই মারেনি। আপনি তালিকা ব্যবহার করার সময় তিনি অ্যারেলিস্ট ব্যবহার করছেন। আপনার সংস্করণটি আরও ভাল।

— ডগ এস

Answer 15

নীচে পরীক্ষা করা হয়েছে এবং এটি কাজ করে। খুব সুন্দর এটি একটি সংস্কৃতি সংবেদনশীল অনুসন্ধানও করে

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

Answer 16

এই কোডটি 100% একটি অ্যারের থেকে সদৃশ মানগুলি সরান [যেমন আমি একটি [i]] ব্যবহার করেছি আপনি যে কোনও ওও ভাষায় রূপান্তর করতে পারেন ..... :)

for(int i=0;i<size;i++)
{
    for(int j=i+1;j<size;j++)
    {
        if(a[i] == a[j])
        {
            for(int k=j;k<size;k++)
            {
                 a[k]=a[k+1];
            }
            j--;
            size--;
        }
    }

}

Answer 17

জেনেরিক এক্সটেনশন পদ্ধতি:

public static IEnumerable<TSource> Distinct<TSource>(this IEnumerable<TSource> source, IEqualityComparer<TSource> comparer)
{
    if (source == null)
        throw new ArgumentNullException(nameof(source));

    HashSet<TSource> set = new HashSet<TSource>(comparer);
    foreach (TSource item in source)
    {
        if (set.Add(item))
        {
            yield return item;
        }
    }
}

Answer 18

অ্যারেলিস্টের সাথে কাজ করার সময় আপনি এই কোডটি ব্যবহার করতে পারেন

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

Answer 19

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

Answer 20

নীচে জাভাতে আপনি একটি সহজ যুক্তি দিয়েছিলেন যে আপনি অ্যারের উপাদানগুলিকে দুবার অতিক্রম করেন এবং যদি আপনি কোনও উপাদান দেখতে পান তবে আপনি শূন্যকে নির্ধারণ করেন এবং আপনি যে উপাদানটির সাথে তুলনা করছেন তার সূচকটি স্পর্শ করবেন না।

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

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

    for(int b=0;b<y.length;b++){
        int temp = y[b];
        for(int v=0;v<y.length;v++){
            if( b!=v && temp==y[v]){
                y[v]=0;
            }
        }
    }
}

Answer 21

  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<string>(ref outputArray, outputArray.Length + 1);
                            outputArray[outputArray.Length-1] = inputArray[i];
                        }
            }
            return outputArray;
        }

Comments

আপনার উত্তরটি ব্যাখ্যা করুন, দয়া করে।

— বদিপারমাগী

Answer 22

using System;
using System.Collections.Generic;
using System.Linq;


namespace Rextester
{
    public class Program
    {
        public static void Main(string[] args)
        {
             List<int> listofint1 = new List<int> { 4, 8, 4, 1, 1, 4, 8 };
           List<int> updatedlist= removeduplicate(listofint1);
            foreach(int num in updatedlist)
               Console.WriteLine(num);
        }


        public static List<int> removeduplicate(List<int> listofint)
         {
             List<int> listofintwithoutduplicate= new List<int>();


              foreach(var num in listofint)
                 {
                  if(!listofintwithoutduplicate.Any(p=>p==num))
                        {
                          listofintwithoutduplicate.Add(num);
                        }
                  }
             return listofintwithoutduplicate;
         }
    }



}

Comments

এটি এটি করার একটি খুব অকার্যকর উপায়। তারা কী করে তা দেখতে অন্যান্য উত্তরগুলি দেখুন।

— ওয়াই হা লি

Answer 23

strINvalues = "1,1,2,2,3,3,4,4";
strINvalues = string.Join(",", strINvalues .Split(',').Distinct().ToArray());
Debug.Writeline(strINvalues);

Kkk নিশ্চিত নয় যে এটি জাদুবিদ্যা বা কেবল সুন্দর কোড

1 টি পদক্ষেপ .স্প্লিট (',')। পৃথক ()। টু অ্যারে ()

2 স্ট্রিং.জয়াইন (",", XXX);

1 অ্যারিকে বিভক্ত করা এবং সদৃশ [লিনকিউ] ব্যবহার করে সদৃশগুলি সরাতে 2 ডুপ্লিকেট ছাড়াই এটিতে আবার যোগদান করুন।

দুঃখিত, আমি স্ট্যাকওভারফ্লোতে কেবল কোডটি কখনও পড়ি না। এটি পাঠ্যের চেয়ে আরও বেশি অর্থবোধ করে;)

Comments

কোড-কেবলমাত্র উত্তরগুলি নিম্ন-মানের উত্তর answers এটি কেন কাজ করে তার জন্য কিছু ব্যাখ্যা যুক্ত করুন।

— তাসলিম ওসেনি

Answer 24

int size = a.Length;
        for (int i = 0; i < size; i++)
        {
            for (int j = i + 1; j < size; j++)
            {
                if (a[i] == a[j])
                {
                    for (int k = j; k < size; k++)
                    {
                        if (k != size - 1)
                        {
                            int temp = a[k];
                            a[k] = a[k + 1];
                            a[k + 1] = temp;

                        }
                    }
                    j--;
                    size--;
                }
            }
        }

Comments

এসও আপনাকে স্বাগতম। যদিও এই কোড স্নিপেট একটি সমাধান সহ সমাধান হতে পারে, সত্যিই আপনার পোস্টের গুণমান উন্নত করতে সহায়তা করে। মনে রাখবেন যে আপনি ভবিষ্যতে পাঠকদের জন্য প্রশ্নের উত্তর দিচ্ছেন, এবং সেই লোকেরা আপনার কোড পরামর্শের কারণগুলি জানেন না।

— অ্যালান.লকিন

আফসোসভাবে এই কোডটি কোনও কিছুই সরিয়ে দেয় না, সুতরাং এটি সদৃশগুলি সরায় না।

— পিএপি

Answer 25

সর্বোত্তম পন্থা? বলা মুশকিল, হ্যাশসেট পদ্ধতিটি দেখতে দ্রুত দেখায়, তবে (তথ্যের উপর নির্ভর করে) বাছাই করা অ্যালগরিদম (কাউন্টসোর্ট?) ব্যবহার করা আরও দ্রুত হতে পারে।

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        Random r = new Random(0); int[] a, b = new int[1000000];
        for (int i = b.Length - 1; i >= 0; i--) b[i] = r.Next(b.Length);
        a = new int[b.Length]; Array.Copy(b, a, b.Length);
        a = dedup0(a); Console.WriteLine(a.Length);
        a = new int[b.Length]; Array.Copy(b, a, b.Length);
        var w = System.Diagnostics.Stopwatch.StartNew();
        a = dedup0(a); Console.WriteLine(w.Elapsed); Console.Read();
    }

    static int[] dedup0(int[] a)  // 48 ms  
    {
        return new HashSet<int>(a).ToArray();
    }

    static int[] dedup1(int[] a)  // 68 ms
    {
        Array.Sort(a); int i = 0, j = 1, k = a.Length; if (k < 2) return a;
        while (j < k) if (a[i] == a[j]) j++; else a[++i] = a[j++];
        Array.Resize(ref a, i + 1); return a;
    }

    static int[] dedup2(int[] a)  //  8 ms
    {
        var b = new byte[a.Length]; int c = 0;
        for (int i = 0; i < a.Length; i++) 
            if (b[a[i]] == 0) { b[a[i]] = 1; c++; }
        a = new int[c];
        for (int j = 0, i = 0; i < b.Length; i++) if (b[i] > 0) a[j++] = i;
        return a;
    }
}

প্রায় শাখা মুক্ত। কিভাবে? ডিবাগ মোড, একটি ছোট অ্যারে সহ পদক্ষেপ (F11): {1,3,1,1,0}

    static int[] dedupf(int[] a)  //  4 ms
    {
        if (a.Length < 2) return a;
        var b = new byte[a.Length]; int c = 0, bi, ai, i, j;
        for (i = 0; i < a.Length; i++)
        { ai = a[i]; bi = 1 ^ b[ai]; b[ai] |= (byte)bi; c += bi; }
        a = new int[c]; i = 0; while (b[i] == 0) i++; a[0] = i++;
        for (j = 0; i < b.Length; i++) a[j += bi = b[i]] += bi * i; return a;
    }

দুটি নেস্টেড লুপ সহ একটি সমাধান হতে কিছু সময় লাগতে পারে, বিশেষত বৃহত্তর অ্যারেগুলির জন্য।

    static int[] dedup(int[] a)
    {
        int i, j, k = a.Length - 1;
        for (i = 0; i < k; i++)
            for (j = i + 1; j <= k; j++) if (a[i] == a[j]) a[j--] = a[k--];
        Array.Resize(ref a, k + 1); return a;
    }