如何在C#.Net中查找字符串中甚至重复的字符

我有一个问题，就是如何在C#中删除字符串中的重复项

示例-输入字符串：

acdhqodcqasaf

输出：

acdhqosaf

---

我真正的意思是删除偶数出现的字符。我已经编写了逻辑，但是我使用了嵌套for循环，它的效率是O（n^2）这不是很好的效率。所以我被要求以不同的方式进行在线搜索，但仍然没有得到答案。

我会使用哈希集来跟踪哪些字符你见过奇数次

string input = "acdhqodcqasaf";
var oddOccurrences = new HashSet<char>();
var output = new StringBuilder();
foreach (var c in input)
{
    if (!oddOccurrences.Contains(c))
    {
        output.Append(c);
        oddOccurrences.Add(c);
    }
    else
    {
        oddOccurrences.Remove(c);
    }
}
Console.WriteLine(output.ToString());

string input=“acdhqodcqasaf”；
var odddoccurrencess=newhashset（）；
var输出=新的StringBuilder（）；
foreach（输入中的var c）
{
如果（！odd.Contains（c））
{
输出。追加（c）；
增加（c）；
}
其他的
{
删除（c）；
}
}
Console.WriteLine（output.ToString（））；

创建一个bool[]，为您记录奇数和偶数：

bool[] even = new bool[256];
string input = "acdhqodcqasaf";
string output = "";
for(int i=0;i<input.Length;i++)
{
    int x = (int)input[i];
    if(!even[x])output += input[i];
    even[x] = !even[x];
}

bool[]偶数=新bool[256]；
字符串输入=“acdhqodcqasaf”；
字符串输出=”；
对于（int i=0；i您可以遍历数组，保留一个
字典以保留每个字符的计数。检查计数以确定是否应删除字符或不将其添加到结果字符串中。
您可以使用字典跟踪出现的次数，并使用
%
运算符：

string input = "acdhqodcqasaf";
var charOccurences = new Dictionary<char, int>();
int removeEvery = 2;
var outputBuilder = new StringBuilder();

foreach (char c in input)
{
    charOccurences.TryGetValue(c, out int charOccurence);
    charOccurence++;
    charOccurences[c] = charOccurence;
    if (charOccurence % removeEvery != 0)
        outputBuilder.Append(c);
}

string output = outputBuilder.ToString();

string input=“acdhqodcqasaf”；
var charoccurrences=新字典（）；
int-removeEvery=2；
var outputBuilder=新的StringBuilder（）；
foreach（输入中的字符c）
{
TryGetValue（c，out int charoccurrence）；
charoccurrence++；
CharOccurrence[c]=CharOccurrence；
如果（字符发生率%removeEvery！=0）
outputBuilder.Append（c）；
}
字符串输出=outputBuilder.ToString（）；
为了好玩和咯咯笑，我停下来观看了这个问题的主要答案，并添加了一个独特的方法：

return new string(input.Distinct().ToArray());

输出很有趣（10k运行）：

当跑10公里时，distinct似乎会赢（速度上），但当跑100次时，结果却大不相同：

ASDHFAJSHKDFASJDFHJgasdfkjhasdjhfashdfkjasdjkfajkhewkjrhwakhfuiwhfsdnfvjndfsjkgnk
Distinct 9
RunForEach1 7
RunForEach2 1
RunFor 1

代码：

使用系统；
使用System.Collections.Generic；
使用System.Linq；
使用系统文本；
名称空间控制台EAPP1
{
班级计划
{
静态void Main（字符串[]参数）
{
var input=Console.ReadLine（）；
var sw=新系统.Diagnostics.Stopwatch（）；
sw.Start（）；
对于（int i=0；i<100000；i++）
{
RunDistinct（输入）；
}
sw.Stop（）；
Console.WriteLine（$“Distinct{sw.elapsedmillesons}”）；
sw.Reset（）；
sw.Start（）；
对于（int i=0；i<100000；i++）
{
RunForEach1（输入）；
}
sw.Stop（）；
WriteLine（$“RunForEach1{sw.elapsedmillisons}”）；
sw.Reset（）；
sw.Start（）；
对于（int i=0；i<100000；i++）
{
RunForEach2（输入）；
}
sw.Stop（）；
WriteLine（$“RunForEach2{sw.elapsedmillisons}”）；
sw.Reset（）；
sw.Start（）；
对于（int i=0；i<100000；i++）
{
RunFor（输入）；
}
sw.Stop（）；
WriteLine（$“RunFor{sw.elapsedmillesons}”）；
Console.ReadKey（）；
}
私有静态字符串RunDistinct（字符串输入）{
返回新字符串（input.Distinct（）.ToArray（））；
}
私有静态字符串RunForEach1（字符串输入）{
var charoccurrences=新字典（）；
int-removeEvery=2；
var outputBuilder=新的StringBuilder（）；
foreach（输入中的字符c）
{
TryGetValue（c，out int charoccurrence）；
charoccurrence++；
CharOccurrence[c]=CharOccurrence；
如果（字符发生率%removeEvery！=0）
outputBuilder.Append（c）；
}
返回outputBuilder.ToString（）；
}
私有静态字符串RunForEach2（字符串输入）
{
var odddoccurrencess=newhashset（）；
var输出=新的StringBuilder（）；
foreach（输入中的var c）
{
如果（！odd.Contains（c））
{
输出。追加（c）；
增加（c）；
}
其他的
{
删除（c）；
}
}
返回output.ToString（）；
}
专用静态字符串RunFor（字符串输入）
{
bool[]偶数=新bool[256]；
字符串输出=”；
for（int i=0；i
您需要在紧密循环中执行此操作，还是需要非常大的字符串？因为如果不需要，我就不会太担心O（n^2）效率。哪怕是重复的呢？“我已经编写了逻辑”你介意和我们分享吗？当然，我会分享-@Heretic。@布莱恩，我认为这没有错。如果我理解正确，OP希望删除每秒钟出现的一个字符-因此，如果该字符在输入中出现三次（并且
a
出现），它应该在输出中出现两次。很好。现在每三次删除一次：）请注意，通过在添加或删除时使用bool返回来避免对Contains的调用，可以稍微提高性能，但我觉得这会降低方法的可读性。@TimSchmelter:哈哈，是的。您可以使用字典来跟踪出现的次数，并对计数使用任意条件来确定是否输出该值。是的，为了完整性，我提供的速度略快于哈希集a
ASDHFAJSHKDFASJDFHJgasdfkjhasdjhfashdfkjasdjkfajkhewkjrhwakhfuiwhfsdnfvjndfsjkgnk
Distinct 9
RunForEach1 7
RunForEach2 1
RunFor 1

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

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            var input = Console.ReadLine();
            var sw = new System.Diagnostics.Stopwatch();

            sw.Start();
            for (int i = 0; i < 100000; i++)
            {
                RunDistinct(input);
            }
            sw.Stop();
            Console.WriteLine($"Distinct {sw.ElapsedMilliseconds}");

            sw.Reset();
            sw.Start();
            for (int i = 0; i < 100000; i++)
            {
                RunForEach1(input);
            }
            sw.Stop();
            Console.WriteLine($"RunForEach1 {sw.ElapsedMilliseconds}");

            sw.Reset();
            sw.Start();
            for (int i = 0; i < 100000; i++)
            {
                RunForEach2(input);
            }
            sw.Stop();
            Console.WriteLine($"RunForEach2 {sw.ElapsedMilliseconds}");

            sw.Reset();
            sw.Start();
            for (int i = 0; i < 100000; i++)
            {
                RunFor(input);
            }
            sw.Stop();
            Console.WriteLine($"RunFor {sw.ElapsedMilliseconds}");

            Console.ReadKey();
        }


        private static string RunDistinct(string input) {
            return new string(input.Distinct().ToArray());
        }

        private static string RunForEach1(string input) {
            var charOccurences = new Dictionary<char, int>();
            int removeEvery = 2;
            var outputBuilder = new StringBuilder();

            foreach (char c in input)
            {
                charOccurences.TryGetValue(c, out int charOccurence);
                charOccurence++;
                charOccurences[c] = charOccurence;
                if (charOccurence % removeEvery != 0)
                    outputBuilder.Append(c);
            }

            return outputBuilder.ToString();
        }

        private static string RunForEach2(string input)
        {
            var oddOccurrences = new HashSet<char>();
            var output = new StringBuilder();
            foreach (var c in input)
            {
                if (!oddOccurrences.Contains(c))
                {
                    output.Append(c);
                    oddOccurrences.Add(c);
                }
                else
                {
                    oddOccurrences.Remove(c);
                }
            }
            return output.ToString();
        }

        private static string RunFor(string input)
        {
            bool[] even = new bool[256];
            string output = "";
            for (int i = 0; i < input.Length; i++)
            {
                int x = (int)input[i];
                if (!even[x]) output += input[i];
                even[x] = !even[x];
            }

            return output;
        }
    }
}