CareerCup

Given two strings s1, s2, write a function that returns true if s2 is a special substring s1. A special substring s2 is such that the s1 contains s2 where each character in s2 appears in sequence in s1, but there can be any characters in s1 in between the sequence.

Example:

isSpecialSubstring('abcdefg', 'abc') => true
isSpecialSubstring('abcdefg', 'acg') => true
isSpecialSubstring('abcdefg', 'acb') => false;


The first two are abc and acg appears in 'abcdefg' in that order, although there might be multiple chars between the next character in s2.

The last one is false, because in 'acb' the character 'b' appears before the character 'c' in 'abcdefg'

Hope thats clear.

The input consists of N cases(equal to about 10000). The first line of the input contains only positive integer N. Then follow the cases. Each case consists of exactly one line with two positive integers separated by space. These are the numbers whose reverse you have to add

The input consists of N cases(equal to about 10000). The first line of the input contains only positive integer N. Then follow the cases. Each case consists of exactly one line with two positive integers separated by space. These are the numbers whose reverse you have to add

create a class of integer collection,
3 APIs:
append(int x),
get(int idx),
add_to_all(int x)，
in O(1) time。

Follow-up:
implement
multiply_to_all(int x)

e.g.
insert(1)
insert(2)
add_to_all(5)
insert(3)
get(0) -> returns 6
get(2) -> return 3
multiply_to_all(10)
insert(4)
get(1) -> returns 70
get(2) -> returns 30
get(3) -> returns 4

Lonely Pixel
Given an N x M image with black pixels and white pixels, if a pixel is the only one in its color throughout its entire row and column, then it is a lonely pixel. Find the number of lonely pixels in black from the image. (O(NM))

We define the following:

There are friends_nodes friends numbered from 1 to friends_nodes.
There are friends_edges pairs of friends, where each (xi, yi) pair of friends is connected by a shared integer token described by friends_weighti.
Any two friends, xi and yi, can be connected by zero or more tokens because if friends xi and yi share token ti and friends yi and zi also share token ti, then xi and zi are also said to share token ti.

Find the maximal product of xi and yi for any directly or indirectly connected (xi, yi) pair of friends such that xi and yi share the maximal number of tokens with each other.

Complete the maxTokens function in the editor. It has four parameters:

Name Type Description
friends_nodes integer The number of friends.
friends_from integer array Each friends_from[i] (where 0 ≤ i < friends_edges) denotes the first friend in pair (friends_from[i], friends_to[i]).
friends_to integer array Each friends_to[i] (where 0 ≤ i < friends_edges) denotes the second friend in pair (friends_from[i], friends_to[i]).
friends_weight integer array Each friends_weight[i] (where 0 ≤ i < friends_edges) denotes the ID number of a token shared by both friends_from[i] and friends_to[i].
Note: friends_edges is the number of pairs of friends that directly share a token.

The function must return an integer denoting the maximal product of xi and yi such that xi and yi are a pair of friends that share the maximal number of tokens with each other.

Input Format
The first line contains two space-separated integers describing the respective values of friends_nodes and friends_edges.
Each line i of the friends_edges subsequent lines (where 0 ≤ i < friends_edges) contains three space-separated integers describing the respective values of friends_fromi, friends_toi, and friends_weighti.

Constraints

2 ≤ friends_nodes ≤ 100
1 ≤ friends_edges ≤ min(200, (friends_nodes × (friends_nodes − 1)) / 2)
1 ≤ friends_weighti ≤ 100
1 ≤ friends_fromi, friends_toi ≤ friends_nodes
1≤ friends_weighti ≤ friends_edges
friends_fromi ≠ friends_toi
Each pair of friends can be connected by zero or more types of tokens.

Output Format
Return an integer denoting the maximal product of xi and yi such that xi and yi are a pair of friends that share the maximal number of tokens with each other.

Sample Input 0
4 5
1 2 1
1 2 2
2 3 1
2 3 3
2 4 3

Sample Output 0
6

Explanation 0
Each pair of n = 4 friends is connected by the following tokens:

Pair (1, 2) shares 2 tokens (i.e., tokens 1 and 2)
Pair (1, 3) shares 1 token (i.e., token 1)
Pair (1, 4) shares 0 tokens
Pair (2, 3) shares 2 tokens (i.e., tokens 1 and 3)
Pair (2, 4) shares 1 token (i.e., token 3)
Pair (3, 4) shares 1 token (i.e., token 3)

The pairs connected by the maximal number of tokens are (1, 2) and (2, 3). Their respective products are 1 × 2 = 2 and 2 × 3 = 6. We then return the largest of these values as our answer, which is 6.

SuperCity consists of a single line of n buildings, where each building i is heighti units tall; however, SuperCity is under attack by two supervillains looking to show off their superpowers! The supervillains are standing on opposite ends of the city, unleashing their powers in an attempt to destroy all n buildings. In a single move, a supervillain unleashes their power and destroys the nearest contiguous block of buildings in which the respective heights of each building are nondecreasing. In other words:
If a supervillain is standing on the left end of the city and the nearest intact building is building i, then performing a move will destroy each consecutive building i, i + 1, i + 2, … satisfying heighti ≤ heighti+1 ≤ heighti+2 ≤ … until there are either no more buildings in their path or there is some building j satisfying heightj > heightj+1.
If a supervillain is standing on the right end of the city and the nearest intact building is building i, then performing a move will destroy each consecutive building i, i − 1, i − 2, … satisfying heighti ≤ heighti-1 ≤ heighti-2 ≤ … until there are either no more buildings in their path or there is some building j satisfying heightj > heightj-1.
Once a supervillain destroys a building, the building's height becomes 0.
Complete the function in the editor below. It has one parameter: an array of integers, height, where each heighti denotes the height of building i. The function must return an integer denoting the minimum number of total moves needed for two supervillains standing on opposite ends of the city (as described by the array of building heights) to destroy all n buildings.
Input Format
The first line contains an integer, n, denoting the number of elements in height.
Each line i of the n subsequent lines contains an integer describing heighti.
Constraints
1≤ n ≤ 105
1 ≤ heighti ≤ 105, where 0 ≤ i < n.
Output Format
Return an integer denoting the minimum number of total moves needed for two supervillains on opposite ends of the array to destroy all n buildings.
Sample Input 0
8
1
2
3
4
8
7
6
5
Sample Output 0
2
Explanation 0
The respective heights of each building are given as height = [1, 2, 3, 4, 8, 7, 6, 5]. The supervillains can perform the following minimal sequence of moves:
Sample Case 0
The diagram above depicts the changes to SuperCity's skyline after each move by a supervillain.
In the first move, the supervillain on the left destroys buildings 0 through 4, because height0 ≤ height1 ≤ height2 ≤ height3 ≤ height4; note that the destruction stops at this point, as height4 > height5.
In the second move, the supervillain on the right destroys buildings 7 through 5, because height7 ≤ height6 ≤ height5.
As it took a minimal two moves for the supervillains to level all the buildings, the function returns 2.
Sample Input 1
6
1
2
1
2
10
9
Sample Output 1
3
Explanation 1
The respective heights of each building are given as height = [1, 2, 1, 2, 10, 9]. The supervillains can perform the following minimal sequence of moves:
Sample Case 1
The diagram above depicts the changes to SuperCity's skyline after each move by a supervillain.
In the first move, the supervillain on the left destroys buildings 0 through 1, because height0 ≤ height1.
In the second move, the supervillain on the right destroys buildings 5 through 4, because height5 ≤ height4.
In the third move, the supervillain on the left destroys buildings 2 through 3, because height2 ≤ height3.
As it took a minimal three moves for the supervillains to level all the buildings, the function returns 3.

Reverse this string 1+2*3-20. Note: 20 must be retained as is.
Expected output: 20-3*2+1

cox customer service is a nice service for emailing. If you new or old user then if Spam filter is not working in the appropriate manner. Or you are getting some difficulties to login and signup activities. or you forget password you will need to change your password. If you any problem then call Cox tech support expert team. We have smart and experienced technicians for email issue. We follow the customer friendly approach to listen to all problems and give instant solutions. number+1-800-982-1502.Click on our website link for more information.
http://www.email-customer-care.com/cox-support

Find max size of contiguous shape below, where X represents a shape and . is empty:

.XXXXXX....
...X..XX..X
...XXXX....
..X.....X..
..XXX..XX..
.....XX....
/*method stub*/
public int GetMaxShape(char[][] array) {
}

i was able to come up with a recursive solution but i'd love tips on a dp solution

PUZZLE
Please solve the following puzzle.
Solving Earth
N O R T H +
E A S T +
S O U T H +
W E S T =
E A R T H

There are 10 unique letters in the above puzzle, assign a unique number from 0 to 9 to each letter, so that the equation holds true. An example of a positive result:

SAMPLE SOLUTION
S = 0, R = 1, W = 2, A = 3, H = 4, N = 5, O = 6, E = 7, T = 8, U = 9

Sample Solution
5 6 1 8 4
7 3 0 8
0 6 9 8 4
2 7 0 8
7 3 1 8 4

REQUIREMENTS
Write a computer program, in any language or code you prefer, that will find and output all the possible combinations or solutions to the above puzzle. One solution was provided above, you need to find how many correct solutions exist. Your code should output all the permutations where the equation is solved correctly. The faster the code executes the better it will be. A good benchmark is to try and get your code to complete in less than 50ms. Please bring your code to the interview and expect to walk us through it.

Design an efficient hash function to perform 2D hashing.
Your function should be O(1) time and should minimize the probability of hash collisions as far as possible.

Basically, complete the following Java code ...

class TwoDData
{
  private int x, y;
  
  public TwoDData(int x, int y)
  {
     this.x = x;
     this.y = y;
  }

  public int getX()
  {
    return this.x;
  }

  public int getY()
  {
      return this.y;
  }

  @Override
   public int hashCode()
   {
      // COMPLETE THIS METHOD
   }
}

Using GIT, how would you checkout a file, make changes and then commit the changes.

Given an array A of integers, having N elements.

It is desired to compute the sum of elements from index i to index j. This query is to be executed millions of times for any i, j values.

Give an O(1) implementation of this query.
You are allowed to do only one-time O(N) pre-processing.

Complete the following Java function

boolean isValidIPv4Address(String input)
{
  // true if "input" is a valid IPv4 address
  // false if not

  // Free to use any methods from these classes String/StringBuffer/StringBuilder only
  // Not allowed to use anything from java.net.*
}

The candidate had listed Chess as his hobby, and was asked the following question.

Design a data structure to represent the game of Chess.

Follow up : Write a function which returns true if enemy king is currently under Check, else returns false.

Give all testcases for the following function

int binarySearch(int A[], int N, int dataToSearch)
{
   // this function will return the index of "dataToSearch" if found, else -1 if not found.
}

Design a specialized stack which supports ALL of these operations in exactly O(1) time.

class SpecializedStack
{

void push(int x)
{
  // Adds an element to this stack in O(1) time
}

int pop()
{
  // removes the topmost element in O(1) time
}

int getMax()
{
   // gets the largest element of this stack in O(1) time
}

}

Two words are called anagrams if one word can be formed by shuffling the letters of another word.
e.g. "hello" and "ollhe" are anagrams.
"listen" and "silent" are anagrams.

But, "cab" and "bag" are NOT anagrams.

Problem : Given a list of English words (all lowercase), write a function to "group" the anagrams together.

e.g. Input = {"abc", "def", "cab", "money", "bca", "yomen"}
Output =
{"abc", "cab", "bca"}
{"def"}
{"money", "yomen"}

Within each "group", the anagrams can occur in any sequence.
Also, sequence of groups is irrelevant.

Expected time complexity = O(NK^2), for N words with longest word length = K.

There are billions and billions of stars in the universe. Which data structure would you use to answer the query
"Give me the k stars nearest to Earth".

Expectation is to come up with the list of parameters/fields in the data structure as well.

Detect if a given 2D matrix is a valid solution to a valid Sudoku puzzle or not.
Basically, you are given a (N^2) x (N^2) matrix where every cell has an integer value. Check if it is a valid Sudoku or not.

There are N number of houses in a straight line. House at index i has valuables worth V[i].
A thief is planning to rob as many houses as possible on this straight line.
Constraint : If he robs house at index i, then he cannot rob houses at indices (i - 1) and (i + 1).
Maximize the total value of valuables which he can rob.

What are two possible ways of passing by reference in C# language ?

Follow up : (Answer to above is "ref" and "out").
Which one would you use and why ?

Distinguish between final, finally and finalize keywords of Java language.

Give an O(N) time and O(1) memory function to check whether an array of integers is sorted in ascending order or not.

public boolean isSortedArray(int[] A)
{
   // complete this code ...
}

How would you design the "call logs" for a mobile phone ? Be as efficient as possible.

Given a 2D matrix A of size m x n, m > 0, n > 0 such that A[i][j] <= A[i][j + 1] and A[i][j] <= A[i + 1][j].

Write a C/C++/Java function to get the k-th smallest element from this matrix.

How to design a Debugger both HLD and LLD?

Given a binary tree that complies to the following rule:
The parent node value is always the the result of the AND operator of its children values.

You modify one of the LEAF nodes value (e.g. if it was 1 it is now 0). Write a function that fixes the tree
so it complies with the above rule.

//
//        0                                 1
//      /   \                             /   \
//    1      0            =====>         1     1
//   / \    / \                         / \   / \
//  1   1  0   1                       1   1 1   1
//
// The parent node value is always children value's LOGICAL AND
//   &
//

Given an array of integers, return the index of the max value in this array.

Note:
If the max value appears more than once, the function should return one the indexes, but make it so that the next call will return different index.

Important: you are not allowed to store state between calls

Example: given this input array

//   0     -1     6    4   5    6      6
//                |             |      |
//               2,1/3       5,1/3     6,1/3

Function signature:

int getIndex(const std::vector<int>& numbers);

Example output:

2
5
6
5
2

Extension:
What if you knew how many times the max value appears in the array, can you improve the function performance?

So using the given example array, the function signature is now:

int getIndex(const std::vector<int>& numbers, int maxCount);