Question

我正在寻找一种方法，该方法将采用两个字符串并返回两者共有的字符数。例如：

“G010”＆amp; “G1820A”应返回3，因为两者都存在G，0和1字符。

如果两个字符都存在两次，则应按如下方式单独计算：

“G12AA”＆amp; “GAA2”应返回4，因为两者中都存在G，A，A和2字符。

对此有何帮助？到目前为止，谷歌搜索并没有太大帮助。

Answer 1

好吧，这个怎么样，它具有最大化延迟评估和最小化字符串操作的优势。

public int CommonChars(string left, string right)
{
    return left.GroupBy(c => c)
        .Join(
            right.GroupBy(c => c),
            g => g.Key,
            g => g.Key,
            (lg, rg) => lg.Zip(rg, (l, r) => l).Count())
        .Sum(); 
}

essentialy，它用char对每一方进行分组，然后找到两边都有一个组的字符。匹配的组被串联计数，直到任何一个用完。将这些计数相加以产生结果。

对于任何两个序列，通常执行此操作将是微不足道的。见下文，

public static int CommomCount<T>(
        this IEnumerable<T> source,
        IEnumerable<T> sequence,
        IEqualityComparer<T> comparer = null)
{
    if (sequence == null)
    {
        return 0;
    }

    if (comparer == null)
    {
        comparer = EqualityComparer<T>.Default;
    }

    return source.GroupBy(t => t, comparer)
        .Join(
            sequence.GroupBy(t => t, comparer),
            g => g.Key,
            g => g.Key,
            (lg, rg) => lg.Zip(rg, (l, r) => l).Count(),
            comparer)
        .Sum();
}

你可以这样使用。

"G12AA".CommonCount("GAA2")

如果您需要不区分大小写或其他特殊处理，可选的comparer参数可能会很有用。

为了恢复原状，我很想删除Sum()并返回IEnumerable<T>，然后在调用中添加总和，就像这样，

public static IEnumerable<T> Commom<T>(
        this IEnumerable<T> source,
        IEnumerable<T> sequence,
        IEqualityComparer<T> comparer = null)
{
    if (sequence == null)
    {
        return Enumerable.Empty<T>();
    }

    if (comparer == null)
    {
        comparer = EqualityComparer<T>.Default;
    }

    return source.GroupBy(t => t, comparer)
        .Join(
            sequence.GroupBy(t => t, comparer),
            g => g.Key,
            g => g.Key,
            (lg, rg) => lg.Zip(rg, (l, r) => l),
            comparer)
        .SelectMany(g => g);
}

所以你可以轻松做到

Console.WriteLine(new string("G12AA".Common("GAA2").ToArray()));

或只是orgininal

"G12AA".Common("GAA2").Count();

Answer 2

试试这个

    public int CommonCharacters(string s1, string s2)
    {
        bool[] matchedFlag = new bool[s2.Length];

        for (int i1 = 0; i1 < s1.Length; i1++)
        {
            for (int i2 = 0; i2 < s2.Length; i2++)
            {
                if (!matchedFlag[i2] && s1.ToCharArray()[i1] == s2.ToCharArray()[i2])
                {
                    matchedFlag[i2] = true;
                    break;
                }
            }
        }

        return matchedFlag.Count(u => u);
    }

Answer 3

你可以使用Linq来解决这个问题：

static void Main(string[] args)
{
    IEnumerable<char> a = "G010".ToCharArray();
    IEnumerable<char> b = "G1820A".ToCharArray();

    int commonChars = FindCommonElements(a, b).Count();
    Console.WriteLine(commonChars);

    Console.ReadLine();
}

private static T[] FindCommonElements<T>(IEnumerable<T> source, IEnumerable<T> target)
{
    ILookup<T, T> lookup2 = target.ToLookup(i => i);

    return (
      from group1 in source.GroupBy(i => i)
      let group2 = lookup2[group1.Key]
      from i in (group1.Count() < group2.Count() ? group1 : group2)
      select i
    ).ToArray();
}

commonChars的值为3. FindCommonElements方法的灵感来自于这个问题：How do I do an integer list intersection while keeping duplicates?

Answer 4

        string s1 = "G12A";
        string s2 = "GAA2";
        List<char> lst1 = s1.ToList();
        List<char> lst2 = s2.ToList();
        int count = 0;
        foreach (char c in lst2)
        {
            if (lst1.Contains(c))
            {
                lst1.Remove(c);
                count++;
            }
        }
        Console.WriteLine(count);

Answer 5

使用Linq：

    int MyCount(string s1, string s2)
    {
        return s1.Count(c =>
                            {
                                var i = s2.IndexOf(c);
                                if (i >= 0)
                                {
                                    s2 = s2.Remove(i, 1);
                                    return true;
                                }
                                return false;
                            });
    }

Answer 6

这个更大的输入可以更快地运行，因为它不进行嵌套循环，而是依赖于使用Dictionary进行散列搜索。另一方面，它使用更多的内存。

 public int CommonCharacterCount(string s1, string s2)
            { 
                var r=0;
                Dictionary<char,int> s2Dict = new Dictionary<char,int>();
                foreach (var ch in s2)
                {
                    if (s2Dict.ContainsKey(ch))
                        s2Dict[ch] = s2Dict[ch]+1;
                    else s2Dict.Add(ch,1);
                }

                foreach (var c in s1)
                {
                    if (s2Dict.ContainsKey(c) && s2Dict[c]>0)
                    {
                        r++;
                        s2Dict[c] = s2Dict[c] - 1;
                    }
                }
                return r;
            }

Answer 7

string myname = "1234";
        string yourname = "12";
        char[] sam = new char[] { };
        sam = myname.ToCharArray();
        char[] sam1 = new char[] { };
        sam1 = yourname.ToCharArray();
        int id = 0;
        int id1 = 0;
        List<string> found = new List<string>();
        List<string> found1 = new List<string>();
        foreach (char item in sam)
        {
            if (found.Contains(item.ToString()))
            {
                found.Add(item.ToString() + id);
                id++;
            }
            else
                found.Add(item.ToString());
        }
        foreach (var item in sam1)
        {
            if (found1.Contains(item.ToString()))
            {
                found1.Add(item.ToString() + id);
                id1++;
            }
            else
                found1.Add(item.ToString());
        }
        var final = found.Except(found1);
        var final2 = found1.Except(found);
        var checkingCount = final.Count() + final2.Count();
        Console.Write(checkingCount);
        Console.ReadLine();

检查出来，顺便说一句，效率不高。但是做对了。

Answer 8

请检查以下代码 - ＆gt; src是第一个字符串，而chk是第二个字符串

var count = 0; var i = 0;   src.ToList（）。ForEach（（x）=＆gt; {
          while（chk.Substring（i）.IndexOf（x）＆gt; = 0）           {
              计数++;               我++;               if（i> chk.Length）休息;           }
  }）;

在C＃中查找两个字符串之间的字符数

8 个答案: