design material

Author: abhiabhi

src/main/images/class.png

@@ -0,0 +1,8 @@
+ he bitwise method evaluates the binary representation of the values of the two inputs. For each bit in the binary representation, a Boolean Exclusive Or is performed. In the Boolean evaluation, if one of the input values for the bit is true and the other is false, the output is one for the bit; if both input values are true or if both are false, the output is zero for the bit. When one or both input values are NoData, the bitwise expression outputs NoData.
+For example, the input values for a particular cell location on two rasters are 5 and 3. The Boolean Exclusive Or is performed, producing a new binary value. When the value of this number is printed as a decimal integer, its base10 value is assigned to the output. The example below is of an 8-bit integer.
+
+Value	Binary representation
+Input 1	5	00000101
+Input 2	3	00000011
+(Bitwise XOr)
+Output	6	00000110

src/main/images/classdia.png

@@ -0,0 +1,83 @@
+package com.arrays;
+
+import java.time.Duration;
+import java.time.Instant;
+
+/**
+ * Input: arr[] = {1, 2, 4, 6, 3, 7, 8}
+ * Output: 5
+ * Explanation: The missing number from 1 to 8 is 5
+ * <p>
+ * Input: arr[] = {1, 2, 3, 5}
+ * Output: 4
+ * Explanation: The missing number from 1 to 5 is 4
+ * <p>
+ * Approach:
+ * XOR has certain properties
+ * Assume a1 ^ a2 ^ a3 ^ …^ an = a and a1 ^ a2 ^ a3 ^ …^ an-1 = b
+ * Then a ^ b = an
+ * Using this property, the missing element can be found. Calculate XOR of all the natural number from 1 to n and store it as a.
+ * Now calculate XOR of all the elements of the array and store it as b.
+ * The missing number will be a ^ b.
+ * ^ is XOR operator.
+ * <p>
+ * Algorithm:
+ * Create two variables a = 0 and b = 0
+ * Run a loop from 1 to n with i as counter.
+ * For every index update a as a = a ^ i
+ * Now traverse the array from start to end.
+ * For every index update b as b = b ^ array[i]
+ * Print the missing number as a ^ b.
+ * <p>
+ * Compelxity Analysis:
+ * Time Complexity: O(n).
+ * Only one traversal of array is needed.
+ * Space Complexity: O(1).
+ * No extra space is needed
+ * <p>
+ * Bitwise operations are incredibly simple and thus usually faster than arithmetic operations.
+ */
+
+public class FindMissingNumber {
+
+    public static long missingNumber(int[] nums, int n) {
+        System.out.println("time start");
+
+        long naturalNumberXOR = 1;
+        long arrayXOR = nums[0];
+
+        for (int i = 2; i <= n + 1; i++) {
+            naturalNumberXOR = naturalNumberXOR ^ i;
+        }
+
+        for (int i = 1; i < nums.length; i++) {
+            arrayXOR = arrayXOR ^ nums[i];
+        }
+        System.out.println("time end");
+        return naturalNumberXOR ^ arrayXOR;
+
+
+    }
+
+
+    public static long missingNumberUsingSUm(int[] nums, int n) {
+        System.out.println("time start");
+        long naturalNumberSum = 1;
+        long arraySum = nums[0];
+
+        naturalNumberSum = (n * (n + 1)) / 2;  //Summation formula GUass's formula
+
+
+        for (int i = 1; i < nums.length; i++) {
+            arraySum = arraySum + nums[i];
+        }
+        System.out.println("time end");
+        return naturalNumberSum - arraySum;
+
+    }
+
+    public static void main(String args[]) {
+        int[] nums = {1, 2, 3, 4, 5, 7, 8, 9, 10};
+        System.out.println("Missing Number:" + missingNumberUsingSUm(nums, 10));
+    }
+}

src/main/images/solidPrinciple.png

@@ -35,6 +35,14 @@ public class MinimumPlatforms_Greedy {
     // Returns minimum number of platforms required
     static int findPlatform(int arr[], int dep[], int n) {
 
+        //Edge case for input.
+        if (arr.length==0){
+            return 0;
+        }
+        if(dep.length==0){
+            return arr.length;
+        }
+
         /**important*/
         // Sort arrival and departure arrays
         Arrays.sort(arr);
@@ -48,7 +56,7 @@ static int findPlatform(int arr[], int dep[], int n) {
         while (i < n && j < n) { /** end the loop when any one iterator completes any one array.*/
             // If next event in sorted order is arrival,
             // increment count of platforms needed
-            if (arr[i] <= dep[j])  /**means one more train came before any train could depart so increment the max_platfroms */ {
+            if (arr[i] <= dep[j]) { /**means one more train came before any train could depart so increment the max_platfroms */
                 max_platforms_so_far++;
                 i++;
 

src/main/images/uml.png

@@ -0,0 +1,92 @@
+package com.design;
+
+import com.linkedlist.model.DoublyLLNode;
+
+import java.util.HashMap;
+
+/**
+ * Design and implement a data structure for Least Recently Used (LRU) cache, which supports get and put.
+ * The key to solve this problem is using a double linked list which enables us to quickly move nodes.
+ *
+ * The LRU cache is a hash table of keys and double linked nodes.
+ * The hash table makes the time of get() to be O(1). The list of double linked nodes make the nodes adding/removal operations O(1).
+ *
+ * By analyzing the get and put, we can summarize there are 2 basic operations:
+ * 1) removeNode(Node t), 2) offerNode(Node t).
+ *
+ */
+class LRUCache {
+    DoublyLLNode head;
+    DoublyLLNode tail;
+    HashMap<Integer, DoublyLLNode> map = null;
+    int cap = 0;
+
+    public LRUCache(int capacity) {
+        this.cap = capacity;
+        this.map = new HashMap<>();
+    }
+
+    public int get(int key) {
+        if(map.get(key)==null){
+            return -1;
+        }
+
+        //move to tail
+        DoublyLLNode t = map.get(key);
+
+        removeDoublyLLNode(t);
+        offerDoublyLLNode(t);
+
+        return t.value;
+    }
+
+    public void put(int key, int value) {
+        if(map.containsKey(key)){
+            DoublyLLNode t = map.get(key);
+            t.value = value;
+
+            //move to tail
+            removeDoublyLLNode(t);
+            offerDoublyLLNode(t);
+        }else{
+            if(map.size()>=cap){
+                //delete head
+                map.remove(head.key);
+                removeDoublyLLNode(head);
+            }
+
+            //add to tail
+            DoublyLLNode DoublyLLNode = new DoublyLLNode(key, value);
+            offerDoublyLLNode(DoublyLLNode);
+            map.put(key, DoublyLLNode);
+        }
+    }
+
+    private void removeDoublyLLNode(DoublyLLNode n){
+        if(n.prev!=null){
+            n.prev.next = n.next;
+        }else{
+            head = n.next;
+        }
+
+        if(n.next!=null){
+            n.next.prev = n.prev;
+        }else{
+            tail = n.prev;
+        }
+    }
+
+    private void offerDoublyLLNode(DoublyLLNode n){
+        if(tail!=null){
+            tail.next = n;
+        }
+
+        n.prev = tail;
+        n.next = null;
+        tail = n;
+
+        if(head == null){
+            head = tail;
+        }
+    }
+}

src/main/java/com/arrays/FindMissingNumber.adoc

@@ -0,0 +1,79 @@
+package com.design;
+
+import javax.jms.Message;
+import javax.jms.MessageListener;
+import javax.jms.TextMessage;
+
+/**
+ * This design uses Strategy Pattern
+ *
+ * Strategy pattern and the open closed principle
+ * According to the strategy pattern, the behaviour of a class should be encapsulated
+ * using interfaces and should not be inherited.
+ * This is compatible with the open closed principle,
+ */
+
+public class LowLevelDesign {
+
+    MessageProcessor processor;
+
+    class MessageConsumer implements MessageListener{
+
+        @JMSListener
+        public void onMessage(Message message){
+            if (message instanceof  TextMessage){
+                processor = new MessageProcessor();
+                MessageParser mp = new swiftParser();
+                processor.setParser(mp);
+                processor.process(message);
+            }
+            if (message instanceof BytesMessage){
+
+            }
+
+
+        }
+
+    }
+
+    class MessageProcessor {
+
+        MessageParser parser;
+
+        public void setParser(MessageParser p){
+            this.parser = p;
+        }
+
+        public void process(Message message){
+            parser.parse(message);
+        }
+
+    }
+
+    interface MessageParser{
+        void parse(Message message);
+    }
+
+    class SwiftParser implements MessageParser{
+
+        @Override
+        public void parse(Message message) {
+
+        }
+    }
+     class JsonParser implements  MessageParser{
+
+         @Override
+         public void parse(Message message) {
+
+         }
+     }
+    class XMLParser implements  MessageParser{
+
+        @Override
+        public void parse(Message message) {
+
+        }
+    }
+
+}

src/main/java/com/arrays/FindMissingNumber.java

@@ -0,0 +1,99 @@
+package com.design;
+
+// Java code skeleton to design an online hotel
+// booking system.
+
+enum RoomStatus {
+    EMPTY,
+    NOT_EMPTY;
+    }
+
+enum RoomType {
+    SINGLE,
+    DOUBLE,
+    TRIPLE;
+}
+
+enum PaymentStatus {
+    PAID,
+    UNPAID;
+}
+
+public enum Facility {
+    LIFT;
+    POWER_BACKUP;
+    HOT_WATERR;
+    BREAKFAST_FREE;
+    SWIMMING_POOL;
+}
+
+class User {
+
+    int userId;
+    String name;
+    Date dateOfBirth;
+    String mobNo;
+    String emailId;
+    String sex;
+}
+
+// For the room in any hotel
+class Room {
+
+    int roomId; // roomNo
+    int hotelId;
+    RoomType roomType;
+    RoomStatus roomStatus;
+}
+
+class Hotel {
+
+    int hotelId;
+    String hotelName;
+    Adress adress;
+
+    // hotel contains the list of rooms
+    List<Room> rooms;
+    float rating;
+    Facilities facilities;
+}
+
+// a new booking is created for each booking
+// done by any user
+class Booking {
+    int bookingId;
+    int userId;
+    int hotelId;
+
+    // We are assuming that in a single
+    // booking we can book only the rooms
+    // of a single hotel
+    List<Rooms> bookedRooms;
+
+    int amount;
+    PaymentStatus status_of_payment;
+    Date bookingTime;
+    Duration duration;
+}
+
+class Address {
+
+    String city;
+    String pinCode;
+    String state;
+    String streetNo;
+    String landmark;
+}
+
+class Duration {
+
+    Date from;
+    Date to;
+
+}
+
+class Facilities {
+
+    List<Facility> facilitiesList;
+}
+