C＃使用字典

Question

I'm sorry in advance if it's bad to ask for this sort of help... but I don't know who else to ask.

I have an assignment to read two text files, and find the 10 longest words in the first file (and the amount of times they're repeated) which dont exist in the second file.

I currently read both of the files with File.ReadAllLines then split them into arrays, where every element is a single word (punctuation marks removed as well) and removed empty entries.

The idea I had to pick out the words fitting the requirements was: to make a dictionary containing a string Word and an int Count. Then make a loop repeating for the first file's length.... firstly comparing the element with the entire dictionary - if it finds a match, increase the Count by 1. Then if it doesn't match with any of the dictionary elements - compare the given element with every element in the 2nd file through another loop, if it finds a match - just go on to the next element of the first file, if it doesn't find any matches - add the word to the dictionary, and set Count to 1.

So my first question is: Is this actually the most efficient way to do this? (Don't forget I've only recently started studying c# and am not allowed to use linq)

Second question: How do I work with the dictionary, because most of the results I could find were very confusing, and we have not yet met them at university.

My code so far:

    // Reading and making all the words lowercase for comparisons
    string punctuation = " ,.?!;:\"\r\n";
    string Read1 = File.ReadAllText("@\\..\\Book1.txt");
    Read1 = Read1.ToLower();
    string Read2 = File.ReadAllText("@\\..\\Book2.txt");
    Read2 = Read2.ToLower();

    //Working with the 1st file
    string[] FirstFileWords = Read1.Split(punctuation.ToCharArray());

    var temp1 = new List<string>();
    foreach (var word in FirstFileWords)
    {
        if (!string.IsNullOrEmpty(word))
            temp1.Add(word);
    }
    FirstFileWords = temp1.ToArray();

    Array.Sort(FirstFileWords, (x, y) => y.Length.CompareTo(x.Length));

    //Working with the 2nd file
    string[] SecondFileWords = Read2.Split(punctuation.ToCharArray());

    var temp2 = new List<string>();
    foreach (var word in SecondFileWords)
    {
        if (!string.IsNullOrEmpty(word))
            temp2.Add(word);
    }
    SecondFileWords = temp2.ToArray();

Answer 1

Well I think you've done very well so far. Not being able to use Linq here is torture ;)

As for performance, you should consider making your SecondFileWords a HashSet<string> as this would increase lookup times if any word exists in the 2nd file tremendously without much effort. I wouldn't go much further in terms of performance optimization for an exercise like that if performance is not a key requirement.

Of course, you would have to check that you don't add duplicates to your 2nd list, so change your current implementation to something like:

HashSet<string> temp2 = new HashSet<string>();

foreach (var word in SecondFileWords)
{
    if (!string.IsNullOrEmpty(word) && !temp2.Contains(word))
    {
        temp2.Add(word);
    }
}

Don't convert this back to an Array again, this is not necessary.

This brings me back to your FirstFileWords which would contain duplicates too. This will cause issues later on when the top words might contain the same word multiple times. So let's get rid of them. Here it's more complicated as you need to retain the information how often a word appeared in your first list.

So let's bring a Dictionary<string, int> into play here now. A Dictionary stores a lookup key, as the HashSet, but in addition, also a value. We will use the key for the word, and the value for a number that contains the amount of how often the word appeared in the first list.

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

foreach (var word in FirstFileWords)
{
    if (string.IsNullOrEmpty(word))
    {
        continue;
    }

    if (temp1.ContainsKey(word))
    {
        temp1[word]++;
    }
    else
    {
        temp1.Add(word, 1);
    }
}

Now a dictionary cannot be sorted, which complicates things at this point as you still need to get your sorting by word length done. So let's get back to your Array.Sort method which I think is a good choice when you are not allowed to use Linq:

KeyValuePair<string, int>[] firstFileWordsWithCount = temp1.ToArray();
Array.Sort(firstFileWordsWithCount, (x, y) => y.Key.Length.CompareTo(x.Key.Length));

Note : You are using .ToArray() in your example, so I think it's OK to use it. But strictly speaking, this would also fall unter using Linq IMHO.

Now all that's left is working through your firstFileWordsWithCount array until you got 10 words that do not exist in the HashSet temp2 . Something like:

int foundWords = 0;

foreach(KeyValuePair<string, int> candidate in firstFileWordsWithCount)
{
    if (!temp2.Contains(candidate.Key))
    {
        Console.WriteLine($"{candidate.Key}: {candidate.Value}");
        foundWords++;
    }

    if (foundWords >= 10)
    {
        break;
    }
}

If anything is unclear, just ask.

Answer 2

This is what you'll get when using dictionaries:

string File1 = "AMD Intel Skylake Processors Graphics Cards Nvidia Architecture Microprocessor Skylake SandyBridge KabyLake";
string File2 = "Graphics Nvidia";
Dictionary<string, int> Dic = new Dictionary<string, int>();
string[] File1Array = File1.Split(" ".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
Array.Sort(File1Array, (s1, s2) => s2.Length.CompareTo(s1.Length));
foreach (string s in File1Array)
{
    if (Dic.ContainsKey(s))
    {
        Dic[s]++;
    }
    else
    {
        Dic.Add(s, 1);
    }
}

string[] File2Array = File2.Split(" ".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
foreach (string s in File2Array)
{
    if (Dic.ContainsKey(s))
    {
        Dic.Remove(s);
    }
}

int i = 0;
foreach (KeyValuePair<string, int> kvp in Dic)
{
i++;
    Console.WriteLine(kvp.Key + " " + kvp.Value);
    if (i == 9)
    {
        break;
    }
}

My earlier attempt was using LINQ, which is apparently not allowed but missed it.

string[] Results = File1.Split(" ".ToCharArray()).Except(File2.Split(" ".ToCharArray())).OrderByDescending(s => s.Length).Take(10).ToArray();

for (int i = 0; i < Results.Length; i++)
{
    Console.WriteLine(Results[i] + " " + Regex.Matches(File1, Results[i]).Count);
}