Word Pattern challenge in LeetCode

Overall, this is a nice, clean solution, congratulations!

Performance

Can you suggest If I can do away with looking up twice. Currently this solution only runs better that around 36% of the other submissions for this current problem. So, I believe there must be a better and faster way.

"Looking up twice" is not the appropriate term. You do one lookup by key, and another lookup by value. These are very different operations, and lumping them together as "two lookups" hides important details. Imagine a program that does one lookup in an array and one lookup with a Google search on the internet, and the author would wonder if slowness might be caused by doing "two lookups". It would hide a crucial detail that one of the "lookups" is clearly much slower than the other.

The lookup in the dictionary by key is very fast, an \$O(1)\$ operation.

The lookup by value in a typical dictionary (or hash map) implementation is much slower, \$O(n)\$, because dictionaries are indexed by key, not by value. They are designed for fast lookups by key, not by value.

To make the lookup by value faster, you can add a set for values.

Scope

It's good to limit the scope of variables to the minimum needed.

• matchstr should be declared inside the loop, as it is not needed outside
• mapPattern should be initialized after the early return, as it might not be needed

Just a few small issues, the main thing (using a HashSet to keep track of the values) has already been covered.

var result = str.Split(' ').ToList();

You don't need this to be a List - it's fine as string[].

result is a bad name. May I suggest words or tokens?

var mapPattern = new Dictionary<char, string>();
if (result.Count != pattern.Count())

You should check for the early return before creating your dictionary. With result renamed to words and as an array, the if would be better as:

if (words.Length != pattern.Length)

string matchstr;

word or token would be a better choice depending on what you call the result of string.Split().

if (mapPattern.TryGetValue(pattern[index], out matchstr))
{
    if (matchstr != result[index])
    {

You can combine these:

if (mapPattern.TryGetValue(pattern[index], out word) 
    && word != words[index])
{
    return false;
}

which saves you some indentation.

Overall, it's a good approach IMO. I submitted a similar approach with an extra hashset and first got a speed ~15% and then submitted it again and got a speed at ~85% so I think it's just pot luck.

Not much but you could change index

foreach (int index = 0; index < pattern.Count; index++)
{

Use a HashSet to store current values

A related approach

public static bool PatterMatch(string pattern, string match)
{
    Dictionary<char, int> dlPattern = new Dictionary<char, int>();
    Dictionary<string, int> dlMatch = new Dictionary<string, int>();
    List<int> lPattern = new List<int>();
    List<int> lMatch = new List<int>();
    int index = 0;
    int indexOut;
    foreach(char p in pattern.ToCharArray())
    {
        if (dlPattern.TryGetValue(p, out indexOut))
        {
            lPattern.Add(indexOut);
        }
        else
        {
            dlPattern.Add(p, index);
            lPattern.Add(index);
            index++;
        }
    }
    index = 0;
    foreach (string s in match.Split(' '))
    {
        if (dlMatch.TryGetValue(s, out indexOut))
        {
            lMatch.Add(indexOut);
        }
        else
        {
            dlMatch.Add(s, index);
            lMatch.Add(index);
            index++;
        }
    }
    return lPattern.SequenceEqual(lMatch);
}