changed poms

Author: gardncl

arrays/src/main/java/AdvanceThroughArray.java

@@ -3,12 +3,7 @@
 public class AdvanceThroughArray {
 
     /*
-    6.4
-
-    Write a program that takes an array of n integers, where A[i]
-    denotes the maximum you can advance from index i, and returns
-    whether it is possible to advance to the last index starting
-    from the beginning of the array
+       6.4
     */
 
     public static boolean arrayAdvance(List<Integer> A) {

arrays/src/main/java/BuySellStockOnce.java

@@ -3,12 +3,8 @@
 public class BuySellStockOnce {
 
     /*
-    6.6
-
-    Write a program that takes an array denoting the daily stock price,
-    and returns the maximum profit that could be made by buying and
-    then selling one share of that stock.
-     */
+       6.6
+    */
 
     public static int buySellStockOnce(List<Integer> A) {
 

arrays/src/main/java/BuySellStockTwice.java

@@ -4,11 +4,7 @@ public class BuySellStockTwice {
 
     /*
     6.7
-
-    Write a program that computes the maximum profit that can
-    be made by buying and selling a share at most twice. The
-    second buy must be made on another date after the first sale.
-     */
+    */
 
     public static int buySellStockTwice(List<Integer> A) {
 

arrays/src/main/java/ComputePascalsTriangle.java

@@ -5,10 +5,7 @@ public class ComputePascalsTriangle {
 
     /*
     6.19
-
-    Write a program which takes as input a non-negative integer n
-    and returns the first n rows of Pascal's triangle.
-     */
+    */
 
     public static List<List<Integer>> generatePascalTriangle(int n) {
 

arrays/src/main/java/ComputeRandomPermutation.java

@@ -5,11 +5,7 @@ public class ComputeRandomPermutation {
 
     /*
     6.13
-
-    Design an algorithm that creates uniformly random permutations of {0,1,...,n-1}.
-    You are given a random number generator that returns integers in the set {0,1,...,n-1}
-    with equal probability; use as few calls to it as possible.
-     */
+    */
 
     public static List<Integer> computeRandomPermutation(int n) {
 

arrays/src/main/java/ComputeRandomSubset.java

@@ -5,13 +5,6 @@ public class ComputeRandomSubset {
 
     /*
     6.14
-
-    Write a program that takes as input a positive integer n and a size k <= n,
-    and returns a size-k subset of {0, 1, 2, ..., n-1}. The subset should be
-    represented as an array. All subsets should be equally likely and, in addition,
-    all permutations of elements of the array should be equally likely.
-    You may assume you have a function which takes as input a non-negative
-    integer t and returns an integer in the set {0, 1,...,t-1} with uniform probability.
     */
 
     public static List<Integer> randomSubset(int n, int k) {

arrays/src/main/java/ComputeSpiralOrdering.java

@@ -5,11 +5,7 @@ public class ComputeSpiralOrdering {
 
     /*
     6.17
-
-    Write a program which takes an nxn 2D array and
-    returns the spiral ordering of the array.
-    Starts at [0,0] and goes clockwise.
-     */
+    */
 
     public static List<Integer> matrixInSpiralOrder(List<List<Integer>> squareMatrix) {
 

arrays/src/main/java/DeleteDuplicates.java

@@ -4,12 +4,7 @@ public class DeleteDuplicates {
 
     /*
     6.5
-
-    Write a program that takes as input an array a sorted array and updates
-    it so that all duplicates have been removed and the remaining elements
-    have been shifted left to fill the emptied indices. Return the
-    number of valid elements.
-     */
+    */
 
     public static int deleteDuplicates(List<Integer> A) {
         return 0;

arrays/src/main/java/DutchNationalFlag.java

@@ -4,12 +4,7 @@ public class DutchNationalFlag {
 
     /*
     6.1
-
-    Write a program that takes an array A and an index i into A, and
-    rearranges the elements such that all elements less that A[i]
-    (the 'pivot') appear first, followed by elements equal to the pivot,
-    followed by elements greater than the pivot.
-     */
+    */
 
     public static void dutchNationalFlag(int p, List<Integer> A) {
 

arrays/src/main/java/EnumeratePrimes.java

@@ -5,10 +5,7 @@ public class EnumeratePrimes {
 
     /*
     6.8
-
-    Write a program that takes an integer argument
-    and returns all the primes between 1 and that integer.
-     */
+    */
 
     public static List<Integer> enumeratePrimes(int n) {
         return Arrays.asList(1);

arrays/src/main/java/GenerateNonuniformRandomNumbers.java

@@ -4,18 +4,7 @@ public class GenerateNonuniformRandomNumbers {
 
     /*
     6.15
-
-    You are given n numbers as well as probabilities p0,p1,...,p(n-1),
-    which sum up to 1. Given a random number generator that produces
-    values in [0,1] uniformly, how would you getRandom one of the n
-    numbers according to the specified probabilities? For example,
-    if the numbers are 3, 5, 7, 11, and the probabilities are
-    9/18, 6/18, 2/18, 1/18, then in 1000000 calls to your program,
-    3 should appear roughly 500000 times,
-    5 should appear roughly 333333 times,
-    7 should appear roughly 111111 times,
-    and 11 should appear roughly 55555 times.
-     */
+    */
 
     public static int getRandom(List<Integer> values, List<Double> probabilities) {
 

arrays/src/main/java/IncrementArbitraryPrecisionInteger.java

@@ -4,12 +4,7 @@ public class IncrementArbitraryPrecisionInteger {
 
     /*
     6.2
-
-    Write a program that takes as input an array of digits encoding a decimal number D
-    and updates the array to represent the number D + 1. For example, if the input is
-    (1,2,9) then you should update the array to (1,3,0). Your algorithm should work
-    even if it is implemented in a language that has finite-precision arithmetic.
-     */
+    */
 
     public static List<Integer> incrementInteger(List<Integer> A) {
         return A;

arrays/src/main/java/MultipleArbitraryPrecisionIntegers.java

@@ -5,10 +5,7 @@ public class MultipleArbitraryPrecisionIntegers {
 
     /*
     6.3
-
-    Write a program that takes two arrays representing integers,
-    and returns an integer representing their product.
-     */
+    */
 
     public static List<Integer> multiply(List<Integer> a, List<Integer> b) {
 

arrays/src/main/java/NextPermutation.java

@@ -5,11 +5,7 @@ public class NextPermutation {
 
     /*
     6.10
-
-    Write a program that takes in a permutation and returns the
-    next permutation under dictionary ordering. If the permutation
-    is the last permutation return an empty array.
-     */
+    */
 
     public static List<Integer> nextPermutation(List<Integer> permutation) {
 

arrays/src/main/java/PermuteElements.java

@@ -4,9 +4,7 @@ public class PermuteElements {
 
     /*
     6.9
-
-    Given an array A of n elements and a permutation P, apply P to A.
-     */
+    */
 
     public static void applyPermutation(List<Integer> perm, List<Integer> a) {
 

arrays/src/main/java/Rotate2DArray.java

@@ -5,10 +5,7 @@ public class Rotate2DArray {
 
     /*
     6.18
-
-    Write a function that takes as input an nxn 2D array,
-    and rotates the array by 90 degrees clockwise.
-     */
+    */
 
     public static List<List<Integer>> rotateMatix(List<List<Integer>> squareMatrix) {
 

arrays/src/main/java/SampleOfflineData.java

@@ -4,12 +4,7 @@ public class SampleOfflineData {
 
     /*
     6.11
-
-    Implement an algorithm that takes an input an array of
-    distinct elements and a size, and returns a subset of
-    the given size of the array elements. All subsets should
-    be equally likely. Return the result in input array itself.
-     */
+    */
 
     public static void randomSampling(int k, List<Integer> list) {
 

arrays/src/main/java/SampleOnlineData.java

@@ -5,11 +5,7 @@ public class SampleOnlineData {
 
     /*
     6.12
-
-    Design a program that takes as input a size k,
-    and reads packets, continuously maintaining a
-    uniform random subset of size k of the read packets.
-     */
+    */
 
     public static List<Integer> runningSample(int k, List<Integer> sequence) {
 

arrays/src/main/java/SudokuChecker.java

@@ -4,13 +4,7 @@ public class SudokuChecker {
 
     /*
     6.16
-
-    Check whether a 9x9 2D array representing a partially
-    sompleted Sudoku is valid. Specifically, check that
-    no row, column, or 3x3 2D subarray contains duplicates.
-    A 0-value in the 2D array indicates that the entry
-    is blank; every other entry is in [1,9].
-     */
+    */
 
     public static boolean isValidSudoku(List<List<Integer>> partialAssignment) {
 

binarysearchtrees/src/main/java/AreNodesOrdered.java

@@ -2,13 +2,7 @@ public class AreNodesOrdered {
 
     /*
     15.11
-
-    Write a program which takes two nodes in a BST and a third node,
-    the "middle" node, and determines if one of the two nodes is a
-    proper ancestor and the other a proper descendant of the middle.
-    (A proper ancestor of a node is an ancestor that is not equal
-    to the node; a proper descendant is defined similarly.)
-     */
+    */
 
     public static boolean totallyOrdered(BinaryTree<Integer> possible1,
                                          BinaryTree<Integer> possible2,

binarysearchtrees/src/main/java/ClientCreditsInfo.java

@@ -2,17 +2,7 @@ public class ClientCreditsInfo {
 
     /*
     15.13
-
-    Design a data structure that implements the following methods:
-        - Insert: add a client with specified credit,
-        replacing any existing entry for the client
-        - Remove: delete the specified client
-        - Lookup: return the number of credits associated
-        with the specified client
-        - Add-to-all: increment the credit count for all current
-        clients by the specified amount
-        - Max: return a client with the highest number of credits
-     */
+    */
 
     public void insert(String clientID, int c) {
 

binarysearchtrees/src/main/java/ClosestEntries.java

@@ -4,12 +4,7 @@ public class ClosestEntries {
 
     /*
     15.6
-
-    Design an algorithm that takes three sorted arrays,
-    and returns one entry from each such that the minimum
-    interval containing these three entries is as small
-    as possible.
-     */
+    */
 
     public static int findMin(List<List<Integer>> sortedArrays) {
 

binarysearchtrees/src/main/java/ComputeLCA.java

@@ -2,11 +2,7 @@ public class ComputeLCA {
 
     /*
     15.4
-
-    Design an algorithm that takes as input a BST and two nodes,
-    and returns the LCA of the two nodes.
-    fig 15.1 with C and G returns B.
-     */
+    */
 
     public static BinaryTree<Integer> findLCA(BinaryTree<Integer> tree,
                                               BinaryTree<Integer> s,

binarysearchtrees/src/main/java/EnumerateEntries.java

@@ -5,10 +5,7 @@ public class EnumerateEntries {
 
     /*
     15.7
-
-    Design an algorithm for efficiently computing the k smallest numbers
-    of the form a+b*sqrt(2) for non-negative integers a and b.
-     */
+    */
 
     public static class ABSqrt2 implements Comparable<ABSqrt2> {
         public int a, b;

binarysearchtrees/src/main/java/FindKLargest.java

@@ -5,12 +5,7 @@ public class FindKLargest {
 
     /*
     15.3
-
-    Write a program that takes as input a BST and an integer k,
-    and returns teh k largest elements in the BST in decreasing
-    order. For example, if the input is the BST in Figure 15.1
-    on Page 158 and k = 3, your program should return [53,47,42].
-     */
+    */
 
     public static List<Integer> findLargest(BinaryTree<Integer> tree, int k) {
 

binarysearchtrees/src/main/java/FirstGreaterThan.java

@@ -2,11 +2,7 @@ public class FirstGreaterThan {
 
     /*
     15.2
-
-    Write a program that takes as input a BST and a value,
-    and returns the first key that would appear in an
-    inorder traversal which is greater than the input value.
-     */
+    */
 
     public static BinaryTree<Integer> find(BinaryTree<Integer> tree, Integer k) {
 

binarysearchtrees/src/main/java/InsertionAndDeletionBST.java

@@ -2,11 +2,7 @@ public class InsertionAndDeletionBST extends BinaryTree<Integer> {
 
     /*
     15.10
-
-    Design efficient functions for inserting and removing keys
-    in a BST. Assume that all elements in the BST are unique,
-    and that your insertion method must preserve this property.
-     */
+    */
 
     public InsertionAndDeletionBST(Integer data) {
         super(data);

binarysearchtrees/src/main/java/IsBST.java

@@ -2,10 +2,7 @@ public class IsBST {
 
     /*
     15.1
-
-    Write a program that takes an input a binary tree and checks
-    if the tree satisfies the BST property.
-     */
+    */
 
     public static boolean isBST(BinaryTree<Integer> tree) {
 

binarysearchtrees/src/main/java/MinimumHeightBST.java

@@ -4,10 +4,7 @@ public class MinimumHeightBST {
 
     /*
     15.9
-
-    How would you build a BST of minimum possible height
-    for a sorted array?
-     */
+    */
 
     public static BinaryTree<Integer> build(List<Integer> A) {