Question

我正在研究一个函数，它将评估一个字符串，并且只允许每个字符的x个实例。

例如，您可以拥有2个允许的字符

aaaabbbbbcddddd

将被评估为

aabbcdd

到目前为止，我已经写过：

public static string removeDuplicateCharacters(String text, int allowedDuplicates)
{
    string seen="";
    foreach (char c in text){

       if(!seen.Contains(c)){
           seen = seen + c;
       } else if(seen.Contains(c)){

             // while the sting contains < allowedDuplicates
            // add c
           }
       }
    return seen; 
 }

我目前无法弄清楚如何创建一个while条件，这个条件也将通过我看到的字符串计算当前正在评估的char的当前实例数。

Answer 1

使用Dictionary轻松解决字符数量问题：

public static string removeDuplicateCharacters(String text, int allowedDuplicates)
{
    string seen="";
    Dictionary<char, int> charCount = new   Dictionary<char, int>();
    foreach (char c in text)
    {
        if(!charCount.ContainsKey(c))
        {
            seen += c;
            charCount.Add(c, 1);
        }
        else if(charCount[c] < allowedDuplicates)
        {
            charCount[c] += 1;
            seen += c;
        }
        else
        {
            //Reached max, do nothing
        }
    }
    return seen; 
 }

这是你的基础，你可以从这里做到如此美好和喜欢。

例如：我建议StringBuilder如果字符串可以变长，因为它对内存的负担较少，因为在执行String时你不必永久地分配新的+=他们。

public static string removeDuplicateCharacters(String text, int allowedDuplicates)
{
    StringBuilder seen = new StringBuilder();

    Dictionary<char, int> charCount = new   Dictionary<char, int>();
    foreach (char c in text)
    {
        if(!charCount.ContainsKey(c))
        {
            seen.Append(c);
            charCount.Add(c, 1);
        }
        else if(charCount[c] < allowedDuplicates)
        {
            charCount[c] += 1;
            seen.Append(c);
        }
        else
        {
            //Reached max, do nothing
        }
    }
    return seen.ToString(); 
 }

如果你想要对大小写进行相同处理，那么另一件事就是如此。然后我会将测试更改为大写或小写，但如果你想在返回字符串中保留原始字符的大小写，你可以执行以下操作。

public static string removeDuplicateCharacters(String text, int allowedDuplicates)
{
    StringBuilder seen = new StringBuilder();

    Dictionary<char, int> charCount = new   Dictionary<char, int>();
    foreach (char c in text)
    {
        char upperCase = c.ToUpper();
        if(!charCount.ContainsKey(upperCase))
        {
            seen.Append(c);
            charCount.Add(upperCase , 1);
        }
        else if(charCount[upperCase] < allowedDuplicates)
        {
            charCount[upperCase ] += 1;
            seen.Append(c);
        }
        else
        {
            //Reached max, do nothing
        }
    }
    return seen.ToString(); 
 }

从这里开始定制。

Answer 2

使用字典跟踪字符数

    public static string removeDuplicateCharacters(string text, int allowedDuplicates)
    {
        var frequency = new Dictionary<char, int>();
        StringBuilder output = new StringBuilder();
        foreach (char c in text)
        {
            int count = 1;
            if (frequency.ContainsKey(c))
                count = ++frequency[c];
            else
                frequency.Add(c, count);

            if (count <= allowedDuplicates)
                output.Append(c);
        }
        return output.ToString();
    }

Answer 3

在这里，我们使用Dictionary跟踪所看到的字符以及我们看到它们的次数，并使用StringBuilder汇总输出字符串：

        public static string RemoveDuplicateCharacters(string text, int allowedDuplicates)
        {
            var seen = new Dictionary<char, int>();
            var sb = new StringBuilder();

            foreach (char c in text)
            {
                int count;
                if (seen.TryGetValue(c, out count))
                {
                    count++;
                } else
                {
                    count = 1;
                }

                seen[c] = count;

                if (count <= allowedDuplicates)
                    sb.Append(c);
            }

            return sb.ToString();
        }

测试：

Console.WriteLine(RemoveDuplicateCharacters("aaaabbbbbcddddda", 3));

输出：

aaabbbcddd

Answer 4

对于初学者来说，这可能是一种更合适的方法。它不需要使用数组或字典，并坚持使用简单的算法原语。（我并不反对他们的使用，我只是预感到这是一次学生练习，甚至可能是为了激励他们的介绍。）

public static string removeDuplicateCharacters(String text, int allowedDuplicates)
{
    string seen= "";
    int count = 0;
    foreach (char c in text) {
        count = 0;
        foreach (char c2 in seen) {
            if (c2 == c) count++;
        }
        if (count < allowedDuplicates) {
            seen = seen + c;
        }
    }
    return seen; 
}

仅允许字符串中的一定数量的字符

4 个答案: