Improving speed of word search algorithm

Code style

1. As you are writing C++ there is no need to declare all local variables at the beginning of a block. Declare them where they are needed.

2. Give your loop counters sensible names. Single letter loop counters are accepted practice but sometimes it makes it easier to read to provide some more descriptive name.

3. There is no value in using while loops everywhere. In some places for loops would be much cleaner to read, especially since they allow you to declare the loop counter in place. I found it very hard to discern all the loop variables to see if they are being used later on for some reason. So your first while loop in main could be rewritten as:

   for (int y = 0; y < Height; y++)
   {
       for (int x = 0; x < Width; x++)
       {
           Data >> Matrix[y][x];
       }
   }
   

   This clearly limits the scope of the loop counter to the loop so anyone reading the code doesn't have to check if the variables might be used further down. It also states the invariants of the loop all in one place. I choose x and y because using x and y to denote coordinates in a 2d structure is fairly common in the programming world. For other loops different names will make more sense.

   Same goes for the outer while loop which loops over all words. The inner while loops are ok since you are skipping some parts but still the loop counters should be renamed to something more suitable.

4. Also your other variables could use more descriptive names. For example

   • Numb should be wordCount
   • Longer should be wordLength

5. As Jamal said: standard naming convention for local variables and methods is camelCase, classes are PascalCase.

6. Do not use an array to hold a bunch of loop counters. See above for recommendations for loops.

• widht is misspelled; it should be width. :-)

• Some generalities regarding naming convention:

  Variables and functions should start with a lowercase letter:

  // "camel case"
  int camelCaseVariable;
  void camelCaseFunction() {}
  

  // "snake case"
  int snake_case_variable;
  void snake_case_function() {}
  

  Custom types should start with a capital letter:

  class Class;
  

  Macros should be uppercase:

  #define MACRO 0
  

• Check()'s body can be simplified as such:

  return Letter == Matrix; // already returns true or false
  

  Its parameters should also be passed by constant reference since they're not being modified:

  bool Check(string const& Letter, string const& Matrix) {}
  

• You should make sure the input file is open before proceeding. If not, terminate from main() by returning 1 or EXIT_FAILURE.

• You could vastly improve readability by using more functions. Putting everything in main() is not always a good idea, especially with a lot of nesting. Define the functions to perform one important task, and call them in main() or wherever else as needed. Function call overhead shouldn't hurt you here, making the readability aspect more important.

  In its current state, more comments may help others follow the code. That, in turn, could help flesh out any optimization issues. However, this isn't a substitute for writing readable code.

For arrays whose size can be determined at compile time, such as Loop and Possible, prefer the use of std::array which will be safer for bounds checking and will not degenerate into a pointer when passed to another function. (std::array is only available with C++11)

For arrays whose size cannot be determined at compile time, such as Matrix and the members of Matrix, prefer to use std::vector which will take care of the memory allocations for you, and allow you more flexibility in your code.

You can still use the bracket [] syntax with std::array and std::vector so only minimal changes to the above code should be required for implementation, but it is safer to use std::vector::at so that vector can perform bounds checking for you (it will throw an exception if you attempt to access an element outside of the bounds of the vector instead of simply giving you access to raw memory.)