CareerCup

Given an ODD number, print diamond pattern of stars recursively.

n = 5, Diamond shape is as follows:
  *
 ***
*****
 ***
  *

void print(int n){
}

/From the input array, output a subset array with numbers part of a Fibonacci series.
// input: [4,2,8,5,20,1,40,13,23]
// output: [2,5,1,8,13]
public static List<Integer> getFibNumbers(int[] nums){}

Can multiple threads improve the time complexity to merge k sorted arrays? If so, how?

Gives an array of unsorted int (may have negative number),
rearrange the array such that the
num at the odd index is greater than the num at the even index.
example
giving 5, 2, 3, 4, 1, one of the expected result is 1,4,2,5,3,
please solve it in o(n) time, where n is the length of the array
public void rearrange(int[] nums){

}

Given a string, find all possible combinations of the upper 
and lower case of each Alphabet char, keep the none Alphabet char as it is.
example1 s = "ab", return: "Ab", "ab", "aB", "AB"
example2 s = "a1b", return: "A1b", "a1b", "a1B", "A1B"
public List<String> getPermutation(String s){
	
}

For a given array, find the subarray (containing at least k number) which has the largest sum.
Example:
// [-4, -2, 1, -3], k = 2, return -1, and the subarray is [-2, 1]
// [1, 1, 1, 1, 1, 1], k = 3, return 6, and the subarray is [1, 1, 1, 1, 1, 1]
try to do it in O(n) time
Followup, if input is stream, how to solve it
public int maxSubArray(int[] nums, int k) {}

find maximum contiguous subarray sum with size (the number of the element in the subarray) <= k
a brute force method is very simple, can you do it better?
public int maxSum(int[] nums, int k){
}

// Read4K - Given a function which reads from a file or
// network stream up to 4k at a time, give a function which
// which can satisfy requests for arbitrary amounts of data
private int read4K(char[] buf) {
// GIVEN
}

// IMPLEMENT:
public int read(char[] buf, int toRead) { }

Due to network latency, if the read4K method return a value < 4k, it does not necessarily mean that we reach the End of File (EOF), in this case, you should continue to read the file until you reach toRead or EOF.

how to keep track of the sum in a sliding window for the data that are on disk
rather than memory

Insert a node in a complete binary tree efficiently.
it is not BST, it is just a regular binary tree
public TreeNode insert(TreeNode root, int val){
}
this my solution using bfs (O(n) time), is there any more efficient method?

import java.util.*;
class TreeNode{
    int val;
    TreeNode left;
    TreeNode right;
    public TreeNode(int val){
        this.val = val;
    }
}
class Solution{
    public TreeNode insertCompleteTree(TreeNode root, int val){
        if(root == null){
            return new TreeNode(val);
        }
        Queue<TreeNode> q = new LinkedList<>();
        q.add(root);
        while(!q.isEmpty()){
            int size = q.size();
            for(int i = 0; i < size; i++){
                TreeNode cur = q.remove();
                if(cur.left == null){
                    cur.left = new TreeNode(val);
                    return root;
                }else{
                    q.add(cur.left);
                }
                if(cur.right == null){
                    cur.right = new TreeNode(val);
                    return root;
                }else{
                    q.add(cur.right);
                }
            }
        }
        return null;
    }
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if(root == null){
            return res;
        }
        Queue<TreeNode> q = new LinkedList<>();
        q.add(root);
        while(!q.isEmpty()){
            int size = q.size();
            List<Integer> list = new ArrayList<>();
            for(int i = 0; i < size; i++){
                TreeNode cur = q.remove();
                list.add(cur.val);
                if(cur.left != null){
                    q.add(cur.left);
                }
                
                if(cur.right != null){
                    q.add(cur.right);
                }
            }
            res.add(list);
        }
        return res;
    }
    public static void main(String[] args){
        Solution s = new Solution();
        TreeNode root = null;
        int[] nums = {1, 2, 3, 4, 5, 6, 7};
        for(int num : nums){
            root = s.insertCompleteTree(root, num);
            System.out.println(s.levelOrder(root));
        }
    }
}

A table has some number of balls at various positions on a line segment.
All are moving with same speed in one or the other direction.
Wherever a collision occurs they change direction.
A ball falls from the edges of the table.
Find the time when all balls fall of the table
given initial position of each ball and speeds

given a graph: example -> A company holds 10% of B company’s share,
B company holds 5% of C company’s share, A company holds 2% of C company’s share,
what percent of C company’s share does A company hold?

// Design and implement key value system
//
// string -> string
// Insert a key-value pair or modify a value
void put(string key, string value);

// Delete a key-value pair
void delete(string key);

// Gets a value given a snapshot
string get(string key, Snapshot snap);

// Take a snapshot
Snapshot takeSnapshot();

// Delete a snapshot
void deleteSnapshot(Snapshot snap);

// put(k1,v1)
// put(k2,v2)
// put(k3,v3)
// takeSnapshot -> snap1 { k1 -> v1, k2 -> v2, k3 -> v3 }
// get(k1,snap1) -> v1
// put(k1,v4)
// delete(k3)
// takeSnapshot -> snap2 { k1 -> v4, k2 -> v2 }
// get(k1,snap2) -> v4
// get(k1,snap1) -> v1
// get(k3,snap2) -> XX
// deleteSnapshot(snap1)
// get(k1,snap1) -> XX

// Space efficient is more important than time efficient, thus please use as small space as possible.

What is the cost / complexity of a String.indexof() function call in java?

Given a task sequence tasks such as ABBABBC, and an integer k, which is the cool down time between two same tasks. Assume the execution for each individual task is 1 unit.
rearrange the task sequence such that the execution time is minimal.
Example:
S = AAABBBCCC, K = 3
Result: ABCABCABC (all 'A's are 3 distance apart, similarly with B's and C's), thus return 9
S = AAABC, K=2
Result: ABCA_ _A, thus return 7
S = AAADBBCC, K = 2:
Result: ABCABCDA, thus return 8
public int rearrangeTasks(String tasks, int cooldown){
}

Given an array of n elements which contains elements from 0 to n-1, with any of these numbers appearing any number of times. Find these repeating numbers in O(n) and using only constant memory space.
Try to do it in one pass
example
[4, 2, 0, 5, 2, 0, 1] return: 0, 2
[1, 2, 3, 0, 0, 1, 3, 6, 6,6] return 0, 1, 3, 6
public List<Integer> findRepeat(int nums[]){
}

How to check the validity of a 4 digit credit card expiration date (mm/yy)
that still works 100 years from now.
public boolean isValid(String s){

}

convert a ternary expression into a Binary tree structure.

     a?b:c 

       a
      / \
     b   c

  a?b?c:d:e

     a
    / \
   b   e
  / \
 c   d
class TreeNode{
    char val;
    TreeNode left;
    TreeNode right;
    public TreeNode(char val){
        this.val = val;
    }
}
 public TreeNode build(String s){}

try to do it in o(n) time complexity, n is the size of the string

Suppose you have a 2-D grid. Each point is either land or water. 
There is also a start point and a goal.
There are also keys that open up doors. Each key corresponds to one door. 
Implement a function that returns the shortest path from the start to the 
goal using land tiles, keys and open doors.

Data Representation
The board will be passed as an array of chars.

A board can have the following tiles.
0 = Water 
1 = Land
2 = Start
3 = Goal

uppercase = door
lowercase = key
Example Maps (keys at each step are not required)
`No doors`
char[][] board1 = {{'0', '2', '1', '1', '1'},
				   {'0', '1', '0', '0', '1'},
				   {'0', '1', '0', '0', '3'},
				   {'0', '1', '0', '0', '1'},
				   {'0', '1', '1', '1', '1'}};
path : [0,1]->[0,2]->[0,3]->[0,4]->[1,4]->[2,4]

`One door`
char[][] board2 = {{'0', '2', '1', '1', '1'},
				   {'0', '1', 'a', '0', 'A'},
				   {'0', '1', '0', '0', '3'},
				   {'0', '1', '0', '0', '1'},
				   {'0', '1', '1', '1', '1'}};
path : [0,1]->[0,2]->[1,2]->[0,2]->[0,3]->[0,4]->[1,4]->[2,4]

public List<int[]> solve(char[][] board) {

Group a list of words so that the same group of words have a common substring, and this common substring is also in the word lists,
example
[cow "," cold "," an "," co "], return [[" can "," an "], [" cow "," cold "," co "]]
["can", "cow", "cold"], return [["can"], ["cow"], ["cold"]]
["c", "ca", "can"], return [["c", "ca", "can"]]

public List<List<String>> groupWords(String[] s)

Write a function that returns true if the binary representation of an integer is a palindrome.

9 = 1001 = palindrome
8 = 1000 = not palindrome

Enter a two digit number, find the year closest to this year.
Example input 99, return 1999;
Input 15, return 2015.
public int getClosestYear(int input){
}

generate random number which differs from the number generated last time in the range of [min, max)
what is the best way to do it?
public int getNumber(int min, int max){

}

Given a undirected graph with each node representing a char and a word,
check if the word can be formed by any path of the graph

example
graph:
a--d--o--g--a--c--t
word : dog, return true;
word: cat, return false;

The same letter may not be used more than once.

class Node {
     char label;
     List<Node> neighbors;
     Node(char x) { 
        label = x; 
        neighbors = new ArrayList<>(); 
     }
}
class Solution {
    public boolean exist(List<Node> nodes, String word) {
        
    }
}

Given a Binary tree (Not binary Search Tree ), find the inorder suc­ces­sor of a node.

class TreeNode{
    TreeNode left;
    TreeNode right;
     int val;
    public TreeNode(int val){
        this.val = val;
    }
}

public TreeNode inOrderSuccessor(TreeNode root, TreeNode n) {

Given a positive integer n, find the no of integers less than equal to n, whose binary representation doesn't contain consecutive 1s.
eg:
I/P : 4
O/P: 4 (0,1,2,4 Valid)
public int count(int n){
}

Given m 0 and n 1, count the total number of permutations where two 1 cannot be adjacent
public int count(int m, int n){
}

Given a binary tree, return all the longest path between any two nodes in a tree. This path may or may not pass through the root.
Example:
Given a binary tree

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
          1
         / \
        2   3
       / \     
      4   5  
Return [4,2,1,3] and [5,2,1,3].

Public List<List<Integer>> getLongestPath(TreeNode root) {
        
    }

write a function that randomly return a random Fibonacci number in range [min, max)
public int getRandom (int min, int max){}

write a function that randomly return a random prime number in range [min, max)
public int getRandom (int min, int max){}