Skip to main content
edited body; edited title
Source Link
Jamal
  • 35.2k
  • 13
  • 134
  • 238

How can I make this mess Finding words of Java for-loops faster?different lengths given six letters

I'm trying to find all the 3, 4, 5, and 6 letter words given 6 letters. I am finding them by comparing every combination of the 6 letters to an ArrayList of words called sortedDictionary. I have worked on the code a good bit to get it to this point. I

I tested how many six letter words are checked and got 720 which is good because 65432*1=720 which means I am not checking any words twice. I can't make it faster by getting rid of duplicate checks because I have already gotten rid of them all.

How can I make this mess of Java for-loops faster?

I'm trying to find all the 3, 4, 5, and 6 letter words given 6 letters. I am finding them by comparing every combination of the 6 letters to an ArrayList of words called sortedDictionary. I have worked on the code a good bit to get it to this point. I tested how many six letter words are checked and got 720 which is good because 65432*1=720 which means I am not checking any words twice. I can't make it faster by getting rid of duplicate checks because I have already gotten rid of them all.

Finding words of different lengths given six letters

I'm trying to find all the 3, 4, 5, and 6 letter words given 6 letters. I am finding them by comparing every combination of the 6 letters to an ArrayList of words called sortedDictionary. I have worked on the code a good bit to get it to this point.

I tested how many six letter words are checked and got 720 which is good because 65432*1=720 which means I am not checking any words twice. I can't make it faster by getting rid of duplicate checks because I have already gotten rid of them all.

added 506 characters in body; edited title
Source Link
Jamal
  • 35.2k
  • 13
  • 134
  • 238

How Cancan I make This Messthis mess of Java For Loops Fasterfor-loops faster?

I'm trying to find all the 3, 4, 5, and 6 letter words given 6 letters. I am finding them by comparing every combination of the 6 letters to an ArrayListArrayList of words called sortedDictionarysortedDictionary. I have worked on the code a good bit to get it to this point. I tested how many six letter words are checked and got 720 which is good because 65432*1=720 which means I am not checking any words twice. I can't make it faster by getting rid of duplicate checks because I have already gotten rid of them all.

Note that sortedDictionarysortedDictionary only contains about 27 hundred words.

      for(int l1 = 0; l1 < 6; l1++){
            for(int l2 = 0; l2 < 6; l2++){
                if(l2 != l1)
                    for(int l3 = 0; l3 < 6; l3++){
                        if(l3 != l1 && l3 != l2){
                            if(sortedDictionary.contains(""+anagramCharacters[l1]+anagramCharacters[l2]+anagramCharacters[l3]))
                                anagram_words.add(""+anagramCharacters[l1]+anagramCharacters[l2]+anagramCharacters[l3]);
                            for(int l4 = 0; l4 < 6; l4++){
                                if(l4 != l1 && l4 != l2 && l4 != l3){
                                    if(sortedDictionary.contains(""+anagramCharacters[l1]+anagramCharacters[l2]+anagramCharacters[l3]+anagramCharacters[l4]))
                                        anagram_words.add(""+anagramCharacters[l1]+anagramCharacters[l2]+anagramCharacters[l3]+anagramCharacters[l4]);
                                    for(int l5 = 0; l5 < 6; l5++){
                                        if(l5 != l1 && l5 != l2 && l5 != l3 && l5 != l4){
                                            if(sortedDictionary.contains(""+anagramCharacters[l1]+anagramCharacters[l2]+anagramCharacters[l3]+anagramCharacters[l4]+anagramCharacters[l5]))
                                                anagram_words.add(""+anagramCharacters[l1]+anagramCharacters[l2]+anagramCharacters[l3]+anagramCharacters[l4]+anagramCharacters[l5]);
                                            for(int l6 = 0; l6 < 6; l6++){
                                                if(l6 != l1 && l6 != l2 && l6 != l3 && l6 != l4 && l6 != l5)
                                                    if(sortedDictionary.contains(""+anagramCharacters[l1]+anagramCharacters[l2]+anagramCharacters[l3]+anagramCharacters[l4]+anagramCharacters[l5]+anagramCharacters[l6]))
                                                        anagram_words.add(""+anagramCharacters[l1]+anagramCharacters[l2]+anagramCharacters[l3]+anagramCharacters[l4]+anagramCharacters[l5]+anagramCharacters[l6]);
                                            }   
                                        }
                                    }   
                                }
                            }
                        }
                    }
            }
        }

My solution, still probably not the best written code but it reduce the loading time from about 1-2 seconds to nearly instant  (no noticeable wait time,time; didn't actually test how long it was).

      for(int i = 0; i < sortedDictionary.size(); i++){
            for(int index = 0; index < anagram.length(); index++)
                anagramCharacters[index] = anagram.charAt(index);
            forloop:
            for(int i2 = 0; i2 < sortedDictionary.get(i).length(); i2++){
                for(int i3 = 0; i3 < anagramCharacters.length; i3++){
                    if(sortedDictionary.get(i).charAt(i2) == anagramCharacters[i3]){
                        anagramCharacters[i3] = 0;
                        break;
                    }
                    else if(i3 == anagramCharacters.length-1)
                        break forloop;
                }
                if(i2 == sortedDictionary.get(i).length()-1)
                    anagram_words.add(sortedDictionary.get(i));
            }
        }

How Can I make This Mess of Java For Loops Faster?

I'm trying to find all the 3, 4, 5, and 6 letter words given 6 letters. I am finding them by comparing every combination of the 6 letters to an ArrayList of words called sortedDictionary. I have worked on the code a good bit to get it to this point. I tested how many six letter words are checked and got 720 which is good because 65432*1=720 which means I am not checking any words twice. I can't make it faster by getting rid of duplicate checks because I have already gotten rid of them all.

Note that sortedDictionary only contains about 27 hundred words.

      for(int l1 = 0; l1 < 6; l1++){
            for(int l2 = 0; l2 < 6; l2++){
                if(l2 != l1)
                    for(int l3 = 0; l3 < 6; l3++){
                        if(l3 != l1 && l3 != l2){
                            if(sortedDictionary.contains(""+anagramCharacters[l1]+anagramCharacters[l2]+anagramCharacters[l3]))
                                anagram_words.add(""+anagramCharacters[l1]+anagramCharacters[l2]+anagramCharacters[l3]);
                            for(int l4 = 0; l4 < 6; l4++){
                                if(l4 != l1 && l4 != l2 && l4 != l3){
                                    if(sortedDictionary.contains(""+anagramCharacters[l1]+anagramCharacters[l2]+anagramCharacters[l3]+anagramCharacters[l4]))
                                        anagram_words.add(""+anagramCharacters[l1]+anagramCharacters[l2]+anagramCharacters[l3]+anagramCharacters[l4]);
                                    for(int l5 = 0; l5 < 6; l5++){
                                        if(l5 != l1 && l5 != l2 && l5 != l3 && l5 != l4){
                                            if(sortedDictionary.contains(""+anagramCharacters[l1]+anagramCharacters[l2]+anagramCharacters[l3]+anagramCharacters[l4]+anagramCharacters[l5]))
                                                anagram_words.add(""+anagramCharacters[l1]+anagramCharacters[l2]+anagramCharacters[l3]+anagramCharacters[l4]+anagramCharacters[l5]);
                                            for(int l6 = 0; l6 < 6; l6++){
                                                if(l6 != l1 && l6 != l2 && l6 != l3 && l6 != l4 && l6 != l5)
                                                    if(sortedDictionary.contains(""+anagramCharacters[l1]+anagramCharacters[l2]+anagramCharacters[l3]+anagramCharacters[l4]+anagramCharacters[l5]+anagramCharacters[l6]))
                                                        anagram_words.add(""+anagramCharacters[l1]+anagramCharacters[l2]+anagramCharacters[l3]+anagramCharacters[l4]+anagramCharacters[l5]+anagramCharacters[l6]);
                                            }   
                                        }
                                    }   
                                }
                            }
                        }
                    }
            }
        }

My solution, still probably not the best written code but it reduce the loading time from about 1-2 seconds to nearly instant(no noticeable wait time, didn't actually test how long it was).

      for(int i = 0; i < sortedDictionary.size(); i++){
            for(int index = 0; index < anagram.length(); index++)
                anagramCharacters[index] = anagram.charAt(index);
            forloop:
            for(int i2 = 0; i2 < sortedDictionary.get(i).length(); i2++){
                for(int i3 = 0; i3 < anagramCharacters.length; i3++){
                    if(sortedDictionary.get(i).charAt(i2) == anagramCharacters[i3]){
                        anagramCharacters[i3] = 0;
                        break;
                    }
                    else if(i3 == anagramCharacters.length-1)
                        break forloop;
                }
                if(i2 == sortedDictionary.get(i).length()-1)
                    anagram_words.add(sortedDictionary.get(i));
            }
        }

How can I make this mess of Java for-loops faster?

I'm trying to find all the 3, 4, 5, and 6 letter words given 6 letters. I am finding them by comparing every combination of the 6 letters to an ArrayList of words called sortedDictionary. I have worked on the code a good bit to get it to this point. I tested how many six letter words are checked and got 720 which is good because 65432*1=720 which means I am not checking any words twice. I can't make it faster by getting rid of duplicate checks because I have already gotten rid of them all.

Note that sortedDictionary only contains about 27 hundred words.

for(int l1 = 0; l1 < 6; l1++){
    for(int l2 = 0; l2 < 6; l2++){
        if(l2 != l1)
            for(int l3 = 0; l3 < 6; l3++){
                if(l3 != l1 && l3 != l2){
                    if(sortedDictionary.contains(""+anagramCharacters[l1]+anagramCharacters[l2]+anagramCharacters[l3]))
                        anagram_words.add(""+anagramCharacters[l1]+anagramCharacters[l2]+anagramCharacters[l3]);
                    for(int l4 = 0; l4 < 6; l4++){
                        if(l4 != l1 && l4 != l2 && l4 != l3){
                            if(sortedDictionary.contains(""+anagramCharacters[l1]+anagramCharacters[l2]+anagramCharacters[l3]+anagramCharacters[l4]))
                                anagram_words.add(""+anagramCharacters[l1]+anagramCharacters[l2]+anagramCharacters[l3]+anagramCharacters[l4]);
                            for(int l5 = 0; l5 < 6; l5++){
                                if(l5 != l1 && l5 != l2 && l5 != l3 && l5 != l4){
                                   if(sortedDictionary.contains(""+anagramCharacters[l1]+anagramCharacters[l2]+anagramCharacters[l3]+anagramCharacters[l4]+anagramCharacters[l5]))
                                       anagram_words.add(""+anagramCharacters[l1]+anagramCharacters[l2]+anagramCharacters[l3]+anagramCharacters[l4]+anagramCharacters[l5]);
                                   for(int l6 = 0; l6 < 6; l6++){
                                       if(l6 != l1 && l6 != l2 && l6 != l3 && l6 != l4 && l6 != l5)
                                           if(sortedDictionary.contains(""+anagramCharacters[l1]+anagramCharacters[l2]+anagramCharacters[l3]+anagramCharacters[l4]+anagramCharacters[l5]+anagramCharacters[l6]))
                                               anagram_words.add(""+anagramCharacters[l1]+anagramCharacters[l2]+anagramCharacters[l3]+anagramCharacters[l4]+anagramCharacters[l5]+anagramCharacters[l6]);
                                    }   
                                }
                            }   
                        }
                    }
                }
            }
    }
}

My solution, still probably not the best written code but it reduce the loading time from about 1-2 seconds to nearly instant  (no noticeable wait time; didn't actually test how long it was).

for(int i = 0; i < sortedDictionary.size(); i++){
    for(int index = 0; index < anagram.length(); index++)
        anagramCharacters[index] = anagram.charAt(index);
    forloop:
    for(int i2 = 0; i2 < sortedDictionary.get(i).length(); i2++){
        for(int i3 = 0; i3 < anagramCharacters.length; i3++){
            if(sortedDictionary.get(i).charAt(i2) == anagramCharacters[i3]){
                anagramCharacters[i3] = 0;
                break;
            }
            else if(i3 == anagramCharacters.length-1)
                break forloop;
        }
        if(i2 == sortedDictionary.get(i).length()-1)
            anagram_words.add(sortedDictionary.get(i));
    }
}
edited tags
Link
200_success
  • 145.7k
  • 22
  • 191
  • 481
Tweeted twitter.com/#!/StackCodeReview/status/406140923958292480
added 889 characters in body
Source Link
java
  • 481
  • 4
  • 8
Loading
Source Link
java
  • 481
  • 4
  • 8
Loading