Merge pull request #20 from code4tomorrow/neha-practice

Ch. 16 practice problems

Author: JJ27

src/com/codefortomorrow/advanced/chapter14/solutions/Bank.java

@@ -52,6 +52,7 @@ public static void withdraw(BankAccount account, int amount) {
 }
 
 class BankAccount {
+
     private int balance;
 
     public BankAccount(int balance) {

src/com/codefortomorrow/advanced/chapter15/solutions/MeasurableProblem.java

@@ -40,6 +40,7 @@ interface Measurable {
 }
 
 class Student implements Measurable {
+
     private double GPA;
     private String name;
 

src/com/codefortomorrow/advanced/chapter16/practice/Access.java

@@ -0,0 +1,11 @@
+package com.codefortomorrow.advanced.chapter16.practice;
+/*
+Using the methods outlined in the “Benefits of LinkedLists” section,
+fill both a LinkedList and an ArrayList with 10,000 elements.
+Then, find the time it takes to access the last element of each list.
+
+Determine which type of list can access elements more efficiently.
+
+Hint: You can use the get(int position) method
+to access the element at a given position of a list.
+*/

src/com/codefortomorrow/advanced/chapter16/practice/Names.java

@@ -0,0 +1,17 @@
+package com.codefortomorrow.advanced.chapter16.practice;
+/*
+Create a LinkedList of Strings, and ask the user to
+input 10 names one by one into the list.
+
+Output this list.
+
+Remove each name that has 5 or fewer letters, and output the new list.
+
+Add the word “Apple” to the beginning of the list.
+
+Add the word “Peanut” to the second-to-last position of the list.
+
+(Hint: Make sure to take advantage of LinkedList methods!)
+
+Output the new list.
+*/

src/com/codefortomorrow/advanced/chapter16/practice/SinglyLinkedListInsert.java

@@ -0,0 +1,30 @@
+package com.codefortomorrow.advanced.chapter16.practice;
+/*
+Adding an insert method to a SinglyLinkedList
+(details in SinglyLinkedList DIY section). 
+
+Hint: It might be necessary to have a separate case for
+inserting at position 0, because that’s when you want to
+insert BEFORE the head. For all other positions (1, 2, etc.),
+you can simply traverse down the list, keeping track of the
+current node, and when you reach the position you want,
+add the node AFTER the current node.
+
+Alternatively, you can always add BEFORE the current node
+for all position cases (insert before the head to place the
+new node at pos 0, insert before node 1 to place the new
+node at pos 1, etc.), but then your exception case would
+be when the user wants to insert a node at the very end of the list.
+In this case, you’d have to write separate code to insert AFTER
+the last node.
+
+Make sure you have a toString() method defined!
+
+The following code should output “{2, 3, 4, 7}”:
+SinglyLinkedList lst = new SinglyLinkedList();
+lst.add(3);
+lst.add(7);
+lst.insert(4, 1);
+lst.insert(2, 0);
+System.out.println(lst);
+*/

src/com/codefortomorrow/advanced/chapter16/practice/Sort.java

@@ -0,0 +1,7 @@
+package com.codefortomorrow.advanced.chapter16.practice;
+/*
+Write a method which takes in a LinkedList of Strings
+and rearranges the elements (without creating a new list)
+so it is sorted in ascending order of String length.
+Don’t use any pre-existing sort methods… write your own. :)
+*/

src/com/codefortomorrow/advanced/chapter16/solutions/Access.java

@@ -0,0 +1,40 @@
+package com.codefortomorrow.advanced.chapter16.solutions;
+
+import java.util.*;
+
+/*
+Using the methods outlined in the “Benefits of LinkedLists” section,
+fill both a LinkedList and an ArrayList with 10,000 elements.
+Then, find the time it takes to access the last element of each list.
+
+Determine which type of list can access elements more efficiently.
+
+Hint: You can use the get(int position) method
+to access the element at a given position of a list.
+*/
+
+public class Access {
+
+    public static void main(String[] args) {
+        long a, b;
+
+        // Define lists with 10,000 elements.
+        LinkedList<Integer> list1 = new LinkedList<Integer>();
+        for (int i = 0; i < 10000; i++) list1.add(1);
+
+        ArrayList<Integer> list2 = new ArrayList<Integer>();
+        for (int i = 0; i < 10000; i++) list2.add(1);
+
+        // Get time for each operation and output the difference.
+        a = System.nanoTime();
+        int c = list1.get(9999);
+        b = System.nanoTime();
+        System.out.println("\nLinked: " + (b - a) + " ns");
+
+        a = System.nanoTime();
+        int d = list2.get(9999);
+        b = System.nanoTime();
+        System.out.println("ArrayList: " + (b - a) + " ns");
+        // Note that the ArrayList takes less time.
+    }
+}

src/com/codefortomorrow/advanced/chapter16/solutions/Names.java

@@ -0,0 +1,42 @@
+package com.codefortomorrow.advanced.chapter16.solutions;
+
+import java.util.*;
+
+/*
+Create a LinkedList of Strings, and ask the user to
+input 10 names one by one into the list.
+
+Output this list.
+
+Remove each name that has 5 or fewer letters, and output the new list.
+
+Add the word “Apple” to the beginning of the list.
+
+Add the word “Peanut” to the second-to-last position of the list.
+
+(Hint: Make sure to take advantage of LinkedList methods!)
+
+Output the new list.
+*/
+
+public class Names {
+
+    public static void main(String[] args) {
+        LinkedList<String> list = new LinkedList<String>();
+        Scanner sc = new Scanner(System.in);
+        for (int i = 0; i < 10; i++) {
+            System.out.print("Enter name " + (i + 1) + ": ");
+            list.add(sc.nextLine());
+        }
+        System.out.println(list);
+
+        for (int i = 0; i < list.size(); i++) if (
+            list.get(i).length() <= 5
+        ) list.remove(i--);
+        System.out.println(list);
+
+        list.add(0, "Apple");
+        list.add(list.size() - 1, "Peanut");
+        System.out.println(list);
+    }
+}

src/com/codefortomorrow/advanced/chapter16/solutions/SinglyLinkedListInsert.java

@@ -0,0 +1,111 @@
+package com.codefortomorrow.advanced.chapter16.solutions;
+
+import java.util.*;
+
+/*
+Adding an insert method to a SinglyLinkedList
+(details in SinglyLinkedList DIY section). 
+
+Hint: It might be necessary to have a separate case for
+inserting at position 0, because that’s when you want to
+insert BEFORE the head. For all other positions (1, 2, etc.),
+you can simply traverse down the list, keeping track of the
+current node, and when you reach the position you want,
+add the node AFTER the current node.
+
+Alternatively, you can always add BEFORE the current node
+for all position cases (insert before the head to place the
+new node at pos 0, insert before node 1 to place the new
+node at pos 1, etc.), but then your exception case would
+be when the user wants to insert a node at the very end of the list.
+In this case, you’d have to write separate code to insert AFTER
+the last node.
+
+Make sure you have a toString() method defined!
+
+The following code should output “{2, 3, 4, 7}”:
+SinglyLinkedList lst = new SinglyLinkedList();
+lst.add(3);
+lst.add(7);
+lst.insert(4, 1);
+lst.insert(2, 0);
+System.out.println(lst);
+*/
+
+// NOTE: You need to make a separate class with a main()
+// method to use this List object. This is simply the object
+// definition.
+
+public class SinglyLinkedListInsert {
+
+    Node head;
+
+    // add() method from SinglyLinkedList DIY section, adds to end of list
+    public void add(int data) {
+        // Create a new node with given data
+        Node new_node = new Node(data);
+
+        // If the Linked List is empty,
+        // then make the new node as head
+        if (head == null) {
+            head = new_node;
+        } else {
+            // Else traverse till the last node
+            // and insert the new_node there
+            Node last = head;
+            while (last.next != null) {
+                last = last.next;
+            }
+
+            // Insert the new_node at last node
+            last.next = new_node;
+        }
+    }
+
+    public void insert(int data, int pos) {
+        // Verify valid pos number
+        if (pos < 0) System.out.print("Invalid position");
+
+        // Create new node and keep track of current node
+        Node new_node = new Node(data);
+        Node current = head;
+
+        // If pos is 0, set new node as head
+        if (pos == 0) {
+            new_node.next = head;
+            head = new_node;
+        } else {
+            while (pos-- >= 0) {
+                if (pos == 0) {
+                    // Add new node after current position
+                    new_node.next = current.next;
+                    current.next = new_node;
+                    break;
+                }
+                // Check if pos is out of bounds (reaches end)
+                if (current.next == null) {
+                    System.out.println("Out of bounds");
+                    break;
+                }
+                current = current.next;
+            }
+        }
+    }
+
+    @Override
+    public String toString() {
+        // For empty lists
+        if (head == null) return "{}";
+
+        String str = "{";
+
+        // Traverse the list until the last node
+        Node current = head;
+        while (current.next != null) {
+            str += "" + current.data + ", ";
+            current = current.next;
+        }
+        str += current.data + "}";
+        return str;
+    }
+}

src/com/codefortomorrow/advanced/chapter16/solutions/Sort.java

@@ -0,0 +1,51 @@
+package com.codefortomorrow.advanced.chapter16.solutions;
+
+import java.util.*;
+
+/*
+Write a method which takes in a LinkedList of Strings
+and rearranges the elements (without creating a new list)
+so it is sorted in ascending order of String length.
+Don’t use any pre-existing sort methods… write your own. :)
+*/
+
+public class Sort {
+
+    public static void main(String[] args) {
+        LinkedList<String> list = new LinkedList<String>();
+        list.addAll(
+            Arrays.asList(
+                "Jeannette",
+                "Sophia",
+                "Computer",
+                "Boots",
+                "Lava",
+                "Lasagna",
+                "Dirty",
+                "Cleanie"
+            )
+        );
+        sort(list);
+        System.out.println(list);
+    }
+
+    public static void sort(LinkedList<String> list) {
+        if (list.size() < 2) return;
+        for (int i = 1; i < list.size(); i++) {
+            String current = list.get(i);
+            // Check if current word is smaller than previous word
+            if (current.length() < list.get(i - 1).length()) {
+                // Add current word before the node with
+                // same or greater word size
+                for (int j = 0; j < i; j++) {
+                    if (list.get(j).length() >= current.length()) {
+                        list.add(j, current);
+                        // Remove duplicate current
+                        list.remove(i + 1);
+                        break;
+                    }
+                }
+            }
+        }
+    }
+}