CareerCup

Median of Stream of Running Integers
Note: The integers are in particular range from 1..n
The time complexity of the code should be o(n)

Design a space shooter program .
Note: The game includes spaceship , bullets and asteroids. Spaceship rotates in 180 degree generating bullets. The position of the bullets gets updated after certain time period every time . No Need to write the code for collision detection
Basic code in expected . Not the entire working code.

Given a matrix. Convert it into a linked list matrix such that each node is connected to its next right and down node.

Ex:
1 2 3
4 5 6
7 8 9

Output:
1->2->3->NULL
| | |
v v v
4->5->6->NULL
| | |
v v v
7->8->9->NULL
| | |
v v v
--NULL-

This is my code.

class Ideone
{
	public static void main(String args[]) throws Exception {
		int arr[][] = { { 1, 2, 3 }, 
				        { 4, 5, 6 } };
		LList op = convert2DArrintoList(arr, 0, 0);
		System.out.println(op);
	}
 
	public static LList convert2DArrintoList(int arr[][], int col, int row) {
		if (col >= arr[0].length || row >= arr.length)
			return null;
		return new LList(arr[row][col], convert2DArrintoList(arr, col, row + 1), convert2DArrintoList(arr, col + 1, row));
	}
 
	static class LList {
		LList(int data) {
			this.data = data;
		}
 
		LList(int data, LList down, LList next) {
			this.data = data;
			this.down = down;
			this.next = next;
		}
 
		LList() {
			this.data = Integer.MAX_VALUE;
		}
 
		@Override
		public String toString() {
			return " " + this.data + " ";
		}
 
		int data;
		LList next;
		LList prev;
		LList rand;
		LList down;
	}
}

Are there better ways of doing it?

Given a binary tree, write a recursive method boolean method(int x, int y) which will return true
1. if node y (meaning a node with a value of int y) is a node that is contained in one of the two possible subtrees of x,
2. true if x==y, and a node with a value x==y exists, otherwise
3. return false,
basicallly whether x contains y? I had a question like this on my exam, I solved this problem using four arguments in my function. I wonder whether it is even possible to solve it with only 2 int arguments and recursively.

Generate all possible matched parenthesis, given n left parenthesis and right parenthesis needs to be matched.