Question

我试图找到字符串中单词的最高位置。

e.g。

Hello World This is a great world, This World is simply great

从上面的字符串我试图计算结果如下：

world，3
很好，2
你好，1
this，2

但忽略长度小于3个字符的任何字词，例如is发生了两次。

我试图调查Dictionary<key, value>对，我试图查看linq的GroupBy扩展名。我知道解决方案介于两者之间，但我无法理解算法以及如何完成这项工作。

Answer 1

使用LINQ和Regex

Regex.Split("Hello World This is a great world, This World is simply great".ToLower(), @"\W+")
    .Where(s => s.Length > 3)
    .GroupBy(s => s)
    .OrderByDescending(g => g.Count())

Answer 2

所以我会避免使用LINQ和Regex之类的东西，因为它听起来像是在试图找到一个算法，并且理解这不会使用某些函数为你做这个。

并非那些不是有效的解决方案。他们是。肯定。

尝试这样的事情

Dictionary<string, int> dictionary = new Dictionary<string, int>();

string sInput = "Hello World, This is a great World. I love this great World";
sInput = sInput.Replace(",", ""); //Just cleaning up a bit
sInput = sInput.Replace(".", ""); //Just cleaning up a bit
string[] arr = sInput.Split(' '); //Create an array of words

foreach (string word in arr) //let's loop over the words
{
    if (word.Length >= 3) //if it meets our criteria of at least 3 letters
    {
        if (dictionary.ContainsKey(word)) //if it's in the dictionary
            dictionary[word] = dictionary[word] + 1; //Increment the count
        else
            dictionary[word] = 1; //put it in the dictionary with a count 1
     }
}

foreach (KeyValuePair<string, int> pair in dictionary) //loop through the dictionary
    Response.Write(string.Format("Key: {0}, Pair: {1}<br />",pair.Key,pair.Value));

Answer 3

const string input = "Hello World This is a great world, This World is simply great";
var words = input
    .Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)
    .Where(w => w.Length >= 3)
    .GroupBy(w => w)
    .OrderByDescending(g => g.Count());

foreach (var word in words)
    Console.WriteLine("{0}x {1}", g.Count(), word.Key);

// 2x World
// 2x This
// 2x great
// 1x Hello
// 1x world,
// 1x simply

不完美，因为它不会修剪逗号，但它会告诉你至少如何进行分组和过滤。

Answer 4

我写了一个字符串处理器类。你可以使用它。

示例：

metaKeywords = bodyText.Process(blackListWords: prepositions).OrderByDescending().TakeTop().GetWords().AsString();

类别：

 public static class StringProcessor
{
    private static List<String> PrepositionList;

    public static string ToNormalString(this string strText)
    {
        if (String.IsNullOrEmpty(strText)) return String.Empty;
        char chNormalKaf = (char)1603;
        char chNormalYah = (char)1610;
        char chNonNormalKaf = (char)1705;
        char chNonNormalYah = (char)1740;
        string result = strText.Replace(chNonNormalKaf, chNormalKaf);
        result = result.Replace(chNonNormalYah, chNormalYah);
        return result;
    }

    public static List<KeyValuePair<String, Int32>> Process(this String bodyText,
        List<String> blackListWords = null,
        int minimumWordLength = 3,
        char splitor = ' ',
        bool perWordIsLowerCase = true)
    {
        string[] btArray = bodyText.ToNormalString().Split(splitor);
        long numberOfWords = btArray.LongLength;
        Dictionary<String, Int32> wordsDic = new Dictionary<String, Int32>(1);
        foreach (string word in btArray)
        {
            if (word != null)
            {
                string lowerWord = word;
                if (perWordIsLowerCase)
                    lowerWord = word.ToLower();
                var normalWord = lowerWord.Replace(".", "").Replace("(", "").Replace(")", "")
                    .Replace("?", "").Replace("!", "").Replace(",", "")
                    .Replace("<br>", "").Replace(":", "").Replace(";", "")
                    .Replace("،", "").Replace("-", "").Replace("\n", "").Trim();
                if ((normalWord.Length > minimumWordLength && !normalWord.IsMemberOfBlackListWords(blackListWords)))
                {
                    if (wordsDic.ContainsKey(normalWord))
                    {
                        var cnt = wordsDic[normalWord];
                        wordsDic[normalWord] = ++cnt;
                    }
                    else
                    {
                        wordsDic.Add(normalWord, 1);
                    }
                }
            }
        }
        List<KeyValuePair<String, Int32>> keywords = wordsDic.ToList();
        return keywords;
    }

    public static List<KeyValuePair<String, Int32>> OrderByDescending(this List<KeyValuePair<String, Int32>> list, bool isBasedOnFrequency = true)
    {
        List<KeyValuePair<String, Int32>> result = null;
        if (isBasedOnFrequency)
            result = list.OrderByDescending(q => q.Value).ToList();
        else
            result = list.OrderByDescending(q => q.Key).ToList();
        return result;
    }

    public static List<KeyValuePair<String, Int32>> TakeTop(this List<KeyValuePair<String, Int32>> list, Int32 n = 10)
    {
        List<KeyValuePair<String, Int32>> result = list.Take(n).ToList();
        return result;
    }

    public static List<String> GetWords(this List<KeyValuePair<String, Int32>> list)
    {
        List<String> result = new List<String>();
        foreach (var item in list)
        {
            result.Add(item.Key);
        }
        return result;
    }

    public static List<Int32> GetFrequency(this List<KeyValuePair<String, Int32>> list)
    {
        List<Int32> result = new List<Int32>();
        foreach (var item in list)
        {
            result.Add(item.Value);
        }
        return result;
    }

    public static String AsString<T>(this List<T> list, string seprator = ", ")
    {
        String result = string.Empty;
        foreach (var item in list)
        {
            result += string.Format("{0}{1}", item, seprator);
        }
        return result;
    }

    private static bool IsMemberOfBlackListWords(this String word, List<String> blackListWords)
    {
        bool result = false;
        if (blackListWords == null) return false;
        foreach (var w in blackListWords)
        {
            if (w.ToNormalString().Equals(word))
            {
                result = true;
                break;
            }
        }
        return result;
    }
}

Answer 5

string words = "Hello World This is a great world, This World is simply great".ToLower();

var results = words.Split(' ').Where(x => x.Length > 3)
                              .GroupBy(x => x)
                              .Select(x => new { Count = x.Count(), Word = x.Key })
                              .OrderByDescending(x => x.Count);

foreach (var item in results)
    Console.WriteLine(String.Format("{0} occured {1} times", item.Word, item.Count));

Console.ReadLine();

获得最多出现的单词：

results.First().Word;

Answer 6

你应该可以使用 Linq 来做到这一点

 string[] splitString = actualString.Split(' ');
            var arrayCount = splitString.GroupBy(a => a);
            foreach (var r in arrayCount)
            {
                Console.WriteLine("This " + r.Key + " appeared " + r.Count() + "  times in a string.");
            }

这可以通过许多不同的方式解决。 Link 供参考。

查找字符串中出现最高的单词C＃

6 个答案: