Как удалить повторяющиеся символы в строке?

Мне нужно реализовать функцию, которая принимает строку в качестве входных данных и находит неповторимый символ из этой строки.

Например, если я передаю строку str = "DHCD", она вернет "DHC" или str2 = "KLKLHHMO", она вернет "KLHMO"

Ответов (21)

Решение

Подход Linq:

public static string RemoveDuplicates(string input)
{
    return new string(input.ToCharArray().Distinct().ToArray());
}
String str="AABBCANCDE";  
String newStr=""; 
for( int i=0; i<str.length(); i++)
{
 if(!newStr.contains(str.charAt(i)+""))
 newStr= newStr+str.charAt(i);
 }
 System.out.println(newStr);

вы можете использовать HashSet:

 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);   
    }
    void removeDuplicate()
    {
      string value1 = RemoveDuplicateChars("Devarajan");
    }

     static string RemoveDuplicateChars(string key)
    {
        string result = "";          
        foreach (char value in key)
            if (result.IndexOf(value) == -1)                   
                result += value;
        return result;
    }
Console.WriteLine("Enter String");

string str = Console.ReadLine();

string result = "";
result += str[0]; // first character of string

for (int i = 1; i < str.Length; i++)
{
    if (str[i - 1] != str[i])
        result += str[i];
}

Console.WriteLine(result);

// Удаляем оба верхних и нижних дубликата

public static string RemoveDuplicates(string key)
    {
        string Result = string.Empty;
        foreach (char a in key)
        {
            if (Result.Contains(a.ToString().ToUpper()) || Result.Contains(a.ToString().ToLower()))
                continue;
            Result += a.ToString();
        }
        return Result;
    }
var input1 = Console.ReadLine().ToLower().ToCharArray();
var input2 = input1;
var WithoutDuplicate = input1.Union(input2);
 class Program
    {
        static void Main(string[] args)
        {
            bool[] doesExists = new bool[256];
            String st = Console.ReadLine();
            StringBuilder sb = new StringBuilder();
            foreach (char ch in st)
            {
                if (!doesExists[ch])
                {
                    sb.Append(ch);
                    doesExists[ch] = true;
                }
            }
            Console.WriteLine(sb.ToString());
        }
    }

демонстрация пространства имен {class Program {

  static void Main(string[] args) {
     string myStr = "kkllmmnnouo";
     Console.WriteLine("Initial String: "+myStr);
    // var unique = new HashSet<char>(myStr);
     HashSet<char> unique = new HashSet<char>(myStr);
     Console.Write("New String after removing duplicates: ");

     foreach (char c in unique) 
        Console.Write(c);   
  }    } }

это работает для меня

private string removeDuplicateChars(String value)
{
    return new string(value.Distinct().ToArray());
}

Не уверен, насколько это оптимально:

public static string RemoveDuplicates(string input)
{
    var output = string.Join("", input.ToHashSet());
    return output;
}

Он сделает свою работу

string removedupes(string s)
{
    string newString = string.Empty;
    List<char> found = new List<char>();
    foreach(char c in s)
    {
       if(found.Contains(c))
          continue;

       newString+=c.ToString();
       found.Add(c);
    }
    return newString;
}

Отмечу, что это преступно неэффективно.

Я думаю, что на первой ревизии я был в бреду.

Для меня это звучит как домашнее задание, поэтому я просто собираюсь описать его на высоком уровне.

  • Прокрутите строку, исследуя каждый символ
  • Проверьте, видели ли вы персонажа раньше
    • если есть, удалите его из строки
    • если нет, обратите внимание, что теперь вы видели этого персонажа

Для строк произвольной длины из байтовых символов (не для широких символов или других кодировок) я бы использовал таблицу поиска, по одному биту на символ (32 байта для 256-битной таблицы). Прокрутите вашу строку, выводите только символы, биты которых не включены, затем включите бит для этого символа.

string removedupes(string s)
{
    string t;
    byte[] found = new byte[256];
    foreach(char c in s)
    {
        if(!found[c]) {
            t.Append(c);
            found[c]=1;
        }
    }
    return t;
}

Я плохо разбираюсь в C#, поэтому не знаю, как правильно использовать битовое поле вместо массива байтов.

Если вы знаете, что ваши строки будут очень короткими, тогда другие подходы могут предложить лучшее использование памяти и / или скорость.

символ * remove_duplicates (char * str) {char * str1, * str2;

if(!str)
    return str;

str1 = str2 = str;

while(*str2)            
{   
    if(strchr(str, *str2)<str2)
    {
        str2++;
        continue;
    }

    *str1++ = *str2++;      
}
*str1 = '\0';

return  str;

}

char* removeDups(const char* str)
{
 char* new_str = (char*)malloc(256*sizeof(char));
 int i,j,current_pos = 0,len_of_new_str;
 new_str[0]='\0';

 for(i=0;i<strlen(str);i++)
{
 len_of_new_str = strlen(new_str);
for(j=0;j<len_of_new_str && new_str[j]!=str[i];j++)
   ;
  if(j==len_of_new_str)
   {
     new_str[len_of_new_str] = str[i];
     new_str[len_of_new_str+1] = '\0';
   }
}
  return new_str;
}

Надеюсь это поможет

Мой ответ на языке Java.
Разместите здесь, чтобы вы могли понять, даже если это на языке Java. Алгоритм останется прежним.

public String removeDup(String s)
  {
    if(s==null) return null;
    int l = s.length();
    //if length is less than 2 return string
    if(l<2)return s;
    char arr[] = s.toCharArray();

    for(int i=0;i<l;i++)
    {
      int j =i+1; //index to check with ith index
      int t = i+1; //index of first repetative char.

      while(j<l)
      {
        if(arr[j]==arr[i])
        {
          j++;

        }
        else
        {
          arr[t]=arr[j];
          t++;
          j++;
        }

      }
      l=t;
    }

    return new String(arr,0,l);
  }

Пересмотренная версия первого ответа, то есть: вам не нужна функция ToCharArray (), чтобы это работало.

public static string RemoveDuplicates(string input)
{
    return new string(input.Distinct().ToArray());
}

// это в C#, проверка не включена для краткости // примитивное решение для удаления повторяющихся символов из заданной строки

    public static char[] RemoveDup(string s)
    {
        char[] c = new char[s.Length];
        int unique = 0;
        c[unique] = s[0];  // Assume: First char is trivial
        for (int i = 1; i < s.Length; i++)
        {
            if (s[i-1] != s[i]
        c[++unique] = s[i];
        }
        return c;
    }

Мне нравится ответ Квинтина Робинсона, только должны быть некоторые улучшения, такие как удаление списка, потому что в этом случае это не обязательно. Кроме того, на мой взгляд, символы в верхнем регистре («K») и символы в нижнем регистре («k») - это одно и то же, поэтому их следует считать как одно целое.

Вот как бы я это сделал:

private static string RemoveDuplicates(string textEntered)
    {

        string newString = string.Empty;

        foreach (var c in textEntered)
        {
            if (newString.Contains(char.ToLower(c)) || newString.Contains(char.ToUpper(c)))
            {
                continue;
            }
            newString += c.ToString();
        }
        return newString;
    }

Ниже приведен код для удаления повторяющихся символов из строки.

        var input = "SaaSingeshe";
        var filteredString = new StringBuilder();
        foreach(char c in input)
        {
            if(filteredString.ToString().IndexOf(c)==-1)
            {
                filteredString.Append(c);
            }
        }
        Console.WriteLine(filteredString);
        Console.ReadKey();