Cfrtjryk

I tried solving the problem in the following manner; I am just a beginner and wanted to know my mistakes and a more efficient way with better time complexity (if any).

    public class d3 {

    public static void main(String args){

    String Search="loop";

    String letters = Search.split("") ;

    int counter;



    String words={"pole","pool","lopo","book","kobo"};



    for(int i=0;i<words.length;i++)

    {

        counter=0;

        String ssplit = words[i].split("");

        for(int j=0;j<words[i].length();j++)

        {



            if(letters.length==ssplit.length)

            {

            for(int k=0;k<letters.length;k++)

            {

                    if(letters[j].equals(ssplit[k]))

                        {counter++;

                        ssplit[k]="*";

                break;





                        }







            }

            if (counter == 4)

            {

                System.out.println(words[i]);



            }



        }

            }





    }



}

}

Whitespace is very important for readability. For posting to Stack Exchange sites I recommend replacing tabs with spaces, because otherwise the site does that for you and the tabstops might not match. Here, though, the whitespace is so crazy that I think you need to look at configuring your IDE to pretty-print the code. Reformatting so that I can understand the structure:

public class d3 {

    public static void main(String args){

        String Search="loop";

        String letters = Search.split("") ;

        int counter;



        String words={"pole","pool","lopo","book","kobo"};



        for(int i=0;i<words.length;i++)

        {

            counter=0;

            String ssplit = words[i].split("");

            for(int j=0;j<words[i].length();j++)

            {

                if(letters.length==ssplit.length)

                {

                    for(int k=0;k<letters.length;k++)

                    {

                        if(letters[j].equals(ssplit[k]))

                        {

                            counter++;

                            ssplit[k]="*";

                            break;

                        }

                    }

                    if (counter == 4)

                    {

                        System.out.println(words[i]);

                    }

                }

            }

        }

    }

}

Names

Java convention is that camel-case names which start with a capital letter are types (classes, interfaces, etc), so Search as the name of a variable is unexpected.

counter is not entirely uninformative, but a better name would tell me what it counts. Similarly, it would be helpful to distinguish which variables relate to the search query and which to the items searched. The best convention I've seen there is PHP's needle and haystack, so I would suggest needleLetters and haystackWords.

foreach statement

Instead of for(int i=0;i<words.length;i++) ... words[i] you can use for (String word : words) ... word. This removes a variable and simplifies the naming, making it easier to see what the code does.

Decomposing strings

String has a method toCharArray(). I think it would make more sense to use that than split("").

Don't put something in a loop which can go outside it

            for(int j=0;j<words[i].length();j++)

            {

                if(letters.length==ssplit.length)

                {

                    ...

                }

            }

could be rewritten

            if(letters.length==ssplit.length)

            {

                for(int j=0;j<ssplit.length;j++)

                {

                    ...

                }

            }

Executing the test once is more efficient, and it's also easier to understand because the maintainer doesn't have to reason about loop invariants to work out what might have changed the second time the test is executed.

Since there's nothing after this test in the loop body, an alternative would be

            if(letters.length!=ssplit.length)

            {

                continue;

            }



            for(int j=0;j<ssplit.length;j++)

            {

                ...

            }

Beware hard-coded constants

Why

                    if (counter == 4)

                    {

                        System.out.println(words[i]);

                    }

? That's a bug. The comparison should be with letters.length. Also, it would make more sense to move the test outside the loop over j.

Use advanced data structures

            for(int j=0;j<words[i].length();j++)

            {

                for(int k=0;k<letters.length;k++)

                {

                    if(letters[j].equals(ssplit[k]))

                    {

                        counter++;

                        ssplit[k]="*";

                        break;

                    }

                }

            }

takes time proportional to words[i].length() * letters.length. If you use java.util.HashMap<Character, Integer> to store a per-character count, you can generate a representation for each word in time proportional to the length of the word, and you can compare the representations of two words in time proportional to the length of each word. In this toy example it doesn't matter, but for real applications the difference between $O(n^2)$ and $O(n)$ can be the difference between a project being feasible and not. The first place to look for optimisations is always the algorithm.

welcome on Codereview.

I am pretty sure that you will find many other ways to do it the comments from @NateGardner is already a good suggestion. But the goal is to review your code so I will just try to suggest some improvements to your code.

First of all I will just reformat the code, create a dedicated class for it and define the input and output.

class WordFinder {

  private final String words;

  WordFinder(String words) {

    this.words = new String[words.length];

    System.arraycopy(words, 0, this.words, 0, words.length);

  }

  String find(String word) {

    // Your code here

  }

}

Then you can start to split your nested logic in different methods and use exiting methods to simplify your code (like String#toCharArray() instead of String#split(""))

  String find(String word) {

    String result = new String[this.words.length];

    char letters = word.toCharArray();

    int counter = 0;

    for (String candidate : this.words) {

        if ( this.matches(letters, candidate.toCharArray()) ) {

            result[counter++] = candidate;

        }

    }

    return Arrays.copyOf(result, counter);

  }

As said in the beginning, there is a lot of way to test two words for matching and I am sure that you will find the best one. For this answer, I decided to compare the hash of each array of char.

Here is my code if you want. But if you can use other structure from the collections or the stream API, this one can be totally different.

public class WordFinder {



    private final String words;



    public WordFinder(String words) {

        this.words = new String[words.length];

        System.arraycopy(words, 0, this.words, 0, words.length);

    }



    public String find(String word) {

        String result = new String[this.words.length];

        char letters = word.toCharArray();

        int counter = 0;

        for (String candidate : this.words) {

            if ( matches(letters, candidate.toCharArray()) ) {

                result[counter++] = candidate;

            }

        }

        return Arrays.copyOf(result, counter);

    }



    private boolean matches(char requirement, char candidate) {

        /* Edited to replace Arrays.hashCode with Arrays.equals, see comments

        return candidate.length==requirement.length &&

           hash(candidate)==hash(requirement);*/



        if ( candidate.length!=requirement.length ) {

            return false;

        } 

        char left = Arrays.copyOf(requirement, requirement.length);

        Arrays.sort(left);

        char right = Arrays.copyOf(candidate, candidate.length);

        Arrays.sort(right );

        return Arrays.equals(left, right);

    }



    /*private int hash(char array) {

        char copy = Arrays.copyOf(array, array.length);

        Arrays.sort(copy);

        return Arrays.hashCode(copy);

    }*/

}