Frequency .java Word frequency counter package frequ.pdf

Frequency .java
/**
* Word frequency counter
*/
package frequency;
import java.util.Iterator;
/**
*
* @author UMD CS
*/
public class Frequency implements Iterable{
private Node first;
private int N;
Frequency(){
N = 0;
first = null;
}
@Override
public Iterator iterator() {
return new ListIterator();
}
/**
*
* List iterator
*
*/
private class ListIterator implements Iterator{
private Node current;
private int index ;
ListIterator(){
current = first;
index = 0;
}
@Override

public boolean hasNext() {
return current != null;
}
public String next() {
if(!hasNext()){
return null;
}
String word = current.key;
int count = current.count;
String r = "("+word + "," + Integer.toString(count)+")";
current = current.next;
return r;
}
@Override
public void remove() {
}
}
/**
*
* Node class
*
*/
private class Node {
private String key;
private int count;
private Node next;
Node(String item){
key = item;
count = 1;
next = null;
}
@Override
public String toString(){
return "("+key +","+count+")";

}
}
/*
* Inserts a word into the linked list. If the word exists, increment the
* count by q.
*/
public void insert(String word){
if(word.equals("")){
return;
}
//TODO
/*
* implement here
*/
}
/**
*
* @param str input string
* This method splits a string into words and pass the words to insert method
*
*/
public void insertWords(String str){
String delims = "[ .,?!'"()}{;/<>&=#-: _]+";
String[] words = str.split(delims);
for(String s: words){
s = s.toLowerCase();
insert(s);
}
}
/**
* prints the word frequency list
*/

public void print(){
Node c = first;
while(c != null){
System.out.print("("+c.key + "," + c.count+")");
c = c.next;
}
System.out.print(" ");
}
}
--------------------------------------------------------------------------------------------------------------------
------------------------------------------------------
WordFrequency.java
package frequency;
import utils.In;
import utils.Stopwatch;
/**
*
* @author UMD CS
*/
public class WordFrequency {
/**
* @param input source
* @param
* This method receives input resource and return the word frequency string
* DO NOT CHANGE THIS METHOD.
*/
public static String freq(String inputSource, int maxLines){
In in;
// Frequency class can only count the frequency of strings. DO NOT CHANGE THIS.
Frequency freq = new Frequency();
int MAX = 100;
String inputSourceName = inputSource;
try {
in = new In(inputSourceName);

while (!in.isEmpty()) {
String s = in.readLine();
//System.out.println(s);
freq.insertWords(s);
}
}
catch (Exception e) {
e.printStackTrace();
}
StringBuilder strFrequency = new StringBuilder();
int cnt = 0;
for(String s: freq){
strFrequency.append(s);
strFrequency.append(",");
cnt++;
if(cnt >= maxLines){break;}
}
return strFrequency.toString();
}
/**
*
*/
public static void main(String[] args) {
In in;
Frequency freq = new Frequency();
int MAX = 100;
// String inputSourceName =
"http://www.cs.umd.edu/class/summer2015/cmsc132/projects/P3_WordFrequency/test1.html";
String inputSourceName = "einstein.txt";
// read one line at a time from URL
System.out.println("read from " + inputSourceName);
System.out.println("---------------------------------------------------------------------------");

Stopwatch sw = new Stopwatch();
try {
in = new In(inputSourceName);
//System.out.println(s);
freq.insertWords(s);
}
}
catch (Exception e) {
e.printStackTrace();
}
System.out.println("Elapsed time:" + sw.elapsedTime());
int cnt = 0;
for(String s: freq){
System.out.println(s);
cnt++;
if(cnt >= MAX){break;}
}
}
}
--------------------------------------------------------------------------------------------------------------------
-----------------------------------------------------
TestSupport.java
package tests;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Scanner;
import javax.swing.JOptionPane;
public class TestsSupport {

/* Leave the following variable set to false. We use while developing the */
/* expected solutions for a test. If you change it to false you will corrupt */
/* your *.txt files containing expected results. */
private static boolean generateOfficialResults = false;
/**
* Feel free to use the correctResults method while developing your own tests.
* Notice that if you define text files with some expected results, the text
* files must be named starting with "studentTest" and ending with the .txt
* extension. If you don't name files this way, then the submit server will
* generate an authorization error.
* @param filename
* @param results
* @return true if the contents of the file corresponds to those in results
*/
public static boolean isCorrect(String filename, String results) {
officialUseIgnore(filename, results);
String officialResults="";
try {
BufferedReader fin = new BufferedReader(new FileReader(filename));
String line;
while ((line = fin.readLine()) != null) {
officialResults += line + " ";
}
fin.close();
}catch (IOException e) {
System.out.println("File operation in isCorrect failed.");
return false;
}
results = removeBlanks(results);
officialResults = removeBlanks(officialResults);
if (results.equals(officialResults)) {
return true;

}
return false;
}
public static boolean sameContents(String firstFile, String secondFile) {
if (removeBlanks(fileData(firstFile)).equals(removeBlanks(fileData(secondFile))))
return true;
return false;
}
public static String fileData(String fileName) {
StringBuffer stringBuffer = new StringBuffer();
try {
FileReader fileReader = new FileReader(fileName);
BufferedReader bufferedReader = new BufferedReader(fileReader);
Scanner fileScanner = new Scanner(bufferedReader);
while (fileScanner.hasNextLine())
stringBuffer.append(fileScanner.nextLine());
fileScanner.close();
} catch (IOException e) {
System.out.println(e.getMessage());
}
return stringBuffer.toString();
}
public static String removeBlanks(String src) {
StringBuffer resultsBuf = new StringBuffer();
char curr;
for (int i=0; iInput. This class provides methods for reading strings

* and numbers from standard input, file input, URLs, and sockets.
*
* The Locale used is: language = English, country = US. This is consistent
* with the formatting conventions with Java floating-point literals,
* command-line arguments (via {@link Double#parseDouble(String)})
* and standard output.
*
* For additional documentation, see
* Section 3.1 of
* Introduction to Programming in Java: An Interdisciplinary Approach
* by Robert Sedgewick and Kevin Wayne.
*
* Like {@link Scanner}, reading a token also consumes preceding Java
* whitespace, reading a full line consumes
* the following end-of-line delimeter, while reading a character consumes
* nothing extra.
*
* Whitespace is defined in {@link Character#isWhitespace(char)}. Newlines
* consist of , , , and Unicode hex code points 0x2028, 0x2029, 0x0085;
* see
* Scanner.java (NB: Java 6u23 and earlier uses only , , ).
*
* @author David Pritchard
* @author Robert Sedgewick
* @author Kevin Wayne
*/
public final class In {
private Scanner scanner;
/*** begin: section (1 of 2) of code duplicated from In to StdIn */
// assume Unicode UTF-8 encoding

private static final String CHARSET_NAME = "UTF-8";
// assume language = English, country = US for consistency with System.out.
private static final Locale LOCALE = Locale.US;
// the default token separator; we maintain the invariant that this value
// is held by the scanner's delimiter between calls
private static final Pattern WHITESPACE_PATTERN
= Pattern.compile("p{javaWhitespace}+");
// makes whitespace characters significant
private static final Pattern EMPTY_PATTERN
= Pattern.compile("");
// used to read the entire input. source:
// http://weblogs.java.net/blog/pat/archive/2004/10/stupid_scanner_1.html
private static final Pattern EVERYTHING_PATTERN
= Pattern.compile("A");
/*** end: section (1 of 2) of code duplicated from In to StdIn */
/**
* Create an input stream from standard input.
*/
public In() {
scanner = new Scanner(new BufferedInputStream(System.in), CHARSET_NAME);
scanner.useLocale(LOCALE);
}
/**
* Create an input stream from a socket.
*/
public In(java.net.Socket socket) {
try {
InputStream is = socket.getInputStream();
scanner = new Scanner(new BufferedInputStream(is), CHARSET_NAME);
}
catch (IOException ioe) {
System.err.println("Could not open " + socket);
}
}
/**

* Create an input stream from a URL.
*/
public In(URL url) {
try {
URLConnection site = url.openConnection();
InputStream is = site.getInputStream();
}
System.err.println("Could not open " + url);
}
}
/**
* Create an input stream from a file.
*/
public In(File file) {
try {
scanner = new Scanner(file, CHARSET_NAME);
}
System.err.println("Could not open " + file);
}
}
/**
* Create an input stream from a filename or web page name.
*/
public In(String s) {
try {
// first try to read file from local file system
File file = new File(s);
if (file.exists()) {
scanner = new Scanner(file, CHARSET_NAME);

return;
}
// next try for files included in jar
URL url = getClass().getResource(s);
// or URL from web
if (url == null) { url = new URL(s); }
URLConnection site = url.openConnection();
// in order to set User-Agent, replace above line with these two
// HttpURLConnection site = (HttpURLConnection) url.openConnection();
// site.addRequestProperty("User-Agent", "Mozilla/4.76");
InputStream is = site.getInputStream();
}
System.err.println("Could not open " + s);
}
}
/**
* Create an input stream from a given Scanner source; use with
* new Scanner(String) to read from a string.
*
* Note that this does not create a defensive copy, so the
* scanner will be mutated as you read on.
*/
public In(Scanner scanner) {
this.scanner = scanner;
}
/**
* Does the input stream exist?
*/
public boolean exists() {
return scanner != null;
}

/*** begin: section (2 of 2) of code duplicated from In to StdIn,
* with all methods changed from "public" to "public static" ***/
/**
* Is the input empty (except possibly for whitespace)? Use this
* to know whether the next call to {@link #readString()},
* {@link #readDouble()}, etc will succeed.
*/
public boolean isEmpty() {
return !scanner.hasNext();
}
/**
* Does the input have a next line? Use this to know whether the
* next call to {@link #readLine()} will succeed.
Functionally
* equivalent to {@link #hasNextChar()}.
*/
public boolean hasNextLine() {
return scanner.hasNextLine();
}
/**
* Is the input empty (including whitespace)? Use this to know
* whether the next call to {@link #readChar()} will succeed.
Functionally
* equivalent to {@link #hasNextLine()}.
*/
public boolean hasNextChar() {
scanner.useDelimiter(EMPTY_PATTERN);
boolean result = scanner.hasNext();
scanner.useDelimiter(WHITESPACE_PATTERN);
return result;
}
/**
* Read and return the next line.
*/
public String readLine() {

String line;
try { line = scanner.nextLine(); }
catch (Exception e) { line = null; }
return line;
}
/**
* Read and return the next character.
*/
public char readChar() {
scanner.useDelimiter(EMPTY_PATTERN);
String ch = scanner.next();
assert (ch.length() == 1) : "Internal (Std)In.readChar() error!"
+ " Please contact the authors.";
scanner.useDelimiter(WHITESPACE_PATTERN);
return ch.charAt(0);
}
/**
* Read and return the remainder of the input as a string.
*/
public String readAll() {
if (!scanner.hasNextLine())
return "";
String result = scanner.useDelimiter(EVERYTHING_PATTERN).next();
// not that important to reset delimeter, since now scanner is empty
scanner.useDelimiter(WHITESPACE_PATTERN); // but let's do it anyway
return result;
}
/**
* Read and return the next string.
*/
public String readString() {
return scanner.next();
}
/**

* Read and return the next int.
*/
public int readInt() {
return scanner.nextInt();
}
/**
* Read and return the next double.
*/
public double readDouble() {
return scanner.nextDouble();
}
/**
* Read and return the next float.
*/
public float readFloat() {
return scanner.nextFloat();
}
/**
* Read and return the next long.
*/
public long readLong() {
return scanner.nextLong();
}
/**
* Read and return the next short.
*/
public short readShort() {
return scanner.nextShort();
}
/**
* Read and return the next byte.
*/
public byte readByte() {
return scanner.nextByte();
}
/**

* Read and return the next boolean, allowing case-insensitive
* "true" or "1" for true, and "false" or "0" for false.
*/
public boolean readBoolean() {
String s = readString();
if (s.equalsIgnoreCase("true")) return true;
if (s.equalsIgnoreCase("false")) return false;
if (s.equals("1")) return true;
if (s.equals("0")) return false;
throw new InputMismatchException();
}
/**
* Read all strings until the end of input is reached, and return them.
*/
public String[] readAllStrings() {
// we could use readAll.trim().split(), but that's not consistent
// since trim() uses characters 0x00..0x20 as whitespace
String[] tokens = WHITESPACE_PATTERN.split(readAll());
if (tokens.length == 0 || tokens[0].length() > 0)
return tokens;
String[] decapitokens = new String[tokens.length-1];
for (int i = 0; i < tokens.length-1; i++)
decapitokens[i] = tokens[i+1];
return decapitokens;
}
/**
* Reads all remaining lines from input stream and returns them as an array of strings.
* @return all remaining lines on input stream, as an array of strings
*/
public String[] readAllLines() {
ArrayList lines = new ArrayList();
while (hasNextLine()) {
lines.add(readLine());
}
return lines.toArray(new String[0]);
}

/**
* Read all ints until the end of input is reached, and return them.
*/
public int[] readAllInts() {
String[] fields = readAllStrings();
int[] vals = new int[fields.length];
for (int i = 0; i < fields.length; i++)
vals[i] = Integer.parseInt(fields[i]);
return vals;
}
/**
* Read all doubles until the end of input is reached, and return them.
*/
public double[] readAllDoubles() {
String[] fields = readAllStrings();
double[] vals = new double[fields.length];
for (int i = 0; i < fields.length; i++)
vals[i] = Double.parseDouble(fields[i]);
return vals;
}
/*** end: section (2 of 2) of code duplicated from In to StdIn */
/**
* Close the input stream.
*/
public void close() {
scanner.close();
}
/**
* Reads all ints from a file
* @deprecated Clearer to use
* new In(filename).{@link #readAllInts()}
*/
public static int[] readInts(String filename) {

return new In(filename).readAllInts();
}
/**
* Reads all doubles from a file
* new In(filename).{@link #readAllDoubles()}
*/
public static double[] readDoubles(String filename) {
return new In(filename).readAllDoubles();
}
/**
* Reads all strings from a file
* new In(filename).{@link #readAllStrings()}
*/
public static String[] readStrings(String filename) {
return new In(filename).readAllStrings();
}
/**
* Reads all ints from stdin
* @deprecated Clearer to use {@link StdIn#readAllInts()}
*/
public static int[] readInts() {
return new In().readAllInts();
}
/**
* Reads all doubles from stdin
* @deprecated Clearer to use {@link StdIn#readAllDoubles()}
*/
public static double[] readDoubles() {
return new In().readAllDoubles();
}
/**
* Reads all strings from stdin
* @deprecated Clearer to use {@link StdIn#readAllStrings()}
*/

public static String[] readStrings() {
return new In().readAllStrings();
}
/**
* Test client.
*/
public static void main(String[] args) {
In in;
String urlName = "test1.txt";
// read from a URL
System.out.println("readAll() from URL " + urlName);
try {
in = new In(urlName);
System.out.println(in.readAll());
}
catch (Exception e) { System.out.println(e); }
System.out.println();
// read one line at a time from URL
System.out.println("readLine() from URL " + urlName);
try {
}
}
// read one string at a time from URL
System.out.println("readString() from URL " + urlName);
try {

String s = in.readString();
}
}
// read one line at a time from file in current directory
System.out.println("readLine() from current directory");
try {
in = new In("test1.txt");
}
}
// read one line at a time from file using relative path
System.out.println("readLine() from relative path");
try {
}
}
// read one char at a time
System.out.println("readChar() from file");

try {
char c = in.readChar();
System.out.print(c);
}
}
// read one line at a time from absolute OS X / Linux path
System.out.println("readLine() from absolute OS X / Linux path");
try {
}
}
// read one line at a time from absolute Windows path
System.out.println("readLine() from absolute Windows path");
try {
}
}

}
}
/*************************************************************************
* Copyright 2002-2012, Robert Sedgewick and Kevin Wayne.
*
* This file is part of stdlib-package.jar, which accompanies the textbook
*
* by R. Sedgewick and K. Wayne, Addison-Wesley, 2007. ISBN 0-321-49805-4.
*
* http://introcs.cs.princeton.edu
*
*
* stdlib-package.jar is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* stdlib-package.jar is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
* You should have received a copy of the GNU General Public License
* along with stdlib-package.jar. If not, see http://www.gnu.org/licenses.
*************************************************************************/
--------------------------------------------------------------------------------------------------------------------
------------------------------------------------------
StopWatch.java
package utils;
/*************************************************************************
* Compilation: javac Stopwatch.java
*
*
*************************************************************************/

/**
* Stopwatch. This class is a data type for measuring
* the running time (wall clock) of a program.
*
* For additional documentation, see
* Section 3.2 of
* by Robert Sedgewick and Kevin Wayne.
*/
public class Stopwatch {
private final long start;
/**
* Create a stopwatch object.
*/
public Stopwatch() {
start = System.currentTimeMillis();
}
/**
* Return elapsed time (in seconds) since this object was created.
*/
public double elapsedTime() {
long now = System.currentTimeMillis();
return (now - start) / 1000.0;
}
}
/*************************************************************************
* Copyright 2002-2012, Robert Sedgewick and Kevin Wayne.
*
* This file is part of stdlib-package.jar, which accompanies the textbook
*
* by R. Sedgewick and K. Wayne, Addison-Wesley, 2007. ISBN 0-321-49805-4.
*

* http://introcs.cs.princeton.edu
*
*
* stdlib-package.jar is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* stdlib-package.jar is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
* You should have received a copy of the GNU General Public License
* along with stdlib-package.jar. If not, see http://www.gnu.org/licenses.
*************************************************************************/
--------------------------------------------------------------------------------------------------------------------
------------------------------------------------------
publictest.java
package tests;
import static org.junit.Assert.*;
import org.junit.Test;
import frequency.WordFrequency;
public class PublicTests {
@Test
public void testEinstein() {
String answer = WordFrequency.freq("einstein.txt",20);
assertTrue(TestsSupport.isCorrect("pubEinstein.txt", answer));
}
@Test
public void test1() {
String answer = WordFrequency.freq("test1.txt",10);
assertTrue(TestsSupport.isCorrect("pubTest1.txt", answer));
}
@Test

public void testSyllabus() {
String answer =
WordFrequency.freq("https://www.cs.umd.edu/class/summer2015/cmsc132/syllabus.shtml",20
0);
assertTrue(TestsSupport.isCorrect("pubSyllabus.txt", answer));
}
@Test
public void testWar_peace() {
String answer = WordFrequency.freq("war_peace.txt",50);
assertTrue(TestsSupport.isCorrect("pubWar_peace.txt", answer));
}
}
--------------------------------------------------------------------------------------------------------------------
-----------------------------------------------
Java code is not working please help
Solution
You have not implemented the above function thats why it was not getting passed.
Apart from that there is condition in WordFrequency.java where you will output maximum of
100 data. So mind that too. Apart from that I don't have any of those files so I can't check it. If
you have any doubt ask me. And next time please give those text file so i can test.

Frequency .java Word frequency counter package frequ.pdf

More Related Content

Similar to Frequency .java Word frequency counter package frequ.pdf (20)

More from arshiartpalace (20)

Recently uploaded (20)

Frequency .java Word frequency counter package frequ.pdf