CareerCup

I agree! O(n*n) is the only solution I get.

public class MergeArrays {

	public static int[] merge(int[] a, int[] b) {
		int length = a.length + b.length;
		int[] c = new int[length];
		
		int i=0, j=0, k=0;
		
		while(k< c.length) {
			
			if(i == a.length) {
				c[k] = b[j++];
			} else if(j == b.length) {
				c[k] = a[i++];
			} else if(a[i] < b[j]) {
				c[k] = a[i++];
			} else {
				c[k] = b[j++];
			}
			++k;
		}
	
		return c;
	}
	
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		int[] a = {1,3,7,9,11};
		int[] b = {2,4,6,7,22};
		
		int[] c = merge(a,b);
		for(int num : c) {
			System.out.print(num + " ");
		}
		
	}
	
}

ignore the main class.. not sure what happened.

<pre lang="" line="1" title="CodeMonkey62146" class="run-this">/* The class name doesn't have to be Main, as long as the class is not public. */
class Main
{
public static void main (String[] args) throws java.lang.Exception
{
java.io.BufferedReader r = new java.io.BufferedReader (new java.io.InputStreamReader (System.in));
String s;
while (!(s=r.readLine()).startsWith("42")) System.out.println(s);
}
}

class ReverseStack {

// a simple recursive method that pops from the bottom of the stack
// and push that number
public void reverse(Stack<Integer> stack) {
if (stack.isEmpty())
return;

int bottom = popFromBottom(stack);
reverse(stack);
stack.push(bottom);
}

// recursive method that gets the number in the bottom of the stack
private Integer popFromBottom(Stack<Integer> stack) {

Integer oldValue = stack.pop();

// if the stack is empty after a pop operation, we know that
// we just got the number in the bottom of the stack and we can
// return this value
if (stack.isEmpty()) {
return oldValue;
}

// if this is not the number in the bottom of the stack, then keep going
Integer value = popFromBottom(stack);

// we need to put everything back into the stack except the number int he bottom
stack.push(oldValue);

return value;
}
}</pre><pre title="CodeMonkey62146" input="yes">
</pre>