CareerCup

Avijit and Jeff holds spoon and fork in the following order

[('Avijit', 'spoon'), ('Avijit', 'spoon'), ('Avijit', 'fork'), ('Jeff', 'spoon')]

Implement a logic which gives the following output
(explanation: Between Avijit there are 2 unique utensils (fork and spoon), while between jeff and jeff and jeff and Avijit there is only one unique utensil)


[('Avijit', 'Avijit', 2), ('Avijit', 'Jeff', 1), ('Jeff', 'Jeff', 1)]

In a tennis tournament of N players every player plays with every other player.
The following condition always hold-
If player P1 has won the match with P2 and player P2 has won from P3, then Player P1 has also defeated P3.
Find winner of tournament in O(N) time and O(1) space. Find rank of players in O(NlogN) time.

Implement binary addition of two strings.
For example "101101" and "111101" equal "1101010"
You cannot use any type conversion, operate only with strings.

find target in chess board with given start position of knight

Given an integer array and an integer K, find the number of sub arrays in which all elements are less than K.

Follow up -
Given an integer array and an integer K, find the number of non overlapping unordered pairs of sub arrays in which all elements are less than K.

Given K sorted (ascending) arrays with N elements in each array, implement an iterator for iterating over the elements of the arrays in ascending order.

The constructor receives all of the input as array of arrays.

You need to implement the MyIterator class with a constructor and the following methods:

class MyIterator<T> {
	T next();
	boolean hasNext();
}

You are allowed to use only O(K) extra space with this class.

example:
input:

[[1,5,7], [2,3,10],[4,6,9]]

The iterator should return:

1,2,3,4,5,6,7,9,10

Views are not lifecycle aware that's true but what more? In modern development there is hardly any difference.

What is a different between view & fragment in modern android development. (Interviewer was not happy with answer related "lifecycle awareness")

two sum

reverse an array for k distance.
[2,3,1,5,4] and k =3
output : [2,3,1,5,4]
method
void reverse(int[] arr, k)

this method will only reverse the array

write another method which will sort the array by incorporating reverse method inside sort.

You must have to call reverse(arr,k) method to sort the array. You are not allowed to modify the reverse method

Given a length n, count the number of strings of length n that can be made using ‘a’, ‘b’ and ‘c’ with at-most one ‘b’ and two ‘c’s allowed.

Question: Can you break the given string into words, provided by a given hashmap of frequency of word as <word: n>

Example:
HashMap -> {"abc":3, "ab":2, "abca":1}
String: abcabcabcabca
output: Yes; [ abc, abc, abc , abca ]

Example:
HashMap -> {"abc":3, "ab":2}
String: abcabab
output: No

Example:
HashMap -> {"abc":3, "ab":2, "abca":1}
String: abcx
output: No

Find whether string S is periodic.
Periodic indicates S = nP.
e.g.
S = "ababab", then n = 3, and P = "ab"
S = "xxxxxx", then n = 1, and P = "x"
S = "aabbaaabba", then n = 2, and P = "aabba"
follow up:
Given string S, find out the P (repetitive pattern) of S.

write a JSON validator

Given an integer 'n', create an array such that each value is repeated twice. For example

n = 3 --> [1,1,2,2,3,3]
n = 4 --> [1,1,2,2,3,3,4,4]

After creating it, find a permutation such that each number is spaced in such a way, they are at a "their value" distance from the second occurrence of the same number.

For example: n = 3 --> This is the array - [1,1,2,2,3,3]

Your output should be [3,1,2,1,3,2]

The second 3 is 3 digits away from the first 3.
The second 2 is 2 digits away from the first 2.
The second 1 is 1 digit away from the first 1.

Return any 1 permutation if it exists. Empty array if no permutation exists.

Follow up: Return all possible permutations.

;***************************************************************************
; Imagine you have received a binary to reverse and you stumbled upon this 
; function. What can you tell me about this function? Does anything stand 
; out that makes you want to take a closer look? 
;
; At a high level, explain what is going on. Then we will go into this code 
; in more detail
;***************************************************************************

Generate random max index

Given an array of integers, randomly return an index of the maximum value seen by far.

e.g.
Given [11,30,2,30,30,30,6,2,62, 62]

Having iterated up to the at element index 5 (where the last 30 is), randomly give an index among [1, 3, 4, 5] which are indices of 30 - the max value by far. Each index should have a ¼ chance to get picked.

Having iterated through the entire array, randomly give an index between 8 and 9 which are indices of the max value 62.

LinkedList :
Input : A>B>C>D>E
Output: A>E>B>D>C

Given a

struct drop{
	float x_cordinate;
	float radius;
}

Return the number of calls that the function Drop() that returns a drop object, needs to be called so that the interval [0, 1) is covered. For each drop object the range covered are values on a line considering x_cordinate as center and radius as the length added on both sides of the x_cordinate on that line?

int numCalls(const function<drop> Drop){
	drop firstDrop = Drop();
	// Code from here
}

For example, if the first Drop() call returns drop object drop.location as 0.5 (considering points on a 1d axis) and drop.radius as 0.2, then the interval covered is [0.3, 0.7). So how many calls need to be made to ensure the interval [0, 1) is covered. The location and radius can map to any real value.

Given a list of arrays of time intervals, write a function that calculates the total amount of time covered by the intervals.
For example:
input = [(1,4), (2,3)]
return 3
input = [(4,6), (1,2)]
return 3
input = {{1,4}, {6,8}, {2,4}, {7,9}, {10, 15}}
return 11

You are given two non-empty linked lists representing two non-negative integers. The most significant digit comes first and each of their nodes contain a single digit. Add the two numbers and return it as a linked list.

given an array representing a non-negative integer (ex: 123 represented as [1,2,3]), return the next integer (output: [1,2,4]).
run through all edge cases (ex: [9,9,9,9,9,9,9,9] etc)

Complicated problem statement but was asked to implement binary search

Sparse Scalar vector dot product.
in less than O(n)

Write a new data structure, "Dictionary with Last"

Methods:
set(key, value) - adds an element to the dictionary
get(key) - returns the element
delete(key) - removes the element
last() - returns the last key that was added or read.

In case a key was removed, last will return the previous key in order.

Given an arbitrary tree remove nodes which have data value 0.
As it stats arbitrary tree, I assumed n-ary tree.

Convert a binary tree to a doubly linked circular linked list.(Tree is binary and not BST).Hint: using Inorder Traversal

Given many coins of 3 different face values, print the combination sums of the coins up to 1000. Must be printed in order.

eg: coins(10, 15, 55)
print:
10
15
20
25
30
.
.
.
1000

l1=[1,2,3,4]
l2=[1,3,6,7,null,null,null,null]
output: l2=[1,1,2,3,3,4,6,7]

k=2, l=[1,2,3,4,5,6]
output: l=[5,6,1,2,3,4]
In place O(1) space complexity