C3ai (#5)

EdwardTang · Yongbing Tang · web-flow · commit 496cbf6ae9c8 · 2020-03-13T00:09:10.000-07:00
* c3ai add c3ai phone interview question

* autonomic phone interview

Co-authored-by: Yongbing Tang &lt;yongbing@lumity.com&gt;
diff --git a/src/main/java/com/company/autonomic/phone/MaxDistinctElements.java b/src/main/java/com/company/autonomic/phone/MaxDistinctElements.java
@@ -0,0 +1,79 @@
+package com.company.autonomic.phone;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.PriorityQueue;
+
+public class MaxDistinctElements {
+
+  /**
+   * Maximum distinct elements after removing k elements
+   *
+   * <p>Given an array arr[] containing n elements. The problem is to find maximum number of
+   * distinct elements (non-repeating) after removing k elements from the array. Note: 1 <= k <= n.
+   *
+   * <p>Examples:
+   *
+   * <p>Input : arr[] = {5, 7, 5, 5, 1, 2, 2}, k = 3 Output : 4 Remove 2 occurrences of element 5
+   * and 1 occurrence of element 2.
+   *
+   * <p>Input : arr[] = {1, 2, 3, 4, 5, 6, 7}, k = 5 Output : 2
+   *
+   * <p>Input : arr[] = {1, 2, 2, 2}, k = 1 Output : 1
+   *
+   * <p>Approach: Following are the steps:
+   *
+   * <p>Create a hash table to store the frequency of each element. Insert frequency of each element
+   * in a max heap. Now, perform the following operation k times. Remove an element from the max
+   * heap. Decrement its value by 1. After this if element is not equal to 0, then again push the
+   * element in the max heap. After the completion of step 3, the number of elements in the max heap
+   * is the required answer.
+   *
+   * <p>High level: Reducing the most frequent elements to get max distinct element number. Mid
+   * -level: Insert the frequencies of each, do K times of reducing the frequency on the top of the
+   * max heap.
+   */
+  public static int maxDistinctElementNumber(int[] input, int k) {
+    Map<Integer, Integer> freqMap = new HashMap<>();
+    PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Collections.reverseOrder());
+
+    // Init the frequency map
+    for (int num : input) {
+      Integer freq = freqMap.get(num);
+      if (freq == null) {
+        freq = 0;
+      }
+      freq++;
+      freqMap.put(num, freq);
+    }
+
+    for (Map.Entry<Integer, Integer> e : freqMap.entrySet()) {
+      maxHeap.offer(e.getValue());
+    }
+
+    for (int i = k; i > 0; i--) {
+      Integer freq = maxHeap.poll();
+      freq--;
+      if (freq > 0) {
+        maxHeap.offer(freq);
+      }
+    }
+    return maxHeap.size();
+  }
+
+  public static void main(String[] args) {
+    int[] arr1 = {5, 7, 5, 5, 1, 2, 2};
+    int k1 = 3;
+    int[] arr2 = {1, 2, 3, 4, 5, 6, 7};
+    int k2 = 5;
+    int[] arr3 = {1, 2, 2, 2};
+    int k3 = 1;
+    System.out.println(
+        "For arr1 and k1 Maximum distinct elements = " + maxDistinctElementNumber(arr1, k1));
+    System.out.println(
+        "For arr2 and k2 Maximum distinct elements = " + maxDistinctElementNumber(arr2, k2));
+    System.out.println(
+        "For arr3 and k3 Maximum distinct elements = " + maxDistinctElementNumber(arr3, k3));
+  }
+}
diff --git a/src/main/java/com/company/c3ai/phone/CounterVirus.java b/src/main/java/com/company/c3ai/phone/CounterVirus.java
@@ -0,0 +1,64 @@
+package com.company.c3ai.phone;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class CounterVirus {
+
+  public static void main(String[] args) {
+    int[] tcpPacket = new int[] {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+    System.out.println(Arrays.toString(tcpPacket));
+    iAmVirus(tcpPacket);
+    System.out.println(Arrays.toString(tcpPacket));
+    findComplementIndex(tcpPacket).forEach(i -> System.out.print(i + " "));
+    System.out.println();
+    changeMeBack(tcpPacket);
+    System.out.println(Arrays.toString(tcpPacket));
+  }
+
+  private static void iAmVirus(int[] tcpPacket) {
+    int n = tcpPacket.length;
+    for (int i = 0; i < n; i++) {
+      for (int j = 0; j < n; j++) {
+        if ((i + 1) * (j + 1) <= n) {
+          tcpPacket[(i + 1) * (j + 1) - 1] = complement(tcpPacket[(i + 1) * (j + 1) - 1]);
+          //          System.out.print(Arrays.toString(tcpPacket));
+          //          System.out.print(" ");
+          //          System.out.println((i + 1) * (j + 1));
+        } else {
+          break;
+        }
+      }
+    }
+  }
+
+  private static int complement(int i) {
+    return i == 0 ? 1 : 0;
+  }
+
+  private static List<Integer> findComplementIndex(int[] tcpPacket) {
+    List<Integer> res = new ArrayList<>();
+    for (int i = 0; i < tcpPacket.length; i++) {
+      if (tcpPacket[i] == 1) {
+        res.add(i);
+      }
+    }
+    return res;
+  }
+
+  /**
+   * Complement the digit at 0,3,8,15,24.....
+   * @param tcpPacket given tcp packet
+   */
+  private static void changeMeBack(int[] tcpPacket) {
+    // write your code here
+    int index = 0;
+    int i = 1;
+    while (index < tcpPacket.length) {
+      tcpPacket[index] = complement(tcpPacket[index]);
+      index += i * 2 + 1;
+      i++;
+    }
+  }
+}
diff --git a/src/main/java/com/company/servicenow/phone/SliceMatrix.java b/src/main/java/com/company/servicenow/phone/SliceMatrix.java
@@ -0,0 +1,75 @@
+package com.company.servicenow.phone;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class SliceMatrix {
+
+  /**
+   * Write a function to slice the matrix with given row numbers and given columns numbers
+   */
+  public static void main(String[] args) {
+    int[][] test =
+        new int[][] {
+          new int[] {1, 1, 1, 1},
+          new int[] {0, 0, 0, 0},
+          new int[] {2, 1, 3, 3},
+          new int[] {1, 2, 4, 4}
+        };
+    int[] rows = new int[] {0, 1};
+    int[] cols = new int[] {1, 2};
+    // rows
+    // 0    [1 1 1 1
+    // 1     0 0 0 0
+    //       2 1 3 3    ==>  [2 3
+    //       1 2 4 4]         1 4]
+    // cols    1 2
+    int[][] result = findSlicedMatrix(test, rows, cols);
+    for (int[] r : result) {
+      for (int num : r) {
+        System.out.print(num + " ");
+      }
+      System.out.println();
+    }
+  }
+
+  /**
+   * Assumption: M, rows, cols are not null nor empty.
+   * High level: use set to check if current row or column should be skipped. Use pointer to create new result 2D-array
+   * Time: (N*M), Space(rows.length + cols.length)
+   */
+  public static int[][] findSlicedMatrix(int[][] M, int[] rows, int[] cols) {
+    // todo: validate input
+    int totalRows = M.length;
+    int totalCols = M[0].length;
+    int remainRows = totalRows - rows.length;
+    int remainCols = totalCols - cols.length;
+    int[][] res = new int[remainRows][remainCols];
+
+    // find the remaining row index and col index in rows and cols,
+    Set<Integer> slicedRows = new HashSet<>();
+    Set<Integer> slicedCols = new HashSet<>();
+
+    for (int row : rows) {
+      slicedRows.add(row);
+    }
+    for (int col : cols) {
+      slicedCols.add(col);
+    }
+
+    for (int i = 0, curRow = 0; i < totalRows; i++) {
+      if (!slicedRows.contains(i)) {
+        for (int j = 0, curCol = 0; j < totalCols; j++) {
+          if (!slicedCols.contains(j)) {
+            if (curRow < remainRows && curCol < remainCols) {
+              res[curRow][curCol] = M[i][j];
+            }
+            curCol++;
+          }
+        }
+        curRow++;
+      }
+    }
+    return res;
+  }
+}
diff --git a/src/main/java/com/laioffer/dfs/StringPermutationWithDupChars.java b/src/main/java/com/laioffer/dfs/StringPermutationWithDupChars.java
@@ -0,0 +1,34 @@
+package com.laioffer.dfs;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/*
+Assumption:  (1) given input is char array ahd not null, not empty (2) output is a list of all permutation Strings
+High level:  use DFS to traverse  all permutations. (1) N levels of recursion tree, each level represents one position. (2) at each level, we need traverse each node with remaining unused letters: i-th level, each node: (n - i) branches
+Recursion tree:
+																															root = aab
+																			/                  |                             \
+		i = 0, 1, 2              swap(0,0).                 swap(0,1)                 swap(0, 2)
+position 0                  **a**ab                    ~~**a**ab~~                **b**aa                    n = 3
+													/          \                /         \                /        \
+		i = 1, 2          swap(1,1)   swap(1,2)        swap(1,1)     swap(1,2)
+position 1            a**a**b     a**b**a        ~~a**a**b       a**b**a~~    b**a**a.   ~~b**a**a~~           * (3-1)
+											 |            |              |                  |           |                |
+    i = 2	           swap(2,2)   swap(2,2)
+ position 2          aa**b**     ab**a**         ~~aa**b**          ab**a**~~     ba**a**    ~~ba**a**~~       * (3 - 2)
+                                                                        clone each string at position 2: O(n)  *  O(n!) brances
+Time: O(N!*N),    Space(the height of the recursion tree) = O(N)
+*/
+public class StringPermutationWithDupChars {
+  public static List<String> findPermutations(char[] input) {
+    List<String> result = new ArrayList<>();
+    dfs(input, 0, result);
+    return result;
+  }
+
+  public static void dfs(char[] input, int index, List<String> result) {
+
+  }
+}
+
diff --git a/src/main/java/com/laioffer/dfs/_99Cents.java b/src/main/java/com/laioffer/dfs/_99Cents.java
@@ -0,0 +1,93 @@
+package com.laioffer.dfs;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class _99Cents {
+
+  /**
+   * Given a number of different denominations of coins (e.g., 1 cent, 5 cents, 10 cents, 25 cents),
+   * get all the possible ways to pay a target number of cents.
+   *
+   * <p>Arguments
+   *
+   * <p>coins - an array of positive integers representing the different denominations of coins,
+   * there are no duplicate numbers and the numbers are sorted by descending order, eg. {25, 10, 5,
+   * 2, 1} target - a non-negative integer representing the target number of cents, eg. 99
+   * Assumptions
+   *
+   * <p>coins is not null and is not empty, all the numbers in coins are positive target >= 0 You
+   * have infinite number of coins for each of the denominations, you can pick any number of the
+   * coins. Return
+   *
+   * <p>a list of ways of combinations of coins to sum up to be target. each way of combinations is
+   * represented by list of integer, the number at each index means the number of coins used for the
+   * denomination at corresponding index. Examples
+   *
+   * <p>coins = {2, 1}, target = 4, the return should be
+   *
+   * <p>[
+   *
+   * <p>[0, 4], (4 cents can be conducted by 0 * 2 cents + 4 * 1 cents)
+   *
+   * <p>[1, 2], (4 cents can be conducted by 1 * 2 cents + 2 * 1 cents)
+   *
+   * <p>[2, 0] (4 cents can be conducted by 2 * 2 cents + 0 * 1 cents)
+   *
+   * <p>]
+   */
+  public static void main(String[] args) {
+    int[] coin = new int[] {25, 10, 5, 1};
+    findCoinCombination(coin, 99, 0, new int[4]);
+    List<List<Integer>> result = combinations(99, coin);
+  }
+
+  public static List<List<Integer>> combinations(int target, int[] coins) {
+    List<List<Integer>> result = new ArrayList<List<Integer>>();
+    List<Integer> cur = new ArrayList<Integer>();
+    helper(target, coins, 0, cur, result);
+    return result;
+  }
+
+  private static void helper(
+      int target, int[] coins, int index, List<Integer> cur, List<List<Integer>> result) {
+    if (index == coins.length - 1) {
+      if (target % coins[coins.length - 1] == 0) {
+        cur.add(target / coins[coins.length - 1]);
+        result.add(new ArrayList<Integer>(cur));
+        cur.remove(cur.size() - 1);
+      }
+      return;
+    }
+    int max = target / coins[index];
+    for (int i = 0; i <= max; i++) {
+      cur.add(i);
+      helper(target - i * coins[index], coins, index + 1, cur, result);
+      cur.remove(cur.size() - 1);
+    }
+  }
+
+  public static void findCoinCombination(int[] coin, int moneyLeft, int index, int[] sol) {
+    if (index == 3) {
+      sol[index] = moneyLeft;
+      printSol(sol, coin);
+      return;
+    }
+
+    for (int i = 0; i <= moneyLeft / coin[index]; i++) {
+      sol[index] = i;
+      findCoinCombination(coin, moneyLeft - i * coin[index], index + 1, sol);
+    }
+  }
+
+  private static void printSol(int[] sol, int[] coin) {
+    StringBuilder sb = new StringBuilder();
+    for (int i = 0; i < sol.length; i++) {
+      sb.append(sol[i]);
+      sb.append('x');
+      sb.append(coin[i]);
+      sb.append(" cent ");
+    }
+    System.out.println(sb.toString());
+  }
+}
