查找字符串中發生的最高字數C＃

Question

我正在嘗試查找字符串中字的最高發生次數。

例如

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

從上面的字符串我試圖計算結果類似如下：

• 世界，3
• 很大，2
• 你好，1
• 此，2

但忽略長度小於3個字符的任何單詞例如發生了兩次的is。

我試圖看看Dictionary<key, value>對，我試圖看看linq的GroupBy擴展名。我知道解決方案存在於兩者之間，但我無法理解算法以及如何完成這一任務。

Answer 1

使用LINQ和正則表達式

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

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 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

所以我會避免LINQ和正則表達式之類的，因爲它聽起來像你試圖找到一個算法，並明白這不使用一些函數來爲你做。

不是說這些都不是有效的解決方案。他們是。當然。

嘗試這樣的事情

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 5

我寫一個字符串處理器class.You可以使用它。

實施例：

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; 
    } 
}