Optimize?

[Nenad]

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.util.Arrays;
import java.util.ArrayList;

public class Search{

    public static ArrayList position(String word, String[] wordlist){
    	ArrayList<Integer> list = new ArrayList<Integer>();
    	int counter = 0;
    	String one = "";
    	String q = "?";
    	for (int i = 0; i<wordlist.length; i++)
    		{
    			if (word.substring(0,1).compareTo(wordlist[i].substring(0, 1)) == 0 || word.substring(0,1).compareTo(q) == 0)
    					{
    						if (word.compareTo(wordlist[i]) == 0)
    						{
    						list.add(counter);
    						counter = counter + wordlist[i].length() + 1;
    						}
    						else if (word.contains(q) && word.length() == wordlist[i].length())
    						{
    							one = wordlist[i];
    						    for (int j = 0; j<word.length(); j++)
    						    {
    						    	if(word.charAt(j) == '?')
    						    	{
    						    		one = one.substring(0,j) + "?" + one.substring(j+1);
    						    		if (word.compareTo(one) == 0)
    						    		{	
    						    		list.add(counter);
    	    							counter = counter + wordlist[i].length() + 1;
    	    							break;
    						    		}
    						    	}
    						    }
    						    if(!(word.compareTo(one) == 0))
    						    {
    						    counter = counter + wordlist[i].length() + 1;
    						    }
    						}
    						else
    			    		counter = counter + wordlist[i].length() + 1;
    					}
    			else
    			counter = counter + wordlist[i].length() + 1;
    		}
		return list;
    }


    public static void main(String[]  args){
        try{
            BufferedReader in;
            if (args.length > 0) {
                try {
                    in = new BufferedReader(new FileReader(args[0]));
                }
                catch (FileNotFoundException e) {
                    System.out.println("Can't open file " + args[0]);
                    return;
                }
            }
            else {
                in = new BufferedReader(new InputStreamReader(System.in));
            }
            StringTokenizer st = new StringTokenizer(in.readLine());
            String[] word = new String[st.countTokens()];
            int i=0;
            while(st.hasMoreTokens()) word[i++]=st.nextToken();
            String searchword= in.readLine();
            while(searchword!=null){
                searchword=searchword.trim();
                System.out.print(searchword+":");
                ArrayList pos = position(searchword, word);
                int[] posi = new int[pos.size()];
                for(i=0;i<posi.length;i++)posi[i]=((Integer)pos.get(i)).intValue();
                Arrays.sort(posi);
                for(i=0;i<posi.length;i++) System.out.print(" "+posi[i]);
                System.out.println();
                searchword=in.readLine();
            }
        }
        catch(Exception e){
            e.printStackTrace();
        }
    }
}

So, what the code does is search a sentence and return the position of the words in that sentence, as an example:

Input:
hello this is a sentence to test the code so that the code can test the code
hello
code
is
thi?
?el??
??u??

Output:
hello: 0
code: whatever whatever whatever
etc.

There are two things to know - the sentence consists of letters from a-z and blank spaces, and the searchwords can have ?, where ? represents any letter from a-z. Hence, is and it would return both if the searchword was i?

The code works perfectly, but it takes some time. If anyone feels like showing me how i could optimize this code to take less time I'd be happy to learn, but if not don't sweat it.

 

[s3rius]

Do you make such a system because you want to build it yourself or because you need it?

'cause if you need it then look into Regular Expressions (Regex). There's for sure some premade C# classes for it. It's basically doing what you want and it's fast.

If you want to build it yourself you might still want to look at implementations of Regexes. They usually use a deterministic finite automaton. That way you can remove a lot of possible matches quickly. It isn't as easy to build though.

 

[JerseyFoo]

I don't know how/want to Java or use the Matcher class; but you want something like this.

import java.io.InputStreamReader;
import java.io.FileReader;
import java.io.BufferedReader;
import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class Search{
    static String pile = "";
    
    static String getIndexes(String word){
        word = word.trim().toLowerCase();
        Pattern regex = Pattern.compile("\b" + word.replace("?", "[a-z]{1}") + "\b");
        Matcher m = regex.matcher(pile);
        String arr = "";
        
        System.out.println("test: " + pile);
        while ( m.lookingAt() ){
            System.out.print("runs");
            arr += " " + m.start();
        }
        return arr;
    }
    
    public static void main(String[] args){
        BufferedReader in = null;
        String ln = "";
        try{
            in = new BufferedReader( 
                args.length > 0 
                ? new FileReader(args[0]) 
                : new InputStreamReader(System.in) 
            );
            ln = in.readLine().trim().toLowerCase();
        } catch(Exception e){
            System.out.print("Read error.");
        }
        pile = " " + ln + " ";
            
        do {
            try{
                ln = in.readLine();
            } catch(Exception e){
                System.out.print("Input error.");
            }
            
            if ( ln.isEmpty() ) break;
            
            System.out.println( ln + ":" + getIndexes(ln) );
        } while ( true );
    }
}

 

[Vestras]

Do you make such a system because you want to build it yourself or because you need it?

'cause if you need it then look into Regular Expressions (Regex). There's for sure some premade C# classes for it. It's basically doing what you want and it's fast.

If you want to build it yourself you might still want to look at implementations of Regexes. They usually use a deterministic finite automaton. That way you can remove a lot of possible matches quickly. It isn't as easy to build though.

That's Java.

 

[s3rius]

That's Java.

No difference.

 

[Sgqvur]

Well you could try using the String.split function.

It should work in the following way (Note that this is a psedoscript):

string cmd = "hello this is a sentence to test the code so that the code can test the code"
my string arary = String.split(" ", cmd)
index = 0
for i = 0; i < my string array size; i++
{
index = cmd.indexOf(my string array, index)
print my string array + ": " + index
}