2. void wordinformation() 
3. {
4.   
5. for (Enumeration e = words.containsKey(s) ; e.hasMoreElements() 
6. {
7. String name = e.nextElement().toString();
8. Word w = (w)words.get(name);
9. println(w.txt + ":" + w.count);
10. }
11. }
 

1. String[] lines = loadStrings("input.txt");
   println(“there are “ + lines.length + ” lines”);
   
   
   I need to print this in the same output file 
   How i can do that

1. println(“there are “ + lines.length + ” lines”);

1. void wordinformation() 
2. {
3.   
4. for (Enumeration e = words.containsKey(s) ; e.hasMoreElements() 
5. {
6. String name = e.nextElement().toString();
7. Word w = (w)words.get(name);
8. println(w.s+ ":" + w.count);
9. }
10. }
2. where I can call this function to print frequent and count in the output file

2. String lines[];
3. String list[];
4. //================================================= 
5. void setup() {
6.   lines = loadStrings("input.txt");
7.   
8.   println("there are " + lines.length + " lines");
9.  
10.   Words words = new Words();
11.  
12.   for (int i=0; i < lines.length; i++) 
13.   {
14.     list = split(lines[i]);
15.     for (int j=0; j < list.length; j++) {
16.       words.addWord(list[j]);
17.     }
18.   }
19.   words.printWords();
20. }
21.  
22. class Words {
23.  Hashtable ht=new Hashtable();
24. //======================================================== 
25.  void addWord(String s) {
26.    Word word;
27.    if (ht.containsKey(s)) {
28.      word = (Word)ht.get(s);
29.      word.count++;   
30.    } else {
31.      word = new Word(s);     
32.    }
33.    ht.put(s,word); 
34.  }
35. //=========================================================== 
36.  void printWords() {
37.    for (Enumeration e = ht.keys() ; e.hasMoreElements() ;)
38.    {
39.      String name = e.nextElement().toString();
40.      Word word = (Word)ht.get(name);
41.      println(word.s + ": " + word.count);
42.    }   
43.   }
44. }
45.  //================================================
46. class Word {
47.   public String s;
48.   public int
49.   count = 1;
50.   Word(String s) {
51.     this.s = s;
52.   }
53. }

1. list = splitTokens(lines[i], " ,.?!:;[]-");

2. void printWords() {
3.    for (Enumeration e = ht.keys() ; e.hasMoreElements() ;)
4.    {
5.      PrintWriter writer = createWriter("result.txt");
6.      writer.println("This is my data");
7.      String name = e.nextElement().toString();
8.      Word word = (Word)ht.get(name);
9.       writer.println(word.s + ": " + word.count);
10.    }   
11.   }
12. }
13. 
    

2. void writeData() {
3.   PrintWriter writer = createWriter("output.txt");
4.   writer.println("This is my data");
5.   for (int i = 0; i < list.length; i++) {
6.     String w= "\"" + word.s + "\"";
7.     String c= "\"" + word.count + "\"";
8.     writer.println(TAB + w+ " :: " + c+ ";");
9.   }
10.   writer.flush();
11.   writer.close();
12. }

1.  String w= "\"" + word.s + "\"";
2.     String c= "\"" + word.count + "\"";

1.       saveStrings("result.txt", word.count);// there are error

2.  void printWords()
3.  {
4.    for (Enumeration e = ht.keys() ; e.hasMoreElements() ;)
5.  {
6.      String name = e.nextElement().toString();
7.      Word word = (Word)ht.get(name);
8.      println(word.txt + " : " + word.count);
9.       }   
10.   }
11. }
12.  

1.  String[] output = ""; //Create a String array to store the output

               

                
  String[] sentences ;
                


                
  for (String sentence : sentences)
                
  {
                
    println(sentence);
                
  }
               

How i can put the sentences in  String[] sentences ;

1. String[] sentences ;
2. 
   
3.      sentences = splitTokens("input.txt", "."); //Split the input by periods "."
4.     for (String sentence : sentences)
5.   {
6.     println(sentence);
7.   }

1. 1. Word word = words.get(w); // Get it from the list
   2.     if (word == null) // Not found
   3.     {
   4.       // Create a new word
   5.       word = new Word(w, pos);
   6.       words.put(w, word);
   7.     }
   8.     else
   9.     {
   10.       // Update it directly in the hash map
   11.       word.add(pos);
   12.     }

2.   WordList.add()

2. String[] stopWordList = { "all", "and", "are", "as", "at", "be", "but", "by", "do", "done,",
3.   "for", "from", "he", "her", "him", "in", "is", "it", "of", "or", "our", "me", "my", "no", "not", "on",
4.   "she", "so", "that", "the", "there", "they", "this", "to", "too", "you", "your"
5. }; // And so on...
6. 
   
7. void setup()
8. {
9.   String[] lines = loadStrings("input.txt");
10. 
    
11.   println("Read " + lines.length + " lines");
12. 
    
13.   WordList words = new WordList();
14.   for (String line : lines)
15.   {
16.     // Get rid of non-alphabetical chars
17.     line = line.replaceAll("[^a-zA-Z -]", " ");
18.     // Collapse multiple spaces into one
19.     line = line.replaceAll(" +", " ").toLowerCase();
20.     String[] wordList = split(line, ' ');
21.     // Add the words of the line
22.     for (String word : wordList)
23.     {
24.       words.add(word);
25.     }
26.   }
27.   words.print();
28.   words.export("output.txt");
29.   exit();
30. }
31. 
    
32. class WordList
33. {
34.   // Simple class to store a word and its count in a collection
35.   // Internal as we don't need to expose it to the outer world...
36.    class Word
37.   {
38.     String w;
39.     ArrayList<Integer> sentenceNbs = new ArrayList<Integer>();
40. 
    
41.     Word(String s, int pos)
42.     {
43.       w = s;
44.       add(pos);
45.     }
46.  
47.     void add(int pos)
48.     {
49.       sentenceNbs.add(pos);
50.     }
51. 
    
52.     // Allows to get a human readable string out of the object
53.     String toString()
54.     {
55.       return w + "\t" + sentenceNbs.size() + "\t" + sentenceNbs;
56.     }
57.  
58.   WordList.add()
59.   {
60.     Word word = words.get(w); // Get it from the list
61.     if (word == null) // Not found
62.     {
63.       // Create a new word
64.       word = new Word(w, pos);
65.       words.put(w, word);
66.     }
67.     else
68.     {
69.       // Update it directly in the hash map
70.       word.add(pos);
71.     }
72.   }
73.   
74.   
75.   // List of words and their count, with unicity guarantee
76.   HashMap<String, Word> words = new HashMap<String, Word>();
77.   // List of stop words, with quick check if a given string is part of this list
78.   HashSet<String> stopWords = new HashSet<String>();
79. 
    
80.   WordList()
81.   {
82.     // Build the stop word structure
83.     stopWords.addAll(Arrays.asList(stopWordList));
84.     // Simple check...
85.     println(stopWords);
86.   }
87. 
    
88.   // Add a word
89.   void add(String w)
90.   {
91.     if (w.length() < 2)
92.       return; // Exclude 0 or 1 sized words
93.     if (stopWords.contains(w))
94.       return; // Exclude known stop words
95. 
    
96.     Word word = words.get(w); // Get it from the list
97.     if (word == null) // Not found
98.     {
99.       // Create a new word
100.       word = new Word(w);
101.       words.put(w, word);
102.     }
103.     else
104.     {
105.       // Update it directly in the hash map
106.       word.count++;
107.     }
108.   }
109. 
     
110.   // Print out the list on the console
111.   void print()
112.   {
113.     // List of the values
114.     Collection<Word> values = words.values();
115.     for (Word word : values)
116.     {
117.       // Print frequent words
118.       if (word.count > 1)
119.       {
120.         println(word); // Calls toString() automatically
121.       }
122.     }
123.   }
124. 
     
125.   // Export the list to a file
126.   void export(String file)
127.   {
128.     Collection<Word> values = words.values();
129.     int nb = values.size();
130.     String[] allWordList = new String[nb];
131.     int c = 0;
132.     for (Word word : values)
133.     {
134.       if (word.count > 1)
135.       {
136.         allWordList[c++] = word.toString(); // Must call explicitly here
137.       }
138.     }
139.     // Make a copy of the array, truncated to the real size
140.     String[] out = Arrays.copyOf(allWordList, c);
141.     // and save it to the file
142.     saveStrings(file, out);
143.   }
144. }

3. String[] stopWordList = { "all", "and", "are", "as", "at", "be", "but", "by", "do", "done,",
4.   "for", "from", "he", "her", "him", "in", "is", "it", "of", "or", "our", "me", "my", "no", "not", "on",
5.   "she", "so", "that", "the", "there", "they", "this", "to", "too", "you", "your"
6. }; // And so on...
7. 
   
8. void setup()
9. {
10.   String[] lines = loadStrings("input.txt");
11. 
    
12.   println("Read " + lines.length + " lines");
13. 
    
14.   WordList words = new WordList();
15.   for (String line : lines)
16.   {
17.     // Get rid of non-alphabetical chars
18.     line = line.replaceAll("[^a-zA-Z -]", " ");
19.     // Collapse multiple spaces into one
20.     line = line.replaceAll(" +", " ").toLowerCase();
21.     String[] wordList = split(line, ' ');
22.     // Add the words of the line
23.     for (String word : wordList)
24.     {
25.       words.add(word);
26.     }
27.   }
28.   words.print();
29.   words.export("output.txt");
30.   exit();
31. }
32. 
    
33. class WordList
34. {
35.   // Simple class to store a word and its count in a collection
36.   // Internal as we don't need to expose it to the outer world...
37.   class Word
38.   {
39.     String w;
40.     ArrayList<Integer> sentenceNbs = new ArrayList<Integer>();
41. 
    
42.     Word(String s, int pos)
43.     {
44.       w = s;
45.       add(pos);
46.     }
47.  
48.     void add(int pos)
49.     {
50.       sentenceNbs.add(pos);
51.     }
52. 
    
53.     // Allows to get a human readable string out of the object
54.     String toString()
55.     {
56.       return w + "\t" + sentenceNbs.size() + "\t" + sentenceNbs;
57.     }
58.   }
59.   // List of words and their count, with unicity guarantee
60.   HashMap<String, Word> words = new HashMap<String, Word>();
61.   // List of stop words, with quick check if a given string is part of this list
62.   HashSet<String> stopWords = new HashSet<String>();
63. 
    
64.   WordList()
65.   {
66.     // Build the stop word structure
67.     stopWords.addAll(Arrays.asList(stopWordList));
68.     // Simple check...
69.     println(stopWords);
70.   }
71. 
    
72.   // Add a word
73.   void add(String w)
74.   {
75.     if (w.length() < 2)
76.       return; // Exclude 0 or 1 sized words
77.     if (stopWords.contains(w))
78.       return; // Exclude known stop words
79. 
    
80.     Word word = words.get(w); // Get it from the list
81.              int pos;
82. 
    
83.     if (word == null) // Not found
84.     {
85. 
    
86. 
    
87.       // Create a new word
88. 
    
89.       word = new Word(w, pos);
90.       words.put(w, word);
91.     }
92.     else
93.     {
94.       // Update it directly in the hash map
95.       word.add(pos);
96.   }
97.   }
98. 
    
99.   // Print out the list on the console
100.   void print()
101.   {
102.     // List of the values
103.     Collection<Word> values = words.values();
104.     for (Word word : values)
105.     {
106.       // Print frequent words
107.       if (word.count > 1)
108.       {
109.         println(word); // Calls toString() automatically
110.       }
111.     }
112.   }
113. 
     
114.   // Export the list to a file
115.   void export(String file)
116.   {
117.     Collection<Word> values = words.values();
118.     int nb = values.size();
119.     String[] allWordList = new String[nb];
120.     int c = 0;
121.     for (Word word : values)
122.     {
123.       if (word.count > 1)
124.       {
125.         allWordList[c++] = word.toString(); // Must call explicitly here
126.       }
127.     }
128.     // Make a copy of the array, truncated to the real size
129.     String[] out = Arrays.copyOf(allWordList, c);
130.     // and save it to the file
131.     saveStrings(file, out);
132.   }
133. }

2.       word = new Word(w, pos);

2.       if (word.count > 2)

2. String[] tokens;  // Array of all words from input file
3. PFont f;
4. 
   
5. String[] ignore = { "only","to", "For example","can","for","of","is","as","a","the","that","an", "the", "i", "it", "you", "and", "to","in","on","you","they","for","from","to","which", };
6. 
   
7. boolean ignoreWord(String what) {
8.   for (int i = 0; i < ignore.length; i++) {
9.   
10.    if (what.equals(ignore[i])) {
11.           if (what.toLowerCase().equals(ignore[i])) {
12. 
    
13.       return true;
14.     }
15.   }
16.   return false;
17. }
18. 
    
19. void setup() {
20. 
    
21.       String[] output = new String[0]; 
22. 
    
23.   // Load file and chop it up
24.   String[] lines = loadStrings("input.txt");
25.   
26.    for(int i = 0; i < lines.length; i ++) 
27.   {
28.     
29.   if(ignoreWord(lines[i])) 
30.   {
31.     String A = lines[i];
32.     A = A.replace(lines[i],"");
33.     println(A);
34.      
35.     String[] before = subset(tokens, 0, i);
36.     String[] after = subset(tokens, min(i + 1, tokens.length), tokens.length - 1 - i);
37.    
38.     tokens = concat(before, after);
39.     i --;
40.     
41.       output = append(outputText,"what i shoud to put here");
42.       saveStrings("result.txt", output);  
43. 
    
44.   
45.   f = createFont("Georgia", 36, true);  
46. }

2. // string array included all the common words
3. 
   
4. String[] ignore = {"only", "to", "For example", "can", "for", "of", "is", "as", "a", "the", "that", "an", "the", "i", "it", "you", "and", "to", "in", "on", "you", "they", "for", "from", "to", "which",
5. };
6. // function to  check if common word and replace it
7. string  ignoreWord(String a)
8. {
9.   for (int i = 0; i < ignore.length; i++) {
10.     if (a.toLowerCase().equals(ignore[i])) {
11.       return ( ignore[i] = ignore[i].replace(ignore[i], ""));
12.     }
13.   }
14.  
15.   return ;
16. }
17. 
    
18. 
    
19. void setup() {
20. 
    
21.   String[] output = new String[0];
22.   // Load file and chop it up
23.   
24.   String[] lines = loadStrings("input.txt");
25.   //for to go through all words 
26.   for(int i = 0; i < lines.length; i ++) 
27.   {
28.        if (ignoreWord(lines[i]))
29.     {
30.       println(lines[i]);
31.       i --;
32.        }
33.   }
34.  
35.   saveStrings("result.txt", output);
36. }

2. String ignoreWord(String a)
3. 
   
4. {
5.   for (int i = 0; i < ignore.length; i++) {
6.     if (a.toLowerCase().equals(ignore[i])) {
7.        ignore[i] = ignore[i].replace(ignore[i], " ");
8.       return ignore[i];
9.     }
10.   }
11.  
12.   }

1.   else return ignore[i]=(" "); 

1.  return ignore[i]=(" ");

2.        if (ignoreWord(lines[i]))

2. String[] tokens;  // Array of all words from input file
3. 
   
4. String[] ignore = {
5.   "only", "to", "For example", "can", "for", "of", "is", "as", "a", "the", "that", "an", "the", "i", "it", "you", "and", "to", "in", "on", "you", "they", "for", "from", "to", "which",
6. };
7. 
   
8. 
   
9. boolean ignoreWord(String what) {
10.   for (int i = 0; i < ignore.length; i++) {
11.     if (what.toLowerCase().equals(ignore[i])) {
12.       return true;
13.     }
14.   }
15.  
16.   return false;
17. }
18. 
    
19. //===========================================
20. 
    
21. void setup() {
22.   String[] output = new String[0];
23.   // Load file and chop it up
24.   String[] lines = loadStrings("input.txt");
25.   for(int i = 0; i < lines.length; i ++) {
26.    
27.     if (ignoreWord(lines[i]))
28.     {
29.       String A = lines[i];
30.       A = A.replace(lines[i], "");
31.       println(A);
32.       String[] before = subset(tokens, 0, i);
33.       String[] after = subset(tokens, min(i + 1, tokens.length), tokens.length - 1 - i);
34.       tokens = concat(before, after);
35.       i --;
36.       output = append(output, "");
37.     }
38.   }
39.  
40.   saveStrings("result.txt", output);
41. }

2. String[] tokens;  // Array of all words from input file
3. 
   
4. String[] ignore = {"only", "to", "For example", "can", "for", "of", "is", "as", "a", "the", "that", "an", "the", "i", "it", "you", "and", "to", "in", "on", "you", "they", "for", "from", "to", "which",
5. };
6. PFont f;
7. 
   
8. 
   
9. boolean ignoreWord(String what) {
10.   for (int i = 0; i < ignore.length; i++) {
11.     if (what.toLowerCase().equals(ignore[i])) {
12.       return true;
13.     }
14.   }
15.  
16.   return false;
17. }
18. 
    
19. //===========================================
20. 
    
21. void setup() 
22. {
23.   String[] output = new String[0];
24.   // Load file and chop it up
25.   String[] lines = loadStrings("input.txt");
26.   String allText = join(lines, " ");
27.   tokens = splitTokens(allText, " ,.?!:;[]-");
28.   for(int i = 0; i < tokens.length; i ++) 
29.   {
30.      if(ignoreWord(tokens[i])) 
31.   {
32.      tokens[i] = tokens[i].replace(tokens[i], "");
33.       println(i);
34.    
35.     String[] before = subset(tokens, 0, i);
36.     String[] after = subset(tokens, min(i + 1, tokens.length), tokens.length - 1 - i);
37.    
38.     tokens = concat(before, after);
39.     i --;
40.   }
41. }
42.   
43.   f = createFont("Georgia", 36, true);  
44.   output = append(output, tokenes[i]);
45.    saveStrings("result.txt", output);
46. 
    
47.     }
48.  

2.   output = append(output, tokens);

1.   output = append(output, tokens[i]);

2. WordAnalysis analysis;
3. }
4.  void setup() 
5. {
6.   analysis = new WordAnalysis();
7.    String[] lines = loadStrings("input.txt");
8.    String allText = join(lines, " ");
9.   String[] wordList = split(allText, " ");
10.   
11.   for (int i = 1; i < wordList.length; i++) 
12.    {
13.       println(wordList[i]);
14. }