renamed method variables for improved readability.

Author: CasualProgrammer25

src/main/java/com/thealgorithms/strings/RabinKarp.java

@@ -16,57 +16,57 @@ private RabinKarp() {
     private static final int ALPHABET_SIZE = 256;
 
     public static List<Integer> search(String text, String pattern) {
-        return search(text, pattern, 101);
+        return search(text, pattern, 101); // 101 is a prime number used as modulo
     }
 
-    public static List<Integer> search(String text, String pattern, int q) {
+    public static List<Integer> search(String text, String pattern, int primeModulo) {
         List<Integer> occurrences = new ArrayList<>();
         if (text == null || pattern == null || pattern.isEmpty()) {
             return occurrences;
         }
 
-        int m = pattern.length();
-        int n = text.length();
-        int t = 0;
-        int p = 0;
-        int h = 1;
-        int j = 0;
-        int i = 0;
+        int patternLength = pattern.length();
+        int textLength = text.length();
+        int textHash = 0;
+        int patternHash = 0;
+        int highestPowerHash = 1;
+        int matchIndex;
+        int currentIndex;
 
-        if (m > n) {
+        if (patternLength > textLength) {
             return new ArrayList<>();
         }
 
-        // h = pow(ALPHABET_SIZE, m-1) % q
-        for (i = 0; i < m - 1; i++) {
-            h = h * ALPHABET_SIZE % q;
+        // highestPowerHash = pow(ALPHABET_SIZE, patternLength-1) % primeModulo
+        for (currentIndex = 0; currentIndex < patternLength - 1; currentIndex++) {
+            highestPowerHash = highestPowerHash * ALPHABET_SIZE % primeModulo;
         }
 
-        for (i = 0; i < m; i++) {
-            p = (ALPHABET_SIZE * p + pattern.charAt(i)) % q;
-            t = (ALPHABET_SIZE * t + text.charAt(i)) % q;
+        for (currentIndex = 0; currentIndex < patternLength; currentIndex++) {
+            patternHash = (ALPHABET_SIZE * patternHash + pattern.charAt(currentIndex)) % primeModulo;
+            textHash = (ALPHABET_SIZE * textHash + text.charAt(currentIndex)) % primeModulo;
         }
 
-        for (i = 0; i <= n - m; i++) {
-            if (p == t) {
-                for (j = 0; j < m; j++) {
-                    if (text.charAt(i + j) != pattern.charAt(j)) {
+        for (currentIndex = 0; currentIndex <= textLength - patternLength; currentIndex++) {
+            if (patternHash == textHash) {
+                for (matchIndex = 0; matchIndex < patternLength; matchIndex++) {
+                    if (text.charAt(currentIndex + matchIndex) != pattern.charAt(matchIndex)) {
                         break;
                     }
                 }
 
-                if (j == m) {
-                    occurrences.add(i);
+                if (matchIndex == patternLength) {
+                    occurrences.add(currentIndex);
                 }
             }
 
-            if (i < n - m) {
-                t = (t - text.charAt(i) * h % q);
-                if (t < 0) {
-                    t += q;
+            if (currentIndex < textLength - patternLength) {
+                textHash = (textHash - text.charAt(currentIndex) * highestPowerHash % primeModulo);
+                if (textHash < 0) {
+                    textHash += primeModulo;
                 }
-                t = t * ALPHABET_SIZE % q;
-                t = (t + text.charAt(i + m)) % q;
+                textHash = textHash * ALPHABET_SIZE % primeModulo;
+                textHash = (textHash + text.charAt(currentIndex + patternLength)) % primeModulo;
             }
         }
         return occurrences;