/** * Unit tests the {@code TrieST} data type. * * @param args the command-line arguments */ public static void main(String[] args) { // build symbol table from standard input TrieST<Integer> st = new TrieST<Integer>(); for (int i = 0; !StdIn.isEmpty(); i++) { String key = StdIn.readString(); st.put(key, i); } // print results if (st.size() < 100) { StdOut.println("keys(\"\"):"); for (String key : st.keys()) { StdOut.println(key + " " + st.get(key)); } StdOut.println(); } StdOut.println("longestPrefixOf(\"shellsort\"):"); StdOut.println(st.longestPrefixOf("shellsort")); StdOut.println(); StdOut.println("longestPrefixOf(\"quicksort\"):"); StdOut.println(st.longestPrefixOf("quicksort")); StdOut.println(); StdOut.println("keysWithPrefix(\"shor\"):"); for (String s : st.keysWithPrefix("shor")) StdOut.println(s); StdOut.println(); StdOut.println("keysThatMatch(\".he.l.\"):"); for (String s : st.keysThatMatch(".he.l.")) StdOut.println(s); }
public static void main(String[] args) { // key = word, value = set of files containing that word ST<String, SET<File>> st = new ST<String, SET<File>>(); // create inverted index of all files StdOut.println("Indexing files"); for (String filename : args) { StdOut.println(" " + filename); File file = new File(filename); In in = new In(file); while (!in.isEmpty()) { String word = in.readString(); if (!st.contains(word)) st.put(word, new SET<File>()); SET<File> set = st.get(word); set.add(file); } } // read queries from standard input, one per line while (!StdIn.isEmpty()) { String query = StdIn.readString(); if (st.contains(query)) { SET<File> set = st.get(query); for (File file : set) { StdOut.println(" " + file.getName()); } } } }
/** * Reads in a command-line integer and sequence of words from * standard input and prints out a word (whose length exceeds * the threshold) that occurs most frequently to standard output. * It also prints out the number of words whose length exceeds * the threshold and the number of distinct such words. * * @param args the command-line arguments */ public static void main(String[] args) { int distinct = 0, words = 0; int minlen = Integer.parseInt(args[0]); ST<String, Integer> st = new ST<String, Integer>(); // compute frequency counts while (!StdIn.isEmpty()) { String key = StdIn.readString(); if (key.length() < minlen) continue; words++; if (st.contains(key)) { st.put(key, st.get(key) + 1); } else { st.put(key, 1); distinct++; } } // find a key with the highest frequency count String max = ""; st.put(max, 0); for (String word : st.keys()) { if (st.get(word) > st.get(max)) max = word; } StdOut.println(max + " " + st.get(max)); StdOut.println("distinct = " + distinct); StdOut.println("words = " + words); }
/** * Reads the currency exchange table from standard input and * prints an arbitrage opportunity to standard output (if one exists). * * @param args the command-line arguments */ public static void main(String[] args) { // V currencies int V = StdIn.readInt(); String[] name = new String[V]; // create complete network EdgeWeightedDigraph G = new EdgeWeightedDigraph(V); for (int v = 0; v < V; v++) { name[v] = StdIn.readString(); for (int w = 0; w < V; w++) { double rate = StdIn.readDouble(); DirectedEdge e = new DirectedEdge(v, w, -Math.log(rate)); G.addEdge(e); } } // find negative cycle BellmanFordSP spt = new BellmanFordSP(G, 0); if (spt.hasNegativeCycle()) { double stake = 1000.0; for (DirectedEdge e : spt.negativeCycle()) { StdOut.printf("%10.5f %s ", stake, name[e.from()]); stake *= Math.exp(-e.weight()); StdOut.printf("= %10.5f %s\n", stake, name[e.to()]); } } else { StdOut.println("No arbitrage opportunity"); } }
/** * Unit tests the {@code BinarySearchST} data type. * * @param args the command-line arguments */ public static void main(String[] args) { BinarySearchST<String, Integer> st = new BinarySearchST<String, Integer>(); for (int i = 0; !StdIn.isEmpty(); i++) { String key = StdIn.readString(); st.put(key, i); } for (String s : st.keys()) StdOut.println(s + " " + st.get(s)); }
/** * Unit tests the {@code LinearProbingHashST} data type. * * @param args the command-line arguments */ public static void main(String[] args) { LinearProbingHashST<String, Integer> st = new LinearProbingHashST<String, Integer>(); for (int i = 0; !StdIn.isEmpty(); i++) { String key = StdIn.readString(); st.put(key, i); } // print keys for (String s : st.keys()) StdOut.println(s + " " + st.get(s)); }
public static void main(String[] args) { SET<String> set = new SET<String>(); // read in strings and add to set while (!StdIn.isEmpty()) { String key = StdIn.readString(); if (!set.contains(key)) { set.add(key); StdOut.println(key); } } }
/**/ public static void main(string[] strarr) { SET sET = new SET(); while (!StdIn.isEmpty()) { string text = StdIn.readString(); if (!sET.contains(text)) { sET.add(text); StdOut.println(text); } } }
public static void main(String[] args) { SET<String> set = new SET<String>(); // read in strings and add to set In in = new In(args[0]); while (!in.isEmpty()) { String word = in.readString(); set.add(word); } // read in string from standard input, printing out all exceptions while (!StdIn.isEmpty()) { String word = StdIn.readString(); if (!set.contains(word)) StdOut.println(word); } }
/** * Unit tests the {@code BST} data type. * * @param args the command-line arguments */ public static void main(String[] args) { BST<String, Integer> st = new BST<String, Integer>(); for (int i = 0; !StdIn.isEmpty(); i++) { String key = StdIn.readString(); if ((st.size() > 1) && (st.floor(key) != st.floor2(key))) throw new RuntimeException("floor() function inconsistent"); st.put(key, i); } for (String s : st.levelOrder()) StdOut.println(s + " " + st.get(s)); StdOut.println(); for (String s : st.keys()) StdOut.println(s + " " + st.get(s)); }
/**/ public static void main(string[] strarr) { SET sET = new SET(); In @in = new In(strarr[0]); while ([email protected]) { string text = @in.readString(); sET.add(text); } while (!StdIn.IsEmpty) { string text = StdIn.readString(); if (sET.contains(text)) { StdOut.println(text); } } }
/** * Unit tests the {@code TrieSET} data type. * * @param args the command-line arguments */ public static void main(String[] args) { TrieSET set = new TrieSET(); while (!StdIn.isEmpty()) { String key = StdIn.readString(); set.add(key); } // print results if (set.size() < 100) { StdOut.println("keys(\"\"):"); for (String key : set) { StdOut.println(key); } StdOut.println(); } StdOut.println("longestPrefixOf(\"shellsort\"):"); StdOut.println(set.longestPrefixOf("shellsort")); StdOut.println(); StdOut.println("longestPrefixOf(\"xshellsort\"):"); StdOut.println(set.longestPrefixOf("xshellsort")); StdOut.println(); StdOut.println("keysWithPrefix(\"shor\"):"); for (String s : set.keysWithPrefix("shor")) StdOut.println(s); StdOut.println(); StdOut.println("keysWithPrefix(\"shortening\"):"); for (String s : set.keysWithPrefix("shortening")) StdOut.println(s); StdOut.println(); StdOut.println("keysThatMatch(\".he.l.\"):"); for (String s : set.keysThatMatch(".he.l.")) StdOut.println(s); }
public static void main(String[] args) { int keyField = Integer.parseInt(args[1]); int valField = Integer.parseInt(args[2]); // symbol table ST<String, String> st = new ST<String, String>(); // read in the data from csv file In in = new In(args[0]); while (in.hasNextLine()) { String line = in.readLine(); String[] tokens = line.split(","); String key = tokens[keyField]; String val = tokens[valField]; st.put(key, val); } while (!StdIn.isEmpty()) { String s = StdIn.readString(); if (st.contains(s)) StdOut.println(st.get(s)); else StdOut.println("Not found"); } }