A couple of new solutions

Author: dawand

Java/Advanced-Java/src/Callbacks/Lambdas.java

@@ -15,8 +15,6 @@ public static void main(String[] args) {
     }
 
     static class Service {
-        public Consumer<String> blah = s -> {
-            System.out.println(s);
-        };
+        public Consumer<String> blah = System.out::println;
     }
 }

System-design/intro.md

@@ -1,67 +1,68 @@
-A - Ask good questions
-B - Don't use buzzwords
-C - Clear and organized thinking
-D - Drive discussions with 80-20 rule
+## System Design Tips
+- A - Ask good questions
+- B - Don't use buzzwords
+- C - Clear and organized thinking
+- D - Drive discussions with 80-20 rule
 
 ## Things to consider
-Features
-API
-Availability
-Latency
-Scalability
-Durability
-Class Diagram
-Security and Privacy
-Cost-effective
+- Features
+- API
+- Availability
+- Latency
+- Scalability
+- Durability
+- Class Diagram
+- Security and Privacy
+- Cost-effective
 
 ## Concepts to know
-Vertical vs horizontal scaling
-CAP theorem
-ACID vs BASE
-Partitioning/Sharding 
-Consistent Hashing
-Optimistic vs pessimistic locking
-Strong vs eventual consistency
-RelationalDB vs NoSQL
-Types of NoSQL
-     Key value
-     Wide column
-     Document-based
-     Graph-based
-Caching
-Data center/racks/hosts
-CPU/memory/Hard drives/Network bandwidth
-Random vs sequential read/writes to disk
-HTTP vs http2 vs WebSocket
-TCP/IP model
-ipv4 vs ipv6
-TCP vs UDP
-DNS lookup
-Http & TLS
-Public key infrastructure and certificate authority(CA)
-Symmetric vs asymmetric encryption
-Load Balancer
-CDNs & Edges
-Bloom filters and Count-Min sketch
-Paxos 
-Leader election
-Design patterns and Object-oriented design
-Virtual machines and containers
-Pub-sub architecture 
-MapReduce
-Multithreading, locks, synchronization, CAS(compare and set)
+- Vertical vs horizontal scaling
+- CAP theorem
+- ACID vs BASE
+- Partitioning/Sharding 
+- Consistent Hashing
+- Optimistic vs pessimistic locking
+- Strong vs eventual consistency
+- RelationalDB vs NoSQL
+- Types of NoSQL
+     - Key value
+     - Wide column
+     - Document-based
+     - Graph-based
+- Caching
+- Data center/racks/hosts
+- CPU/memory/Hard drives/Network bandwidth
+- Random vs sequential read/writes to disk
+- HTTP vs http2 vs WebSocket
+- TCP/IP model
+- ipv4 vs ipv6
+- TCP vs UDP
+- DNS lookup
+- Http & TLS
+- Public key infrastructure and certificate authority(CA)
+- Symmetric vs asymmetric encryption
+- Load Balancer
+- CDNs & Edges
+- Bloom filters and Count-Min sketch
+- Paxos 
+- Leader election
+- Design patterns and Object-oriented design
+- Virtual machines and containers
+- Pub-sub architecture 
+- MapReduce
+- Multithreading, locks, synchronization, CAS(compare and set)
 
 ##Tools
-Cassandra
-MongoDB/Couchbase
-Mysql
-Memcached
-Redis
-Zookeeper
-Kafka
-NGINX
-HAProxy
-Solr, Elastic search
-Amazon S3
-Docker, Kubernetes, Mesos
-Hadoop/Spark and HDFS
+- Cassandra
+- MongoDB/Couchbase
+- Mysql
+- Memcached
+- Redis
+- Zookeeper
+- Kafka
+- NGINX
+- HAProxy
+- Solr, Elastic search
+- Amazon S3
+- Docker, Kubernetes, Mesos
+- Hadoop/Spark and HDFS

out/production/interview-preparation/Solution.class

@@ -0,0 +1,39 @@
+import java.util.ArrayList;
+import java.util.List;
+
+public class Solution {
+
+    public List<Integer> cellCompute(int[] states, int days){
+        List<Integer> list = new ArrayList<>();
+
+        int[] tempStates = new int[8];
+        int j = 0;
+
+        while (j < days){
+            tempStates[0] = states[1];
+
+            for (int i = 1; i < 7; i++) {
+                tempStates[i] = states[i-1] ^ states[i+1];
+            }
+
+            tempStates[7] = states[6];
+
+            System.arraycopy(tempStates, 0, states, 0, 8);
+
+            j++;
+        }
+
+        for (int i = 0; i < 8; i++) {
+            list.add(states[i]);
+        }
+
+        return list;
+    }
+
+    public static void main(String[] args) {
+        Solution s = new Solution();
+
+        System.out.println(s.cellCompute(new int[] {1,0,0,0,0,1,0,0}, 1));
+        System.out.println(s.cellCompute(new int[] {1,1,1,0,1,1,1,1}, 2));
+    }
+}

out/production/interview-preparation/Solution1.class

@@ -0,0 +1,55 @@
+import java.util.*;
+
+public class Solution1 {
+
+    public List<String> sortJunctionBoxes(List<String> boxList) {
+        List<String> list = new ArrayList<>();
+        List<String> oldList = new ArrayList<>();
+        List<String> newList = new ArrayList<>();
+
+        for (String box: boxList) {
+            String[] boxWords = box.split(" ");
+
+            if (Character.isDigit(boxWords[1].charAt(0)))
+//            if (isNumeric())
+                newList.add(box);
+            else
+                oldList.add(box);
+        }
+
+//        newList.forEach(System.out::println);
+
+        oldList.sort((o1, o2) -> {
+            String s1 = o1.substring(o1.indexOf(" "));
+            String s2 = o2.substring(o2.indexOf(" "));
+
+            if (s1.equals(s2))
+                return o1.substring(0, o1.indexOf(" ")).compareTo(o2.substring(0, o2.indexOf(" ")));
+
+            return s1.compareTo(s2);
+        });
+
+        list.addAll(oldList);
+        list.addAll(newList);
+
+        return list;
+    }
+
+    boolean isNumeric(String str){
+        return str.contains("+d");
+    }
+    public static void main(String[] args) {
+        Solution1 s = new Solution1();
+
+        List<String> list = new ArrayList<>();
+        list.add("r1 box ape bit");
+        list.add("br8 eat nim did");
+        list.add("b4 tye 121 432");
+        list.add("b4 sea 121 432");
+        list.add("w1 has uni gry");
+        list.add("b4 xi me nu");
+        list.add("b4 32 43 54");
+
+        s.sortJunctionBoxes(list).forEach(System.out::println);
+    }
+}

out/production/interview-preparation/Solution2$PairInt.class

@@ -0,0 +1,53 @@
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class Solution2 {
+
+    public List<PairInt> optimizeUtilization(List<PairInt> foregroundAppsList, List<PairInt> backgroundAppsList) {
+        List<PairInt> list = new ArrayList<>();
+
+        Map<Integer, List<PairInt>> map = new HashMap<>();
+
+        for (PairInt pairInt : foregroundAppsList) {
+            for (PairInt anInt : backgroundAppsList) {
+                int f2 = pairInt.second;
+                int b2 = anInt.second;
+                List<PairInt> sums = map.getOrDefault(f2 + b2, new ArrayList<>());
+                sums.add(new PairInt(pairInt.first, anInt.first));
+                map.put(f2 + b2, sums);
+            }
+        }
+
+        map.keySet().forEach(System.out::println);
+
+        return list;
+    }
+
+    public static void main(String[] args) {
+        Solution2 s = new Solution2();
+
+        List<PairInt> foregroundAppsList = new ArrayList<>();
+        foregroundAppsList.add(new PairInt(1,2));
+        foregroundAppsList.add(new PairInt(2,4));
+        foregroundAppsList.add(new PairInt(3,5));
+
+        List<PairInt> backgroundAppsList = new ArrayList<>();
+        backgroundAppsList.add(new PairInt(1,3));
+        backgroundAppsList.add(new PairInt(2,5));
+
+        System.out.println(s.optimizeUtilization(foregroundAppsList, backgroundAppsList));
+    }
+
+    static class PairInt {
+
+        int first;
+        int second;
+
+        PairInt(int first, int second){
+            this.first = first;
+            this.second = second;
+        }
+    }
+}

out/production/interview-preparation/Solution2.class

@@ -15,7 +15,7 @@ static List<String> topKFrequent(String[] words, int k){
         }
 
         PriorityQueue<Map.Entry<String, Integer>> pq = new PriorityQueue<>(
-                (a,b) -> a.getValue() == b.getValue()
+                (a,b) -> a.getValue().equals(b.getValue())
                         ? b.getKey().compareTo(a.getKey())
                         : a.getValue() - b.getValue()
         );