How I can find a string from a set of 100 Ascii string...please need HELP

Ahh homework.. those were the days.

Brute force is a starting point..
You could load the 100 strings into an array.
You could iterate over the array
Create Map matches
For each string in array
  for each letter of input
      do an indexof the first letter if found store in matches(string,num times matched)
      if found continue letter loop
  end letter loop
end loop
  iterate over matches map.entries
      if value of entry == # input letters it matches
  end iterate

In my solution you could also just use the map always instead of the array.. and load the map from the file to begin with.. then loop over each entry in the map in place of iterating over the array..

My solution boils down to using the 100 strings as the key to the map and the number of times a letter in input matches that string as the value of the map.

Hello Mightyone,
     Thanks a lot, however I still not understanding such as is it the best way to solve this problems far optimization goes?

Does Hashmap supports implementations of ArrayList? My understanding is HashSet support TreeSet and HashMap supports TreeMap. Please explain or may be you can give me more directions in details about this problem and I can write a small program and test it.

Thanks again

>>Does Hashmap supports implementations of ArrayList?
I don't know what you mean.. Hashmap implements Map and ArrayList implements List

You don't need an arraylist to solve.. all you need is a Map with counters in my solution.  

You will need to define what optimize for time means to you.. What is optimal time? Is it linear? Like adding more values or more input characters means linear growth in time?

List tmp = map.getValue("s");

should of courde be

List tmp = (ArrayList)map.getValue("s");

Here is my solution written out.. obviously it would need to be tweaked to read from the args and potentially loop over the remainder.. but you should get the idea

public class Work {

    public static void main(String[] args) {
        Map storage = new HashMap();
        char[] input1 = "tt".toCharArray();
        String[] entries = new String[] {"seth", "ryan", "morgan", "ccgn"};
        for (int i = 0; i < entries.length; i++) {
            storage.put(entries[i],new Integer(0));
        }
        Set entrySet = storage.entrySet();
        for (Iterator iter = entrySet.iterator(); iter.hasNext();) {
            Map.Entry element = (Map.Entry) iter.next();
            String key = (String)element.getKey();
            for (int i = 0; i < input1.length; i++) {
                Integer value = (Integer)element.getValue();
                if (key.indexOf(input1[i]) != -1) {
                    int newValue = value.intValue() + 1;
                    storage.put(key,new Integer(newValue));
                }
            }
        }
        for (Iterator iter = entrySet.iterator(); iter.hasNext();) {
            Map.Entry element = (Map.Entry) iter.next();
            int value = ((Integer)element.getValue()).intValue();
            if (value == input1.length) System.out.println ("Got one:" + element.getKey());
        }
    }
}

So you could optimize this by cutting down on the number of iterations across the input variables if you want be eliminating duplicates.  The values are already optimized in that indexof will stop at the first character that it finds.

Thanks again however a good performance is absolutely necessary therefore loops are not a good idea at least I think so.  How about declarative programming approach in general for ASCII character set?

As I said I am looking for declaractive  approach. It is like Declarative (SQL), most work done by Data Engine within the DBMS.

Can we define a relational logic for this ascii character set such as some kind of mathematical relation in the db level? Like some kind of parents child relationship and assert into tables.

Then use SQL to find the correct sting I am looking for?

I know sql but how I implement the whole problem using declarative approach. In other words what are the designs steps involve. Explanations of these step.

Thanks

If you want it fast you should use bitsets.

Your big pool of strings are converted into a similar pool of bitsets with a bit set for each character occurring in the string

a is bit 0, b is bit 1, c is bit 2, ...    a long integer have 64 bits, that should be plenty for alphabet and digits

this way each string becomes a long, you only need to do this once. and remember which long belong to which string.

when the user type in his string you convert that to a bitset too. in the same way.

and now you can test eaxh string FAST (not sure about your exact condition, so velow are to if's for testing

    if ( ( userBitSet & poolBitSet[0] ) != 0 ) {
         // at least one of the characters in the userstring is in pool string nr 0
    }
or
    if ( ( userBitSet & poolBitSet[0] ) == userBitSet ) {
        // all of the characters in the userstring is in pool string nr 0
    }

regards JakobA

Hi JakobA,
    I think yours approach is correct. So here is my conditions

I have a set of 100 ascii strings this could be loaded from a file
Then a string is input from stdin.

Need to write code or pseudocode that returns to stdout a subset of strings in (1) that contain the same distinct characters regardless of order, and regardless of how many times any particular character repeats as input in (2).

For example, lets say I have strings in (1): seth, ryan, morgan, ccgn
One user types in: ---> an and the output should be "ryan", “morgan” and "ccgn"
and another user types in:----> hh then the output should be “seth”

Now could you please explain yours logic one more time in details that satisfy the above mentioned logic and how I can implement it?


Thanks for yours kind help

Actually, there is a problem there. Your question shout 'Homework', and by the rules of EE we must not do peoples homework for them. Abowe I gave a broad outline ( and it seems you got the idea :-)), but we cannot give you much more than that before you yourself start implementing it, then we can help you debug here and there and maybe even suggest an improvement or two.

sorry, but thems the rules.

regards JakobA

Hi JakobA,
   I am a full time employee and I am not a student. If it was my home work assignment I would not bother to ask anyone and do whatever I can.

Therefore I hope you understand and please enlighten me what I asked before. I appreciated yours help and thank you very much.

Best Regards,

BobbyS

Well ok. here is a draft. Pseudo in < > brackets, but utterly untested so you will likely find lots of syntax and spelling errors.

class BitSetString {     //objects of this class store one string along with its bitset.

    private static final String alfabet = "abcdefghijklmnopqrstuvwxyz0123456789";
                                  //in the bitset bits are set by the characters position in the string alfabet

    private String str;
    private long bitSet;

    public BitSetString( String inStr ) {
        this.str = inStr;
        String tempStr = inStr.toLowerCase();
        int j;
        this.bitSet = 0;
        for (int i=inStr.length()-1; i >= 0; i--) {
            j = alfabet.indexOf( tempStr.charAt(i) );
            if( j >= 0 ) this.bitSet = this.bitSet | (1L<<j);
        }
    }

    public boolean containNone( BitSetString that ) {
        return ( this.bitSet & that.bitSet ) == 0;
    }

    public boolean containSome( BitSetString that ) {
        return ( this.bitSet & that.bitSet ) != 0;
    }

    public boolean containAll( BitSetString that ) {
        return ( this.bitSet & that.bitSet ) == that.bitSet;
    }

    public String toString() {
        return this.str;
    }
}// endclass BitSetString


class MainProgram {

    ArrayList pool = new ArrayList();
    <xxx>Reader fileInput;

    String readAString();
        if( <no more strings in fileInput> ) {
            return null;
        } else {
            return <string read from fileInput>;
        }
    }
   
    public static void main ( String[] args ) {
        String temp;
        BitSetString userBitSet;
        fileInput = <setup and open the file>;
        while ( null != ( temp =readAString() ) ) {
            pool.add( new BitSetString(temp) );
        }
        <close the file>;

        temp = System.in.readln()
        while ( null != ( temp = <line froms stdin> ) ) {
            userBitSet = new BitSetString(temp);
            boolean noneFoundYet = true;
            for( int i=0; i<pool.size(); i++ ){
                if( ((BitSetString)pool.get(i)).containAll(userBitSet) ){
                    if( noneFoundYet ) {
                        System.out.println( "\n\"" +temp +"\" is entirely contained in:" );
                        noneFoundYet == false;
                    }
                    System.out.println( "> " +(BitSetString)pool.get(i) );
                }
            }
            if( noneFoundYet ) {
                System.out.println( "\n\"" +temp +"\" was not contained in any of the strings" );
            }
        }
    }
}// endclass mainProgram

regards JakobA

>>good performance is absolutely necessary therefore loops are not a good idea

I don't really agree with this statement.. there are going to be java loops involved, unless you offload the processing somewhere else.. like a database.  Then a using "like" solution should work just fine..

The bitset approach may (it needs to be tested) faster than other approaches but most developers get confused pretty quickly by the operations on the bits and thus the solution is not very maintainable.  If this truly is not homework, then that should be taken into account.

Considering that 100 strings even if fully sized strings are going to be entirely in memory, optimizing becomes a case of using the least I/O possible.

If you use a database, it will have to read the "table" once.  Otherwise using a brute force of loops or hashmaps or bitsets will probably not be very different in speed.

First develop a solution that works and then optimize if you need to.

Hello JakobA,
      Thanks so much for yours monumental help. I read this programs many times and I still in the process of implementing it and then test it.

In the mean time may I ask you the following questions?

class MainProgram {

    ArrayList pool = new ArrayList();
    <xxx>Reader fileInput;

    String readAString();
        if( <no more strings in fileInput> ) {
            return null;
        } else {
            return <string read from fileInput>;
        }
    }

Where do I call this class at?  Let’s take this one at a step.  The following parts of the main program first I need to set up a FileInputStream with the input file name and BufferedReader around here (fileInput = <setup and open the file>;) right?

Then I call radAString() method which is in class MainProgram. So this method will read one string at a time from the imput 100 ASCII string …is that right?

Next pool.add gets this string whos bits just gets set up by BitSetString in this line (pool.add( new BitSetString(temp) );  ) right?

public static void main ( String[] args ) {
        String temp;
        BitSetString userBitSet;  //should it be BitSetString userBitSet = new BitSetString();    
          fileInput = <setup and open the file>;
        while ( null != ( temp =readAString() ) ) {
            pool.add( new BitSetString(temp) );
        }
        <close the file>;

If I have a class name MainProgram then should not we have a object of this class somewhere in the main? I know you mentioned this is not the complete code so I am asking you that would help me to solve problem down the road. Therefore what do you suggest?  
Since pool and readAString are into this class I need to create an instance of this class in the main and then read pool array and readAString method through instance object right? Can you give me an example please. In the same sample code you provided.

Class MainProgram  also has ArrayList pool = new ArrayList(), can I just declare a String Array here instead of ArryList? Again this is just a question and you are the master here. I mean whats the purpose of ArrayList here?

Could you please explain the following lines

if( ((BitSetString)pool.get(i)).containAll(userBitSet) ) //this is in main


Please explain this part that is the constructor of BitSetString inside the loop. It would be so helpful how this bitset works if you give some simple example.

public BitSetString( String inStr ) {
        this.str = inStr;
        String tempStr = inStr.toLowerCase();
        int j;
        this.bitSet = 0;
        for (int i=inStr.length()-1; i >= 0; i--) {
            j = alfabet.indexOf( tempStr.charAt(i) );
            if( j >= 0 ) this.bitSet = this.bitSet | (1L<<j);
        }


Thank a lot and I am looking forward to hear from you.

Sincerely

BobbyS

Yes.
  you save the program (text for both classes) in a file with the same name and extension .java "MainClass.java", you can rename the class to something else, but then you should change the name of the file too. that filename/classname correspondence is used by java to find the starting class.

Yes.
  (remember the 'e' in 'readAString')

Yes.
  pool end up containing all your 100 strings, each in its own BitSetString object.

No.
  you do not need to make an object of the 'starting' class. It is always static. and Oops, I forgot that in declaring its variables, they should be:
    static ArrayList pool = new ArrayList();
    static <xxx>Reader fileInput;
and the subroutine:
    static String readAString() {
consider the chicken and egg problem if you had to instantiate an object in order to get code to run, how would you get the code instantiating that object to run? :-))

Yes & No.
  If you can absolutely guarantee that there are exactly 100 strings to be read in, then you can just use an array instead of the ArrayList. I chose to yse an ArrayList because then it do not matter if you give it 10, 25, 100 or 5000 strings, an Arraylist adjust its size as needed. An array must be declared with its final size when you create it.
  If you feel you can safely use an array instead it would look like this:
    static BitSetString[] pool = new BitSetString[100];
                 //declares an array with room for 100 BitSetString objects

if( ((BitSetString)pool.get(i)).containAll(userBitSet) )
if(                                                     )   start of if statement with its condition
    ((BitSetString)pool.get(i))                             fetch BitSetString nr i from the list
                   pool.get(i)                              fetch whatever was stored in position i.
     (BitSetString)                                         cast that 'whatever' to a BitSetString object
                               .containAll(          )      in that object we call method containAll
                                           userBitSet       with the users BitSetString as parameter
the value returned by that method is a boolean and that then become the condition for the if statement.

public BitSetString( String inStr ) {
        this.str = inStr;
        String tempStr = inStr.toLowerCase();   //convert to lovercase, 'A' becomes 'a', etc
        int j;                                  //local variable used inside the loop
        this.bitSet = 0;                                          //start with a bitset of all 0's
        for (int i=inStr.length()-1; i >= 0; i--) {              // for i pointing to each letter in the string

            j = alfabet.indexOf( tempStr.charAt(i) );        //find that letter in the alfabet string
                                                                              // j point to its position (j==-1 if not found)
//                                       tempStr.charAt(i)           //fetch character nr i from string tempStr
//               alfabet.indexOf(                            )        //find position of that character in string alfabet

            if( j >= 0 ) this.bitSet = this.bitSet | (1L<<j);  // set the corresponding bit in the bitset
//                                                              (1L<<j)    // 1L means the 1 value is a 'long' integer.  <<j  shift left j steps
//                                                            |               // bitwise or
//                                            this.bitSet                  // with the long variable bitSet in this object.
        }

so if the input string i "an" (as in your example) we
    find the 'n' character
    find that 'n' is the character at position 13 in the string 'alfabet' (position numbers start with nr 0)
    take a long with its lowest bit set:  0000000000000000000000000000000000000000000000000000000000000001 (64 bits)
    shift it left 13 steps                       0000000000000000000000000000000000000000000000000010000000000000
    or it into this.bitSet                       0000000000000000000000000000000000000000000000000010000000000000
    find the 'a' character
    find that 'a' is the character at position 0 in the string 'alfabet'
    take a long with its lowest bit set:  0000000000000000000000000000000000000000000000000000000000000001 (64 bits)
    shift it left 0 steps (no change)      0000000000000000000000000000000000000000000000000000000000000001
    or it into this.bitSet                       0000000000000000000000000000000000000000000000000010000000000001
each different character cause a different bit to be set, and if a character occur twice that bit is just set twice (waste of time there. but cheaper to just set the bit twice than it is to test if it has not been set already and then maybe set it)

regards JakobA

My program iterates over the list of possible values only one time per input and fails fast (the break part).  Plus you have already proven the point that bitset logic is more difficult for the novice programmer to understand.. my program is clean, short, easy to understand, and more than likely just as performant as the bitset..

Hello JakobA,
  Thanks again and I can name the eitire following lines of code as MainProgram.java right?

MainProgram.java
___________________________________________________________________________________________
class BitSetString {     //objects of this class store one string along with its bitset.

    private static final String alfabet = "abcdefghijklmnopqrstuvwxyz0123456789";
                                  //in the bitset bits are set by the characters position in the string alfabet

    private String str;
    private long bitSet;

    public BitSetString( String inStr ) {
        this.str = inStr;
        String tempStr = inStr.toLowerCase();
        int j;
        this.bitSet = 0;
        for (int i=inStr.length()-1; i >= 0; i--) {
            j = alfabet.indexOf( tempStr.charAt(i) );
            if( j >= 0 ) this.bitSet = this.bitSet | (1L<<j);
        }
    }

    public boolean containNone( BitSetString that ) {
        return ( this.bitSet & that.bitSet ) == 0;
    }

    public boolean containSome( BitSetString that ) {
        return ( this.bitSet & that.bitSet ) != 0;
    }

    public boolean containAll( BitSetString that ) {
        return ( this.bitSet & that.bitSet ) == that.bitSet;
    }

    public String toString() {
        return this.str;
    }
}// endclass BitSetString


class MainProgram {

    static ArrayList pool = new ArrayList();
    static <xxx>Reader fileInput;
    static String readAString() {
        if( <no more strings in fileInput> ) {
            return null;
        } else {
            return <string read from fileInput>;
        }
    }
   
    public static void main ( String[] args ) {
        String temp;
        BitSetString userBitSet;
        fileInput = <setup and open the file>;
        while ( null != ( temp =readAString() ) ) {
            pool.add( new BitSetString(temp) );
        }
        <close the file>;

        temp = System.in.readln()
        while ( null != ( temp = <line froms stdin> ) ) {
            userBitSet = new BitSetString(temp);
            boolean noneFoundYet = true;
            for( int i=0; i<pool.size(); i++ ){
                if( ((BitSetString)pool.get(i)).containAll(userBitSet) ){
                    if( noneFoundYet ) {
                        System.out.println( "\n\"" +temp +"\" is entirely contained in:" );
                        noneFoundYet == false;
                    }
                    System.out.println( "> " +(BitSetString)pool.get(i) );
                }
            }
            if( noneFoundYet ) {
                System.out.println( "\n\"" +temp +"\" was not contained in any of the strings" );
            }
        }
    }
}// endclass mainProgram
___________________________________________________________________________________________

May I request you to explain this statement

static <xxx>Reader fileInput; --> This is in the MainProgram.

What is the difference if I say like this

public class MainProgram { ......} instead class MainProgram { ..... }. I mean i know what is public means and in this case why we are not using public?

I just can't say enough thanks but yours help is remarkable.

Regards,

BobbyS

Hello matthewdfleming,
    I implemented yours program and run through it and its working fine.


Thank you very much for yours kind help. However I may have some questions that I would like to ask in few days.

I was looking for BitSet solutions because company desire to implement something like that.


However I really appreciated yours wonderful help and I am sure you can address some of my questions.


Best Wishes and Regards,

BobbyS

Yes you can put it all i an single file.

    static <xxx>Reader fileInput;
The <xxx> means I do not know which of Java's many premade readers you will use it could be
    BufferedReader, CharArrayReader, FilterReader, PipedReader, StringReader
any of them are capable of reading your file
most likely though is
    static BufferedReader = new BufferedReader( new FileReader( "filename.txt" ) );

I think you are right. the class MainProgram should be public, so
   public class MainProgram {
is more correct.

you will also need import statements for the arraylist
  import java.util.ArrayList;
and for whatever readers you decide to use. fx
  import java.io.FileReader;
  import java.io.BufferedReader;

Hello JakobA
    So far I have implemented this


import java.util.*;
import java.io.*;

class BitSetString {    
          //objects of this class store one string along with its bitset.

    private static final String alfabet = "abcdefghijklmnopqrstuvwxyz0123456789";
        //in the bitset bits are set by the characters position in the string alfabet

    private String str;
    private long bitSet;

    public BitSetString( String inStr ) {
        this.str = inStr;
        String tempStr = inStr.toLowerCase();
        int j;
        this.bitSet = 0;
        for (int i=inStr.length()-1; i >= 0; i--) {
            j = alfabet.indexOf( tempStr.charAt(i) );
            if( j >= 0 ) this.bitSet = this.bitSet | (1L<<j);
        }
    }

    public boolean containNone( BitSetString that ) {
        return ( this.bitSet & that.bitSet ) == 0;
    }

    public boolean containSome( BitSetString that ) {
        return ( this.bitSet & that.bitSet ) != 0;
    }

    public boolean containAll( BitSetString that ) {
        return ( this.bitSet & that.bitSet ) == that.bitSet;
    }

    public String toString() {
        return this.str;
    }
}// endclass BitSetString



public class MyBitSetString {
   
    static ArrayList pool = new ArrayList();
    static <xxx>Reader fileInput;
    static String readAString() {
        if( <no more strings in fileInput> ) {
            return null;
        } else {
            return <string read from fileInput>;
        }
    }
   
    public static void main ( String[] args ) {
        String temp;
        BitSetString userBitSet;
        FileReader fr     = new FileReader("myfile.txt" );// Read from a file
        BufferedReader br = new BufferedReader(fr);  
        //fileInput = <setup and open the file>;
        while ( null != ( temp = br.readAString() ) ) {
            pool.add( new BitSetString(temp) );
        }
        fr.close(); // <close the file>;

        //temp = System.in.readln()
        BufferedReader standbr = new BufferedReader(new InputStreamReader(System.in));
        temp = standbr.readln ();
       // while ( null != ( temp = <line froms stdin> ) ) {
        while ( null != ( temp) ) {
            userBitSet = new BitSetString(temp);
            boolean noneFoundYet = true;
            for( int i=0; i<pool.size(); i++ ){
                if( ((BitSetString)pool.get(i)).containAll(userBitSet) ){
                    if( noneFoundYet ) {
                        System.out.println( "\n\"" +temp +"\" is entirely contained in:" );
                        noneFoundYet == false;
                    }
                    System.out.println( "> " +(BitSetString)pool.get(i) );
                }
            }
            if( noneFoundYet ) {
                System.out.println( "\n\"" +temp +"\" was not contained in any of the strings" );
            }
        }
    }
}// endclass MyBitSetString

I am still not sure about this part...

static <xxx>Reader fileInput;
    static String readAString() {
        if( <no more strings in fileInput> ) {
            return null;
        } else {
            return <string read from fileInput>;
        }
    }
do you mean that make a seperate method call for external file instead of the main block the way I did it here. Such as


FileReader fr     = new FileReader("myfile.txt" );// Read from a file
BufferedReader br = new BufferedReader(fr);  
        //fileInput = <setup and open the file>;
        while ( null != ( temp = br.readAString() ) ) {
            pool.add( new BitSetString(temp) );
        }
        fr.close(); // <close the file>;



Also this part which is reading from a standard input that is what users going to type in for seaching a name etc code looks correct the way I did...

//temp = System.in.readln()
 BufferedReader standbr = new BufferedReader(new InputStreamReader(System.in));
 temp = standbr.readln ();
  // while ( null != ( temp = <line froms stdin> ) ) {
 while ( null != ( temp) ) { ..... }


Please explain me one more time the uses of this array
private static final String alfabet = "abcdefghijklmnopqrstuvwxyz0123456789";
into class BitSetString {   }


Thank you very very much

About the method  readAString()

  It is a matter of preference whether that should be written as a separate method or just included in the loop in the main program.

  My preference is to make it a separate method because hat makes the overall function of the main program easier to understand. You are free to write it inside the main methos if you like, it will work the same in either case.


Your code for reading from system.in looks fine.


private static final String alfabet = "abcdefghijklmnopqrstuvwxyz0123456789";

  The string 'alfabet' have 2 functions.
1) It define the characters that will be considered when comparing two strings. (here only letters and digits, any commas, dashes or blanks will be ignored).
2) It defines an ordering of those characters so they will each have a unique number 'a' has nr 0, 'b' has nr 1, 'c' has nr 2, ...  The number is used to set a unique bit in the bitset for each different character.

regards JakobA

Hello JakobA,
   Thanks again. Here is my two implementations with output result

1)
import java.util.*;
import java.io.*;

class BitSetString {    
          //objects of this class store one string along with its bitset.

    private static final String alfabet = "abcdefghijklmnopqrstuvwxyz0123456789";
        //in the bitset bits are set by the characters position in the string alfabet

    private String str;
    private long bitSet;

    public BitSetString( String inStr ) {
        this.str = inStr;
        String tempStr = inStr.toLowerCase();
        int j;
        this.bitSet = 0;
        for (int i=inStr.length()-1; i >= 0; i--) {
            j = alfabet.indexOf( tempStr.charAt(i) );
            if( j >= 0 ) this.bitSet = this.bitSet | (1L<<j);
        }
    }

    public boolean containNone( BitSetString that ) {
        return ( this.bitSet & that.bitSet ) == 0;
    }

    public boolean containSome( BitSetString that ) {
        return ( this.bitSet & that.bitSet ) != 0;
    }

    public boolean containAll( BitSetString that ) {
        return ( this.bitSet & that.bitSet ) == that.bitSet;
    }

    public String toString() {
        return this.str;
    }
}// endclass BitSetString


public class MyBitSetString {
      
      static ArrayList pool = new ArrayList();
      
    /* static String readAString() */
     
    public static void main ( String[] args ) {
        String temp;
        BitSetString userBitSet;
        try {
          FileReader fr     = new FileReader("mynameset.txt" );
          BufferedReader br = new BufferedReader(fr);  
          while (null != (temp=br.readLine ())) {
                 temp=temp.trim();
               pool.add( new BitSetString(temp) );
          }
          fr.close(); // <close the file>;
          } catch (IOException e) {
                System.out.println("IO Error:" + e.getMessage()); }
        System.out.println( "\n\"" + "Please enter a string that you want to search or quit to quit" +"\n\"");
        //temp = System.in.readln()
        BufferedReader buf_in = new BufferedReader(new InputStreamReader(System.in));
        try {
           while ( null != ( temp = buf_in.readLine ()) ) {  
                temp = temp.trim();
                if (temp.equals("quit")) { System.exit(0);}
              
              userBitSet = new BitSetString(temp);
              boolean noneFoundYet = true;
              for( int i=0; i<pool.size(); i++ ){
                  if( ((BitSetString)pool.get(i)).containAll(userBitSet) ){
                     if( noneFoundYet ) {
                         System.out.println( "\n\"" +temp +"\" is entirely contained in:" );
                         noneFoundYet = false;
                     }
                   System.out.println( "> " +(BitSetString)pool.get(i) );
                 }
             }
             if( noneFoundYet ) {
                 System.out.println( "\n\"" +temp +"\" was not contained in any of the strings" );
             }
             System.out.println( "\n\"" + "Enter another name to search or quit to quit" +"\n");
           }
          } catch (IOException e) {
             System.out.println ("IO exception = " + e.getMessage());
      }
  }
}// endclass MyBitSetString

__________________________
mynameset.txt
josh, cory, jesse, seth, nick, hens

output

"Please enter a string that you want to search or quit to quit
"
josh

"josh" is entirely contained in:
> josh, cory, jesse, seth, nick, hens

"Enter another name to search or quit to quit

sh

"sh" is entirely contained in:
> josh, cory, jesse, seth, nick, hens

"Enter another name to search or quit to quit

ry

"ry" is entirely contained in:
> josh, cory, jesse, seth, nick, hens

"Enter another name to search or quit to quit



"" is entirely contained in:
> josh, cory, jesse, seth, nick, hens

"Enter another name to search or quit to quit

j

"j" is entirely contained in:
> josh, cory, jesse, seth, nick, hens

"Enter another name to search or quit to quit

 se

"se" is entirely contained in:
> josh, cory, jesse, seth, nick, hens

"Enter another name to search or quit to quit

quit

If you look at the output then you can see every time this program print the entire contaent of the string if its found
an exact match or a close match etc...

Q> Why...could you please tell me ?

Here is the second program

2)
import java.util.*;
import java.io.*;

class BitSetString {    
          //objects of this class store one string along with its bitset.

    private static final String alfabet = "abcdefghijklmnopqrstuvwxyz0123456789";
        //in the bitset bits are set by the characters position in the string alfabet

    private String str;
    private long bitSet;

    public BitSetString( String inStr ) {
        this.str = inStr;
        String tempStr = inStr.toLowerCase();
        int j;
        this.bitSet = 0;
        for (int i=inStr.length()-1; i >= 0; i--) {
            j = alfabet.indexOf( tempStr.charAt(i) );
            if( j >= 0 ) this.bitSet = this.bitSet | (1L<<j);
        }
    }

    public boolean containNone( BitSetString that ) {
        return ( this.bitSet & that.bitSet ) == 0;
    }

    public boolean containSome( BitSetString that ) {
        return ( this.bitSet & that.bitSet ) != 0;
    }

    public boolean containAll( BitSetString that ) {
        return ( this.bitSet & that.bitSet ) == that.bitSet;
    }

    public String toString() {
        return this.str;
    }
}// endclass BitSetStringing


public class MyBitSetString {
      
      static ArrayList pool = new ArrayList();
      
    /* static String readAString() */
     
    public static void main ( String[] args ) {
        String temp, name;
        BitSetString userBitSet;
        try {
          FileReader fr     = new FileReader("mynameset.txt" );
          BufferedReader br = new BufferedReader(fr);  
          while (null != (temp=br.readLine ())) {
                 temp=temp.trim();
                 StringTokenizer tokens = new StringTokenizer(temp, ",");
                 while (tokens.hasMoreTokens()) {
                    name=tokens.nextToken();
                    pool.add( new BitSetString(name) );
                 }
          }
          fr.close(); // <close the file>;
          } catch (IOException e) {
                System.out.println("IO Error:" + e.getMessage()); }
        System.out.println("Please enter a string that you want to search or quit to quit\n" + "\n\"");
        BufferedReader buf_in = new BufferedReader(new InputStreamReader(System.in));
        try {
           while ( null != ( temp = buf_in.readLine ()) ) {  
                temp = temp.trim();
                if (temp.equals("quit")) { System.exit(0);}
              
              userBitSet = new BitSetString(temp);
              boolean noneFoundYet = true;
              for( int i=0; i<pool.size(); i++ ){
                  if( ((BitSetString)pool.get(i)).containAll(userBitSet) ){
                     if( noneFoundYet ) {
                         System.out.println( "\n\"" +temp +"\" is entirely contained in:" );
                         noneFoundYet = false;
                     }
                   System.out.println( "> " +(BitSetString)pool.get(i) );
                 }
             }
             if( noneFoundYet ) {
                 System.out.println( "\n\"" +temp +"\" was not contained in any of the strings" );
             }
             System.out.println( "\n\"" + "Enter another name to search or quit to quit" +"\n");
           }
          } catch (IOException e) {
             System.out.println ("IO exception = " + e.getMessage());
      }
  }
}// endclass MyBitSetString


I made changes in the code after readling a line from the external file I used StringTokenizer to break
the input line into individual name or token and then used pool.add.

StringTokenizer tokens = new StringTokenizer(temp, ",");
                 while (tokens.hasMoreTokens()) {
                    name=tokens.nextToken();
                    pool.add( new BitSetString(name) );

Here is the output
Please enter a string that you want to search or quit to quit

"
jh

"jh" is entirely contained in:
> josh

"Enter another name to search or quit to quit

sam

"sam" was not contained in any of the strings

"Enter another name to search or quit to quit

jh

"jh" is entirely contained in:
> josh

"Enter another name to search or quit to quit

nick

"nick" is entirely contained in:
>  nick

"Enter another name to search or quit to quit

cory

"cory" is entirely contained in:
>  cory

"Enter another name to search or quit to quit



"" is entirely contained in:
> josh
>  cory
>  jesse
>  seth
>  nick
>  hens

"Enter another name to search or quit to quit

quit

This program output is exactly the way I want it. If the program found an exact or close match it prints only those not the entire line.

I understand its because of  StringTokenizer.

Q> Could you please tell me if there is any other way I could code this other than StringTokenizer so that entire line or sting does
not print like first program

Q> In both the program if I just hit enter its print the entire contents of the string why ?

Q> When I compile both the program from Dos prompt I get the following message. Could you please explain why?

C:\programs\java\applet>javac MyBitSetString.java
Note: MyBitSetString.java uses unchecked or unsafe operations.
Note: Recompile with -Xlint:unchecked for details.

C:\programs\java\applet>javac -Xlint MyBitSetString.java
MyBitSetString.java:59: warning: [unchecked] unchecked call to add(E) as a member
 of the raw type java.util.ArrayList
                      pool.add( new BitSetString(name) );
                              ^
1 warning


However when I use Eclipse I don't get this warning.

Thank a lot for all yours help

Hi JakobA,
    I am very thankful and delighted for yours help and I managed to successfully implemted the design you have suggested.

Perhaps you can tell me something about the following:

When a customer said -> in java keyword “New” tends to fragile code.

Could you please tell me why this above remark made?

What is a good design patterns that reduce the interclass dependencies?

Could you please show me pseudo code in java how this Design patterns could be used to substitute the use of the java keyword New

Thanks a lot.
Nick

Hi matthiashowell,
    Thank you very much for all yours help.  

Perhaps you can tell me something about the following:

When a customer said -> in java keyword “New” tends to fragile code.

Could you please tell me why this above remark made?

What is a good design patterns that reduce the interclass dependencies?

Could you please show me pseudo code in java how this Design patterns could be used to substitute the use of the java keyword New

Thanks
Nick