\n * This implementation uses a singly-linked list with a static nested class Node.\n * See {@link LinkedBag} for the version from the\n * textbook that uses a non-static nested class.\n * The add, isEmpty, and size operations\n * take constant time. Iteration takes time proportional to the number of items.\n *
\n * For additional documentation, see Section 1.3 of\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n *\n * @param \n * The indexOf operations takes logarithmic time in the worst case.\n * \n * For additional documentation, see Section 1.1 of\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic class BinarySearch {\n\n /**\n * This class should not be instantiated.\n */\n private BinarySearch() { }\n\n /**\n * Returns the index of the specified key in the specified array.\n *\n * @param a the array of integers, must be sorted in ascending order\n * @param key the search key\n * @return index of key in array {@code a} if present; {@code -1} otherwise\n */\n public static int indexOf(int[] a, int key) {\n int lo = 0;\n int hi = a.length - 1;\n while (lo <= hi) {\n // Key is in a[lo..hi] or not present.\n int mid = lo + (hi - lo) / 2;\n if (key < a[mid]) hi = mid - 1;\n else if (key > a[mid]) lo = mid + 1;\n else return mid;\n }\n return -1;\n }\n\n /**\n * Returns the index of the specified key in the specified array.\n * This function is poorly named because it does not give the rank\n * if the array has duplicate keys or if the key is not in the array.\n *\n * @param key the search key\n * @param a the array of integers, must be sorted in ascending order\n * @return index of key in array {@code a} if present; {@code -1} otherwise\n * @deprecated Replaced by {@link #indexOf(int[], int)}.\n */\n @Deprecated\n public static int rank(int key, int[] a) {\n return indexOf(a, key);\n }\n\n /**\n * Reads in a sequence of integers from the whitelist file, specified as\n * a command-line argument; reads in integers from standard input;\n * prints to standard output those integers that do not appear in the file.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n\n // read the integers from a file\n In in = new In(args[0]);\n int[] whitelist = in.readAllInts();\n\n // sort the array\n Arrays.sort(whitelist);\n\n // read integer key from standard input; print if not in whitelist\n while (!StdIn.isEmpty()) {\n int key = StdIn.readInt();\n if (BinarySearch.indexOf(whitelist, key) == -1)\n StdOut.println(key);\n }\n }\n}\n\n/******************************************************************************\n * Copyright 2002-2016, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "code/algs4/BinaryStdIn.java",
"content": "/******************************************************************************\n * Compilation: javac BinaryStdIn.java\n * Execution: java BinaryStdIn < input > output\n * Dependencies: none \n * \n * Supports reading binary data from standard input.\n *\n * % java BinaryStdIn < input.jpg > output.jpg\n * % diff input.jpg output.jpg\n *\n ******************************************************************************/\n\npackage algs4;\n\nimport java.io.BufferedInputStream;\nimport java.io.IOException;\nimport java.util.NoSuchElementException;\n\n/**\n * Binary standard input. This class provides methods for reading\n * in bits from standard input, either one bit at a time (as a {@code boolean}),\n * 8 bits at a time (as a {@code byte} or {@code char}),\n * 16 bits at a time (as a {@code short}), 32 bits at a time\n * (as an {@code int} or {@code float}), or 64 bits at a time (as a\n * {@code double} or {@code long}).\n * \n * All primitive types are assumed to be represented using their \n * standard Java representations, in big-endian (most significant\n * byte first) order.\n * \n * The client should not intermix calls to {@code BinaryStdIn} with calls\n * to {@code StdIn} or {@code System.in};\n * otherwise unexpected behavior will result.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic final class BinaryStdIn {\n private static BufferedInputStream in = new BufferedInputStream(System.in);\n private static final int EOF = -1; // end of file\n\n private static int buffer; // one character buffer\n private static int n; // number of bits left in buffer\n\n // static initializer\n static {\n fillBuffer();\n }\n\n // don't instantiate\n private BinaryStdIn() { }\n\n private static void fillBuffer() {\n try {\n buffer = in.read();\n n = 8;\n }\n catch (IOException e) {\n System.out.println(\"EOF\");\n buffer = EOF;\n n = -1;\n }\n }\n\n /**\n * Close this input stream and release any associated system resources.\n */\n public static void close() {\n try {\n in.close();\n }\n catch (IOException ioe) {\n throw new IllegalStateException(\"Could not close BinaryStdIn\", ioe);\n }\n }\n\n /**\n * Returns true if standard input is empty.\n * @return true if and only if standard input is empty\n */\n public static boolean isEmpty() {\n return buffer == EOF;\n }\n\n /**\n * Reads the next bit of data from standard input and return as a boolean.\n *\n * @return the next bit of data from standard input as a {@code boolean}\n * @throws NoSuchElementException if standard input is empty\n */\n public static boolean readBoolean() {\n if (isEmpty()) throw new NoSuchElementException(\"Reading from empty input stream\");\n n--;\n boolean bit = ((buffer >> n) & 1) == 1;\n if (n == 0) fillBuffer();\n return bit;\n }\n\n /**\n * Reads the next 8 bits from standard input and return as an 8-bit char.\n * Note that {@code char} is a 16-bit type;\n * to read the next 16 bits as a char, use {@code readChar(16)}.\n *\n * @return the next 8 bits of data from standard input as a {@code char}\n * @throws NoSuchElementException if there are fewer than 8 bits available on standard input\n */\n public static char readChar() {\n if (isEmpty()) throw new NoSuchElementException(\"Reading from empty input stream\");\n\n // special case when aligned byte\n if (n == 8) {\n int x = buffer;\n fillBuffer();\n return (char) (x & 0xff);\n }\n\n // combine last n bits of current buffer with first 8-n bits of new buffer\n int x = buffer;\n x <<= (8 - n);\n int oldN = n;\n fillBuffer();\n if (isEmpty()) throw new NoSuchElementException(\"Reading from empty input stream\");\n n = oldN;\n x |= (buffer >>> n);\n return (char) (x & 0xff);\n // the above code doesn't quite work for the last character if n = 8\n // because buffer will be -1, so there is a special case for aligned byte\n }\n\n /**\n * Reads the next r bits from standard input and return as an r-bit character.\n *\n * @param r number of bits to read.\n * @return the next r bits of data from standard input as a {@code char}\n * @throws NoSuchElementException if there are fewer than {@code r} bits available on standard input\n * @throws IllegalArgumentException unless {@code 1 <= r <= 16}\n */\n public static char readChar(int r) {\n if (r < 1 || r > 16) throw new IllegalArgumentException(\"Illegal value of r = \" + r);\n\n // optimize r = 8 case\n if (r == 8) return readChar();\n\n char x = 0;\n for (int i = 0; i < r; i++) {\n x <<= 1;\n boolean bit = readBoolean();\n if (bit) x |= 1;\n }\n return x;\n }\n\n /**\n * Reads the remaining bytes of data from standard input and return as a string. \n *\n * @return the remaining bytes of data from standard input as a {@code String}\n * @throws NoSuchElementException if standard input is empty or if the number of bits\n * available on standard input is not a multiple of 8 (byte-aligned)\n */\n public static String readString() {\n if (isEmpty()) throw new NoSuchElementException(\"Reading from empty input stream\");\n\n StringBuilder sb = new StringBuilder();\n while (!isEmpty()) {\n char c = readChar();\n sb.append(c);\n }\n return sb.toString();\n }\n\n\n /**\n * Reads the next 16 bits from standard input and return as a 16-bit short.\n *\n * @return the next 16 bits of data from standard input as a {@code short}\n * @throws NoSuchElementException if there are fewer than 16 bits available on standard input\n */\n public static short readShort() {\n short x = 0;\n for (int i = 0; i < 2; i++) {\n char c = readChar();\n x <<= 8;\n x |= c;\n }\n return x;\n }\n\n /**\n * Reads the next 32 bits from standard input and return as a 32-bit int.\n *\n * @return the next 32 bits of data from standard input as a {@code int}\n * @throws NoSuchElementException if there are fewer than 32 bits available on standard input\n */\n public static int readInt() {\n int x = 0;\n for (int i = 0; i < 4; i++) {\n char c = readChar();\n x <<= 8;\n x |= c;\n }\n return x;\n }\n\n /**\n * Reads the next r bits from standard input and return as an r-bit int.\n *\n * @param r number of bits to read.\n * @return the next r bits of data from standard input as a {@code int}\n * @throws NoSuchElementException if there are fewer than {@code r} bits available on standard input\n * @throws IllegalArgumentException unless {@code 1 <= r <= 32}\n */\n public static int readInt(int r) {\n if (r < 1 || r > 32) throw new IllegalArgumentException(\"Illegal value of r = \" + r);\n\n // optimize r = 32 case\n if (r == 32) return readInt();\n\n int x = 0;\n for (int i = 0; i < r; i++) {\n x <<= 1;\n boolean bit = readBoolean();\n if (bit) x |= 1;\n }\n return x;\n }\n\n /**\n * Reads the next 64 bits from standard input and return as a 64-bit long.\n *\n * @return the next 64 bits of data from standard input as a {@code long}\n * @throws NoSuchElementException if there are fewer than 64 bits available on standard input\n */\n public static long readLong() {\n long x = 0;\n for (int i = 0; i < 8; i++) {\n char c = readChar();\n x <<= 8;\n x |= c;\n }\n return x;\n }\n\n\n /**\n * Reads the next 64 bits from standard input and return as a 64-bit double.\n *\n * @return the next 64 bits of data from standard input as a {@code double}\n * @throws NoSuchElementException if there are fewer than 64 bits available on standard input\n */\n public static double readDouble() {\n return Double.longBitsToDouble(readLong());\n }\n\n /**\n * Reads the next 32 bits from standard input and return as a 32-bit float.\n *\n * @return the next 32 bits of data from standard input as a {@code float}\n * @throws NoSuchElementException if there are fewer than 32 bits available on standard input\n */\n public static float readFloat() {\n return Float.intBitsToFloat(readInt());\n }\n\n\n /**\n * Reads the next 8 bits from standard input and return as an 8-bit byte.\n *\n * @return the next 8 bits of data from standard input as a {@code byte}\n * @throws NoSuchElementException if there are fewer than 8 bits available on standard input\n */\n public static byte readByte() {\n char c = readChar();\n return (byte) (c & 0xff);\n }\n \n /**\n * Test client. Reads in a binary input file from standard input and writes\n * it to standard output.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n\n // read one 8-bit char at a time\n while (!BinaryStdIn.isEmpty()) {\n char c = BinaryStdIn.readChar();\n BinaryStdOut.write(c);\n }\n BinaryStdOut.flush();\n }\n}\n\n/******************************************************************************\n * Copyright 2002-2016, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "code/algs4/BinaryStdOut.java",
"content": "/******************************************************************************\n * Compilation: javac BinaryStdOut.java\n * Execution: java BinaryStdOut\n * Dependencies: none\n *\n * Write binary data to standard output, either one 1-bit boolean,\n * one 8-bit char, one 32-bit int, one 64-bit double, one 32-bit float,\n * or one 64-bit long at a time.\n *\n * The bytes written are not aligned.\n *\n ******************************************************************************/\n\npackage algs4;\n\nimport java.io.BufferedOutputStream;\nimport java.io.IOException;\n\n/**\n * Binary standard output. This class provides methods for converting\n * primtive type variables ({@code boolean}, {@code byte}, {@code char},\n * {@code int}, {@code long}, {@code float}, and {@code double})\n * to sequences of bits and writing them to standard output.\n * Uses big-endian (most-significant byte first).\n * \n * The client must {@code flush()} the output stream when finished writing bits.\n * \n * The client should not intermixing calls to {@code BinaryStdOut} with calls\n * to {@code StdOut} or {@code System.out}; otherwise unexpected behavior \n * will result.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic final class BinaryStdOut {\n private static BufferedOutputStream out = new BufferedOutputStream(System.out);\n\n private static int buffer; // 8-bit buffer of bits to write out\n private static int n; // number of bits remaining in buffer\n\n // don't instantiate\n private BinaryStdOut() { }\n\n /**\n * Write the specified bit to standard output.\n */\n private static void writeBit(boolean bit) {\n // add bit to buffer\n buffer <<= 1;\n if (bit) buffer |= 1;\n\n // if buffer is full (8 bits), write out as a single byte\n n++;\n if (n == 8) clearBuffer();\n } \n\n /**\n * Write the 8-bit byte to standard output.\n */\n private static void writeByte(int x) {\n assert x >= 0 && x < 256;\n\n // optimized if byte-aligned\n if (n == 0) {\n try {\n out.write(x);\n }\n catch (IOException e) {\n e.printStackTrace();\n }\n return;\n }\n\n // otherwise write one bit at a time\n for (int i = 0; i < 8; i++) {\n boolean bit = ((x >>> (8 - i - 1)) & 1) == 1;\n writeBit(bit);\n }\n }\n\n // write out any remaining bits in buffer to standard output, padding with 0s\n private static void clearBuffer() {\n if (n == 0) return;\n if (n > 0) buffer <<= (8 - n);\n try {\n out.write(buffer);\n }\n catch (IOException e) {\n e.printStackTrace();\n }\n n = 0;\n buffer = 0;\n }\n\n /**\n * Flush standard output, padding 0s if number of bits written so far\n * is not a multiple of 8.\n */\n public static void flush() {\n clearBuffer();\n try {\n out.flush();\n }\n catch (IOException e) {\n e.printStackTrace();\n }\n }\n\n /**\n * Flush and close standard output. Once standard output is closed, you can no\n * longer write bits to it.\n */\n public static void close() {\n flush();\n try {\n out.close();\n }\n catch (IOException e) {\n e.printStackTrace();\n }\n }\n\n\n /**\n * Write the specified bit to standard output.\n * @param x the {@code boolean} to write.\n */\n public static void write(boolean x) {\n writeBit(x);\n } \n\n /**\n * Write the 8-bit byte to standard output.\n * @param x the {@code byte} to write.\n */\n public static void write(byte x) {\n writeByte(x & 0xff);\n }\n\n /**\n * Write the 32-bit int to standard output.\n * @param x the {@code int} to write.\n */\n public static void write(int x) {\n writeByte((x >>> 24) & 0xff);\n writeByte((x >>> 16) & 0xff);\n writeByte((x >>> 8) & 0xff);\n writeByte((x >>> 0) & 0xff);\n }\n\n /**\n * Write the r-bit int to standard output.\n * @param x the {@code int} to write.\n * @param r the number of relevant bits in the char.\n * @throws IllegalArgumentException if {@code r} is not between 1 and 32.\n * @throws IllegalArgumentException if {@code x} is not between 0 and 2r - 1.\n */\n public static void write(int x, int r) {\n if (r == 32) {\n write(x);\n return;\n }\n if (r < 1 || r > 32) throw new IllegalArgumentException(\"Illegal value for r = \" + r);\n if (x < 0 || x >= (1 << r)) throw new IllegalArgumentException(\"Illegal \" + r + \"-bit char = \" + x);\n for (int i = 0; i < r; i++) {\n boolean bit = ((x >>> (r - i - 1)) & 1) == 1;\n writeBit(bit);\n }\n }\n\n\n\n\n\n /**\n * Write the 64-bit double to standard output.\n * @param x the {@code double} to write.\n */\n public static void write(double x) {\n write(Double.doubleToRawLongBits(x));\n }\n\n /**\n * Write the 64-bit long to standard output.\n * @param x the {@code long} to write.\n */\n public static void write(long x) {\n writeByte((int) ((x >>> 56) & 0xff));\n writeByte((int) ((x >>> 48) & 0xff));\n writeByte((int) ((x >>> 40) & 0xff));\n writeByte((int) ((x >>> 32) & 0xff));\n writeByte((int) ((x >>> 24) & 0xff));\n writeByte((int) ((x >>> 16) & 0xff));\n writeByte((int) ((x >>> 8) & 0xff));\n writeByte((int) ((x >>> 0) & 0xff));\n }\n\n /**\n * Write the 32-bit float to standard output.\n * @param x the {@code float} to write.\n */\n public static void write(float x) {\n write(Float.floatToRawIntBits(x));\n }\n\n /**\n * Write the 16-bit int to standard output.\n * @param x the {@code short} to write.\n */\n public static void write(short x) {\n writeByte((x >>> 8) & 0xff);\n writeByte((x >>> 0) & 0xff);\n }\n\n /**\n * Write the 8-bit char to standard output.\n * @param x the {@code char} to write.\n * @throws IllegalArgumentException if {@code x} is not betwen 0 and 255.\n */\n public static void write(char x) {\n if (x < 0 || x >= 256) throw new IllegalArgumentException(\"Illegal 8-bit char = \" + x);\n writeByte(x);\n }\n\n /**\n * Write the r-bit char to standard output.\n * @param x the {@code char} to write.\n * @param r the number of relevant bits in the char.\n * @throws IllegalArgumentException if {@code r} is not between 1 and 16.\n * @throws IllegalArgumentException if {@code x} is not between 0 and 2r - 1.\n */\n public static void write(char x, int r) {\n if (r == 8) {\n write(x);\n return;\n }\n if (r < 1 || r > 16) throw new IllegalArgumentException(\"Illegal value for r = \" + r);\n if (x >= (1 << r)) throw new IllegalArgumentException(\"Illegal \" + r + \"-bit char = \" + x);\n for (int i = 0; i < r; i++) {\n boolean bit = ((x >>> (r - i - 1)) & 1) == 1;\n writeBit(bit);\n }\n }\n\n /**\n * Write the string of 8-bit characters to standard output.\n * @param s the {@code String} to write.\n * @throws IllegalArgumentException if any character in the string is not\n * between 0 and 255.\n */\n public static void write(String s) {\n for (int i = 0; i < s.length(); i++)\n write(s.charAt(i));\n }\n\n /**\n * Write the String of r-bit characters to standard output.\n * @param s the {@code String} to write.\n * @param r the number of relevants bits in each character.\n * @throws IllegalArgumentException if r is not between 1 and 16.\n * @throws IllegalArgumentException if any character in the string is not\n * between 0 and 2r - 1.\n */\n public static void write(String s, int r) {\n for (int i = 0; i < s.length(); i++)\n write(s.charAt(i), r);\n }\n\n /**\n * Test client.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n int m = Integer.parseInt(args[0]);\n\n // write n integers to binary standard output\n for (int i = 0; i < m; i++) {\n BinaryStdOut.write(i);\n }\n BinaryStdOut.flush();\n }\n\n}\n\n/******************************************************************************\n * Copyright 2002-2016, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "code/algs4/Counter.java",
"content": "/******************************************************************************\n * Compilation: javac Counter.java\n * Execution: java Counter n trials\n * Dependencies: StdRandom.java StdOut.java\n *\n * A mutable data type for an integer counter.\n *\n * The test clients create n counters and performs trials increment\n * operations on random counters.\n *\n * java Counter 6 600000\n * 100140 counter0\n * 100273 counter1\n * 99848 counter2\n * 100129 counter3\n * 99973 counter4\n * 99637 counter5\n *\n ******************************************************************************/\n\npackage algs4;\n\n/**\n * The {@code Counter} class is a mutable data type to encapsulate a counter.\n * \n * For additional documentation,\n * see Section 1.2 of\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic class Counter implements Comparable \n// * This implementation uses depth-first search.\n// * The constructor takes time proportional to V + E\n// * (in the worst case),\n// * where V is the number of vertices and E is the number of edges.\n// * Afterwards, the preorder, postorder, and reverse postorder\n// * operation takes take time proportional to V.\n// * \n// * For additional documentation,\n// * see Section 4.2 of\n// * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n// *\n// * @author Robert Sedgewick\n// * @author Kevin Wayne\n// */\n//public class DepthFirstOrder {\n// private boolean[] marked; // marked[v] = has v been marked in dfs?\n// private int[] pre; // pre[v] = preorder number of v\n// private int[] post; // post[v] = postorder number of v\n// private Queue \n * For additional documentation, see Section 3.1 of\n * Computer Science: An Interdisciplinary Approach by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic final class Draw implements ActionListener, MouseListener, MouseMotionListener, KeyListener {\n\n /**\n * The color black.\n */\n public static final Color BLACK = Color.BLACK;\n\n /**\n * The color blue.\n */\n public static final Color BLUE = Color.BLUE;\n\n /**\n * The color cyan.\n */\n public static final Color CYAN = Color.CYAN;\n\n /**\n * The color dark gray.\n */\n public static final Color DARK_GRAY = Color.DARK_GRAY;\n\n /**\n * The color gray.\n */\n public static final Color GRAY = Color.GRAY;\n\n /**\n * The color green.\n */\n public static final Color GREEN = Color.GREEN;\n\n /**\n * The color light gray.\n */\n public static final Color LIGHT_GRAY = Color.LIGHT_GRAY;\n\n /**\n * The color magenta.\n */\n public static final Color MAGENTA = Color.MAGENTA;\n\n /**\n * The color orange.\n */\n public static final Color ORANGE = Color.ORANGE;\n\n /**\n * The color pink.\n */\n public static final Color PINK = Color.PINK;\n\n /**\n * The color red.\n */\n public static final Color RED = Color.RED;\n\n /**\n * The color white.\n */\n public static final Color WHITE = Color.WHITE;\n\n /**\n * The color yellow.\n */\n public static final Color YELLOW = Color.YELLOW;\n\n /**\n * Shade of blue used in Introduction to Programming in Java.\n * It is Pantone 300U. The RGB values are approximately (9, 90, 166).\n */\n public static final Color BOOK_BLUE = new Color(9, 90, 166);\n\n /**\n * Shade of light blue used in Introduction to Programming in Java.\n * The RGB values are approximately (103, 198, 243).\n */\n public static final Color BOOK_LIGHT_BLUE = new Color(103, 198, 243);\n \n /**\n * Shade of red used in Algorithms, 4th edition.\n * It is Pantone 1805U. The RGB values are approximately (150, 35, 31).\n */\n public static final Color BOOK_RED = new Color(150, 35, 31);\n\n // default colors\n private static final Color DEFAULT_PEN_COLOR = BLACK;\n private static final Color DEFAULT_CLEAR_COLOR = WHITE;\n\n // boundary of drawing canvas, 0% border\n private static final double BORDER = 0.0;\n private static final double DEFAULT_XMIN = 0.0;\n private static final double DEFAULT_XMAX = 1.0;\n private static final double DEFAULT_YMIN = 0.0;\n private static final double DEFAULT_YMAX = 1.0;\n\n // default canvas size is SIZE-by-SIZE\n private static final int DEFAULT_SIZE = 512;\n\n // default pen radius\n private static final double DEFAULT_PEN_RADIUS = 0.002;\n\n // default font\n private static final Font DEFAULT_FONT = new Font(\"SansSerif\", Font.PLAIN, 16);\n\n // current pen color\n private Color penColor;\n\n // canvas size\n private int width = DEFAULT_SIZE;\n private int height = DEFAULT_SIZE;\n\n // current pen radius\n private double penRadius;\n\n // show we draw immediately or wait until next show?\n private boolean defer = false;\n\n private double xmin, ymin, xmax, ymax;\n\n // name of window\n private String name = \"Draw\";\n\n // for synchronization\n private final Object mouseLock = new Object();\n private final Object keyLock = new Object();\n\n // current font\n private Font font;\n\n // the JLabel for drawing\n private JLabel draw;\n\n // double buffered graphics\n private BufferedImage offscreenImage, onscreenImage;\n private Graphics2D offscreen, onscreen;\n\n // the frame for drawing to the screen\n private JFrame frame = new JFrame();\n\n // mouse state\n private boolean mousePressed = false;\n private double mouseX = 0;\n private double mouseY = 0;\n\n // keyboard state\n private final LinkedList \n * This method takes as an argument the keycode (corresponding to a physical key).\n * It can handle action keys (such as F1 and arrow keys) and modifier keys\n * (such as shift and control).\n * See {@link KeyEvent} for a description of key codes.\n *\n * @param keycode the keycode to check\n * @return {@code true} if {@code keycode} is currently being pressed;\n * {@code false} otherwise\n */\n public boolean isKeyPressed(int keycode) {\n synchronized (keyLock) {\n return keysDown.contains(keycode);\n }\n }\n\n /**\n * This method cannot be called directly.\n */\n @Override\n public void keyTyped(KeyEvent e) {\n synchronized (keyLock) {\n keysTyped.addFirst(e.getKeyChar());\n }\n\n // notify all listeners\n for (DrawListener listener : listeners)\n listener.keyTyped(e.getKeyChar());\n }\n\n /**\n * This method cannot be called directly.\n */\n @Override\n public void keyPressed(KeyEvent e) {\n synchronized (keyLock) {\n keysDown.add(e.getKeyCode());\n }\n\n // notify all listeners\n for (DrawListener listener : listeners)\n listener.keyPressed(e.getKeyCode());\n }\n\n /**\n * This method cannot be called directly.\n */\n @Override\n public void keyReleased(KeyEvent e) {\n synchronized (keyLock) {\n keysDown.remove(e.getKeyCode());\n }\n\n // notify all listeners\n for (DrawListener listener : listeners)\n listener.keyPressed(e.getKeyCode());\n }\n\n\n\n\n /**\n * Test client.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n\n // create one drawing window\n Draw draw1 = new Draw(\"Test client 1\");\n draw1.square(.2, .8, .1);\n draw1.filledSquare(.8, .8, .2);\n draw1.circle(.8, .2, .2);\n draw1.setPenColor(Draw.MAGENTA);\n draw1.setPenRadius(.02);\n draw1.arc(.8, .2, .1, 200, 45);\n\n\n // create another one\n Draw draw2 = new Draw(\"Test client 2\");\n draw2.setCanvasSize(900, 200);\n // draw a blue diamond\n draw2.setPenRadius();\n draw2.setPenColor(Draw.BLUE);\n double[] x = { .1, .2, .3, .2 };\n double[] y = { .2, .3, .2, .1 };\n draw2.filledPolygon(x, y);\n\n // text\n draw2.setPenColor(Draw.BLACK);\n draw2.text(0.2, 0.5, \"bdfdfdfdlack text\");\n draw2.setPenColor(Draw.WHITE);\n draw2.text(0.8, 0.8, \"white text\");\n }\n\n}\n\n/******************************************************************************\n * Copyright 2002-2016, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "code/algs4/DrawListener.java",
"content": "/******************************************************************************\n * Compilation: javac DrawListener.java\n * Execution: none\n * Dependencies: none\n *\n * Interface that accompanies Draw.java.\n ******************************************************************************/\n\npackage algs4;\n\npublic interface DrawListener {\n\n /**\n * Invoked when the mouse has been pressed.\n *\n * @param x the x-coordinate of the mouse\n * @param y the y-coordinate of the mouse\n */\n void mousePressed(double x, double y);\n\n /**\n * Invoked when the mouse has been dragged.\n *\n * @param x the x-coordinate of the mouse\n * @param y the y-coordinate of the mouse\n */\n void mouseDragged(double x, double y);\n\n /**\n * Invoked when the mouse has been released.\n *\n * @param x the x-coordinate of the mouse\n * @param y the y-coordinate of the mouse\n */\n void mouseReleased(double x, double y);\n\n /**\n * Invoked when a key has been typed.\n *\n * @param c the character typed\n */\n void keyTyped(char c);\n\n /**\n * Invoked when a key has been pressed.\n *\n * @param keycode the key combination pressed\n */\n void keyPressed(int keycode);\n\n /**\n * Invoked when a key has been released.\n *\n * @param keycode the key combination released\n */\n void keyReleased(int keycode);\n}\n\n/******************************************************************************\n * Copyright 2002-2016, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "code/algs4/Heap.java",
"content": "/******************************************************************************\n * Compilation: javac Heap.java\n * Execution: java Heap < input.txt\n * Dependencies: StdOut.java StdIn.java\n * Data files: http://algs4.cs.princeton.edu/24pq/tiny.txt\n * http://algs4.cs.princeton.edu/24pq/words3.txt\n * \n * Sorts a sequence of strings from standard input using heapsort.\n *\n * % more tiny.txt\n * S O R T E X A M P L E\n *\n * % java Heap < tiny.txt\n * A E E L M O P R S T X [ one string per line ]\n *\n * % more words3.txt\n * bed bug dad yes zoo ... all bad yet\n *\n * % java Heap < words3.txt\n * all bad bed bug dad ... yes yet zoo [ one string per line ]\n *\n ******************************************************************************/\n\npackage algs4;\n\n/**\n * The {@code Heap} class provides a static methods for heapsorting\n * an array.\n * \n * For additional documentation, see Section 2.4 of\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic class Heap {\n\n // This class should not be instantiated.\n private Heap() { }\n\n /**\n * Rearranges the array in ascending order, using the natural order.\n * @param pq the array to be sorted\n */\n public static void sort(Comparable[] pq) {\n int n = pq.length;\n for (int k = n/2; k >= 1; k--)\n sink(pq, k, n);\n while (n > 1) {\n exch(pq, 1, n--);\n sink(pq, 1, n);\n }\n }\n\n /***************************************************************************\n * Helper functions to restore the heap invariant.\n ***************************************************************************/\n\n private static void sink(Comparable[] pq, int k, int n) {\n while (2*k <= n) {\n int j = 2*k;\n if (j < n && less(pq, j, j+1)) j++;\n if (!less(pq, k, j)) break;\n exch(pq, k, j);\n k = j;\n }\n }\n\n /***************************************************************************\n * Helper functions for comparisons and swaps.\n * Indices are \"off-by-one\" to support 1-based indexing.\n ***************************************************************************/\n private static boolean less(Comparable[] pq, int i, int j) {\n return pq[i-1].compareTo(pq[j-1]) < 0;\n }\n\n private static void exch(Object[] pq, int i, int j) {\n Object swap = pq[i-1];\n pq[i-1] = pq[j-1];\n pq[j-1] = swap;\n }\n\n // is v < w ?\n private static boolean less(Comparable v, Comparable w) {\n return v.compareTo(w) < 0;\n }\n \n\n /***************************************************************************\n * Check if array is sorted - useful for debugging.\n ***************************************************************************/\n private static boolean isSorted(Comparable[] a) {\n for (int i = 1; i < a.length; i++)\n if (less(a[i], a[i-1])) return false;\n return true;\n }\n\n\n // print array to standard output\n private static void show(Comparable[] a) {\n for (int i = 0; i < a.length; i++) {\n StdOut.println(a[i]);\n }\n }\n\n /**\n * Reads in a sequence of strings from standard input; heapsorts them; \n * and prints them to standard output in ascending order. \n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n String[] a = StdIn.readAllStrings();\n Heap.sort(a);\n show(a);\n assert isSorted(a);\n }\n}\n\n/******************************************************************************\n * Copyright 2002-2016, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "code/algs4/HexDump.java",
"content": "/******************************************************************************\n * Compilation: javac HexDump.java\n * Execution: java HexDump < file\n * Dependencies: BinaryStdIn.java StdOut.java\n * Data file: http://algs4.cs.princeton.edu/55compression/abra.txt\n * \n * Reads in a binary file and writes out the bytes in hex, 16 per line.\n *\n * % more abra.txt\n * ABRACADABRA!\n *\n * % java HexDump 16 < abra.txt\n * 41 42 52 41 43 41 44 41 42 52 41 21\n * 96 bits\n *\n *\n * Remark\n * --------------------------\n * - Similar to the Unix utilities od (octal dump) or hexdump (hexadecimal dump).\n *\n * % od -t x1 < abra.txt \n * 0000000 41 42 52 41 43 41 44 41 42 52 41 21\n * 0000014\n *\n ******************************************************************************/\n\npackage algs4;\n\n/**\n * The {@code HexDump} class provides a client for displaying the contents\n * of a binary file in hexadecimal.\n * \n * For additional documentation,\n * see Section 5.5 of\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n * \n * See also {@link BinaryDump} and {@link PictureDump}.\n * For more full-featured versions, see the Unix utilities\n * {@code od} (octal dump) and {@code hexdump} (hexadecimal dump).\n * \n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic class HexDump {\n\n // Do not instantiate.\n private HexDump() { }\n\n /**\n * Reads in a sequence of bytes from standard input and writes\n * them to standard output using hexademical notation, k hex digits\n * per line, where k is given as a command-line integer (defaults\n * to 16 if no integer is specified); also writes the number\n * of bits.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n int bytesPerLine = 16;\n if (args.length == 1) {\n bytesPerLine = Integer.parseInt(args[0]);\n }\n\n int i;\n for (i = 0; !BinaryStdIn.isEmpty(); i++) {\n if (bytesPerLine == 0) {\n BinaryStdIn.readChar();\n continue;\n }\n if (i == 0) StdOut.printf(\"\");\n else if (i % bytesPerLine == 0) StdOut.printf(\"\\n\", i);\n else StdOut.print(\" \");\n char c = BinaryStdIn.readChar();\n StdOut.printf(\"%02x\", c & 0xff);\n }\n if (bytesPerLine != 0) StdOut.println();\n StdOut.println((i*8) + \" bits\");\n }\n}\n\n/******************************************************************************\n * Copyright 2002-2016, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "code/algs4/In.java",
"content": "/******************************************************************************\n * Compilation: javac In.java\n * Execution: java In (basic test --- see source for required files)\n * Dependencies: none\n *\n * Reads in data of various types from standard input, files, and URLs.\n *\n ******************************************************************************/\n\npackage algs4;\n\nimport java.io.BufferedInputStream;\nimport java.io.File;\nimport java.io.FileInputStream;\nimport java.io.IOException;\nimport java.io.InputStream;\nimport java.net.URL;\nimport java.net.Socket;\n// import java.net.HttpURLConnection;\nimport java.net.URLConnection;\nimport java.util.ArrayList;\nimport java.util.InputMismatchException;\nimport java.util.Locale;\nimport java.util.NoSuchElementException;\nimport java.util.Scanner;\nimport java.util.regex.Pattern;\n\n/**\n * Input. This class provides methods for reading strings\n * and numbers from standard input, file input, URLs, and sockets. \n * \n * The Locale used is: language = English, country = US. This is consistent\n * with the formatting conventions with Java floating-point literals,\n * command-line arguments (via {@link Double#parseDouble(String)})\n * and standard output. \n * \n * For additional documentation, see \n * Section 3.1 of\n * Computer Science: An Interdisciplinary Approach \n * by Robert Sedgewick and Kevin Wayne.\n * \n * Like {@link Scanner}, reading a token also consumes preceding Java\n * whitespace, reading a full line consumes\n * the following end-of-line delimeter, while reading a character consumes\n * nothing extra. \n * \n * Whitespace is defined in {@link Character#isWhitespace(char)}. Newlines\n * consist of \\n, \\r, \\r\\n, and Unicode hex code points 0x2028, 0x2029, 0x0085;\n * see \n * Scanner.java (NB: Java 6u23 and earlier uses only \\r, \\r, \\r\\n).\n *\n * @author David Pritchard\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic final class In {\n \n ///// begin: section (1 of 2) of code duplicated from In to StdIn.\n \n // assume Unicode UTF-8 encoding\n private static final String CHARSET_NAME = \"UTF-8\";\n\n // assume language = English, country = US for consistency with System.out.\n private static final Locale LOCALE = Locale.US;\n\n // the default token separator; we maintain the invariant that this value \n // is held by the scanner's delimiter between calls\n private static final Pattern WHITESPACE_PATTERN\n = Pattern.compile(\"\\\\p{javaWhitespace}+\");\n\n // makes whitespace characters significant \n private static final Pattern EMPTY_PATTERN\n = Pattern.compile(\"\");\n\n // used to read the entire input. source:\n // http://weblogs.java.net/blog/pat/archive/2004/10/stupid_scanner_1.html\n private static final Pattern EVERYTHING_PATTERN\n = Pattern.compile(\"\\\\A\");\n\n //// end: section (1 of 2) of code duplicated from In to StdIn.\n\n private Scanner scanner;\n\n /**\n * Initializes an input stream from standard input.\n */\n public In() {\n scanner = new Scanner(new BufferedInputStream(System.in), CHARSET_NAME);\n scanner.useLocale(LOCALE);\n }\n\n /**\n * Initializes an input stream from a socket.\n *\n * @param socket the socket\n * @throws IllegalArgumentException if cannot open {@code socket}\n * @throws IllegalArgumentException if {@code socket} is {@code null}\n */\n public In(Socket socket) {\n if (socket == null) throw new IllegalArgumentException(\"socket argument is null\");\n try {\n InputStream is = socket.getInputStream();\n scanner = new Scanner(new BufferedInputStream(is), CHARSET_NAME);\n scanner.useLocale(LOCALE);\n }\n catch (IOException ioe) {\n throw new IllegalArgumentException(\"Could not open \" + socket, ioe);\n }\n }\n\n /**\n * Initializes an input stream from a URL.\n *\n * @param url the URL\n * @throws IllegalArgumentException if cannot open {@code url}\n * @throws IllegalArgumentException if {@code url} is {@code null}\n */\n public In(URL url) {\n if (url == null) throw new IllegalArgumentException(\"url argument is null\");\n try {\n URLConnection site = url.openConnection();\n InputStream is = site.getInputStream();\n scanner = new Scanner(new BufferedInputStream(is), CHARSET_NAME);\n scanner.useLocale(LOCALE);\n }\n catch (IOException ioe) {\n throw new IllegalArgumentException(\"Could not open \" + url, ioe);\n }\n }\n\n /**\n * Initializes an input stream from a file.\n *\n * @param file the file\n * @throws IllegalArgumentException if cannot open {@code file}\n * @throws IllegalArgumentException if {@code file} is {@code null}\n */\n public In(File file) {\n if (file == null) throw new IllegalArgumentException(\"file argument is null\");\n try {\n // for consistency with StdIn, wrap with BufferedInputStream instead of use\n // file as argument to Scanner\n FileInputStream fis = new FileInputStream(file);\n scanner = new Scanner(new BufferedInputStream(fis), CHARSET_NAME);\n scanner.useLocale(LOCALE);\n }\n catch (IOException ioe) {\n throw new IllegalArgumentException(\"Could not open \" + file, ioe);\n }\n }\n\n\n /**\n * Initializes an input stream from a filename or web page name.\n *\n * @param name the filename or web page name\n * @throws IllegalArgumentException if cannot open {@code name} as\n * a file or URL\n * @throws IllegalArgumentException if {@code name} is {@code null}\n */\n public In(String name) {\n if (name == null) throw new IllegalArgumentException(\"argument is null\");\n try {\n // first try to read file from local file system\n File file = new File(name);\n if (file.exists()) {\n // for consistency with StdIn, wrap with BufferedInputStream instead of use\n // file as argument to Scanner\n FileInputStream fis = new FileInputStream(file);\n scanner = new Scanner(new BufferedInputStream(fis), CHARSET_NAME);\n scanner.useLocale(LOCALE);\n return;\n }\n\n // next try for files included in jar\n URL url = getClass().getResource(name);\n\n // or URL from web\n if (url == null) {\n url = new URL(name);\n }\n\n URLConnection site = url.openConnection();\n\n // in order to set User-Agent, replace above line with these two\n // HttpURLConnection site = (HttpURLConnection) url.openConnection();\n // site.addRequestProperty(\"User-Agent\", \"Mozilla/4.76\");\n\n InputStream is = site.getInputStream();\n scanner = new Scanner(new BufferedInputStream(is), CHARSET_NAME);\n scanner.useLocale(LOCALE);\n }\n catch (IOException ioe) {\n throw new IllegalArgumentException(\"Could not open \" + name, ioe);\n }\n }\n\n /**\n * Initializes an input stream from a given {@link Scanner} source; use with \n * {@code new Scanner(String)} to read from a string.\n * \n * Note that this does not create a defensive copy, so the\n * scanner will be mutated as you read on. \n *\n * @param scanner the scanner\n * @throws IllegalArgumentException if {@code scanner} is {@code null}\n */\n public In(Scanner scanner) {\n if (scanner == null) throw new IllegalArgumentException(\"scanner argument is null\");\n this.scanner = scanner;\n }\n\n /**\n * Returns true if this input stream exists.\n *\n * @return {@code true} if this input stream exists; {@code false} otherwise\n */\n public boolean exists() {\n return scanner != null;\n }\n \n //// begin: section (2 of 2) of code duplicated from In to StdIn,\n //// with all methods changed from \"public\" to \"public static\".\n\n /**\n * Returns true if input stream is empty (except possibly whitespace).\n * Use this to know whether the next call to {@link #readString()}, \n * {@link #readDouble()}, etc will succeed.\n *\n * @return {@code true} if this input stream is empty (except possibly whitespace);\n * {@code false} otherwise\n */\n public boolean isEmpty() {\n return !scanner.hasNext();\n }\n\n /** \n * Returns true if this input stream has a next line.\n * Use this method to know whether the\n * next call to {@link #readLine()} will succeed.\n * This method is functionally equivalent to {@link #hasNextChar()}.\n *\n * @return {@code true} if this input stream has more input (including whitespace);\n * {@code false} otherwise\n */\n public boolean hasNextLine() {\n return scanner.hasNextLine();\n }\n\n /**\n * Returns true if this input stream has more inputy (including whitespace).\n * Use this method to know whether the next call to {@link #readChar()} will succeed.\n * This method is functionally equivalent to {@link #hasNextLine()}.\n * \n * @return {@code true} if this input stream has more input (including whitespace);\n * {@code false} otherwise \n */\n public boolean hasNextChar() {\n scanner.useDelimiter(EMPTY_PATTERN);\n boolean result = scanner.hasNext();\n scanner.useDelimiter(WHITESPACE_PATTERN);\n return result;\n }\n\n\n /**\n * Reads and returns the next line in this input stream.\n *\n * @return the next line in this input stream; {@code null} if no such line\n */\n public String readLine() {\n String line;\n try {\n line = scanner.nextLine();\n }\n catch (NoSuchElementException e) {\n line = null;\n }\n return line;\n }\n\n /**\n * Reads and returns the next character in this input stream.\n *\n * @return the next character in this input stream\n */\n public char readChar() {\n scanner.useDelimiter(EMPTY_PATTERN);\n String ch = scanner.next();\n assert ch.length() == 1 : \"Internal (Std)In.readChar() error!\"\n + \" Please contact the authors.\";\n scanner.useDelimiter(WHITESPACE_PATTERN);\n return ch.charAt(0);\n } \n\n\n /**\n * Reads and returns the remainder of this input stream, as a string.\n *\n * @return the remainder of this input stream, as a string\n */\n public String readAll() {\n if (!scanner.hasNextLine())\n return \"\";\n\n String result = scanner.useDelimiter(EVERYTHING_PATTERN).next();\n // not that important to reset delimeter, since now scanner is empty\n scanner.useDelimiter(WHITESPACE_PATTERN); // but let's do it anyway\n return result;\n }\n\n\n /**\n * Reads the next token from this input stream and returns it as a {@code String}.\n *\n * @return the next {@code String} in this input stream\n */\n public String readString() {\n return scanner.next();\n }\n\n /**\n * Reads the next token from this input stream, parses it as a {@code int},\n * and returns the {@code int}.\n *\n * @return the next {@code int} in this input stream\n */\n public int readInt() {\n return scanner.nextInt();\n }\n\n /**\n * Reads the next token from this input stream, parses it as a {@code double},\n * and returns the {@code double}.\n *\n * @return the next {@code double} in this input stream\n */\n public double readDouble() {\n return scanner.nextDouble();\n }\n\n /**\n * Reads the next token from this input stream, parses it as a {@code float},\n * and returns the {@code float}.\n *\n * @return the next {@code float} in this input stream\n */\n public float readFloat() {\n return scanner.nextFloat();\n }\n\n /**\n * Reads the next token from this input stream, parses it as a {@code long},\n * and returns the {@code long}.\n *\n * @return the next {@code long} in this input stream\n */\n public long readLong() {\n return scanner.nextLong();\n }\n\n /**\n * Reads the next token from this input stream, parses it as a {@code short},\n * and returns the {@code short}.\n *\n * @return the next {@code short} in this input stream\n */\n public short readShort() {\n return scanner.nextShort();\n }\n\n /**\n * Reads the next token from this input stream, parses it as a {@code byte},\n * and returns the {@code byte}.\n * \n * To read binary data, use {@link BinaryIn}.\n *\n * @return the next {@code byte} in this input stream\n */\n public byte readByte() {\n return scanner.nextByte();\n }\n\n /**\n * Reads the next token from this input stream, parses it as a {@code boolean}\n * (interpreting either {@code \"true\"} or {@code \"1\"} as {@code true},\n * and either {@code \"false\"} or {@code \"0\"} as {@code false}).\n *\n * @return the next {@code boolean} in this input stream\n */\n public boolean readBoolean() {\n String s = readString();\n if (\"true\".equalsIgnoreCase(s)) return true;\n if (\"false\".equalsIgnoreCase(s)) return false;\n if (\"1\".equals(s)) return true;\n if (\"0\".equals(s)) return false;\n throw new InputMismatchException();\n }\n\n /**\n * Reads all remaining tokens from this input stream and returns them as\n * an array of strings.\n *\n * @return all remaining tokens in this input stream, as an array of strings\n */\n public String[] readAllStrings() {\n // we could use readAll.trim().split(), but that's not consistent\n // since trim() uses characters 0x00..0x20 as whitespace\n String[] tokens = WHITESPACE_PATTERN.split(readAll());\n if (tokens.length == 0 || tokens[0].length() > 0)\n return tokens;\n String[] decapitokens = new String[tokens.length-1];\n for (int i = 0; i < tokens.length-1; i++)\n decapitokens[i] = tokens[i+1];\n return decapitokens;\n }\n\n /**\n * Reads all remaining lines from this input stream and returns them as\n * an array of strings.\n *\n * @return all remaining lines in this input stream, as an array of strings\n */\n public String[] readAllLines() {\n ArrayList \n * This implementation uses a binary heap along with an array to associate\n * keys with integers in the given range.\n * The insert, delete-the-minimum, delete,\n * change-key, decrease-key, and increase-key\n * operations take logarithmic time.\n * The is-empty, size, min-index, min-key,\n * and key-of operations take constant time.\n * Construction takes time proportional to the specified capacity.\n * \n * For additional documentation, see Section 2.4 of\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n *\n * @param \n * For additional documentation, \n * see Section 1.2 of \n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne. \n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic class Interval1D {\n\n /**\n * Compares two intervals by min endpoint.\n */\n public static final Comparator \n * For additional documentation, \n * see Section 1.2 of \n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne. \n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic class Interval2D {\n private final Interval1D x;\n private final Interval1D y;\n\n /**\n * Initializes a two-dimensional interval.\n * @param x the one-dimensional interval of x-coordinates\n * @param y the one-dimensional interval of y-coordinates\n */\n public Interval2D(Interval1D x, Interval1D y) {\n this.x = x;\n this.y = y;\n }\n\n /**\n * Does this two-dimensional interval intersect that two-dimensional interval?\n * @param that the other two-dimensional interval\n * @return true if this two-dimensional interval intersects\n * that two-dimensional interval; false otherwise\n */\n public boolean intersects(Interval2D that) {\n if (!this.x.intersects(that.x)) return false;\n if (!this.y.intersects(that.y)) return false;\n return true;\n }\n\n /**\n * Does this two-dimensional interval contain the point p?\n * @param p the two-dimensional point\n * @return true if this two-dimensional interval contains the point p; false otherwise\n */\n public boolean contains(Point2D p) {\n return x.contains(p.x()) && y.contains(p.y());\n }\n\n /**\n * Returns the area of this two-dimensional interval.\n * @return the area of this two-dimensional interval\n */\n public double area() {\n return x.length() * y.length();\n }\n \n /**\n * Returns a string representation of this two-dimensional interval.\n * @return a string representation of this two-dimensional interval\n * in the form [xmin, xmax] x [ymin, ymax]\n */\n public String toString() {\n return x + \" x \" + y;\n }\n\n /**\n * Does this interval equal the other interval?\n * @param other the other interval\n * @return true if this interval equals the other interval; false otherwise\n */\n public boolean equals(Object other) {\n if (other == this) return true;\n if (other == null) return false;\n if (other.getClass() != this.getClass()) return false;\n Interval2D that = (Interval2D) other;\n return this.x.equals(that.x) && this.y.equals(that.y);\n }\n\n \n /**\n * Returns an integer hash code for this interval. \n * @return an integer hash code for this interval \n */\n public int hashCode() {\n int hash1 = x.hashCode();\n int hash2 = y.hashCode();\n return 31*hash1 + hash2;\n }\n\n /**\n * Draws this two-dimensional interval to standard draw.\n */\n public void draw() {\n double xc = (x.min() + x.max()) / 2.0;\n double yc = (y.min() + y.max()) / 2.0;\n StdDraw.rectangle(xc, yc, x.length() / 2.0, y.length() / 2.0);\n }\n\n /**\n * Unit tests the {@code Interval2D} data type.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n double xmin = Double.parseDouble(args[0]);\n double xmax = Double.parseDouble(args[1]);\n double ymin = Double.parseDouble(args[2]);\n double ymax = Double.parseDouble(args[3]);\n int trials = Integer.parseInt(args[4]);\n\n Interval1D xInterval = new Interval1D(xmin, xmax);\n Interval1D yInterval = new Interval1D(ymin, ymax);\n Interval2D box = new Interval2D(xInterval, yInterval);\n box.draw();\n\n Counter counter = new Counter(\"hits\");\n for (int t = 0; t < trials; t++) {\n double x = StdRandom.uniform(0.0, 1.0);\n double y = StdRandom.uniform(0.0, 1.0);\n Point2D point = new Point2D(x, y);\n\n if (box.contains(point)) counter.increment();\n else point.draw();\n }\n\n StdOut.println(counter);\n StdOut.printf(\"box area = %.2f\\n\", box.area());\n }\n}\n\n/******************************************************************************\n * Copyright 2002-2016, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "code/algs4/MinPQ.java",
"content": "/******************************************************************************\n * Compilation: javac MinPQ.java\n * Execution: java MinPQ < input.txt\n * Dependencies: StdIn.java StdOut.java\n * Data files: http://algs4.cs.princeton.edu/24pq/tinyPQ.txt\n * \n * Generic min priority queue implementation with a binary heap.\n * Can be used with a comparator instead of the natural order.\n *\n * % java MinPQ < tinyPQ.txt\n * E A E (6 left on pq)\n *\n * We use a one-based array to simplify parent and child calculations.\n *\n * Can be optimized by replacing full exchanges with half exchanges\n * (ala insertion sort).\n *\n ******************************************************************************/\n\npackage algs4;\n\nimport java.util.Comparator;\nimport java.util.Iterator;\nimport java.util.NoSuchElementException;\n\n/**\n * The {@code MinPQ} class represents a priority queue of generic keys.\n * It supports the usual insert and delete-the-minimum\n * operations, along with methods for peeking at the minimum key,\n * testing if the priority queue is empty, and iterating through\n * the keys.\n * \n * This implementation uses a binary heap.\n * The insert and delete-the-minimum operations take\n * logarithmic amortized time.\n * The min, size, and is-empty operations take constant time.\n * Construction takes time proportional to the specified capacity or the number of\n * items used to initialize the data structure.\n * \n * For additional documentation, see Section 2.4 of\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n *\n * @param \n * Takes time proportional to the number of keys, using sink-based heap construction.\n *\n * @param keys the array of keys\n */\n public MinPQ(Key[] keys) {\n n = keys.length;\n pq = (Key[]) new Object[keys.length + 1];\n for (int i = 0; i < n; i++)\n pq[i+1] = keys[i];\n for (int k = n/2; k >= 1; k--)\n sink(k);\n assert isMinHeap();\n }\n\n /**\n * Returns true if this priority queue is empty.\n *\n * @return {@code true} if this priority queue is empty;\n * {@code false} otherwise\n */\n public boolean isEmpty() {\n return n == 0;\n }\n\n /**\n * Returns the number of keys on this priority queue.\n *\n * @return the number of keys on this priority queue\n */\n public int size() {\n return n;\n }\n\n /**\n * Returns a smallest key on this priority queue.\n *\n * @return a smallest key on this priority queue\n * @throws NoSuchElementException if this priority queue is empty\n */\n public Key min() {\n if (isEmpty()) throw new NoSuchElementException(\"Priority queue underflow\");\n return pq[1];\n }\n\n // helper function to double the size of the heap array\n private void resize(int capacity) {\n assert capacity > n;\n Key[] temp = (Key[]) new Object[capacity];\n for (int i = 1; i <= n; i++) {\n temp[i] = pq[i];\n }\n pq = temp;\n }\n\n /**\n * Adds a new key to this priority queue.\n *\n * @param x the key to add to this priority queue\n */\n public void insert(Key x) {\n // double size of array if necessary\n if (n == pq.length - 1) resize(2 * pq.length);\n\n // add x, and percolate it up to maintain heap invariant\n pq[++n] = x;\n swim(n);\n assert isMinHeap();\n }\n\n /**\n * Removes and returns a smallest key on this priority queue.\n *\n * @return a smallest key on this priority queue\n * @throws NoSuchElementException if this priority queue is empty\n */\n public Key delMin() {\n if (isEmpty()) throw new NoSuchElementException(\"Priority queue underflow\");\n exch(1, n);\n Key min = pq[n--];\n sink(1);\n pq[n+1] = null; // avoid loitering and help with garbage collection\n if ((n > 0) && (n == (pq.length - 1) / 4)) resize(pq.length / 2);\n assert isMinHeap();\n return min;\n }\n\n\n /***************************************************************************\n * Helper functions to restore the heap invariant.\n ***************************************************************************/\n\n private void swim(int k) {\n while (k > 1 && greater(k/2, k)) {\n exch(k, k/2);\n k = k/2;\n }\n }\n\n private void sink(int k) {\n while (2*k <= n) {\n int j = 2*k;\n if (j < n && greater(j, j+1)) j++;\n if (!greater(k, j)) break;\n exch(k, j);\n k = j;\n }\n }\n\n /***************************************************************************\n * Helper functions for compares and swaps.\n ***************************************************************************/\n private boolean greater(int i, int j) {\n if (comparator == null) {\n return ((Comparable \n * The iterator doesn't implement {@code remove()} since it's optional.\n *\n * @return an iterator that iterates over the keys in ascending order\n */\n public Iterator \n * For additional documentation, see\n * Section 3.1 of\n * Computer Science: An Interdisciplinary Approach\n * by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic class Out {\n\n // force Unicode UTF-8 encoding; otherwise it's system dependent\n private static final String CHARSET_NAME = \"UTF-8\";\n\n // assume language = English, country = US for consistency with In\n private static final Locale LOCALE = Locale.US;\n\n private PrintWriter out;\n\n /**\n * Initializes an output stream from a {@link OutputStream}.\n *\n * @param os the {@code OutputStream}\n */\n public Out(OutputStream os) {\n try {\n OutputStreamWriter osw = new OutputStreamWriter(os, CHARSET_NAME);\n out = new PrintWriter(osw, true);\n }\n catch (IOException e) {\n e.printStackTrace();\n }\n }\n\n /**\n * Initializes an output stream from standard output.\n */\n public Out() {\n this(System.out);\n }\n\n /**\n * Initializes an output stream from a socket.\n *\n * @param socket the socket\n */\n public Out(Socket socket) {\n try {\n OutputStream os = socket.getOutputStream();\n OutputStreamWriter osw = new OutputStreamWriter(os, CHARSET_NAME);\n out = new PrintWriter(osw, true);\n }\n catch (IOException e) {\n e.printStackTrace();\n }\n }\n\n /**\n * Initializes an output stream from a file.\n *\n * @param filename the name of the file\n */\n public Out(String filename) {\n try {\n OutputStream os = new FileOutputStream(filename);\n OutputStreamWriter osw = new OutputStreamWriter(os, CHARSET_NAME);\n out = new PrintWriter(osw, true);\n }\n catch (IOException e) {\n e.printStackTrace();\n }\n }\n\n /**\n * Closes the output stream.\n */\n public void close() {\n out.close();\n }\n\n /**\n * Terminates the current line by printing the line-separator string.\n */\n public void println() {\n out.println();\n }\n\n /**\n * Prints an object to this output stream and then terminates the line.\n *\n * @param x the object to print\n */\n public void println(Object x) {\n out.println(x);\n }\n\n /**\n * Prints a boolean to this output stream and then terminates the line.\n *\n * @param x the boolean to print\n */\n public void println(boolean x) {\n out.println(x);\n }\n\n /**\n * Prints a character to this output stream and then terminates the line.\n *\n * @param x the character to print\n */\n public void println(char x) {\n out.println(x);\n }\n\n /**\n * Prints a double to this output stream and then terminates the line.\n *\n * @param x the double to print\n */\n public void println(double x) {\n out.println(x);\n }\n\n /**\n * Prints a float to this output stream and then terminates the line.\n *\n * @param x the float to print\n */\n public void println(float x) {\n out.println(x);\n }\n\n /**\n * Prints an integer to this output stream and then terminates the line.\n *\n * @param x the integer to print\n */\n public void println(int x) {\n out.println(x);\n }\n\n /**\n * Prints a long to this output stream and then terminates the line.\n *\n * @param x the long to print\n */\n public void println(long x) {\n out.println(x);\n }\n\n /**\n * Prints a byte to this output stream and then terminates the line.\n * \n * To write binary data, see {@link BinaryOut}.\n *\n * @param x the byte to print\n */\n public void println(byte x) {\n out.println(x);\n }\n\n\n\n /**\n * Flushes this output stream.\n */\n public void print() {\n out.flush();\n }\n\n /**\n * Prints an object to this output stream and flushes this output stream.\n * \n * @param x the object to print\n */\n public void print(Object x) {\n out.print(x);\n out.flush();\n }\n\n /**\n * Prints a boolean to this output stream and flushes this output stream.\n * \n * @param x the boolean to print\n */\n public void print(boolean x) {\n out.print(x);\n out.flush();\n }\n\n /**\n * Prints a character to this output stream and flushes this output stream.\n * \n * @param x the character to print\n */\n public void print(char x) {\n out.print(x);\n out.flush();\n }\n\n /**\n * Prints a double to this output stream and flushes this output stream.\n * \n * @param x the double to print\n */\n public void print(double x) {\n out.print(x);\n out.flush();\n }\n\n /**\n * Prints a float to this output stream and flushes this output stream.\n * \n * @param x the float to print\n */\n public void print(float x) {\n out.print(x);\n out.flush();\n }\n\n /**\n * Prints an integer to this output stream and flushes this output stream.\n * \n * @param x the integer to print\n */\n public void print(int x) {\n out.print(x);\n out.flush();\n }\n\n /**\n * Prints a long integer to this output stream and flushes this output stream.\n * \n * @param x the long integer to print\n */\n public void print(long x) {\n out.print(x);\n out.flush();\n }\n\n /**\n * Prints a byte to this output stream and flushes this output stream.\n * \n * @param x the byte to print\n */\n public void print(byte x) {\n out.print(x);\n out.flush();\n }\n\n /**\n * Prints a formatted string to this output stream, using the specified format\n * string and arguments, and then flushes this output stream.\n *\n * @param format the format string\n * @param args the arguments accompanying the format string\n */\n public void printf(String format, Object... args) {\n out.printf(LOCALE, format, args);\n out.flush();\n }\n\n /**\n * Prints a formatted string to this output stream, using the specified\n * locale, format string, and arguments, and then flushes this output stream.\n *\n * @param locale the locale\n * @param format the format string\n * @param args the arguments accompanying the format string\n */\n public void printf(Locale locale, String format, Object... args) {\n out.printf(locale, format, args);\n out.flush();\n }\n\n\n /**\n * A test client.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n Out out;\n\n // write to stdout\n out = new Out();\n out.println(\"Test 1\");\n out.close();\n\n // write to a file\n out = new Out(\"test.txt\");\n out.println(\"Test 2\");\n out.close();\n }\n\n}\n\n/******************************************************************************\n * Copyright 2002-2016, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "code/algs4/Particle.java",
"content": "/******************************************************************************\n * Compilation: javac Particle.java\n * Execution: none\n * Dependencies: StdDraw.java\n * \n * A particle moving in the unit box with a given position, velocity,\n * radius, and mass.\n *\n ******************************************************************************/\n\npackage algs4;\n\nimport java.awt.Color;\n\n/**\n * The {@code Particle} class represents a particle moving in the unit box,\n * with a given position, velocity, radius, and mass. Methods are provided\n * for moving the particle and for predicting and resolvling elastic\n * collisions with vertical walls, horizontal walls, and other particles.\n * This data type is mutable because the position and velocity change.\n * \n * For additional documentation, \n * see Section 6.1 of \n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne. \n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic class Particle {\n private static final double INFINITY = Double.POSITIVE_INFINITY;\n\n private double rx, ry; // position\n private double vx, vy; // velocity\n private int count; // number of collisions so far\n private final double radius; // radius\n private final double mass; // mass\n private final Color color; // color\n\n\n /**\n * Initializes a particle with the specified position, velocity, radius, mass, and color.\n *\n * @param rx x-coordinate of position\n * @param ry y-coordinate of position\n * @param vx x-coordinate of velocity\n * @param vy y-coordinate of velocity\n * @param radius the radius\n * @param mass the mass\n * @param color the color\n */\n public Particle(double rx, double ry, double vx, double vy, double radius, double mass, Color color) {\n this.vx = vx;\n this.vy = vy;\n this.rx = rx;\n this.ry = ry;\n this.radius = radius;\n this.mass = mass;\n this.color = color;\n }\n \n /**\n * Initializes a particle with a random position and velocity.\n * The position is uniform in the unit box; the velocity in\n * either direciton is chosen uniformly at random.\n */\n public Particle() {\n rx = StdRandom.uniform(0.0, 1.0);\n ry = StdRandom.uniform(0.0, 1.0);\n vx = StdRandom.uniform(-0.005, 0.005);\n vy = StdRandom.uniform(-0.005, 0.005);\n radius = 0.01;\n mass = 0.5;\n color = Color.BLACK;\n }\n\n /**\n * Moves this particle in a straight line (based on its velocity)\n * for the specified amount of time.\n *\n * @param dt the amount of time\n */\n public void move(double dt) {\n rx += vx * dt;\n ry += vy * dt;\n }\n\n /**\n * Draws this particle to standard draw.\n */\n public void draw() {\n StdDraw.setPenColor(color);\n StdDraw.filledCircle(rx, ry, radius);\n }\n\n /**\n * Returns the number of collisions involving this particle with\n * vertical walls, horizontal walls, or other particles.\n * This is equal to the number of calls to {@link #bounceOff},\n * {@link #bounceOffVerticalWall}, and\n * {@link #bounceOffHorizontalWall}.\n *\n * @return the number of collisions involving this particle with\n * vertical walls, horizontal walls, or other particles\n */\n public int count() {\n return count;\n }\n\n /**\n * Returns the amount of time for this particle to collide with the specified\n * particle, assuming no interening collisions.\n *\n * @param that the other particle\n * @return the amount of time for this particle to collide with the specified\n * particle, assuming no interening collisions; \n * {@code Double.POSITIVE_INFINITY} if the particles will not collide\n */\n public double timeToHit(Particle that) {\n if (this == that) return INFINITY;\n double dx = that.rx - this.rx;\n double dy = that.ry - this.ry;\n double dvx = that.vx - this.vx;\n double dvy = that.vy - this.vy;\n double dvdr = dx*dvx + dy*dvy;\n if (dvdr > 0) return INFINITY;\n double dvdv = dvx*dvx + dvy*dvy;\n double drdr = dx*dx + dy*dy;\n double sigma = this.radius + that.radius;\n double d = (dvdr*dvdr) - dvdv * (drdr - sigma*sigma);\n // if (drdr < sigma*sigma) StdOut.println(\"overlapping particles\");\n if (d < 0) return INFINITY;\n return -(dvdr + Math.sqrt(d)) / dvdv;\n }\n\n /**\n * Returns the amount of time for this particle to collide with a vertical\n * wall, assuming no interening collisions.\n *\n * @return the amount of time for this particle to collide with a vertical wall,\n * assuming no interening collisions; \n * {@code Double.POSITIVE_INFINITY} if the particle will not collide\n * with a vertical wall\n */\n public double timeToHitVerticalWall() {\n if (vx > 0) return (1.0 - rx - radius) / vx;\n else if (vx < 0) return (radius - rx) / vx; \n else return INFINITY;\n }\n\n /**\n * Returns the amount of time for this particle to collide with a horizontal\n * wall, assuming no interening collisions.\n *\n * @return the amount of time for this particle to collide with a horizontal wall,\n * assuming no interening collisions; \n * {@code Double.POSITIVE_INFINITY} if the particle will not collide\n * with a horizontal wall\n */\n public double timeToHitHorizontalWall() {\n if (vy > 0) return (1.0 - ry - radius) / vy;\n else if (vy < 0) return (radius - ry) / vy;\n else return INFINITY;\n }\n\n /**\n * Updates the velocities of this particle and the specified particle according\n * to the laws of elastic collision. Assumes that the particles are colliding\n * at this instant.\n *\n * @param that the other particle\n */\n public void bounceOff(Particle that) {\n double dx = that.rx - this.rx;\n double dy = that.ry - this.ry;\n double dvx = that.vx - this.vx;\n double dvy = that.vy - this.vy;\n double dvdr = dx*dvx + dy*dvy; // dv dot dr\n double dist = this.radius + that.radius; // distance between particle centers at collison\n\n // magnitude of normal force\n double magnitude = 2 * this.mass * that.mass * dvdr / ((this.mass + that.mass) * dist);\n\n // normal force, and in x and y directions\n double fx = magnitude * dx / dist;\n double fy = magnitude * dy / dist;\n\n // update velocities according to normal force\n this.vx += fx / this.mass;\n this.vy += fy / this.mass;\n that.vx -= fx / that.mass;\n that.vy -= fy / that.mass;\n\n // update collision counts\n this.count++;\n that.count++;\n }\n\n /**\n * Updates the velocity of this particle upon collision with a vertical\n * wall (by reflecting the velocity in the x-direction).\n * Assumes that the particle is colliding with a vertical wall at this instant.\n */\n public void bounceOffVerticalWall() {\n vx = -vx;\n count++;\n }\n\n /**\n * Updates the velocity of this particle upon collision with a horizontal\n * wall (by reflecting the velocity in the y-direction).\n * Assumes that the particle is colliding with a horizontal wall at this instant.\n */\n public void bounceOffHorizontalWall() {\n vy = -vy;\n count++;\n }\n\n /**\n * Returns the kinetic energy of this particle.\n * The kinetic energy is given by the formula 1/2 m v2,\n * where m is the mass of this particle and v is its velocity.\n *\n * @return the kinetic energy of this particle\n */\n public double kineticEnergy() {\n return 0.5 * mass * (vx*vx + vy*vy);\n }\n}\n\n/******************************************************************************\n * Copyright 2002-2016, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "code/algs4/Picture.java",
"content": "/******************************************************************************\n * Compilation: javac Picture.java\n * Execution: java Picture imagename\n * Dependencies: none\n *\n * Data type for manipulating individual pixels of an image. The original\n * image can be read from a file in jpg, gif, or png format, or the\n * user can create a blank image of a given size. Includes methods for\n * displaying the image in a window on the screen or saving to a file.\n *\n * % java Picture mandrill.jpg\n *\n * Remarks\n * -------\n * - pixel (x, y) is column x and row y, where (0, 0) is upper left\n *\n * - see also GrayPicture.java for a grayscale version\n *\n ******************************************************************************/\n\npackage algs4;\n\nimport java.awt.Color;\nimport java.awt.FileDialog;\nimport java.awt.Toolkit;\nimport java.awt.event.ActionEvent;\nimport java.awt.event.ActionListener;\nimport java.awt.event.KeyEvent;\nimport java.awt.image.BufferedImage;\nimport java.io.File;\nimport java.io.IOException;\nimport java.net.URL;\nimport javax.imageio.ImageIO;\nimport javax.swing.ImageIcon;\nimport javax.swing.JFrame;\nimport javax.swing.JLabel;\nimport javax.swing.JMenu;\nimport javax.swing.JMenuBar;\nimport javax.swing.JMenuItem;\nimport javax.swing.KeyStroke;\n\n\n/**\n * This class provides methods for manipulating individual pixels of\n * an image. The original image can be read from a {@code .jpg}, {@code .gif},\n * or {@code .png} file or the user can create a blank image of a given size.\n * This class includes methods for displaying the image in a window on\n * the screen or saving it to a file.\n * \n * Pixel (col, row) is column col and row row.\n * By default, the origin (0, 0) is the pixel in the top-left corner,\n * which is a common convention in image processing.\n * The method {@code setOriginLowerLeft()} change the origin to the lower left.\n * \n * For additional documentation, see\n * Section 3.1 of\n * Computer Science: An Interdisciplinary Approach\n * by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic final class Picture implements ActionListener {\n private BufferedImage image; // the rasterized image\n private JFrame frame; // on-screen view\n private String filename; // name of file\n private boolean isOriginUpperLeft = true; // location of origin\n private final int width, height; // width and height\n\n /**\n * Initializes a blank {@code width}-by-{@code height} picture, with {@code width} columns\n * and {@code height} rows, where each pixel is black.\n *\n * @param width the width of the picture\n * @param height the height of the picture\n * @throws IllegalArgumentException if {@code width} is negative\n * @throws IllegalArgumentException if {@code height} is negative\n */\n public Picture(int width, int height) {\n if (width < 0) throw new IllegalArgumentException(\"width must be nonnegative\");\n if (height < 0) throw new IllegalArgumentException(\"height must be nonnegative\");\n this.width = width;\n this.height = height;\n image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);\n // set to TYPE_INT_ARGB to support transparency\n filename = width + \"-by-\" + height;\n }\n\n /**\n * Initializes a new picture that is a deep copy of the argument picture.\n *\n * @param picture the picture to copy\n */\n public Picture(Picture picture) {\n width = picture.width();\n height = picture.height();\n image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);\n filename = picture.filename;\n for (int col = 0; col < width(); col++)\n for (int row = 0; row < height(); row++)\n image.setRGB(col, row, picture.get(col, row).getRGB());\n }\n\n /**\n * Initializes a picture by reading from a file or URL.\n *\n * @param filename the name of the file (.png, .gif, or .jpg) or URL.\n * @throws IllegalArgumentException if cannot read image\n */\n public Picture(String filename) {\n this.filename = filename;\n try {\n // try to read from file in working directory\n File file = new File(filename);\n if (file.isFile()) {\n image = ImageIO.read(file);\n }\n\n // now try to read from file in same directory as this .class file\n else {\n URL url = getClass().getResource(filename);\n if (url == null) {\n url = new URL(filename);\n }\n image = ImageIO.read(url);\n }\n\n if (image == null) {\n throw new IllegalArgumentException(\"could not read image file: \" + filename);\n }\n\n width = image.getWidth(null);\n height = image.getHeight(null);\n }\n catch (IOException ioe) {\n throw new IllegalArgumentException(\"could not open image file: \" + filename, ioe);\n }\n }\n\n /**\n * Initializes a picture by reading in a .png, .gif, or .jpg from a file.\n *\n * @param file the file\n * @throws IllegalArgumentException if cannot read image\n */\n public Picture(File file) {\n try {\n image = ImageIO.read(file);\n }\n catch (IOException ioe) {\n throw new IllegalArgumentException(\"could not open file: \" + file, ioe);\n }\n if (image == null) {\n throw new IllegalArgumentException(\"could not read file: \" + file);\n }\n width = image.getWidth(null);\n height = image.getHeight(null);\n filename = file.getName();\n }\n\n /**\n * Returns a JLabel containing this picture, for embedding in a JPanel,\n * JFrame or other GUI widget.\n *\n * @return the {@code JLabel}\n */\n public JLabel getJLabel() {\n if (image == null) return null; // no image available\n ImageIcon icon = new ImageIcon(image);\n return new JLabel(icon);\n }\n\n /**\n * Sets the origin to be the upper left pixel. This is the default.\n */\n public void setOriginUpperLeft() {\n isOriginUpperLeft = true;\n }\n\n /**\n * Sets the origin to be the lower left pixel.\n */\n public void setOriginLowerLeft() {\n isOriginUpperLeft = false;\n }\n\n /**\n * Displays the picture in a window on the screen.\n */\n public void show() {\n\n // create the GUI for viewing the image if needed\n if (frame == null) {\n frame = new JFrame();\n\n JMenuBar menuBar = new JMenuBar();\n JMenu menu = new JMenu(\"File\");\n menuBar.add(menu);\n JMenuItem menuItem1 = new JMenuItem(\" Save... \");\n menuItem1.addActionListener(this);\n menuItem1.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_S,\n Toolkit.getDefaultToolkit().getMenuShortcutKeyMask()));\n menu.add(menuItem1);\n frame.setJMenuBar(menuBar);\n\n\n\n frame.setContentPane(getJLabel());\n // f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);\n frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);\n frame.setTitle(filename);\n frame.setResizable(false);\n frame.pack();\n frame.setVisible(true);\n }\n\n // draw\n frame.repaint();\n }\n\n /**\n * Returns the height of the picture.\n *\n * @return the height of the picture (in pixels)\n */\n public int height() {\n return height;\n }\n\n /**\n * Returns the width of the picture.\n *\n * @return the width of the picture (in pixels)\n */\n public int width() {\n return width;\n }\n\n private void validateRow(int row) {\n if (row < 0 || row >= height())\n throw new IndexOutOfBoundsException(\"row must be between 0 and \" + (height() - 1) + \": \" + row);\n }\n\n private void validateCol(int col) {\n if (col < 0 || col >= width())\n throw new IndexOutOfBoundsException(\"col must be between 0 and \" + (width() - 1) + \": \" + col);\n }\n\n /**\n * Returns the color of pixel ({@code col}, {@code row}).\n *\n * @param col the column index\n * @param row the row index\n * @return the color of pixel ({@code col}, {@code row})\n * @throws IndexOutOfBoundsException unless both {@code 0 <= col < width} and {@code 0 <= row < height}\n */\n public Color get(int col, int row) {\n validateCol(col);\n validateRow(row);\n if (isOriginUpperLeft) return new Color(image.getRGB(col, row));\n else return new Color(image.getRGB(col, height - row - 1));\n }\n\n /**\n * Sets the color of pixel ({@code col}, {@code row}) to given color.\n *\n * @param col the column index\n * @param row the row index\n * @param color the color\n * @throws IndexOutOfBoundsException unless both {@code 0 <= col < width} and {@code 0 <= row < height}\n * @throws IllegalArgumentException if {@code color} is {@code null}\n */\n public void set(int col, int row, Color color) {\n validateCol(col);\n validateRow(row);\n if (color == null) throw new IllegalArgumentException(\"color argument is null\");\n if (isOriginUpperLeft) image.setRGB(col, row, color.getRGB());\n else image.setRGB(col, height - row - 1, color.getRGB());\n }\n\n /**\n * Returns true if this picture is equal to the argument picture.\n *\n * @param other the other picture\n * @return {@code true} if this picture is the same dimension as {@code other}\n * and if all pixels have the same color; {@code false} otherwise\n */\n public boolean equals(Object other) {\n if (other == this) return true;\n if (other == null) return false;\n if (other.getClass() != this.getClass()) return false;\n Picture that = (Picture) other;\n if (this.width() != that.width()) return false;\n if (this.height() != that.height()) return false;\n for (int col = 0; col < width(); col++)\n for (int row = 0; row < height(); row++)\n if (!this.get(col, row).equals(that.get(col, row))) return false;\n return true;\n }\n\n /**\n * This operation is not supported because pictures are mutable.\n *\n * @return does not return a value\n * @throws UnsupportedOperationException if called\n */\n public int hashCode() {\n throw new UnsupportedOperationException(\"hashCode() is not supported because pictures are mutable\");\n }\n\n /**\n * Saves the picture to a file in a standard image format.\n * The filetype must be .png or .jpg.\n *\n * @param name the name of the file\n */\n public void save(String name) {\n save(new File(name));\n }\n\n /**\n * Saves the picture to a file in a PNG or JPEG image format.\n *\n * @param file the file\n */\n public void save(File file) {\n filename = file.getName();\n if (frame != null) frame.setTitle(filename);\n String suffix = filename.substring(filename.lastIndexOf('.') + 1);\n if (\"jpg\".equalsIgnoreCase(suffix) || \"png\".equalsIgnoreCase(suffix)) {\n try {\n ImageIO.write(image, suffix, file);\n }\n catch (IOException e) {\n e.printStackTrace();\n }\n }\n else {\n System.out.println(\"Error: filename must end in .jpg or .png\");\n }\n }\n\n /**\n * Opens a save dialog box when the user selects \"Save As\" from the menu.\n */\n @Override\n public void actionPerformed(ActionEvent e) {\n FileDialog chooser = new FileDialog(frame,\n \"Use a .png or .jpg extension\", FileDialog.SAVE);\n chooser.setVisible(true);\n if (chooser.getFile() != null) {\n save(chooser.getDirectory() + File.separator + chooser.getFile());\n }\n }\n\n\n /**\n * Unit tests this {@code Picture} data type.\n * Reads a picture specified by the command-line argument,\n * and shows it in a window on the screen.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n Picture picture = new Picture(args[0]);\n System.out.printf(\"%d-by-%d\\n\", picture.width(), picture.height());\n picture.show();\n }\n\n}\n\n\n/******************************************************************************\n * Copyright 2002-2016, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "code/algs4/PictureDump.java",
"content": "/******************************************************************************\n * Compilation: javac PictureDump.java\n * Execution: java PictureDump width height < file\n * Dependencies: BinaryStdIn.java Picture.java\n * Data file: http://introcs.cs.princeton.edu/stdlib/abra.txt\n * \n * Reads in a binary file and writes out the bits as w-by-h picture,\n * with the 1 bits in black and the 0 bits in white.\n *\n * % more abra.txt \n * ABRACADABRA!\n *\n * % java PictureDump 16 6 < abra.txt\n *\n ******************************************************************************/\n\npackage algs4;\n\nimport java.awt.Color;\n\n\n/**\n * The {@code PictureDump} class provides a client for displaying the contents\n * of a binary file as a black-and-white picture.\n * \n * For additional documentation,\n * see Section 5.5 of\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n * \n * See also {@link BinaryDump} and {@link HexDump}.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic class PictureDump {\n\n // Do not instantiate.\n private PictureDump() { }\n\n /**\n * Reads in a sequence of bytes from standard input and draws\n * them to standard drawing output as a width-by-height picture,\n * using black for 1 and white for 0 (and red for any leftover\n * pixels).\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n int width = Integer.parseInt(args[0]);\n int height = Integer.parseInt(args[1]);\n Picture picture = new Picture(width, height);\n for (int row = 0; row < height; row++) {\n for (int col = 0; col < width; col++) {\n if (!BinaryStdIn.isEmpty()) {\n boolean bit = BinaryStdIn.readBoolean();\n if (bit) picture.set(col, row, Color.BLACK);\n else picture.set(col, row, Color.WHITE);\n }\n else {\n picture.set(col, row, Color.RED);\n }\n }\n }\n picture.show();\n }\n}\n\n/******************************************************************************\n * Copyright 2002-2016, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "code/algs4/Point2D.java",
"content": "/******************************************************************************\n * Compilation: javac Point2D.java\n * Execution: java Point2D x0 y0 N\n * Dependencies: StdDraw.java StdRandom.java\n *\n * Immutable point data type for points in the plane.\n *\n ******************************************************************************/\n\npackage algs4;\n\nimport java.util.Arrays;\nimport java.util.Comparator;\n\n\n/**\n * The {@code Point} class is an immutable data type to encapsulate a\n * two-dimensional point with real-value coordinates.\n * \n * Note: in order to deal with the difference behavior of double and \n * Double with respect to -0.0 and +0.0, the Point2D constructor converts\n * any coordinates that are -0.0 to +0.0.\n * \n * For additional documentation, \n * see Section 1.2 of \n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne. \n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic final class Point2D implements Comparable \n * This implementation uses a singly-linked list with a static nested class for\n * linked-list nodes. See {@link LinkedQueue} for the version from the\n * textbook that uses a non-static nested class.\n * The enqueue, dequeue, peek, size, and is-empty\n * operations all take constant time in the worst case.\n * \n * For additional documentation, see Section 1.3 of\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n *\n * @param \n * Even though this implementation include the method {@code equals()}, it\n * does not support the method {@code hashCode()} because sets are mutable.\n * \n * This implementation uses a balanced binary search tree. It requires that\n * the key type implements the {@code Comparable} interface and calls the\n * {@code compareTo()} and method to compare two keys. It does not call either\n * {@code equals()} or {@code hashCode()}.\n * The add, contains, delete, minimum,\n * maximum, ceiling, and floor methods take\n * logarithmic time in the worst case.\n * The size, and is-empty operations take constant time.\n * Construction takes constant time.\n * \n * This implementation uses a balanced binary search tree. It requires that\n * For additional documentation, see\n * Section 3.5 of\n * Algorithms in Java, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n *\n * @param \n * Note that this method declares two empty sets to be equal\n * even if they are parameterized by different generic types.\n * This is consistent with the behavior of {@code equals()} \n * within Java's Collections framework.\n * \n * @param other the other set\n * @return {@code true} if this set equals {@code other};\n * {@code false} otherwise\n */\n @Override\n public boolean equals(Object other) {\n if (other == this) return true;\n if (other == null) return false;\n if (other.getClass() != this.getClass()) return false;\n SET that = (SET) other;\n return this.set.equals(that.set);\n }\n\n /**\n * This operation is not supported because sets are mutable.\n *\n * @return does not return a value\n * @throws UnsupportedOperationException if called\n */\n @Override\n public int hashCode() {\n throw new UnsupportedOperationException(\"hashCode() is not supported because sets are mutable\");\n }\n\n /**\n * Returns a string representation of this set.\n *\n * @return a string representation of this set, enclosed in curly braces,\n * with adjacent keys separated by a comma and a space\n */\n @Override\n public String toString() {\n String s = set.toString();\n return \"{ \" + s.substring(1, s.length() - 1) + \" }\";\n }\n\n /**\n * Unit tests the {@code SET} data type.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n SET \n * This implementation uses a balanced binary search tree. It requires that\n * the key type implements the {@code Comparable} interface and calls the\n * {@code compareTo()} and method to compare two keys. It does not call either\n * {@code equals()} or {@code hashCode()}.\n * The put, contains, remove, minimum,\n * maximum, ceiling, and floor operations each take\n * logarithmic time in the worst case.\n * The size, and is-empty operations take constant time.\n * Construction takes constant time.\n * \n * For additional documentation, see Section 3.5 of\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n *\n * @param \n * To iterate over all of the keys in the symbol table named {@code st},\n * use the foreach notation: {@code for (Key key : st.keys())}.\n *\n * @return all keys in this symbol table\n */\n public Iterable \n * This method is provided for backward compatibility with the version from\n * Introduction to Programming in Java: An Interdisciplinary Approach.\n *\n * @return an iterator to all of the keys in this symbol table\n * @deprecated Replaced by {@link #keys()}.\n */\n @Deprecated\n public Iterator \n * This implementation uses a singly-linked list with a static nested class for\n * linked-list nodes. See {@link LinkedStack} for the version from the\n * textbook that uses a non-static nested class.\n * The push, pop, peek, size, and is-empty\n * operations all take constant time in the worst case.\n * \n * For additional documentation,\n * see Section 1.3 of\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n *\n * @param \n * Getting started.\n * To use standard drawing, you must have {@code StdDraw.class} in your\n * Java classpath. If you used our autoinstaller, you should be all set.\n * Otherwise, download\n * StdDraw.java\n * and put a copy in your working directory.\n * \n * Now, type the following short program into your editor:\n * \n * Points and lines.\n * You can draw points and line segments with the following methods:\n * \n * The x- and y-coordinates must be in the drawing area\n * (between 0 and 1 and by default) or the points and lines will not be visible.\n * \n * Squares, circles, rectangles, and ellipses.\n * You can draw squares, circles, rectangles, and ellipses using\n * the following methods:\n * \n * All of these methods take as arguments the location and size of the shape.\n * The location is always specified by the x- and y-coordinates\n * of its center.\n * The size of a circle is specified by its radius and the size of an ellipse is\n * specified by the lengths of its semi-major and semi-minor axes.\n * The size of a square or rectangle is specified by its half-width or half-height.\n * The convention for drawing squares and rectangles is parallel to those for\n * drawing circles and ellipses, but may be unexpected to the uninitiated.\n * \n * The methods above trace outlines of the given shapes. The following methods\n * draw filled versions:\n * \n * Circular arcs.\n * You can draw circular arcs with the following method:\n * \n * The arc is from the circle centered at (x, y) of the specified radius.\n * The arc extends from angle1 to angle2. By convention, the angles are\n * polar (counterclockwise angle from the x-axis)\n * and represented in degrees. For example, {@code StdDraw.arc(0.0, 0.0, 1.0, 0, 90)}\n * draws the arc of the unit circle from 3 o'clock (0 degrees) to 12 o'clock (90 degrees).\n * \n * Polygons.\n * You can draw polygons with the following methods:\n * \n * The points in the polygon are ({@code x[i]}, {@code y[i]}).\n * For example, the following code fragment draws a filled diamond\n * with vertices (0.1, 0.2), (0.2, 0.3), (0.3, 0.2), and (0.2, 0.1):\n * \n * Pen size.\n * The pen is circular, so that when you set the pen radius to r\n * and draw a point, you get a circle of radius r. Also, lines are\n * of thickness 2r and have rounded ends. The default pen radius\n * is 0.005 and is not affected by coordinate scaling. This default pen\n * radius is about 1/200 the width of the default canvas, so that if\n * you draw 100 points equally spaced along a horizontal or vertical line,\n * you will be able to see individual circles, but if you draw 200 such\n * points, the result will look like a line.\n * \n * For example, {@code StdDraw.setPenRadius(0.025)} makes\n * the thickness of the lines and the size of the points to be five times\n * the 0.005 default.\n * To draw points with the minimum possible radius (one pixel on typical\n * displays), set the pen radius to 0.0.\n * \n * Pen color.\n * All geometric shapes (such as points, lines, and circles) are drawn using\n * the current pen color. By default, it is black.\n * You can change the pen color with the following methods:\n * \n * The first method allows you to specify colors using the RGB color system.\n * This color picker\n * is a convenient way to find a desired color.\n * The second method allows you to specify colors using the\n * {@link Color} data type that is discussed in Chapter 3. Until then,\n * you can use this method with one of these predefined colors in standard drawing:\n * {@link #BLACK}, {@link #BLUE}, {@link #CYAN}, {@link #DARK_GRAY}, {@link #GRAY},\n * {@link #GREEN}, {@link #LIGHT_GRAY}, {@link #MAGENTA}, {@link #ORANGE},\n * {@link #PINK}, {@link #RED}, {@link #WHITE}, and {@link #YELLOW}.\n * For example, {@code StdDraw.setPenColor(StdDraw.MAGENTA)} sets the\n * pen color to magenta.\n * \n * Canvas size.\n * By default, all drawing takes places in a 512-by-512 canvas.\n * The canvas does not include the window title or window border.\n * You can change the size of the canvas with the following method:\n * \n * This sets the canvas size to be width-by-height pixels.\n * It also erases the current drawing and resets the coordinate system,\n * pen radius, pen color, and font back to their default values.\n * Ordinarly, this method is called once, at the very beginning of a program.\n * For example, {@code StdDraw.setCanvasSize(800, 800)}\n * sets the canvas size to be 800-by-800 pixels.\n * \n * Canvas scale and coordinate system.\n * By default, all drawing takes places in the unit square, with (0, 0) at\n * lower left and (1, 1) at upper right. You can change the default\n * coordinate system with the following methods:\n * \n * The arguments are the coordinates of the minimum and maximum \n * x- or y-coordinates that will appear in the canvas.\n * For example, if you wish to use the default coordinate system but\n * leave a small margin, you can call {@code StdDraw.setScale(-.05, 1.05)}.\n * \n * These methods change the coordinate system for subsequent drawing\n * commands; they do not affect previous drawings.\n * These methods do not change the canvas size; so, if the x-\n * and y-scales are different, squares will become rectangles\n * and circles will become ellipsoidal.\n * \n * Text.\n * You can use the following methods to annotate your drawings with text:\n * \n * The first two methods write the specified text in the current font,\n * centered at (x, y).\n * The second method allows you to rotate the text.\n * The last two methods either left- or right-align the text at (x, y).\n * \n * The default font is a Sans Serif font with point size 16.\n * You can use the following method to change the font:\n * \n * You use the {@link Font} data type to specify the font. This allows you to\n * choose the face, size, and style of the font. For example, the following\n * code fragment sets the font to Arial Bold, 60 point.\n * \n * Images.\n * You can use the following methods to add images to your drawings:\n * \n * These methods draw the specified image, centered at (x, y).\n * The supported image formats are JPEG, PNG, and GIF.\n * The image will display at its native size, independent of the coordinate system.\n * Optionally, you can rotate the image a specified number of degrees counterclockwise\n * or rescale it to fit snugly inside a width-by-height bounding box.\n * \n * Saving to a file.\n * You save your image to a file using the File → Save menu option.\n * You can also save a file programatically using the following method:\n * \n * The supported image formats are JPEG and PNG. The filename must have either the\n * extension .jpg or .png.\n * We recommend using PNG for drawing that consist solely of geometric shapes and JPEG \n * for drawings that contains pictures.\n * \n * Clearing the canvas.\n * To clear the entire drawing canvas, you can use the following methods:\n * \n * The first method clears the canvas to white; the second method\n * allows you to specify a color of your choice. For example,\n * {@code StdDraw.clear(StdDraw.LIGHT_GRAY)} clears the canvas to a shade\n * of gray.\n * \n * Computer animations and double buffering.\n * Double buffering is one of the most powerful features of standard drawing,\n * enabling computer animations.\n * The following methods control the way in which objects are drawn:\n * \n * By default, double buffering is disabled, which means that as soon as you\n * call a drawing\n * method—such as {@code point()} or {@code line()}—the\n * results appear on the screen.\n * \n * When double buffering is enabled by calling {@link #enableDoubleBuffering()},\n * all drawing takes place on the offscreen canvas. The offscreen canvas\n * is not displayed. Only when you call\n * {@link #show()} does your drawing get copied from the offscreen canvas to\n * the onscreen canvas, where it is displayed in the standard drawing window. You \n * can think of double buffering as collecting all of the lines, points, shapes,\n * and text that you tell it to draw, and then drawing them all\n * simultaneously, upon request.\n * \n * The most important use of double buffering is to produce computer\n * animations, creating the illusion of motion by rapidly\n * displaying static drawings. To produce an animation, repeat\n * the following four steps:\n * \n * The {@link #clear()}, {@link #show()}, and {@link #pause(int dt)} methods\n * support the first, third, and fourth of these steps, respectively.\n * \n * For example, this code fragment animates two balls moving in a circle.\n * \n * Keyboard and mouse inputs.\n * Standard drawing has very basic support for keyboard and mouse input.\n * It is much less powerful than most user interface libraries provide, but also much simpler.\n * You can use the following methods to intercept mouse events:\n * \n * The first method tells you whether a mouse button is currently being pressed.\n * The last two methods tells you the x- and y-coordinates of the mouse's\n * current position, using the same coordinate system as the canvas (the unit square, by default).\n * You should use these methods in an animation loop that waits a short while before trying\n * to poll the mouse for its current state.\n * You can use the following methods to intercept keyboard events:\n * \n * If the user types lots of keys, they will be saved in a list until you process them.\n * The first method tells you whether the user has typed a key (that your program has\n * not yet processed).\n * The second method returns the next key that the user typed (that your program has\n * not yet processed) and removes it from the list of saved keystrokes.\n * The third method tells you whether a key is currently being pressed.\n * \n * Accessing control parameters.\n * You can use the following methods to access the current pen color, pen radius,\n * and font:\n * \n * These methods are useful when you want to temporarily change a\n * control parameter and reset it back to its original value.\n * \n * Corner cases.\n * To avoid clutter, the API doesn't explicitly refer to arguments that are\n * null, infinity, or NaN.\n * \n * Performance tricks.\n * Standard drawing is capable of drawing large amounts of data.\n * Here are a few tricks and tips:\n * \n * Known bugs and issues.\n * \n * Reference.\n * For additional documentation,\n * see Section 1.5 of\n * Introduction to Programming in Java: An Interdisciplinary Approach\n * by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic final class StdDraw implements ActionListener, MouseListener, MouseMotionListener, KeyListener {\n\n /**\n * The color black.\n */\n public static final Color BLACK = Color.BLACK;\n\n /**\n * The color blue.\n */\n public static final Color BLUE = Color.BLUE;\n\n /**\n * The color cyan.\n */\n public static final Color CYAN = Color.CYAN;\n\n /**\n * The color dark gray.\n */\n public static final Color DARK_GRAY = Color.DARK_GRAY;\n\n /**\n * The color gray.\n */\n public static final Color GRAY = Color.GRAY;\n\n /**\n * The color green.\n */\n public static final Color GREEN = Color.GREEN;\n\n /**\n * The color light gray.\n */\n public static final Color LIGHT_GRAY = Color.LIGHT_GRAY;\n\n /**\n * The color magenta.\n */\n public static final Color MAGENTA = Color.MAGENTA;\n\n /**\n * The color orange.\n */\n public static final Color ORANGE = Color.ORANGE;\n\n /**\n * The color pink.\n */\n public static final Color PINK = Color.PINK;\n\n /**\n * The color red.\n */\n public static final Color RED = Color.RED;\n\n /**\n * The color white.\n */\n public static final Color WHITE = Color.WHITE;\n\n /**\n * The color yellow.\n */\n public static final Color YELLOW = Color.YELLOW;\n\n /**\n * Shade of blue used in Introduction to Programming in Java.\n * It is Pantone 300U. The RGB values are approximately (9, 90, 166).\n */\n public static final Color BOOK_BLUE = new Color(9, 90, 166);\n\n /**\n * Shade of light blue used in Introduction to Programming in Java.\n * The RGB values are approximately (103, 198, 243).\n */\n public static final Color BOOK_LIGHT_BLUE = new Color(103, 198, 243);\n\n /**\n * Shade of red used in Algorithms, 4th edition.\n * It is Pantone 1805U. The RGB values are approximately (150, 35, 31).\n */\n public static final Color BOOK_RED = new Color(150, 35, 31);\n\n // default colors\n private static final Color DEFAULT_PEN_COLOR = BLACK;\n private static final Color DEFAULT_CLEAR_COLOR = WHITE;\n\n // current pen color\n private static Color penColor;\n\n // default canvas size is DEFAULT_SIZE-by-DEFAULT_SIZE\n private static final int DEFAULT_SIZE = 512;\n private static int width = DEFAULT_SIZE;\n private static int height = DEFAULT_SIZE;\n\n // default pen radius\n private static final double DEFAULT_PEN_RADIUS = 0.002;\n\n // current pen radius\n private static double penRadius;\n\n // show we draw immediately or wait until next show?\n private static boolean defer = false;\n\n // boundary of drawing canvas, 0% border\n // private static final double BORDER = 0.05;\n private static final double BORDER = 0.00;\n private static final double DEFAULT_XMIN = 0.0;\n private static final double DEFAULT_XMAX = 1.0;\n private static final double DEFAULT_YMIN = 0.0;\n private static final double DEFAULT_YMAX = 1.0;\n private static double xmin, ymin, xmax, ymax;\n\n // for synchronization\n private static Object mouseLock = new Object();\n private static Object keyLock = new Object();\n\n // default font\n private static final Font DEFAULT_FONT = new Font(\"SansSerif\", Font.PLAIN, 16);\n\n // current font\n private static Font font;\n\n // double buffered graphics\n private static BufferedImage offscreenImage, onscreenImage;\n private static Graphics2D offscreen, onscreen;\n\n // singleton for callbacks: avoids generation of extra .class files\n private static StdDraw std = new StdDraw();\n\n // the frame for drawing to the screen\n private static JFrame frame;\n\n // mouse state\n private static boolean mousePressed = false;\n private static double mouseX = 0;\n private static double mouseY = 0;\n\n // queue of typed key characters\n private static LinkedList \n * The predefined pen colors are\n * {@code StdDraw.BLACK}, {@code StdDraw.BLUE}, {@code StdDraw.CYAN},\n * {@code StdDraw.DARK_GRAY}, {@code StdDraw.GRAY}, {@code StdDraw.GREEN},\n * {@code StdDraw.LIGHT_GRAY}, {@code StdDraw.MAGENTA}, {@code StdDraw.ORANGE},\n * {@code StdDraw.PINK}, {@code StdDraw.RED}, {@code StdDraw.WHITE}, and\n * {@code StdDraw.YELLOW}.\n *\n * @param color the color to make the pen\n */\n public static void setPenColor(Color color) {\n if (color == null) throw new NullPointerException();\n penColor = color;\n offscreen.setColor(penColor);\n }\n\n /**\n * Sets the pen color to the specified RGB color.\n *\n * @param red the amount of red (between 0 and 255)\n * @param green the amount of green (between 0 and 255)\n * @param blue the amount of blue (between 0 and 255)\n * @throws IllegalArgumentException if {@code red}, {@code green},\n * or {@code blue} is outside its prescribed range\n */\n public static void setPenColor(int red, int green, int blue) {\n if (red < 0 || red >= 256) throw new IllegalArgumentException(\"amount of red must be between 0 and 255\");\n if (green < 0 || green >= 256) throw new IllegalArgumentException(\"amount of green must be between 0 and 255\");\n if (blue < 0 || blue >= 256) throw new IllegalArgumentException(\"amount of blue must be between 0 and 255\");\n setPenColor(new Color(red, green, blue));\n }\n\n /**\n * Returns the current font.\n *\n * @return the current font\n */\n public static Font getFont() {\n return font;\n }\n\n /**\n * Sets the font to the default font (sans serif, 16 point).\n */\n public static void setFont() {\n setFont(DEFAULT_FONT);\n }\n\n /**\n * Sets the font to the specified value.\n *\n * @param font the font\n */\n public static void setFont(Font font) {\n if (font == null) throw new NullPointerException();\n StdDraw.font = font;\n }\n\n\n /***************************************************************************\n * Drawing geometric shapes.\n ***************************************************************************/\n\n /**\n * Draws a line segment between (x0, y0) and\n * (x1, y1).\n *\n * @param x0 the x-coordinate of one endpoint\n * @param y0 the y-coordinate of one endpoint\n * @param x1 the x-coordinate of the other endpoint\n * @param y1 the y-coordinate of the other endpoint\n */\n public static void line(double x0, double y0, double x1, double y1) {\n offscreen.draw(new Line2D.Double(scaleX(x0), scaleY(y0), scaleX(x1), scaleY(y1)));\n draw();\n }\n\n /**\n * Draws one pixel at (x, y).\n * This method is private because pixels depend on the display.\n * To achieve the same effect, set the pen radius to 0 and call {@code point()}.\n *\n * @param x the x-coordinate of the pixel\n * @param y the y-coordinate of the pixel\n */\n private static void pixel(double x, double y) {\n offscreen.fillRect((int) Math.round(scaleX(x)), (int) Math.round(scaleY(y)), 1, 1);\n }\n\n /**\n * Draws a point centered at (x, y).\n * The point is a filled circle whose radius is equal to the pen radius.\n * To draw a single-pixel point, first set the pen radius to 0.\n *\n * @param x the x-coordinate of the point\n * @param y the y-coordinate of the point\n */\n public static void point(double x, double y) {\n double xs = scaleX(x);\n double ys = scaleY(y);\n double r = penRadius;\n float scaledPenRadius = (float) (r * DEFAULT_SIZE);\n\n // double ws = factorX(2*r);\n // double hs = factorY(2*r);\n // if (ws <= 1 && hs <= 1) pixel(x, y);\n if (scaledPenRadius <= 1) pixel(x, y);\n else offscreen.fill(new Ellipse2D.Double(xs - scaledPenRadius/2, ys - scaledPenRadius/2,\n scaledPenRadius, scaledPenRadius));\n draw();\n }\n\n /**\n * Draws a circle of the specified radius, centered at (x, y).\n *\n * @param x the x-coordinate of the center of the circle\n * @param y the y-coordinate of the center of the circle\n * @param radius the radius of the circle\n * @throws IllegalArgumentException if {@code radius} is negative\n */\n public static void circle(double x, double y, double radius) {\n if (!(radius >= 0)) throw new IllegalArgumentException(\"radius must be nonnegative\");\n double xs = scaleX(x);\n double ys = scaleY(y);\n double ws = factorX(2*radius);\n double hs = factorY(2*radius);\n if (ws <= 1 && hs <= 1) pixel(x, y);\n else offscreen.draw(new Ellipse2D.Double(xs - ws/2, ys - hs/2, ws, hs));\n draw();\n }\n\n /**\n * Draws a filled circle of the specified radius, centered at (x, y).\n *\n * @param x the x-coordinate of the center of the circle\n * @param y the y-coordinate of the center of the circle\n * @param radius the radius of the circle\n * @throws IllegalArgumentException if {@code radius} is negative\n */\n public static void filledCircle(double x, double y, double radius) {\n if (!(radius >= 0)) throw new IllegalArgumentException(\"radius must be nonnegative\");\n double xs = scaleX(x);\n double ys = scaleY(y);\n double ws = factorX(2*radius);\n double hs = factorY(2*radius);\n if (ws <= 1 && hs <= 1) pixel(x, y);\n else offscreen.fill(new Ellipse2D.Double(xs - ws/2, ys - hs/2, ws, hs));\n draw();\n }\n\n\n /**\n * Draws an ellipse with the specified semimajor and semiminor axes,\n * centered at (x, y).\n *\n * @param x the x-coordinate of the center of the ellipse\n * @param y the y-coordinate of the center of the ellipse\n * @param semiMajorAxis is the semimajor axis of the ellipse\n * @param semiMinorAxis is the semiminor axis of the ellipse\n * @throws IllegalArgumentException if either {@code semiMajorAxis}\n * or {@code semiMinorAxis} is negative\n */\n public static void ellipse(double x, double y, double semiMajorAxis, double semiMinorAxis) {\n if (!(semiMajorAxis >= 0)) throw new IllegalArgumentException(\"ellipse semimajor axis must be nonnegative\");\n if (!(semiMinorAxis >= 0)) throw new IllegalArgumentException(\"ellipse semiminor axis must be nonnegative\");\n double xs = scaleX(x);\n double ys = scaleY(y);\n double ws = factorX(2*semiMajorAxis);\n double hs = factorY(2*semiMinorAxis);\n if (ws <= 1 && hs <= 1) pixel(x, y);\n else offscreen.draw(new Ellipse2D.Double(xs - ws/2, ys - hs/2, ws, hs));\n draw();\n }\n\n /**\n * Draws an ellipse with the specified semimajor and semiminor axes,\n * centered at (x, y).\n *\n * @param x the x-coordinate of the center of the ellipse\n * @param y the y-coordinate of the center of the ellipse\n * @param semiMajorAxis is the semimajor axis of the ellipse\n * @param semiMinorAxis is the semiminor axis of the ellipse\n * @throws IllegalArgumentException if either {@code semiMajorAxis}\n * or {@code semiMinorAxis} is negative\n */\n public static void filledEllipse(double x, double y, double semiMajorAxis, double semiMinorAxis) {\n if (!(semiMajorAxis >= 0)) throw new IllegalArgumentException(\"ellipse semimajor axis must be nonnegative\");\n if (!(semiMinorAxis >= 0)) throw new IllegalArgumentException(\"ellipse semiminor axis must be nonnegative\");\n double xs = scaleX(x);\n double ys = scaleY(y);\n double ws = factorX(2*semiMajorAxis);\n double hs = factorY(2*semiMinorAxis);\n if (ws <= 1 && hs <= 1) pixel(x, y);\n else offscreen.fill(new Ellipse2D.Double(xs - ws/2, ys - hs/2, ws, hs));\n draw();\n }\n\n\n /**\n * Draws a circular arc of the specified radius,\n * centered at (x, y), from angle1 to angle2 (in degrees).\n *\n * @param x the x-coordinate of the center of the circle\n * @param y the y-coordinate of the center of the circle\n * @param radius the radius of the circle\n * @param angle1 the starting angle. 0 would mean an arc beginning at 3 o'clock.\n * @param angle2 the angle at the end of the arc. For example, if\n * you want a 90 degree arc, then angle2 should be angle1 + 90.\n * @throws IllegalArgumentException if {@code radius} is negative\n */\n public static void arc(double x, double y, double radius, double angle1, double angle2) {\n if (radius < 0) throw new IllegalArgumentException(\"arc radius must be nonnegative\");\n while (angle2 < angle1) angle2 += 360;\n double xs = scaleX(x);\n double ys = scaleY(y);\n double ws = factorX(2*radius);\n double hs = factorY(2*radius);\n if (ws <= 1 && hs <= 1) pixel(x, y);\n else offscreen.draw(new Arc2D.Double(xs - ws/2, ys - hs/2, ws, hs, angle1, angle2 - angle1, Arc2D.OPEN));\n draw();\n }\n\n /**\n * Draws a square of side length 2r, centered at (x, y).\n *\n * @param x the x-coordinate of the center of the square\n * @param y the y-coordinate of the center of the square\n * @param halfLength one half the length of any side of the square\n * @throws IllegalArgumentException if {@code halfLength} is negative\n */\n public static void square(double x, double y, double halfLength) {\n if (!(halfLength >= 0)) throw new IllegalArgumentException(\"half length must be nonnegative\");\n double xs = scaleX(x);\n double ys = scaleY(y);\n double ws = factorX(2*halfLength);\n double hs = factorY(2*halfLength);\n if (ws <= 1 && hs <= 1) pixel(x, y);\n else offscreen.draw(new Rectangle2D.Double(xs - ws/2, ys - hs/2, ws, hs));\n draw();\n }\n\n /**\n * Draws a filled square of the specified size, centered at (x, y).\n *\n * @param x the x-coordinate of the center of the square\n * @param y the y-coordinate of the center of the square\n * @param halfLength one half the length of any side of the square\n * @throws IllegalArgumentException if {@code halfLength} is negative\n */\n public static void filledSquare(double x, double y, double halfLength) {\n if (!(halfLength >= 0)) throw new IllegalArgumentException(\"half length must be nonnegative\");\n double xs = scaleX(x);\n double ys = scaleY(y);\n double ws = factorX(2*halfLength);\n double hs = factorY(2*halfLength);\n if (ws <= 1 && hs <= 1) pixel(x, y);\n else offscreen.fill(new Rectangle2D.Double(xs - ws/2, ys - hs/2, ws, hs));\n draw();\n }\n\n\n /**\n * Draws a rectangle of the specified size, centered at (x, y).\n *\n * @param x the x-coordinate of the center of the rectangle\n * @param y the y-coordinate of the center of the rectangle\n * @param halfWidth one half the width of the rectangle\n * @param halfHeight one half the height of the rectangle\n * @throws IllegalArgumentException if either {@code halfWidth} or {@code halfHeight} is negative\n */\n public static void rectangle(double x, double y, double halfWidth, double halfHeight) {\n if (!(halfWidth >= 0)) throw new IllegalArgumentException(\"half width must be nonnegative\");\n if (!(halfHeight >= 0)) throw new IllegalArgumentException(\"half height must be nonnegative\");\n double xs = scaleX(x);\n double ys = scaleY(y);\n double ws = factorX(2*halfWidth);\n double hs = factorY(2*halfHeight);\n if (ws <= 1 && hs <= 1) pixel(x, y);\n else offscreen.draw(new Rectangle2D.Double(xs - ws/2, ys - hs/2, ws, hs));\n draw();\n }\n\n /**\n * Draws a filled rectangle of the specified size, centered at (x, y).\n *\n * @param x the x-coordinate of the center of the rectangle\n * @param y the y-coordinate of the center of the rectangle\n * @param halfWidth one half the width of the rectangle\n * @param halfHeight one half the height of the rectangle\n * @throws IllegalArgumentException if either {@code halfWidth} or {@code halfHeight} is negative\n */\n public static void filledRectangle(double x, double y, double halfWidth, double halfHeight) {\n if (!(halfWidth >= 0)) throw new IllegalArgumentException(\"half width must be nonnegative\");\n if (!(halfHeight >= 0)) throw new IllegalArgumentException(\"half height must be nonnegative\");\n double xs = scaleX(x);\n double ys = scaleY(y);\n double ws = factorX(2*halfWidth);\n double hs = factorY(2*halfHeight);\n if (ws <= 1 && hs <= 1) pixel(x, y);\n else offscreen.fill(new Rectangle2D.Double(xs - ws/2, ys - hs/2, ws, hs));\n draw();\n }\n\n\n /**\n * Draws a polygon with the vertices \n * (x0, y0),\n * (x1, y1), ...,\n * (xn−1, yn−1).\n *\n * @param x an array of all the x-coordinates of the polygon\n * @param y an array of all the y-coordinates of the polygon\n * @throws IllegalArgumentException unless {@code x[]} and {@code y[]}\n * are of the same length\n */\n public static void polygon(double[] x, double[] y) {\n if (x == null) throw new NullPointerException();\n if (y == null) throw new NullPointerException();\n int n1 = x.length;\n int n2 = y.length;\n if (n1 != n2) throw new IllegalArgumentException(\"arrays must be of the same length\");\n int n = n1;\n GeneralPath path = new GeneralPath();\n path.moveTo((float) scaleX(x[0]), (float) scaleY(y[0]));\n for (int i = 0; i < n; i++)\n path.lineTo((float) scaleX(x[i]), (float) scaleY(y[i]));\n path.closePath();\n offscreen.draw(path);\n draw();\n }\n\n /**\n * Draws a polygon with the vertices \n * (x0, y0),\n * (x1, y1), ...,\n * (xn−1, yn−1).\n *\n * @param x an array of all the x-coordinates of the polygon\n * @param y an array of all the y-coordinates of the polygon\n * @throws IllegalArgumentException unless {@code x[]} and {@code y[]}\n * are of the same length\n */\n public static void filledPolygon(double[] x, double[] y) {\n if (x == null) throw new NullPointerException();\n if (y == null) throw new NullPointerException();\n int n1 = x.length;\n int n2 = y.length;\n if (n1 != n2) throw new IllegalArgumentException(\"arrays must be of the same length\");\n int n = n1;\n GeneralPath path = new GeneralPath();\n path.moveTo((float) scaleX(x[0]), (float) scaleY(y[0]));\n for (int i = 0; i < n; i++)\n path.lineTo((float) scaleX(x[i]), (float) scaleY(y[i]));\n path.closePath();\n offscreen.fill(path);\n draw();\n }\n\n\n /***************************************************************************\n * Drawing images.\n ***************************************************************************/\n // get an image from the given filename\n private static Image getImage(String filename) {\n if (filename == null) throw new NullPointerException();\n\n // to read from file\n ImageIcon icon = new ImageIcon(filename);\n\n // try to read from URL\n if ((icon == null) || (icon.getImageLoadStatus() != MediaTracker.COMPLETE)) {\n try {\n URL url = new URL(filename);\n icon = new ImageIcon(url);\n }\n catch (Exception e) {\n /* not a url */\n }\n }\n\n // in case file is inside a .jar (classpath relative to StdDraw)\n if ((icon == null) || (icon.getImageLoadStatus() != MediaTracker.COMPLETE)) {\n URL url = StdDraw.class.getResource(filename);\n if (url != null)\n icon = new ImageIcon(url);\n }\n\n // in case file is inside a .jar (classpath relative to root of jar)\n if ((icon == null) || (icon.getImageLoadStatus() != MediaTracker.COMPLETE)) {\n URL url = StdDraw.class.getResource(\"/\" + filename);\n if (url == null) throw new IllegalArgumentException(\"image \" + filename + \" not found\");\n icon = new ImageIcon(url);\n }\n\n return icon.getImage();\n }\n\n /***************************************************************************\n * [Summer 2016] Should we update to use ImageIO instead of ImageIcon()?\n * Seems to have some issues loading images on some systems\n * and slows things down on other systems.\n * especially if you don't call ImageIO.setUseCache(false)\n * One advantage is that it returns a BufferedImage.\n ***************************************************************************/\n/*\n private static BufferedImage getImage(String filename) {\n if (filename == null) throw new NullPointerException();\n\n // from a file or URL\n try {\n URL url = new URL(filename);\n BufferedImage image = ImageIO.read(url);\n return image;\n } \n catch (IOException e) {\n // ignore\n }\n\n // in case file is inside a .jar (classpath relative to StdDraw)\n try {\n URL url = StdDraw.class.getResource(filename);\n BufferedImage image = ImageIO.read(url);\n return image;\n } \n catch (IOException e) {\n // ignore\n }\n\n // in case file is inside a .jar (classpath relative to root of jar)\n try {\n URL url = StdDraw.class.getResource(\"/\" + filename);\n BufferedImage image = ImageIO.read(url);\n return image;\n } \n catch (IOException e) {\n // ignore\n }\n throw new IllegalArgumentException(\"image \" + filename + \" not found\");\n }\n*/\n /**\n * Draws the specified image centered at (x, y).\n * The supported image formats are JPEG, PNG, and GIF.\n * As an optimization, the picture is cached, so there is no performance\n * penalty for redrawing the same image multiple times (e.g., in an animation).\n * However, if you change the picture file after drawing it, subsequent\n * calls will draw the original picture.\n *\n * @param x the center x-coordinate of the image\n * @param y the center y-coordinate of the image\n * @param filename the name of the image/picture, e.g., \"ball.gif\"\n * @throws IllegalArgumentException if the image filename is invalid\n */\n public static void picture(double x, double y, String filename) {\n // BufferedImage image = getImage(filename);\n Image image = getImage(filename);\n double xs = scaleX(x);\n double ys = scaleY(y);\n // int ws = image.getWidth(); // can call only if image is a BufferedImage\n // int hs = image.getHeight();\n int ws = image.getWidth(null);\n int hs = image.getHeight(null);\n if (ws < 0 || hs < 0) throw new IllegalArgumentException(\"image \" + filename + \" is corrupt\");\n\n offscreen.drawImage(image, (int) Math.round(xs - ws/2.0), (int) Math.round(ys - hs/2.0), null);\n draw();\n }\n\n /**\n * Draws the specified image centered at (x, y),\n * rotated given number of degrees.\n * The supported image formats are JPEG, PNG, and GIF.\n *\n * @param x the center x-coordinate of the image\n * @param y the center y-coordinate of the image\n * @param filename the name of the image/picture, e.g., \"ball.gif\"\n * @param degrees is the number of degrees to rotate counterclockwise\n * @throws IllegalArgumentException if the image filename is invalid\n */\n public static void picture(double x, double y, String filename, double degrees) {\n // BufferedImage image = getImage(filename);\n Image image = getImage(filename);\n double xs = scaleX(x);\n double ys = scaleY(y);\n // int ws = image.getWidth(); // can call only if image is a BufferedImage\n // int hs = image.getHeight();\n int ws = image.getWidth(null);\n int hs = image.getHeight(null);\n if (ws < 0 || hs < 0) throw new IllegalArgumentException(\"image \" + filename + \" is corrupt\");\n\n offscreen.rotate(Math.toRadians(-degrees), xs, ys);\n offscreen.drawImage(image, (int) Math.round(xs - ws/2.0), (int) Math.round(ys - hs/2.0), null);\n offscreen.rotate(Math.toRadians(+degrees), xs, ys);\n\n draw();\n }\n\n /**\n * Draws the specified image centered at (x, y),\n * rescaled to the specified bounding box.\n * The supported image formats are JPEG, PNG, and GIF.\n *\n * @param x the center x-coordinate of the image\n * @param y the center y-coordinate of the image\n * @param filename the name of the image/picture, e.g., \"ball.gif\"\n * @param scaledWidth the width of the scaled image (in screen coordinates)\n * @param scaledHeight the height of the scaled image (in screen coordinates)\n * @throws IllegalArgumentException if either {@code scaledWidth}\n * or {@code scaledHeight} is negative\n * @throws IllegalArgumentException if the image filename is invalid\n */\n public static void picture(double x, double y, String filename, double scaledWidth, double scaledHeight) {\n Image image = getImage(filename);\n if (scaledWidth < 0) throw new IllegalArgumentException(\"width is negative: \" + scaledWidth);\n if (scaledHeight < 0) throw new IllegalArgumentException(\"height is negative: \" + scaledHeight);\n double xs = scaleX(x);\n double ys = scaleY(y);\n double ws = factorX(scaledWidth);\n double hs = factorY(scaledHeight);\n if (ws < 0 || hs < 0) throw new IllegalArgumentException(\"image \" + filename + \" is corrupt\");\n if (ws <= 1 && hs <= 1) pixel(x, y);\n else {\n offscreen.drawImage(image, (int) Math.round(xs - ws/2.0),\n (int) Math.round(ys - hs/2.0),\n (int) Math.round(ws),\n (int) Math.round(hs), null);\n }\n draw();\n }\n\n\n /**\n * Draws the specified image centered at (x, y), rotated\n * given number of degrees, and rescaled to the specified bounding box.\n * The supported image formats are JPEG, PNG, and GIF.\n *\n * @param x the center x-coordinate of the image\n * @param y the center y-coordinate of the image\n * @param filename the name of the image/picture, e.g., \"ball.gif\"\n * @param scaledWidth the width of the scaled image (in screen coordinates)\n * @param scaledHeight the height of the scaled image (in screen coordinates)\n * @param degrees is the number of degrees to rotate counterclockwise\n * @throws IllegalArgumentException if either {@code scaledWidth}\n * or {@code scaledHeight} is negative\n * @throws IllegalArgumentException if the image filename is invalid\n */\n public static void picture(double x, double y, String filename, double scaledWidth, double scaledHeight, double degrees) {\n if (scaledWidth < 0) throw new IllegalArgumentException(\"width is negative: \" + scaledWidth);\n if (scaledHeight < 0) throw new IllegalArgumentException(\"height is negative: \" + scaledHeight);\n Image image = getImage(filename);\n double xs = scaleX(x);\n double ys = scaleY(y);\n double ws = factorX(scaledWidth);\n double hs = factorY(scaledHeight);\n if (ws < 0 || hs < 0) throw new IllegalArgumentException(\"image \" + filename + \" is corrupt\");\n if (ws <= 1 && hs <= 1) pixel(x, y);\n\n offscreen.rotate(Math.toRadians(-degrees), xs, ys);\n offscreen.drawImage(image, (int) Math.round(xs - ws/2.0),\n (int) Math.round(ys - hs/2.0),\n (int) Math.round(ws),\n (int) Math.round(hs), null);\n offscreen.rotate(Math.toRadians(+degrees), xs, ys);\n\n draw();\n }\n\n /***************************************************************************\n * Drawing text.\n ***************************************************************************/\n\n /**\n * Write the given text string in the current font, centered at (x, y).\n *\n * @param x the center x-coordinate of the text\n * @param y the center y-coordinate of the text\n * @param text the text to write\n */\n public static void text(double x, double y, String text) {\n if (text == null) throw new NullPointerException();\n offscreen.setFont(font);\n FontMetrics metrics = offscreen.getFontMetrics();\n double xs = scaleX(x);\n double ys = scaleY(y);\n int ws = metrics.stringWidth(text);\n int hs = metrics.getDescent();\n offscreen.drawString(text, (float) (xs - ws/2.0), (float) (ys + hs));\n draw();\n }\n\n /**\n * Write the given text string in the current font, centered at (x, y) and\n * rotated by the specified number of degrees.\n * @param x the center x-coordinate of the text\n * @param y the center y-coordinate of the text\n * @param text the text to write\n * @param degrees is the number of degrees to rotate counterclockwise\n */\n public static void text(double x, double y, String text, double degrees) {\n if (text == null) throw new NullPointerException();\n double xs = scaleX(x);\n double ys = scaleY(y);\n offscreen.rotate(Math.toRadians(-degrees), xs, ys);\n text(x, y, text);\n offscreen.rotate(Math.toRadians(+degrees), xs, ys);\n }\n\n\n /**\n * Write the given text string in the current font, left-aligned at (x, y).\n * @param x the x-coordinate of the text\n * @param y the y-coordinate of the text\n * @param text the text\n */\n public static void textLeft(double x, double y, String text) {\n if (text == null) throw new NullPointerException();\n offscreen.setFont(font);\n FontMetrics metrics = offscreen.getFontMetrics();\n double xs = scaleX(x);\n double ys = scaleY(y);\n int hs = metrics.getDescent();\n offscreen.drawString(text, (float) xs, (float) (ys + hs));\n draw();\n }\n\n /**\n * Write the given text string in the current font, right-aligned at (x, y).\n *\n * @param x the x-coordinate of the text\n * @param y the y-coordinate of the text\n * @param text the text to write\n */\n public static void textRight(double x, double y, String text) {\n if (text == null) throw new NullPointerException();\n offscreen.setFont(font);\n FontMetrics metrics = offscreen.getFontMetrics();\n double xs = scaleX(x);\n double ys = scaleY(y);\n int ws = metrics.stringWidth(text);\n int hs = metrics.getDescent();\n offscreen.drawString(text, (float) (xs - ws), (float) (ys + hs));\n draw();\n }\n\n\n\n /**\n * Copies the offscreen buffer to the onscreen buffer, pauses for t milliseconds\n * and enables double buffering.\n * @param t number of milliseconds\n * @deprecated replaced by {@link #enableDoubleBuffering}, {@link #show()}, and {@link #pause}\n */\n @Deprecated\n public static void show(int t) {\n // sleep until the next time we're allowed to draw\n long millis = System.currentTimeMillis();\n if (millis < nextDraw) {\n try {\n Thread.sleep(nextDraw - millis);\n }\n catch (InterruptedException e) {\n System.out.println(\"Error sleeping\");\n }\n millis = nextDraw;\n }\n\n show();\n enableDoubleBuffering();\n\n // when are we allowed to draw again\n nextDraw = millis + t;\n }\n\n /**\n * Pause for t milliseconds. This method is intended to support computer animations.\n * @param t number of milliseconds\n */\n public static void pause(int t) {\n // sleep until the next time we're allowed to draw\n long millis = System.currentTimeMillis();\n if (millis < nextDraw) {\n try {\n Thread.sleep(nextDraw - millis);\n }\n catch (InterruptedException e) {\n System.out.println(\"Error sleeping\");\n }\n millis = nextDraw;\n }\n\n // when are we allowed to draw again\n nextDraw = millis + t;\n }\n\n /**\n * Copies offscreen buffer to onscreen buffer. There is no reason to call\n * this method unless double buffering is enabled.\n */\n public static void show() {\n onscreen.drawImage(offscreenImage, 0, 0, null);\n frame.repaint();\n }\n\n // draw onscreen if defer is false\n private static void draw() {\n if (!defer) show();\n }\n\n /**\n * Enable double buffering. All subsequent calls to \n * drawing methods such as {@code line()}, {@code circle()},\n * and {@code square()} will be deffered until the next call\n * to show(). Useful for animations.\n */\n public static void enableDoubleBuffering() {\n defer = true;\n }\n\n /**\n * Disable double buffering. All subsequent calls to \n * drawing methods such as {@code line()}, {@code circle()},\n * and {@code square()} will be displayed on screen when called.\n * This is the default.\n */\n public static void disableDoubleBuffering() {\n defer = false;\n }\n\n\n /***************************************************************************\n * Save drawing to a file.\n ***************************************************************************/\n\n /**\n * Saves the drawing to using the specified filename.\n * The supported image formats are JPEG and PNG;\n * the filename suffix must be {@code .jpg} or {@code .png}.\n *\n * @param filename the name of the file with one of the required suffixes\n */\n public static void save(String filename) {\n if (filename == null) throw new NullPointerException();\n File file = new File(filename);\n String suffix = filename.substring(filename.lastIndexOf('.') + 1);\n\n // png files\n if (suffix.toLowerCase().equals(\"png\")) {\n try {\n ImageIO.write(onscreenImage, suffix, file);\n }\n catch (IOException e) {\n e.printStackTrace();\n }\n }\n\n // need to change from ARGB to RGB for JPEG\n // reference: http://archives.java.sun.com/cgi-bin/wa?A2=ind0404&L=java2d-interest&D=0&P=2727\n else if (suffix.toLowerCase().equals(\"jpg\")) {\n WritableRaster raster = onscreenImage.getRaster();\n WritableRaster newRaster;\n newRaster = raster.createWritableChild(0, 0, width, height, 0, 0, new int[] {0, 1, 2});\n DirectColorModel cm = (DirectColorModel) onscreenImage.getColorModel();\n DirectColorModel newCM = new DirectColorModel(cm.getPixelSize(),\n cm.getRedMask(),\n cm.getGreenMask(),\n cm.getBlueMask());\n BufferedImage rgbBuffer = new BufferedImage(newCM, newRaster, false, null);\n try {\n ImageIO.write(rgbBuffer, suffix, file);\n }\n catch (IOException e) {\n e.printStackTrace();\n }\n }\n\n else {\n System.out.println(\"Invalid image file type: \" + suffix);\n }\n }\n\n\n /**\n * This method cannot be called directly.\n */\n @Override\n public void actionPerformed(ActionEvent e) {\n FileDialog chooser = new FileDialog(StdDraw.frame, \"Use a .png or .jpg extension\", FileDialog.SAVE);\n chooser.setVisible(true);\n String filename = chooser.getFile();\n if (filename != null) {\n StdDraw.save(chooser.getDirectory() + File.separator + chooser.getFile());\n }\n }\n\n\n /***************************************************************************\n * Mouse interactions.\n ***************************************************************************/\n\n /**\n * Returns true if the mouse is being pressed.\n *\n * @return {@code true} if the mouse is being pressed; {@code false} otherwise\n */\n public static boolean mousePressed() {\n synchronized (mouseLock) {\n return mousePressed;\n }\n }\n\n /**\n * Returns the x-coordinate of the mouse.\n *\n * @return the x-coordinate of the mouse\n */\n public static double mouseX() {\n synchronized (mouseLock) {\n return mouseX;\n }\n }\n\n /**\n * Returns the y-coordinate of the mouse.\n *\n * @return y-coordinate of the mouse\n */\n public static double mouseY() {\n synchronized (mouseLock) {\n return mouseY;\n }\n }\n\n\n /**\n * This method cannot be called directly.\n */\n @Override\n public void mouseClicked(MouseEvent e) { }\n\n /**\n * This method cannot be called directly.\n */\n @Override\n public void mouseEntered(MouseEvent e) { }\n\n /**\n * This method cannot be called directly.\n */\n @Override\n public void mouseExited(MouseEvent e) { }\n\n /**\n * This method cannot be called directly.\n */\n @Override\n public void mousePressed(MouseEvent e) {\n synchronized (mouseLock) {\n mouseX = StdDraw.userX(e.getX());\n mouseY = StdDraw.userY(e.getY());\n mousePressed = true;\n }\n }\n\n /**\n * This method cannot be called directly.\n */\n @Override\n public void mouseReleased(MouseEvent e) {\n synchronized (mouseLock) {\n mousePressed = false;\n }\n }\n\n /**\n * This method cannot be called directly.\n */\n @Override\n public void mouseDragged(MouseEvent e) {\n synchronized (mouseLock) {\n mouseX = StdDraw.userX(e.getX());\n mouseY = StdDraw.userY(e.getY());\n }\n }\n\n /**\n * This method cannot be called directly.\n */\n @Override\n public void mouseMoved(MouseEvent e) {\n synchronized (mouseLock) {\n mouseX = StdDraw.userX(e.getX());\n mouseY = StdDraw.userY(e.getY());\n }\n }\n\n\n /***************************************************************************\n * Keyboard interactions.\n ***************************************************************************/\n\n /**\n * Returns true if the user has typed a key (that has not yet been processed).\n *\n * @return {@code true} if the user has typed a key (that has not yet been processed\n * by {@link #nextKeyTyped()}; {@code false} otherwise\n */\n public static boolean hasNextKeyTyped() {\n synchronized (keyLock) {\n return !keysTyped.isEmpty();\n }\n }\n\n /**\n * Returns the next key that was typed by the user (that your program has not already processed).\n * This method should be preceded by a call to {@link #hasNextKeyTyped()} to ensure\n * that there is a next key to process.\n * This method returns a Unicode character corresponding to the key\n * typed (such as {@code 'a'} or {@code 'A'}).\n * It cannot identify action keys (such as F1 and arrow keys)\n * or modifier keys (such as control).\n *\n * @return the next key typed by the user (that your program has not already processed).\n * @throws NoSuchElementException if there is no remaining key\n */\n public static char nextKeyTyped() {\n synchronized (keyLock) {\n if (keysTyped.isEmpty()) {\n throw new NoSuchElementException(\"your program has already processed all keystrokes\");\n }\n return keysTyped.removeLast();\n }\n }\n\n /**\n * Returns true if the given key is being pressed.\n * \n * This method takes the keycode (corresponding to a physical key)\n * as an argument. It can handle action keys\n * (such as F1 and arrow keys) and modifier keys (such as shift and control).\n * See {@link KeyEvent} for a description of key codes.\n *\n * @param keycode the key to check if it is being pressed\n * @return {@code true} if {@code keycode} is currently being pressed;\n * {@code false} otherwise\n */\n public static boolean isKeyPressed(int keycode) {\n synchronized (keyLock) {\n return keysDown.contains(keycode);\n }\n }\n\n\n /**\n * This method cannot be called directly.\n */\n @Override\n public void keyTyped(KeyEvent e) {\n synchronized (keyLock) {\n keysTyped.addFirst(e.getKeyChar());\n }\n }\n\n /**\n * This method cannot be called directly.\n */\n @Override\n public void keyPressed(KeyEvent e) {\n synchronized (keyLock) {\n keysDown.add(e.getKeyCode());\n }\n }\n\n /**\n * This method cannot be called directly.\n */\n @Override\n public void keyReleased(KeyEvent e) {\n synchronized (keyLock) {\n keysDown.remove(e.getKeyCode());\n }\n }\n\n\n\n\n /**\n * Test client.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n StdDraw.square(.2, .8, .1);\n StdDraw.filledSquare(.8, .8, .2);\n StdDraw.circle(.8, .2, .2);\n\n StdDraw.setPenColor(StdDraw.BOOK_RED);\n StdDraw.setPenRadius(.02);\n StdDraw.arc(.8, .2, .1, 200, 45);\n\n // draw a blue diamond\n StdDraw.setPenRadius();\n StdDraw.setPenColor(StdDraw.BOOK_BLUE);\n double[] x = { .1, .2, .3, .2 };\n double[] y = { .2, .3, .2, .1 };\n StdDraw.filledPolygon(x, y);\n\n // text\n StdDraw.setPenColor(StdDraw.BLACK);\n StdDraw.text(0.2, 0.5, \"black text\");\n StdDraw.setPenColor(StdDraw.WHITE);\n StdDraw.text(0.8, 0.8, \"white text\");\n }\n\n}\n\n/******************************************************************************\n * Copyright 2002-2016, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "code/algs4/StdIn.java",
"content": "/******************************************************************************\n * Compilation: javac StdIn.java\n * Execution: java StdIn (interactive test of basic functionality)\n * Dependencies: none\n *\n * Reads in data of various types from standard input.\n *\n ******************************************************************************/\n\npackage algs4;\n\nimport java.util.ArrayList;\nimport java.util.InputMismatchException;\nimport java.util.Locale;\nimport java.util.NoSuchElementException;\nimport java.util.Scanner;\nimport java.util.regex.Pattern;\n\n/**\n * The {@code StdIn} class provides static methods for reading strings\n * and numbers from standard input.\n * These functions fall into one of four categories:\n * \n * Generally, it is best not to mix functions from the different\n * categories in the same program. \n * \n * Reading tokens from standard input one at a time,\n * and converting to numbers and strings.\n * You can use the following methods to read numbers, strings, and booleans\n * from standard input:\n * \n * Each method skips over any input that is whitespace. Then, it reads\n * the next token and attempts to convert it into a value of the specified\n * type. If it succeeds, it returns that value; otherwise, it\n * throws a {@link InputMismatchException}.\n * \n * Whitespace includes spaces, tabs, and newlines; the full definition\n * is inherited from {@link Character#isWhitespace(char)}.\n * A token is a maximal sequence of non-whitespace characters.\n * The precise rules for describing which tokens can be converted to\n * integers and floating-point numbers are inherited from\n * Scanner,\n * using the locale {@link Locale#US}; the rules\n * for floating-point numbers are slightly different\n * from those in {@link Double#valueOf(String)},\n * but unlikely to be of concern to most programmers.\n * \n * Reading characters from standard input, one at a time.\n * You can use the following two methods to read characters from standard input:\n * \n * The first method returns true if standard input has more input (including whitespace).\n * The second method reads and returns the next character of input on standard \n * input (possibly a whitespace character).\n * \n * As an example, the following code fragment reads characters from standard input,\n * one character at a time, and prints it to standard output.\n * \n * Reading lines from standard input, one at a time.\n * You can use the following two methods to read lines from standard input:\n * \n * The first method returns true if standard input has more input (including whitespace).\n * The second method reads and returns the remaining portion of \n * the next line of input on standard input (possibly whitespace),\n * discarding the trailing line separator.\n * \n * A line separator is defined to be one of the following strings:\n * {@code \\n} (Linux), {@code \\r} (old Macintosh),\n * {@code \\r\\n} (Windows),\n * {@code \u2028}, {@code \u2029}, or {@code \u0085}.\n * \n * As an example, the following code fragment reads text from standard input,\n * one line at a time, and prints it to standard output.\n * \n * Reading a sequence of values of the same type from standard input.\n * You can use the following methods to read a sequence numbers, strings,\n * or booleans (all of the same type) from standard input:\n * \n * The first three methods read of all of remaining token on standard input\n * and dconverts the tokens to values of\n * the specified type, as in the corresponding\n * {@code readDouble}, {@code readInt}, and {@code readString()} methods.\n * The {@code readAllLines()} method reads all remaining lines on standard\n * input and returns them as an array of strings.\n * The {@code readAll()} method reads all remaining input on standard\n * input and returns it as a string.\n * \n * As an example, the following code fragment reads all of the remaining\n * tokens from standard input and returns them as an array of strings.\n * \n * Differences with Scanner.\n * {@code StdIn} and {@link Scanner} are both designed to parse \n * tokens and convert them to primitive types and strings.\n * Some of the main differences are summarized below:\n * \n * Historical note: {@code StdIn} preceded {@code Scanner}; when\n * {@code Scanner} was introduced, this class was reimplemented to use {@code Scanner}.\n * \n * Using standard input.\n * Standard input is fundamental operating system abstraction, on Mac OS X,\n * Windows, and Linux.\n * The methods in {@code StdIn} are blocking, which means that they\n * will wait until you enter input on standard input.\n * If your program has a loop that repeats until standard input is empty,\n * you must signal that the input is finished.\n * To do so, depending on your operating system and IDE,\n * use either {@code \n * Known bugs.\n * Java's UTF-8 encoding does not recognize the optional \n * byte-order mask.\n * If the input begins with the optional byte-order mask, {@code StdIn}\n * will have an extra character {@code \uFEFF} at the beginning.\n * \n * Reference. \n * For additional documentation,\n * see Section 1.5 of \n * Introduction to Programming in Java: An Interdisciplinary Approach\n * by Robert Sedgewick and Kevin Wayne.\n *\n * @author David Pritchard\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic final class StdIn {\n\n /*** begin: section (1 of 2) of code duplicated from In to StdIn. */\n \n // assume Unicode UTF-8 encoding\n private static final String CHARSET_NAME = \"UTF-8\";\n\n // assume language = English, country = US for consistency with System.out.\n private static final Locale LOCALE = Locale.US;\n\n // the default token separator; we maintain the invariant that this value\n // is held by the scanner's delimiter between calls\n private static final Pattern WHITESPACE_PATTERN = Pattern.compile(\"\\\\p{javaWhitespace}+\");\n\n // makes whitespace significant\n private static final Pattern EMPTY_PATTERN = Pattern.compile(\"\");\n\n // used to read the entire input\n private static final Pattern EVERYTHING_PATTERN = Pattern.compile(\"\\\\A\");\n\n /*** end: section (1 of 2) of code duplicated from In to StdIn. */\n\n private static Scanner scanner;\n \n // it doesn't make sense to instantiate this class\n private StdIn() { }\n\n //// begin: section (2 of 2) of code duplicated from In to StdIn,\n //// with all methods changed from \"public\" to \"public static\"\n\n /**\n * Returns true if standard input is empty (except possibly for whitespace).\n * Use this method to know whether the next call to {@link #readString()}, \n * {@link #readDouble()}, etc will succeed.\n *\n * @return {@code true} if standard input is empty (except possibly\n * for whitespace); {@code false} otherwise\n */\n public static boolean isEmpty() {\n return !scanner.hasNext();\n }\n\n /**\n * Returns true if standard input has a next line.\n * Use this method to know whether the\n * next call to {@link #readLine()} will succeed.\n * This method is functionally equivalent to {@link #hasNextChar()}.\n *\n * @return {@code true} if standard input is empty;\n * {@code false} otherwise\n */\n public static boolean hasNextLine() {\n return scanner.hasNextLine();\n }\n\n /**\n * Returns true if standard input has more inputy (including whitespace).\n * Use this method to know whether the next call to {@link #readChar()} will succeed.\n * This method is functionally equivalent to {@link #hasNextLine()}.\n *\n * @return {@code true} if standard input has more input (including whitespace);\n * {@code false} otherwise\n */\n public static boolean hasNextChar() {\n scanner.useDelimiter(EMPTY_PATTERN);\n boolean result = scanner.hasNext();\n scanner.useDelimiter(WHITESPACE_PATTERN);\n return result;\n }\n\n\n /**\n * Reads and returns the next line, excluding the line separator if present.\n *\n * @return the next line, excluding the line separator if present;\n * {@code null} if no such line\n */\n public static String readLine() {\n String line;\n try {\n line = scanner.nextLine();\n }\n catch (NoSuchElementException e) {\n line = null;\n }\n return line;\n }\n\n /**\n * Reads and returns the next character.\n *\n * @return the next character\n * @throws NoSuchElementException if standard input is empty\n */\n public static char readChar() {\n scanner.useDelimiter(EMPTY_PATTERN);\n String ch = scanner.next();\n assert ch.length() == 1 : \"Internal (Std)In.readChar() error!\"\n + \" Please contact the authors.\";\n scanner.useDelimiter(WHITESPACE_PATTERN);\n return ch.charAt(0);\n } \n\n\n /**\n * Reads and returns the remainder of the input, as a string.\n *\n * @return the remainder of the input, as a string\n * @throws NoSuchElementException if standard input is empty\n */\n public static String readAll() {\n if (!scanner.hasNextLine())\n return \"\";\n\n String result = scanner.useDelimiter(EVERYTHING_PATTERN).next();\n // not that important to reset delimeter, since now scanner is empty\n scanner.useDelimiter(WHITESPACE_PATTERN); // but let's do it anyway\n return result;\n }\n\n\n /**\n * Reads the next token and returns the {@code String}.\n *\n * @return the next {@code String}\n * @throws NoSuchElementException if standard input is empty\n */\n public static String readString() {\n return scanner.next();\n }\n\n /**\n * Reads the next token from standard input, parses it as an integer, and returns the integer.\n *\n * @return the next integer on standard input\n * @throws NoSuchElementException if standard input is empty\n * @throws InputMismatchException if the next token cannot be parsed as an {@code int}\n */\n public static int readInt() {\n return scanner.nextInt();\n }\n\n /**\n * Reads the next token from standard input, parses it as a double, and returns the double.\n *\n * @return the next double on standard input\n * @throws NoSuchElementException if standard input is empty\n * @throws InputMismatchException if the next token cannot be parsed as a {@code double}\n */\n public static double readDouble() {\n return scanner.nextDouble();\n }\n\n /**\n * Reads the next token from standard input, parses it as a float, and returns the float.\n *\n * @return the next float on standard input\n * @throws NoSuchElementException if standard input is empty\n * @throws InputMismatchException if the next token cannot be parsed as a {@code float}\n */\n public static float readFloat() {\n return scanner.nextFloat();\n }\n\n /**\n * Reads the next token from standard input, parses it as a long integer, and returns the long integer.\n *\n * @return the next long integer on standard input\n * @throws NoSuchElementException if standard input is empty\n * @throws InputMismatchException if the next token cannot be parsed as a {@code long}\n */\n public static long readLong() {\n return scanner.nextLong();\n }\n\n /**\n * Reads the next token from standard input, parses it as a short integer, and returns the short integer.\n *\n * @return the next short integer on standard input\n * @throws NoSuchElementException if standard input is empty\n * @throws InputMismatchException if the next token cannot be parsed as a {@code short}\n */\n public static short readShort() {\n return scanner.nextShort();\n }\n\n /**\n * Reads the next token from standard input, parses it as a byte, and returns the byte.\n *\n * @return the next byte on standard input\n * @throws NoSuchElementException if standard input is empty\n * @throws InputMismatchException if the next token cannot be parsed as a {@code byte}\n */\n public static byte readByte() {\n return scanner.nextByte();\n }\n\n /**\n * Reads the next token from standard input, parses it as a boolean,\n * and returns the boolean.\n *\n * @return the next boolean on standard input\n * @throws NoSuchElementException if standard input is empty\n * @throws InputMismatchException if the next token cannot be parsed as a {@code boolean}:\n * {@code true} or {@code 1} for true, and {@code false} or {@code 0} for false,\n * ignoring case\n */\n public static boolean readBoolean() {\n String s = readString();\n if (s.equalsIgnoreCase(\"true\")) return true;\n if (s.equalsIgnoreCase(\"false\")) return false;\n if (s.equals(\"1\")) return true;\n if (s.equals(\"0\")) return false;\n throw new InputMismatchException();\n }\n\n /**\n * Reads all remaining tokens from standard input and returns them as an array of strings.\n *\n * @return all remaining tokens on standard input, as an array of strings\n */\n public static String[] readAllStrings() {\n // we could use readAll.trim().split(), but that's not consistent\n // because trim() uses characters 0x00..0x20 as whitespace\n String[] tokens = WHITESPACE_PATTERN.split(readAll());\n if (tokens.length == 0 || tokens[0].length() > 0)\n return tokens;\n\n // don't include first token if it is leading whitespace\n String[] decapitokens = new String[tokens.length-1];\n for (int i = 0; i < tokens.length - 1; i++)\n decapitokens[i] = tokens[i+1];\n return decapitokens;\n }\n\n /**\n * Reads all remaining lines from standard input and returns them as an array of strings.\n * @return all remaining lines on standard input, as an array of strings\n */\n public static String[] readAllLines() {\n ArrayList \n * Getting started.\n * To use this class, you must have {@code StdOut.class} in your\n * Java classpath. If you used our autoinstaller, you should be all set.\n * Otherwise, download\n * StdOut.java\n * and put a copy in your working directory.\n * \n * Here is an example program that uses {@code StdOut}:\n * \n * Differences with System.out.\n * The behavior of {@code StdOut} is similar to that of {@link System#out},\n * but there are a few subtle differences:\n * \n * Reference.\n * For additional documentation,\n * see Section 1.5 of\n * Introduction to Programming in Java: An Interdisciplinary Approach\n * by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic final class StdOut {\n\n // force Unicode UTF-8 encoding; otherwise it's system dependent\n private static final String CHARSET_NAME = \"UTF-8\";\n\n // assume language = English, country = US for consistency with StdIn\n private static final Locale LOCALE = Locale.US;\n\n // send output here\n private static PrintWriter out;\n\n // this is called before invoking any methods\n static {\n try {\n out = new PrintWriter(new OutputStreamWriter(System.out, CHARSET_NAME), true);\n }\n catch (UnsupportedEncodingException e) {\n System.out.println(e);\n }\n }\n\n // don't instantiate\n private StdOut() { }\n\n /**\n * Closes standard output.\n */\n public static void close() {\n out.close();\n }\n\n /**\n * Terminates the current line by printing the line-separator string.\n */\n public static void println() {\n out.println();\n }\n\n /**\n * Prints an object to this output stream and then terminates the line.\n *\n * @param x the object to print\n */\n public static void println(Object x) {\n out.println(x);\n }\n\n /**\n * Prints a boolean to standard output and then terminates the line.\n *\n * @param x the boolean to print\n */\n public static void println(boolean x) {\n out.println(x);\n }\n\n /**\n * Prints a character to standard output and then terminates the line.\n *\n * @param x the character to print\n */\n public static void println(char x) {\n out.println(x);\n }\n\n /**\n * Prints a double to standard output and then terminates the line.\n *\n * @param x the double to print\n */\n public static void println(double x) {\n out.println(x);\n }\n\n /**\n * Prints an integer to standard output and then terminates the line.\n *\n * @param x the integer to print\n */\n public static void println(float x) {\n out.println(x);\n }\n\n /**\n * Prints an integer to standard output and then terminates the line.\n *\n * @param x the integer to print\n */\n public static void println(int x) {\n out.println(x);\n }\n\n /**\n * Prints a long to standard output and then terminates the line.\n *\n * @param x the long to print\n */\n public static void println(long x) {\n out.println(x);\n }\n\n /**\n * Prints a short integer to standard output and then terminates the line.\n *\n * @param x the short to print\n */\n public static void println(short x) {\n out.println(x);\n }\n\n /**\n * Prints a byte to standard output and then terminates the line.\n * \n * To write binary data, see {@link BinaryStdOut}.\n *\n * @param x the byte to print\n */\n public static void println(byte x) {\n out.println(x);\n }\n\n /**\n * Flushes standard output.\n */\n public static void print() {\n out.flush();\n }\n\n /**\n * Prints an object to standard output and flushes standard output.\n * \n * @param x the object to print\n */\n public static void print(Object x) {\n out.print(x);\n out.flush();\n }\n\n /**\n * Prints a boolean to standard output and flushes standard output.\n * \n * @param x the boolean to print\n */\n public static void print(boolean x) {\n out.print(x);\n out.flush();\n }\n\n /**\n * Prints a character to standard output and flushes standard output.\n * \n * @param x the character to print\n */\n public static void print(char x) {\n out.print(x);\n out.flush();\n }\n\n /**\n * Prints a double to standard output and flushes standard output.\n * \n * @param x the double to print\n */\n public static void print(double x) {\n out.print(x);\n out.flush();\n }\n\n /**\n * Prints a float to standard output and flushes standard output.\n * \n * @param x the float to print\n */\n public static void print(float x) {\n out.print(x);\n out.flush();\n }\n\n /**\n * Prints an integer to standard output and flushes standard output.\n * \n * @param x the integer to print\n */\n public static void print(int x) {\n out.print(x);\n out.flush();\n }\n\n /**\n * Prints a long integer to standard output and flushes standard output.\n * \n * @param x the long integer to print\n */\n public static void print(long x) {\n out.print(x);\n out.flush();\n }\n\n /**\n * Prints a short integer to standard output and flushes standard output.\n * \n * @param x the short integer to print\n */\n public static void print(short x) {\n out.print(x);\n out.flush();\n }\n\n /**\n * Prints a byte to standard output and flushes standard output.\n *\n * @param x the byte to print\n */\n public static void print(byte x) {\n out.print(x);\n out.flush();\n }\n\n /**\n * Prints a formatted string to standard output, using the specified format\n * string and arguments, and then flushes standard output.\n *\n *\n * @param format the format string\n * @param args the arguments accompanying the format string\n */\n public static void printf(String format, Object... args) {\n out.printf(LOCALE, format, args);\n out.flush();\n }\n\n /**\n * Prints a formatted string to standard output, using the locale and\n * the specified format string and arguments; then flushes standard output.\n *\n * @param locale the locale\n * @param format the format string\n * @param args the arguments accompanying the format string\n */\n public static void printf(Locale locale, String format, Object... args) {\n out.printf(locale, format, args);\n out.flush();\n }\n\n /**\n * Unit tests some of the methods in {@code StdOut}.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n\n // write to stdout\n StdOut.println(\"Test\");\n StdOut.println(17);\n StdOut.println(true);\n StdOut.printf(\"%.6f\\n\", 1.0/7.0);\n }\n\n}\n\n/******************************************************************************\n * Copyright 2002-2016, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "code/algs4/StdRandom.java",
"content": "/******************************************************************************\n * Compilation: javac StdRandom.java\n * Execution: java StdRandom\n * Dependencies: StdOut.java\n *\n * A library of static methods to generate pseudo-random numbers from\n * different distributions (bernoulli, uniform, gaussian, discrete,\n * and exponential). Also includes a method for shuffling an array.\n *\n *\n * % java StdRandom 5\n * seed = 1316600602069\n * 59 16.81826 true 8.83954 0 \n * 32 91.32098 true 9.11026 0 \n * 35 10.11874 true 8.95396 3 \n * 92 32.88401 true 8.87089 0 \n * 72 92.55791 true 9.46241 0 \n *\n * % java StdRandom 5\n * seed = 1316600616575\n * 96 60.17070 true 8.72821 0 \n * 79 32.01607 true 8.58159 0 \n * 81 59.49065 true 9.10423 1 \n * 96 51.65818 true 9.02102 0 \n * 99 17.55771 true 8.99762 0 \n *\n * % java StdRandom 5 1316600616575\n * seed = 1316600616575\n * 96 60.17070 true 8.72821 0 \n * 79 32.01607 true 8.58159 0 \n * 81 59.49065 true 9.10423 1 \n * 96 51.65818 true 9.02102 0 \n * 99 17.55771 true 8.99762 0 \n *\n *\n * Remark\n * ------\n * - Relies on randomness of nextDouble() method in java.util.Random\n * to generate pseudorandom numbers in [0, 1).\n *\n * - This library allows you to set and get the pseudorandom number seed.\n *\n * - See http://www.honeylocust.com/RngPack/ for an industrial\n * strength random number generator in Java.\n *\n ******************************************************************************/\n\npackage algs4;\n\nimport java.util.Random;\n\n/**\n * The {@code StdRandom} class provides static methods for generating\n * random number from various discrete and continuous distributions, \n * including Bernoulli, uniform, Gaussian, exponential, pareto,\n * Poisson, and Cauchy. It also provides method for shuffling an\n * array or subarray.\n * \n * For additional documentation,\n * see Section 2.2 of\n * Introduction to Programming in Java: An Interdisciplinary Approach\n * by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic final class StdRandom {\n\n private static Random random; // pseudo-random number generator\n private static long seed; // pseudo-random number generator seed\n\n // static initializer\n static {\n // this is how the seed was set in Java 1.4\n seed = System.currentTimeMillis();\n random = new Random(seed);\n }\n\n // don't instantiate\n private StdRandom() { }\n\n /**\n * Sets the seed of the pseudorandom number generator.\n * This method enables you to produce the same sequence of \"random\"\n * number for each execution of the program.\n * Ordinarily, you should call this method at most once per program.\n *\n * @param s the seed\n */\n public static void setSeed(long s) {\n seed = s;\n random = new Random(seed);\n }\n\n /**\n * Returns the seed of the pseudorandom number generator.\n *\n * @return the seed\n */\n public static long getSeed() {\n return seed;\n }\n\n /**\n * Returns a random real number uniformly in [0, 1).\n *\n * @return a random real number uniformly in [0, 1)\n */\n public static double uniform() {\n return random.nextDouble();\n }\n\n /**\n * Returns a random integer uniformly in [0, n).\n * \n * @param n number of possible integers\n * @return a random integer uniformly between 0 (inclusive) and {@code N} (exclusive)\n * @throws IllegalArgumentException if {@code n <= 0}\n */\n public static int uniform(int n) {\n if (n <= 0) throw new IllegalArgumentException(\"Parameter N must be positive\");\n return random.nextInt(n);\n }\n\n ///////////////////////////////////////////////////////////////////////////\n // STATIC METHODS BELOW RELY ON JAVA.UTIL.RANDOM ONLY INDIRECTLY VIA\n // THE STATIC METHODS ABOVE.\n ///////////////////////////////////////////////////////////////////////////\n\n /**\n * Returns a random real number uniformly in [0, 1).\n * \n * @return a random real number uniformly in [0, 1)\n * @deprecated Replaced by {@link #uniform()}.\n */\n @Deprecated\n public static double random() {\n return uniform();\n }\n\n /**\n * Returns a random integer uniformly in [a, b).\n * \n * @param a the left endpoint\n * @param b the right endpoint\n * @return a random integer uniformly in [a, b)\n * @throws IllegalArgumentException if {@code b <= a}\n * @throws IllegalArgumentException if {@code b - a >= Integer.MAX_VALUE}\n */\n public static int uniform(int a, int b) {\n if (b <= a) throw new IllegalArgumentException(\"Invalid range\");\n if ((long) b - a >= Integer.MAX_VALUE) throw new IllegalArgumentException(\"Invalid range\");\n return a + uniform(b - a);\n }\n\n /**\n * Returns a random real number uniformly in [a, b).\n * \n * @param a the left endpoint\n * @param b the right endpoint\n * @return a random real number uniformly in [a, b)\n * @throws IllegalArgumentException unless {@code a < b}\n */\n public static double uniform(double a, double b) {\n if (!(a < b)) throw new IllegalArgumentException(\"Invalid range\");\n return a + uniform() * (b-a);\n }\n\n /**\n * Returns a random boolean from a Bernoulli distribution with success\n * probability p.\n *\n * @param p the probability of returning {@code true}\n * @return {@code true} with probability {@code p} and\n * {@code false} with probability {@code p}\n * @throws IllegalArgumentException unless {@code p >= 0.0} and {@code p <= 1.0}\n */\n public static boolean bernoulli(double p) {\n if (!(p >= 0.0 && p <= 1.0))\n throw new IllegalArgumentException(\"Probability must be between 0.0 and 1.0\");\n return uniform() < p;\n }\n\n /**\n * Returns a random boolean from a Bernoulli distribution with success\n * probability 1/2.\n * \n * @return {@code true} with probability 1/2 and\n * {@code false} with probability 1/2\n */\n public static boolean bernoulli() {\n return bernoulli(0.5);\n }\n\n /**\n * Returns a random real number from a standard Gaussian distribution.\n * \n * @return a random real number from a standard Gaussian distribution\n * (mean 0 and standard deviation 1).\n */\n public static double gaussian() {\n // use the polar form of the Box-Muller transform\n double r, x, y;\n do {\n x = uniform(-1.0, 1.0);\n y = uniform(-1.0, 1.0);\n r = x*x + y*y;\n } while (r >= 1 || r == 0);\n return x * Math.sqrt(-2 * Math.log(r) / r);\n\n // Remark: y * Math.sqrt(-2 * Math.log(r) / r)\n // is an independent random gaussian\n }\n\n /**\n * Returns a random real number from a Gaussian distribution with mean μ\n * and standard deviation σ.\n * \n * @param mu the mean\n * @param sigma the standard deviation\n * @return a real number distributed according to the Gaussian distribution\n * with mean {@code mu} and standard deviation {@code sigma}\n */\n public static double gaussian(double mu, double sigma) {\n return mu + sigma * gaussian();\n }\n\n /**\n * Returns a random integer from a geometric distribution with success\n * probability p.\n * \n * @param p the parameter of the geometric distribution\n * @return a random integer from a geometric distribution with success\n * probability {@code p}; or {@code Integer.MAX_VALUE} if\n * {@code p} is (nearly) equal to {@code 1.0}.\n * @throws IllegalArgumentException unless {@code p >= 0.0} and {@code p <= 1.0}\n */\n public static int geometric(double p) {\n if (!(p >= 0.0 && p <= 1.0))\n throw new IllegalArgumentException(\"Probability must be between 0.0 and 1.0\");\n // using algorithm given by Knuth\n return (int) Math.ceil(Math.log(uniform()) / Math.log(1.0 - p));\n }\n\n /**\n * Returns a random integer from a Poisson distribution with mean λ.\n *\n * @param lambda the mean of the Poisson distribution\n * @return a random integer from a Poisson distribution with mean {@code lambda}\n * @throws IllegalArgumentException unless {@code lambda > 0.0} and not infinite\n */\n public static int poisson(double lambda) {\n if (!(lambda > 0.0))\n throw new IllegalArgumentException(\"Parameter lambda must be positive\");\n if (Double.isInfinite(lambda))\n throw new IllegalArgumentException(\"Parameter lambda must not be infinite\");\n // using algorithm given by Knuth\n // see http://en.wikipedia.org/wiki/Poisson_distribution\n int k = 0;\n double p = 1.0;\n double expLambda = Math.exp(-lambda);\n do {\n k++;\n p *= uniform();\n } while (p >= expLambda);\n return k-1;\n }\n\n /**\n * Returns a random real number from the standard Pareto distribution.\n *\n * @return a random real number from the standard Pareto distribution\n */\n public static double pareto() {\n return pareto(1.0);\n }\n\n /**\n * Returns a random real number from a Pareto distribution with\n * shape parameter α.\n *\n * @param alpha shape parameter\n * @return a random real number from a Pareto distribution with shape\n * parameter {@code alpha}\n * @throws IllegalArgumentException unless {@code alpha > 0.0}\n */\n public static double pareto(double alpha) {\n if (!(alpha > 0.0))\n throw new IllegalArgumentException(\"Shape parameter alpha must be positive\");\n return Math.pow(1 - uniform(), -1.0/alpha) - 1.0;\n }\n\n /**\n * Returns a random real number from the Cauchy distribution.\n *\n * @return a random real number from the Cauchy distribution.\n */\n public static double cauchy() {\n return Math.tan(Math.PI * (uniform() - 0.5));\n }\n\n /**\n * Returns a random integer from the specified discrete distribution.\n *\n * @param probabilities the probability of occurrence of each integer\n * @return a random integer from a discrete distribution:\n * {@code i} with probability {@code probabilities[i]}\n * @throws NullPointerException if {@code probabilities} is {@code null}\n * @throws IllegalArgumentException if sum of array entries is not (very nearly) equal to {@code 1.0}\n * @throws IllegalArgumentException unless {@code probabilities[i] >= 0.0} for each index {@code i}\n */\n public static int discrete(double[] probabilities) {\n if (probabilities == null) throw new NullPointerException(\"argument array is null\");\n double EPSILON = 1E-14;\n double sum = 0.0;\n for (int i = 0; i < probabilities.length; i++) {\n if (!(probabilities[i] >= 0.0))\n throw new IllegalArgumentException(\"array entry \" + i + \" must be nonnegative: \" + probabilities[i]);\n sum += probabilities[i];\n }\n if (sum > 1.0 + EPSILON || sum < 1.0 - EPSILON)\n throw new IllegalArgumentException(\"sum of array entries does not approximately equal 1.0: \" + sum);\n\n // the for loop may not return a value when both r is (nearly) 1.0 and when the\n // cumulative sum is less than 1.0 (as a result of floating-point roundoff error)\n while (true) {\n double r = uniform();\n sum = 0.0;\n for (int i = 0; i < probabilities.length; i++) {\n sum = sum + probabilities[i];\n if (sum > r) return i;\n }\n }\n }\n\n /**\n * Returns a random integer from the specified discrete distribution.\n *\n * @param frequencies the frequency of occurrence of each integer\n * @return a random integer from a discrete distribution:\n * {@code i} with probability proportional to {@code frequencies[i]}\n * @throws NullPointerException if {@code frequencies} is {@code null}\n * @throws IllegalArgumentException if all array entries are {@code 0}\n * @throws IllegalArgumentException if {@code frequencies[i]} is negative for any index {@code i}\n * @throws IllegalArgumentException if sum of frequencies exceeds {@code Integer.MAX_VALUE} (231 - 1)\n */\n public static int discrete(int[] frequencies) {\n if (frequencies == null) throw new NullPointerException(\"argument array is null\");\n long sum = 0;\n for (int i = 0; i < frequencies.length; i++) {\n if (frequencies[i] < 0)\n throw new IllegalArgumentException(\"array entry \" + i + \" must be nonnegative: \" + frequencies[i]);\n sum += frequencies[i];\n }\n if (sum == 0)\n throw new IllegalArgumentException(\"at least one array entry must be positive\");\n if (sum >= Integer.MAX_VALUE)\n throw new IllegalArgumentException(\"sum of frequencies overflows an int\");\n\n // pick index i with probabilitity proportional to frequency\n double r = uniform((int) sum);\n sum = 0;\n for (int i = 0; i < frequencies.length; i++) {\n sum += frequencies[i];\n if (sum > r) return i;\n }\n\n // can't reach here\n assert false;\n return -1;\n }\n\n /**\n * Returns a random real number from an exponential distribution\n * with rate λ.\n * \n * @param lambda the rate of the exponential distribution\n * @return a random real number from an exponential distribution with\n * rate {@code lambda}\n * @throws IllegalArgumentException unless {@code lambda > 0.0}\n */\n public static double exp(double lambda) {\n if (!(lambda > 0.0))\n throw new IllegalArgumentException(\"Rate lambda must be positive\");\n return -Math.log(1 - uniform()) / lambda;\n }\n\n /**\n * Rearranges the elements of the specified array in uniformly random order.\n *\n * @param a the array to shuffle\n * @throws NullPointerException if {@code a} is {@code null}\n */\n public static void shuffle(Object[] a) {\n if (a == null) throw new NullPointerException(\"argument array is null\");\n int n = a.length;\n for (int i = 0; i < n; i++) {\n int r = i + uniform(n-i); // between i and n-1\n Object temp = a[i];\n a[i] = a[r];\n a[r] = temp;\n }\n }\n\n /**\n * Rearranges the elements of the specified array in uniformly random order.\n *\n * @param a the array to shuffle\n * @throws NullPointerException if {@code a} is {@code null}\n */\n public static void shuffle(double[] a) {\n if (a == null) throw new NullPointerException(\"argument array is null\");\n int n = a.length;\n for (int i = 0; i < n; i++) {\n int r = i + uniform(n-i); // between i and n-1\n double temp = a[i];\n a[i] = a[r];\n a[r] = temp;\n }\n }\n\n /**\n * Rearranges the elements of the specified array in uniformly random order.\n *\n * @param a the array to shuffle\n * @throws NullPointerException if {@code a} is {@code null}\n */\n public static void shuffle(int[] a) {\n if (a == null) throw new NullPointerException(\"argument array is null\");\n int n = a.length;\n for (int i = 0; i < n; i++) {\n int r = i + uniform(n-i); // between i and n-1\n int temp = a[i];\n a[i] = a[r];\n a[r] = temp;\n }\n }\n\n\n /**\n * Rearranges the elements of the specified subarray in uniformly random order.\n *\n * @param a the array to shuffle\n * @param lo the left endpoint (inclusive)\n * @param hi the right endpoint (inclusive)\n * @throws NullPointerException if {@code a} is {@code null}\n * @throws IndexOutOfBoundsException unless {@code (0 <= lo) && (lo <= hi) && (hi < a.length)}\n * \n */\n public static void shuffle(Object[] a, int lo, int hi) {\n if (a == null) throw new NullPointerException(\"argument array is null\");\n if (lo < 0 || lo > hi || hi >= a.length) {\n throw new IndexOutOfBoundsException(\"Illegal subarray range\");\n }\n for (int i = lo; i <= hi; i++) {\n int r = i + uniform(hi-i+1); // between i and hi\n Object temp = a[i];\n a[i] = a[r];\n a[r] = temp;\n }\n }\n\n /**\n * Rearranges the elements of the specified subarray in uniformly random order.\n *\n * @param a the array to shuffle\n * @param lo the left endpoint (inclusive)\n * @param hi the right endpoint (inclusive)\n * @throws NullPointerException if {@code a} is {@code null}\n * @throws IndexOutOfBoundsException unless {@code (0 <= lo) && (lo <= hi) && (hi < a.length)}\n */\n public static void shuffle(double[] a, int lo, int hi) {\n if (a == null) throw new NullPointerException(\"argument array is null\");\n if (lo < 0 || lo > hi || hi >= a.length) {\n throw new IndexOutOfBoundsException(\"Illegal subarray range\");\n }\n for (int i = lo; i <= hi; i++) {\n int r = i + uniform(hi-i+1); // between i and hi\n double temp = a[i];\n a[i] = a[r];\n a[r] = temp;\n }\n }\n\n /**\n * Rearranges the elements of the specified subarray in uniformly random order.\n *\n * @param a the array to shuffle\n * @param lo the left endpoint (inclusive)\n * @param hi the right endpoint (inclusive)\n * @throws NullPointerException if {@code a} is {@code null}\n * @throws IndexOutOfBoundsException unless {@code (0 <= lo) && (lo <= hi) && (hi < a.length)}\n */\n public static void shuffle(int[] a, int lo, int hi) {\n if (a == null) throw new NullPointerException(\"argument array is null\");\n if (lo < 0 || lo > hi || hi >= a.length) {\n throw new IndexOutOfBoundsException(\"Illegal subarray range\");\n }\n for (int i = lo; i <= hi; i++) {\n int r = i + uniform(hi-i+1); // between i and hi\n int temp = a[i];\n a[i] = a[r];\n a[r] = temp;\n }\n }\n\n /**\n * Unit test.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n int n = Integer.parseInt(args[0]);\n if (args.length == 2) StdRandom.setSeed(Long.parseLong(args[1]));\n double[] probabilities = { 0.5, 0.3, 0.1, 0.1 };\n int[] frequencies = { 5, 3, 1, 1 };\n String[] a = \"A B C D E F G\".split(\" \");\n\n StdOut.println(\"seed = \" + StdRandom.getSeed());\n for (int i = 0; i < n; i++) {\n StdOut.printf(\"%2d \", uniform(100));\n StdOut.printf(\"%8.5f \", uniform(10.0, 99.0));\n StdOut.printf(\"%5b \", bernoulli(0.5));\n StdOut.printf(\"%7.5f \", gaussian(9.0, 0.2));\n StdOut.printf(\"%1d \", discrete(probabilities));\n StdOut.printf(\"%1d \", discrete(frequencies));\n StdRandom.shuffle(a);\n for (String s : a)\n StdOut.print(s);\n StdOut.println();\n }\n }\n\n}\n\n/******************************************************************************\n * Copyright 2002-2016, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "code/chapter1_1_Programming_Model/BinarySearch.java",
"content": "package chapter1_1_Programming_Model;\n\nimport java.util.Arrays;\nimport algs4.*;\n\n/**\n * 二分查找\n * @author huang\n */\npublic class BinarySearch {\n\n public static int rank(int key, int[] a) {\n // 数组必须有序\n int lo = 0;\n int hi = a.length - 1;\n while(lo <= hi) {\n int mid = lo + (hi - lo) / 2;\n if(key < a[mid])\n hi = mid - 1;\n else if(key > a[mid])\n lo = mid + 1;\n else\n return mid;\n }\n return -1;\n }\n \n public static void main(String[] args) {\n \n int[] whitelist = In.readInts(args[0]);\n Arrays.sort(whitelist);\n while(!StdIn.isEmpty()){\n int key = StdIn.readInt();\n if(rank(key, whitelist) < 0)\n StdOut.println(key);\n }\n\n }\n\n}\n"
},
{
"path": "code/chapter1_1_Programming_Model/BouncingBall.java",
"content": "package chapter1_1_Programming_Model;\n\nimport algs4.StdDraw;\n\npublic class BouncingBall {\n\n public static void main(String[] args) {\n \n // set the scale of the coordinate system\n StdDraw.setXscale(-1.0, 1.0);\n StdDraw.setYscale(-1.0, 1.0);\n StdDraw.enableDoubleBuffering();\n \n // initial values\n double rx = .480, ry = .860; // position\n double vx = .015, vy = .023; // velocity\n double radius = .05; // radius\n \n // main animation loop\n while(true) {\n // bounce off wall according to law of elastic collision\n if(Math.abs(rx + vx) > 1.0 - radius)\n vx = -vx;\n if(Math.abs(ry + vy) > 1.0 - radius)\n vy = -vy;\n \n // update position\n rx = rx + vx;\n ry = ry + vy;\n \n // clear the background\n StdDraw.setPenColor(StdDraw.GRAY);\n StdDraw.filledSquare(0, 0, 1.0);\n \n // draw ball on the screen\n StdDraw.setPenColor(StdDraw.BLACK);\n StdDraw.filledCircle(rx, ry, radius);\n \n // display and pause for 20 ms\n StdDraw.show();\n StdDraw.pause(20);\n }\n \n\n }\n\n}\n"
},
{
"path": "code/chapter1_1_Programming_Model/Ex1.java",
"content": "package chapter1_1_Programming_Model;\n\nimport algs4.StdOut;\n\npublic class Ex1 {\n\n public static void main(String[] args) {\n \n StdOut.println((0 + 15) / 2);\n StdOut.println(2.0e-6 * 100000000.1);\n StdOut.println(true && false || true && true);\n\n }\n\n}\n"
},
{
"path": "code/chapter1_1_Programming_Model/Ex10.java",
"content": "package chapter1_1_Programming_Model;\n\nimport algs4.StdOut;\n\npublic class Ex10 {\n\n public static void main(String[] args) {\n \n int[] a = new int[10];\n for(int i = 0; i < 10; i++)\n a[i] = i*i;\n for(int i = 9; i >= 0; i--)\n StdOut.printf(\"%d \", a[i]);\n }\n\n}\n"
},
{
"path": "code/chapter1_1_Programming_Model/Ex11.java",
"content": "package chapter1_1_Programming_Model;\n\nimport algs4.StdOut;\nimport algs4.StdRandom;\n\npublic class Ex11 {\n\n public static void main(String[] args) {\n \n boolean[][] arr = new boolean[7][6];\n for(int i = 0; i < 7; i++) {\n for(int j = 0; j < 6; j++) {\n double num = StdRandom.uniform();\n if(num > 0.5)\n arr[i][j] = true;\n else\n arr[i][j] = false;\n }\n }\n \n printBoolArr(arr);\n\n }\n \n public static void printBoolArr (boolean[][] arr) {\n\n StdOut.print(' ');\n for (int i = 0; i < arr[0].length; i++) {\n StdOut.print(i);\n }\n StdOut.println();\n for (int i = 0; i < arr.length; i++) {\n StdOut.print(i);\n for (int j = 0; j < arr[i].length; j++) {\n StdOut.print(arr[i][j] ? '*' : ' ');\n }\n StdOut.println();\n }\n }\n\n}\n"
},
{
"path": "code/chapter1_1_Programming_Model/Ex13.java",
"content": "package chapter1_1_Programming_Model;\n\nimport algs4.StdOut;\nimport algs4.StdRandom;\n\npublic class Ex13 {\n\n public static void main(String[] args) {\n\n int M = 3, N = 4;\n int[][] arr = new int[M][N];\n for (int i = 0; i < arr.length; i++)\n for (int j = 0; j < arr[0].length; j++)\n arr[i][j] = StdRandom.uniform(20);\n StdOut.println(\"oldArr: \");\n printArr(arr);\n StdOut.println(\"newArr: \");\n printArr(arrReverse(arr));\n\n }\n\n public static int[][] arrReverse(int[][] arr) {\n int[][] newArr = new int[arr[0].length][arr.length];\n for(int i = 0; i < newArr.length; i++)\n for(int j = 0; j < newArr[0].length; j++)\n newArr[i][j] = arr[j][i];\n\n return newArr;\n }\n\n public static void printArr(int[][] arr) {\n for (int i = 0; i < arr.length; i++) {\n for(int j = 0; j < arr[0].length; j++) {\n StdOut.printf(\"%d \",arr[i][j]);\n }\n StdOut.println();\n \n }\n\n }\n\n}\n"
},
{
"path": "code/chapter1_1_Programming_Model/Ex14.java",
"content": "package chapter1_1_Programming_Model;\n\nimport algs4.StdOut;\n\npublic class Ex14 {\n\n public static void main(String[] args) {\n \n StdOut.print(lg(8));\n\n }\n \n public static int lg(int N) {\n \n int i = 0;\n while(n2(i) <= N)\n i++;\n return i-1;\n }\n \n public static int n2(int n) {\n int result = 1;\n for(int i = 0; i < n; i++)\n result *= 2;\n return result;\n }\n\n}\n"
},
{
"path": "code/chapter1_1_Programming_Model/Ex15.java",
"content": "package chapter1_1_Programming_Model;\n\nimport algs4.StdOut;\n\npublic class Ex15 {\n\n public static void main(String[] args) {\n \n int[] arr = {0, 1, 1, 1};\n int[] timesArr = histogram(arr, 2);\n for(int j = 0; j < timesArr.length; j++) {\n StdOut.printf(\"%d \", timesArr[j]);\n }\n }\n \n public static int[] histogram(int[] a, int M) {\n \n int[] arr = new int[M];\n for(int i = 0; i < M; i++){\n int times = 0;\n for(int j = 0; j < a.length; j++){\n if(a[j] == i)\n times++;\n }\n arr[i] = times;\n }\n return arr;\n }\n\n}\n"
},
{
"path": "code/chapter1_1_Programming_Model/Ex19.java",
"content": "package chapter1_1_Programming_Model;\n\nimport algs4.StdOut;\n\npublic class Ex19 {\n \n static final int M = 100;\n static long[] arr = new long[M];\n \n public static long F(int N) {\n if(N == 0)\n arr[N] = 0;\n else if(N == 1)\n arr[N] = 1;\n else\n arr[N] = arr[N - 1] + arr[N - 2];\n return arr[N];\n }\n \n public static void main(String[] args) {\n for(int N = 0; N < M; N++)\n StdOut.println(N + \" \" + F(N));\n }\n\n}\n"
},
{
"path": "code/chapter1_1_Programming_Model/Ex2.java",
"content": "package chapter1_1_Programming_Model;\n\nimport algs4.StdOut;\n\npublic class Ex2 {\n\n public static void main(String[] args) {\n\n StdOut.println((1 + 2.236) / 2);\n StdOut.println(1 + 2 + 3 + 4.0);\n StdOut.println(4.1 >= 4);\n StdOut.println(1 + 2 + \"3\");\n\n }\n\n}\n"
},
{
"path": "code/chapter1_1_Programming_Model/Ex20.java",
"content": "package chapter1_1_Programming_Model;\n\nimport algs4.StdOut;\n\npublic class Ex20 {\n\n public static void main(String[] args) {\n \n StdOut.print(ln10(9));\n\n }\n \n public static double ln10(int N) {\n \n if(N == 1)\n return Math.log10(1);\n return Math.log10(N) + ln10(N - 1);\n }\n\n}\n"
},
{
"path": "code/chapter1_1_Programming_Model/Ex3.java",
"content": "package chapter1_1_Programming_Model;\n\nimport algs4.StdIn;\nimport algs4.StdOut;\n\npublic class Ex3 {\n public static void main(String[] args) {\n int a = StdIn.readInt();\n int b = StdIn.readInt();\n int c = StdIn.readInt();\n if(a == b && a == c) {\n StdOut.println(\"equal\");\n } else {\n StdOut.println(\"not equal\");\n }\n }\n}\n"
},
{
"path": "code/chapter1_1_Programming_Model/Ex30.java",
"content": "package chapter1_1_Programming_Model;\n\nimport algs4.StdOut;\n\npublic class Ex30 {\n\n public static void main(String[] args) {\n \n int N = 10;\n boolean[][] arr = new boolean [N][N];\n setArrBoolean(arr);\n \n for(int i = 0; i < arr.length; i++) {\n for(int j = 0; j < arr.length; j++) {\n StdOut.printf(\"%b \", arr[i][j]);\n }\n StdOut.println();\n }\n }\n \n public static void setArrBoolean(boolean[][] arr) {\n for(int i = 0; i < arr.length; i++) {\n for(int j = 0; j < arr.length; j++) {\n arr[i][j] = true;\n for(int k = 2; k <= i; k++) {\n if((i % k == 0) && (j % k == 0)) {\n arr[i][j] = false;\n }\n }\n }\n } \n }\n\n}\n"
},
{
"path": "code/chapter1_1_Programming_Model/Ex31.java",
"content": "package chapter1_1_Programming_Model;\n\nimport java.awt.Color;\n\nimport algs4.StdDraw;\nimport algs4.StdRandom;\n\npublic class Ex31 {\n \n static class Point {\n double x, y;\n \n public Point(double x, double y) {\n super();\n this.x = x;\n this.y = y;\n }\n }\n\n public static void main(String[] args) {\n \n int N = Integer.parseInt(args[0]);\n double p = Double.parseDouble(args[1]);\n if(p < 0 || p > 1) {\n System.out.println(\"p is not valid!\");\n return;\n }\n Point[] points = new Point[N];\n double angle = 360.0 / N;\n StdDraw.circle(.5, .5, .5);\n StdDraw.setPenRadius(.05);\n \n for(int i = 0; i < N; i++) {\n points[i] = new Point(.5 + .5 * Math.cos(angle * i * Math.PI / 180),\n .5 + .5 * Math.sin(angle * i * Math.PI / 180));\n StdDraw.point(points[i].x, points[i].y);\n }\n \n StdDraw.setPenRadius(.01);\n StdDraw.setPenColor(Color.GRAY);\n \n for(int i = 0; i < N - 1; i++) {\n for(int j = i + 1; j < N; j++) {\n if(StdRandom.bernoulli(p)) {\n StdDraw.line(points[i].x, points[i].y, points[j].x, points[j].y);\n }\n }\n }\n\n }\n\n}\n"
},
{
"path": "code/chapter1_1_Programming_Model/Ex32.java",
"content": "package chapter1_1_Programming_Model;\n\nimport java.util.ArrayList;\nimport java.util.Scanner;\n\nimport algs4.StdDraw;\n\npublic class Ex32 {\n\n public static void main(String[] args) {\n \n @SuppressWarnings(\"resource\")\n Scanner scanner = new Scanner(System.in);\n ArrayList\n * public class TestStdDraw {\n * public static void main(String[] args) {\n * StdDraw.setPenRadius(0.05);\n * StdDraw.setPenColor(StdDraw.BLUE);\n * StdDraw.point(0.5, 0.5);\n * StdDraw.setPenColor(StdDraw.MAGENTA);\n * StdDraw.line(0.2, 0.2, 0.8, 0.2);\n * }\n * }\n * \n * If you compile and execute the program, you should see a window\n * appear with a thick magenta line and a blue point.\n * This program illustrates the two main types of methods in standard\n * drawing—methods that draw geometric shapes and methods that\n * control drawing parameters.\n * The methods {@code StdDraw.line()} and {@code StdDraw.point()}\n * draw lines and points; the methods {@code StdDraw.setPenRadius()}\n * and {@code StdDraw.setPenColor()} control the line thickness and color.\n * \n *
\n * \n *
\n * \n *
\n * \n *
\n * \n *
\n * \n * double[] x = { 0.1, 0.2, 0.3, 0.2 };\n * double[] y = { 0.2, 0.3, 0.2, 0.1 };\n * StdDraw.filledPolygon(x, y);\n * \n * \n *
\n * \n *
\n * \n *
\n * \n *
\n * \n *
\n * \n *
\n * \n * Font font = new Font(\"Arial\", Font.BOLD, 60);\n * StdDraw.setFont(font);\n * StdDraw.text(0.5, 0.5, \"Hello, World\");\n *
\n * \n *
\n * \n *
\n * \n *
\n * \n *
\n * \n *
\n * \n * StdDraw.setScale(-2, +2);\n * StdDraw.enableDoubleBuffering();\n *\n * for (double t = 0.0; true; t += 0.02) {\n * double x = Math.sin(t);\n * double y = Math.cos(t);\n * StdDraw.clear();\n * StdDraw.filledCircle(x, y, 0.05);\n * StdDraw.filledCircle(-x, -y, 0.05);\n * StdDraw.show();\n * StdDraw.pause(20);\n * }\n * \n * \n *
\n * \n *
\n * \n *
\n * \n *
\n * \n *
\n * \n *
\n * \n *
\n * \n *
\n * \n *
\n * \n * while (StdIn.hasNextChar()) {\n * char c = StdIn.readChar();\n * StdOut.print(c);\n * }\n * \n * \n *
\n * \n * while (StdIn.hasNextLine()) {\n * String line = StdIn.readLine();\n * StdOut.println(line);\n * }\n * \n * \n *
\n * \n * String[] words = StdIn.readAllStrings();\n *
\n * \n *
\n * \n * public class TestStdOut {\n * public static void main(String[] args) {\n * int a = 17;\n * int b = 23;\n * int sum = a + b;\n * StdOut.println(\"Hello, World\");\n * StdOut.printf(\"%d + %d = %d\\n\", a, b, sum);\n * }\n * }\n * \n * \n *
\n *