CareerCup

boolean isFactorialDivisible(int x, int y) {
        for (int i = x; i > 0; --i) {
            if (y % i == 0) {
                y = y / i;
            }
        }
        return y == 1;
    }

public class FirstOccurrance {
    public int findFirst(int[] a, int target)
    {
        int first = 0;
        int last = a.length - 1;
        while (first <= last)
        {
            int mid = (first + last) / 2;
            if (a[mid] == target)
            {
                if (mid + 1 == a.length || first == last)
                {
                    return mid;
                }
                else
                {
                    last = mid;
                }
            }
            else if (a[mid] < target)
            {
                first = mid + 1;
            }
            else
            {
                last = mid - 1;
            }
        }
        return -1;
    }
}

public class PrintConsecutive {
    public void print(char[] chars) {
        for (int i = 0; i < chars.length; ++i) {
            System.out.print(chars[i]);
            int j = i + 1;
            for (; j < chars.length; ++j) {
                if (chars[j - 1] + 1 == chars[j]) {
                    System.out.print(chars[j]);
                } else {
                    break;
                }
            }
            System.out.println();
            i = j - 1;
        }
    }
    
    public static void main(String[] args) {
        PrintConsecutive p = new PrintConsecutive();
        p.print("ABCXYZACCD".toCharArray());
    }
}

class ArrayRearrange {
	void checkArray(int[] array) {
		int oddCount = 0;
		int evenCount = 0;
		for (int entry : array) {
			if (entry % 2 == 0) {
				++evenCount;
			} else {
				++oddCount;
			}
		}
		if (oddCount != evenCount) {
			throw new IllegalArgumentException("there should be same number of odd an even entries");
		}
	}
	
	public void swapOddEven(int[] array) {
		checkArray(array);
		int lastEvenImbalance = -1;
		int lastOddImbalance = -1;
		for (int i = 0; i < array.length; ++i) {
			if (array[i] % 2 == 0) {
				if (i % 2 != 0) lastEvenImbalance = i;
			} else {
				if (i % 2 == 0) lastOddImbalance = i;
			}
			if (lastEvenImbalance != -1 && lastOddImbalance != -1) {
				int temp = array[lastEvenImbalance];
				array[lastEvenImbalance] = array[lastOddImbalance];
				array[lastOddImbalance] = temp;
				lastEvenImbalance = -1;
				lastEvenImbalance = -1;
			}
		}
	}
	
	public static void main(String[] args) {
		int[] array = {1,2,3,4};
		ArrayRearrange arrayRearrange = new ArrayRearrange();
		arrayRearrange.swapOddEven(array);
		for (int entry : array) {
			System.out.println(entry);
		}
	}
}

public class StringInterleave {
    public boolean isInterLeave(String a, String b, String target) {
        int aIndex = 0;
        int aSize = a.length();
        
        int bIndex = 0;
        int bSize = b.length();
        
        for (int i = 0; i < target.length(); ++i) {
            char targetChar = target.charAt(i);
            if (aIndex < aSize && a.charAt(aIndex) == targetChar) {
                ++aIndex;
            } else if (bIndex < bSize && b.charAt(bIndex) == targetChar) {
                ++bIndex;
            }
        }
        return aIndex == aSize && bIndex == bSize;
    }
    
    public static void main(String[] args) {
    	String A="abcd", B="xyz", C="axybczd";
        System.out.println(new StringInterleave().isInterLeave(A, B, C));
	}
}

Yup. This is one way to do it:

http :/ / en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle

I'm guessing you mean the maximum sum is 21. It's 3 + 8 + 3 + 7.
Here's the code.

import java.util.List;
import java.util.LinkedList;
import java.util.Vector;


public class SumFinder {
	
	List<Integer> getNeighbors(int maxDepth, int currentIndex) {
		List<Integer> neighbors = new LinkedList<Integer>();
		neighbors.add(currentIndex);
		neighbors.add(currentIndex + 1);
		if(currentIndex != 0) {
			neighbors.add(currentIndex - 1);
		}
		return neighbors;
	}
	
	int maxSum(Vector<Vector<Integer>> numbers, int curDepth, int previousIndex, int curSum) {
		if(curDepth == numbers.size()) {
			return curSum;
		}
		
		List<Integer> neighbors = getNeighbors(numbers.size(), previousIndex);
		int maxSum = 0;
		Vector<Integer> numbersThisDepth = numbers.get(curDepth);
		int nextDepth = curDepth + 1;
		for(Integer neighbor : neighbors) {
			maxSum = Math.max(maxSum, maxSum(numbers, nextDepth, neighbor, curSum + numbersThisDepth.get(neighbor)));
		}
		return maxSum;
	}

	
	Vector<Integer> stringToInteger(String numbersAsString) {
		Vector<Integer> numbers = new Vector<Integer>();
		for(String number : numbersAsString.split(" ")) {
			numbers.add(Integer.parseInt(number));
		}
		return numbers;
	}
	
	public static void main(String[] args) {
		SumFinder sumFinder = new SumFinder();
		Vector<Vector<Integer>> numbers = new Vector<Vector<Integer>>();
		numbers.add(sumFinder.stringToInteger("3"));
		numbers.add(sumFinder.stringToInteger("8 5"));
		numbers.add(sumFinder.stringToInteger("2 3 1"));
		numbers.add(sumFinder.stringToInteger("0 7 4 2"));
		System.out.println(sumFinder.maxSum(numbers, 1, 0, numbers.get(0).get(0)));
	}
}

This seems to work. An evaluation stack is sufficient.

import java.util.Scanner;

class RPN {
	public static void main(String[] args) {
		RPN rpn = new RPN();
		Scanner scanner = new Scanner(System.in);
		int numLines = scanner.nextInt();
		for(int i = 0; i < numLines; ++i) {
			System.out.println(rpn.processExpression(scanner.next()));
		}
	}

	private int processExpression(String expression) {
		int length = expression.length();
		if(length == 0) {
			return 0;
		}
		int change = 0;
		int stackOperandCount = 0;
		for(int i = 0; i < length; ++i) {
			if(expression.charAt(i) == 'x') {
				stackOperandCount = stackOperandCount + 1;
			} else {
				if(stackOperandCount > 1) {
					stackOperandCount = stackOperandCount - 1;
				} else {
					change = change + 1;
				}
			}
		}
		if(stackOperandCount != 0) {
			change = change + stackOperandCount - 1;
		}
		return change;
	}
}

#include <iostream>

bool should_swap(int left, int right) {
    return left == 0 && right != 0;
}

void print(int *a, int n) {
    for(int i = 0; i < n; ++i) {
        std::cout << a[i] << ' ';
    }
    std::cout << std::endl;
}

void move_zeros(int *a, int n) {
    if(!a || !n) {
            return;
    }
    for(int i = 0; i < n; ++i) {
        for(int j = n - 1; j > i; --j) {
            if(should_swap(a[j - 1], a[j])) {
                int temp = a[j];
                a[j] = a[j - 1];
                a[j - 1] = temp;
            }
        }
    }
}

int main() {
    int a[] = {1,0,2,0,3,0,0};
    int n = sizeof(a) / sizeof(int);
    print(a, n);
    move_zeros(a, n);
    print(a, n);
    return (0);
}

public class Matrix {

	private void print(int[][] matrix) {
		int d = matrix.length;
		for (int i = 0; i < d; ++i) {
			for (int j = 0; j < matrix[i].length; ++j) {
				System.out.print(matrix[i][j]);
				System.out.print(' ');
			}
			System.out.println();
		}
	}

	public void processMatrix(int[][] matrix, int si, int sj) {
		for (int i = si; i < matrix.length; ++i) {
			for (int j = sj; j < matrix[i].length; ++j) {
				if (matrix[i][j] == 1) {
					if (j + 1 < matrix[0].length) {
						processMatrix(matrix, i, j + 1);
					} else {
						processMatrix(matrix, i + 1, 0);
					}
					for (int r = 0; r < matrix.length; ++r) {
						matrix[r][j] = 1;
					}
					for (int c = 0; c < matrix[i].length; ++c) {
						matrix[i][c] = 1;
					}
					return;
				}
			}
		}
	}

	public static void main(String[] args) {
		int[][] m = { { 1, 0, 0, 1 }, { 0, 0, 1, 0 }, { 0, 0, 0, 0 } };
		Matrix instance = new Matrix();
		instance.print(m);
		instance.processMatrix(m, 0, 0);
		System.out.println("after");
		instance.print(m);
	}
}

numbers with odd number of factors would change state. The rest would remain in the same state as the initial state.

int max_num(int num) {
        bool is_neg = num < 0;
        if(is_neg) {
            num = num * -1;
        }
        int count[10];
        for(int i = 0; i < 10; ++i) {
            count[i] = 0;
        }
        while(num != 0) {
            ++count[num % 10];
            num /= 10;
        }
        if(!is_neg) {
            for(int i = 9; i >= 0; --i) {
                while(count[i] != 0) {
                    num = num * 10 + i;
                    count[i]--;
                }
            }
        } else {
            for(int i = 0; i < 10; ++i) {
                while(count[i] != 0) {
                    num = num * 10 + i;
                    count[i]--;
                }
            }
            num = num * -1;
        }
        return num;
}

Since it's only 1000 at the most, we can cache all the values for maximum efficiency.

class Fib {
	
	private int[] _solved;
	Fib(int max) {
		_solved = new int[max + 1];
		_solved[0] = 1;
		_solved[1] = 1;
		for(int i = 2; i <= max; ++i) {
			_solved[i] = _solved[i - 1] + _solved[i - 2];
		}
	}
	
	public int fib(int term) {
		return _solved[term];
	}
	
}

You have to negate the if check.
if(s.add(a)) {
System.out.println(a);
}

At this point, I'm not sure how much memory we have considering we have a million parking spaces.
One possible solution is to use a bit vector. Each spot would be
0: spot available
1: spot occupied.

Thoughts?

Agreed.

#include <cstdlib>
#include <cstring>
#include <iostream>

void reverse(char *src, char *end)
{
    while(src < end) {
        char temp = *src;
        *src++ = *end;
        *end-- = temp;
    }
}

void reverse_sentence(char *src, size_t len)
{
    if(len < 3) {
        return;
    }
    reverse(src, src + len - 2);
    char *end = src + len - 1;
    while(src != end) {
        char *start = src;
        for(; start < end && *start != ' '; ++start)
            ;
        reverse(src, start - 1);
        for(;start < end && *start == ' '; ++start)
            ;
        src = start;
    }
}

int main()
{
    char c[] = "hey there world.";
    std::clog << "before reversing  " << c << std::endl;
    reverse_sentence(c, std::strlen(c));
    std::clog << "after reversing  " << c << std::endl;
    return (EXIT_SUCCESS);
}

#include <cstdlib>
#include <sstream>
#include <iostream>

int
main(int argc, char **argv)
{
    if(argc != 2) {
        std::cerr << "the string is required" << std::endl;
        return (EXIT_FAILURE);
    }   
    std::stringstream buf;
    char *pcur = argv[1];
    while(*pcur != '\0') {
        char cur_char = *pcur;
        int count = 1;
        pcur += 1;
        while(*pcur != '\0' && *pcur == cur_char) {
            count += 1;
            pcur += 1;
        }   
        buf << cur_char << count;
    }   
    std::cout << buf.str() << std::endl;
    return (EXIT_SUCCESS);
}

This sounds like a backtracking problem.

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

class Solution {
	
	public static void main(String[] args) {
		
		Solution instance = new Solution();
		Set<String> dictionary = new HashSet();
		dictionary.add("google");
		dictionary.add("is");
		dictionary.add("awesome");
		List<String> store = new ArrayList<String>();
		instance.printWords("googleisawesome", store, dictionary);
		for(int i = store.size() - 1; i >= 0; --i) {
			System.out.println(store.get(i));
		}
	}


	private boolean printWords(String string, List<String> store, Set<String> dictionary) {
		if(string.length() == 0) {
			return true;
		}
		for(int i = 1; i <= string.length(); ++i) {
			String curWord = string.substring(0, i);
			if(dictionary.contains(curWord) && printWords(string.substring(i), store, dictionary)) {
				store.add(curWord);
				return true;
			}
		}
		return false;
	}
}

Seems like the focus should be on constructing the new tree and not on reconstructing the original tree from just the preorder traversal. It's just not possible to arrive at a unique tree with just that.
Node[1] would hold the new root for a non-null tree.

public Node[] sum(Node root) {
		if(root == null) {
			return null;
		}
		Node newRoot = new Node(0);
		Node sum = new Node(0);
		if(root.getLeft() != null || root.getRight() != null) {
			Node[] leftSum = sum(root.getLeft());
			Node[] rightSum = sum(root.getRight());
			sum = add(leftSum, rightSum);
			newRoot.setData(sum.getData());
			if(leftSum != null) {
				newRoot.setLeft(leftSum[1]);
			}
			if(rightSum != null) {
				newRoot.setRight(rightSum[1]);
			}
		}
		return new Node[] { root, newRoot };
	}

	private Node add(Node[] left, Node[] right) {
		int lSum = left == null ? 0 : left[0].getData();
		int rSum = right == null ? 0 : right[0].getData();
		return new Node(lSum + rSum);
	}

2 ways:
Sol 1:
1: Create a bool of size n.
2: For each entry in array, if bool_array[n[i] - 1] is true, then, that's the duplicate element.

Sol 2:
1: Sort the array.
2: for i = 1 to n - 1:
2.1: if a[i] == a[i - 1] return a[i];

stackoverflow . com/ questions/ 8551519/ string-reduction-programming-contest-solution-needed/ 8997695#8997695

this boils down to serializing a linked list. the code and explanation is there in 'programming interviews exposed'

public class FindSplitPos {
	public int findPos(int[] array) {
		if(array == null || array.length < 3) {
			throw new IllegalArgumentException("invalid array size");
		}
		int start = 0;
		int end = array.length - 1;
		while(start <= end) {
			int mid = start + (end - start) / 2;
			if(mid == 0 || mid + 1 >= array.length) {
				break;
			} else if(array[mid - 1] < array[mid] && array[mid + 1] < array[mid]) {
				return mid;
			} else if(array[mid - 1] < array[mid] && array[mid + 1] > array[mid]) {
				start = mid + 1;
			} else if(array[mid - 1] > array[mid] && array[mid + 1] < array[mid]) {
				end = mid - 1;
			} else {
				break;
			}
		}
		return -1;
	}
}

Thank you :)

The idea is to see how the elements change position. Since this is rotation, the elements have to change in a sane way without jumping around. Looked at it and figured it out.

@nmc : Yes. To rotate the array 180 degrees, call rotate90(matrix) twice.

@swathi: The variable start has been removed.

Cheers.

Take the transpose of the matrix and reverse elements row-wise

class Rotate90 {
	
	public static void reverseElementsRowWise(int[][] matrix) {
		int n = matrix.length;
		for(int i = 0; i < n; ++i) {
			for(int j = 0; j < n / 2; ++j) {
				int temp = matrix[i][n - j - 1];
				matrix[i][n - j - 1] = matrix[i][j];
				matrix[i][j] = temp;
			}
		}
	}
	
	public static void transpose(int[][] matrix) {
		int n = matrix.length;
		for(int i = 0; i < n; ++i) {
			for(int j = i + 1; j < n; ++j) {
				int temp = matrix[i][j];
				matrix[i][j] = matrix[j][i];
				matrix[j][i] = temp;
			}
		}
	}
	
	public static void rotate90(int[][] matrix) {
		transpose(matrix);
		reverseElementsRowWise(matrix);
	}
	
	public static void print(int[][] matrix) {
		int n = matrix.length;
		for(int i = 0; i < n; ++i) {
			for(int j = 0; j < n; ++j) {
				System.out.print(matrix[i][j]);
				System.out.print(' ');
			}
			System.out.println();
		}
	}
	
	public static void main(String[] args) {
		int[][] matrix = {
				{1, 2, 3, 4},
				{5, 6, 7, 8},
				{9, 10, 11, 12},
				{13, 14, 15, 16}};
		System.out.println("before");
		print(matrix);
		rotate90(matrix);
		System.out.println("after");
		print(matrix);
	}
}

http :// scriptasylum . com/ tutorials/ infix_postfix/ algorithms/ infix-postfix/ index. htm

return ~x == 0;

Done.

one important case to consider. We'll have to back up till both nodes reach the same depth. Then, move one step at at time for each node till we reach the common ancestor.

Node lca(Node left, Node right) {
    while(left.depth() > right.depth()) left = left.parent();
    while(right.depth() > left.depth()) right = right.parent();
    while(left != right) {
        left = left.parent();
        right = right.parent();
    }
    return left;
}

They never said not to change the array. So, why not sort the array and look for 2 adjacent elements that are the same?
Merge sort would do an in-place sort. The second phase is straight forward. Just a thought.

Please ignore this. See the corrected one below.

<pre lang="" line="1" title="CodeMonkey69754" class="run-this">class BiggestNumber {

int biggestNumber(int n) {
int originalNumber = n;
int[] digitFrequencies = new int[10];
boolean isNegative = n < 0;
if (isNegative) {
n *= -1;
}
while (n != 0) {
++digitFrequencies[n % 10];
n /= 10;
}
n = 0;
if (isNegative) {
boolean isZeroThere = digitFrequencies[0] != 0;
if(isZeroThere) {
for(int i = 1; i < 10; ++i) {
if(digitFrequencies[i] != 0) {
n = n * 10 + i;
digitFrequencies[i] = digitFrequencies[i] - 1;
break;
}
}
while (digitFrequencies[0] != 0) {
n *= 10;
digitFrequencies[0] = digitFrequencies[0] - 1;
}
}
for (int i = 1; i < 10; ++i) {
while (digitFrequencies[i] != 0) {
n = n * 10 + i;
digitFrequencies[i] = digitFrequencies[i] - 1;
}
}
n *= -1;
} else {
for (int i = 9; i > -1; --i) {
while (digitFrequencies[i] != 0) {
n = n * 10 + i;
digitFrequencies[i] = digitFrequencies[i] - 1;
}
}
}
return n == originalNumber ? -1 : n;
}

public static void main(String[] args) {
BiggestNumber instance = new BiggestNumber();
System.out.println(instance.biggestNumber(0));
System.out.println(instance.biggestNumber(1230));
System.out.println(instance.biggestNumber(-2130));
System.out.println(instance.biggestNumber(3210));
System.out.println(instance.biggestNumber(-1023));
}
}

</pre><pre title="CodeMonkey69754" input="yes">
</pre>

Use a bitset.
Let the LONG_MIN be at index 0.
For every number, set the bit in the bitset.
Any bit one which is not set is the missing number.

Why not?

<pre lang="" line="1" title="CodeMonkey67436" class="run-this">class BiggestNumber {

int biggestNumber(int n) {
int originalNumber = n;
int[] digitFrequencies = new int[10];
boolean isNegative = n < 0;
if (isNegative) {
n *= -1;
}
while (n != 0) {
++digitFrequencies[n % 10];
n /= 10;
}
n = 0;
if (isNegative) {
for (int i = 1; i < 10; ++i) {
while (digitFrequencies[i] != 0) {
n = n * 10 + i;
digitFrequencies[i] = digitFrequencies[i] - 1;
}
while (digitFrequencies[0] != 0) {
n *= 10;
digitFrequencies[0] = digitFrequencies[0] - 1;
}
}
n *= -1;
} else {
for (int i = 9; i > -1; --i) {
while (digitFrequencies[i] != 0) {
n = n * 10 + i;
digitFrequencies[i] = digitFrequencies[i] - 1;
}
}
}
return n == originalNumber ? -1 : n;
}

public static void main(String[] args) {
BiggestNumber instance = new BiggestNumber();
System.out.println(instance.biggestNumber(0));
System.out.println(instance.biggestNumber(1230));
System.out.println(instance.biggestNumber(-2130));
System.out.println(instance.biggestNumber(3210));
System.out.println(instance.biggestNumber(-1023));
}
}
</pre><pre title="CodeMonkey67436" input="yes">
</pre>

<pre lang="" line="1" title="CodeMonkey21595" class="run-this">class TreeNode {

public TreeNode(int data) {
this.data = data;
}
public int getData() {
return data;
}
public void setData(int data) {
this.data = data;
}
public TreeNode getLeft() {
return left;
}
public void setLeft(TreeNode left) {
this.left = left;
}
public TreeNode getRight() {
return right;
}
public void setRight(TreeNode right) {
this.right = right;
}
private int data;
private TreeNode left;
private TreeNode right;
}
class SumFromRoot {
/**
*
* @param root, the tree root.
* @param remainingSum, the remaining sum to be found
* @param originalSum, the original sum we were looking for
*
* @return true if sum is 0 or sum is found.
*/
public boolean hasSum(TreeNode root, int remainingSum, int originalSum) {
if(root == null) {
return remainingSum == 0;
} else if(remainingSum == 0) {
return true;
} else {
if(remainingSum - root.getData() == 0) {
return true;
}
return hasSum(root.getLeft(), originalSum, originalSum) ||
hasSum(root.getLeft(), remainingSum - root.getData(), originalSum) ||
hasSum(root.getRight(), originalSum, originalSum) ||
hasSum(root.getRight(), remainingSum - root.getData(), originalSum);
}
}

/**
* 1
* / \
* 2 -3
* /
* 4
*/
public static void main(String[] args) {
TreeNode root = new TreeNode(1);
root.setData(1);
root.setLeft(new TreeNode(2));
root.setRight(new TreeNode(-3));
root.getLeft().setLeft(new TreeNode(4));
SumFromRoot instance = new SumFromRoot();
for(int i = -3; i < 9; ++i) {
System.out.print(i);
System.out.print(' ');
System.out.println(String.valueOf(instance.hasSum(root, i, i)));
}
}
}
</pre><pre title="CodeMonkey21595" input="yes">
</pre>

<pre lang="" line="1" title="CodeMonkey22501" class="run-this">class SortedArrayMerge {
public int[] merge(int[] a, int[] b) {
int aLength = a == null ? 0 : a.length;
int bLength = b == null ? 0 : b.length;

int[] mergedArray = new int[aLength + bLength];
int ai = 0;
int bi = 0;
int mergeIndex = 0;
while (ai < aLength && bi < bLength) {
mergedArray[mergeIndex++] = a[ai] < b[bi] ? a[ai++] : b[bi++];
}
if (ai < aLength) {
while (ai < aLength) {
mergedArray[mergeIndex++] = a[ai++];
}
} else {
while (bi < bLength) {
mergedArray[mergeIndex++] = b[bi++];
}
}
return mergedArray;
}

private static void check(int[] expected, int[] actual) {
boolean failure = expected.length != actual.length;
if(!failure) {
for(int i = 0; i < expected.length; ++i) {
if(expected[i] != actual[i]) {
failure = true;
break;
}
}
}
if(failure) {
System.out.println("FAILURE");
} else {
System.out.println("SUCCESS");
}
}

public static void main(String[] args) {
SortedArrayMerge instance = new SortedArrayMerge();
check(instance.merge(new int[] {}, new int[] {}), new int[] {});
check(instance.merge(new int[] {1}, new int[] {}), new int[] {1});
check(instance.merge(new int[] {}, new int[] {1}), new int[] {1});
check(instance.merge(new int[] {0, 0}, new int[] {0, 1}), new int[] {0, 0, 0, 1});
check(instance.merge(new int[] {1, 2}, new int[] {0, 3}), new int[] {0, 1, 2, 3});
}
}
</pre><pre title="CodeMonkey22501" input="yes">
</pre>

Yes. It would. You'll just need a check for negative numbers.

public void print(int number) {
		if(number < 0) {
			System.out.println('-');
			number *= -1;
		}
		if(number < 10) {
			System.out.println(number);
		} else {
			print(number / 10);
			System.out.println(number % 10);
		}
	}

Yes. It would. You'll just need a check for negative numbers.

public void print(int number) {
		if(number < 0) {
			System.out.println('-');
			number *= -1;
		}
		if(number < 10) {
			System.out.println(number);
		} else {
			print(number / 10);
			System.out.println(number % 10);
		}
	}

<pre lang="" line="1" title="CodeMonkey55407" class="run-this">class PrintNumber {

public void print(int number) {
if(number < 0) {
System.out.println('-');
number *= -1;
}
if(number < 10) {
System.out.println(number);
} else {
int pow = (int) Math.pow(10, (int) Math.log10(number));
do {
System.out.println(number / pow);
number %= pow;
pow /= 10;
} while(pow != 0);
}
}

public static void main(String[] args) {
PrintNumber instance = new PrintNumber();
instance.print(0);
instance.print(1);
instance.print(10);
instance.print(12);
instance.print(122);
instance.print(-1);
instance.print(-123);
}
}
</pre><pre title="CodeMonkey55407" input="yes">
</pre>

<pre lang="" line="1" title="CodeMonkey42021" class="run-this">// Sorry about that
import java.util.HashMap;
import java.util.Map;


class Solution1 {

Map<Character, Integer> countChars(String aString) {
Map<Character, Integer> counter = new HashMap<Character, Integer>();
for(int i = 0; i < aString.length(); ++i) {
char curChar = aString.charAt(i);
Integer count = counter.get(curChar);
if(count == null) {
count = new Integer(1);
} else {
count++;
}
counter.put(curChar, count);
}
return counter;
}

public boolean areAnagrams(String a, String b) {
int la = a.length();
int lb = b.length();
if(la == 0) return lb == 0;
else if(lb == 0) return la == 0;
else if (la != lb) return false;
return countChars(a).equals(countChars(b));
}

public static void main(String[] args) {
Solution1 instance = new Solution1();
System.out.println(instance.areAnagrams("", ""));
System.out.println(instance.areAnagrams("", "A"));
System.out.println(instance.areAnagrams("A", ""));
System.out.println(instance.areAnagrams("ABC", "CBA"));
System.out.println(instance.areAnagrams("ABC", "ABC"));
System.out.println(instance.areAnagrams("ABC", "ABCC"));
System.out.println(instance.areAnagrams("ABC", "BA"));
}
}
</pre><pre title="CodeMonkey42021" input="yes">
</pre>

<pre lang="" line="1" title="CodeMonkey28380" class="run-this">
class Solution1 {
public boolean areAnagrams(String a, String b) {
int la = a.length();
int lb = b.length();
if(la == 0) return lb == 0;
else if(lb == 0) return la == 0;
else if (la != lb) return false;
for(int i = 0; i < la; ++i) {
if(a.charAt(i) != b.charAt(lb - (i + 1))) {
return false;
}
}
return true;
}

public static void main(String[] args) {
Solution1 instance = new Solution1();
System.out.println(instance.areAnagrams("", ""));
System.out.println(instance.areAnagrams("", "A"));
System.out.println(instance.areAnagrams("A", ""));
System.out.println(instance.areAnagrams("ABC", "CBA"));
System.out.println(instance.areAnagrams("ABC", "ABC"));
System.out.println(instance.areAnagrams("ABC", "BA"));
}
}
</pre><pre title="CodeMonkey28380" input="yes">
</pre>

<pre lang="" line="1" title="CodeMonkey65891" class="run-this">class MaxLoss {
public int maxLoss(int[] prices) {
int maxLoss = 0;
for(int i = 0; i < prices.length; ++i) {
for(int j = i + 1; j < prices.length; ++j) {
if(prices[i] > prices[j]) {
maxLoss = Math.max(maxLoss, prices[i] - prices[j]);
}
}
}
return maxLoss;
}

public static void main(String[] args) {
int[] prices = {1, 2, 3, 7, 5, 8, 9, 4, 6, 10, 12 };
System.out.println(new MaxLoss().maxLoss(prices));
}
}
</pre><pre title="CodeMonkey65891" input="yes">
</pre>

<pre lang="" line="1" title="CodeMonkey98658" class="run-this">class MaxLoss {
public int maxLoss(int[] prices) {
int maxLoss = 0;
for(int i = 0; i < prices.length; ++i) {
int curMaxLoss = 0;
for(int j = i + 1; j < prices.length; ++j) {
if(prices[i] > prices[j]) {
curMaxLoss = Math.max(curMaxLoss, prices[i] - prices[j]);
}
}
maxLoss = Math.max(maxLoss, curMaxLoss);
}
return maxLoss;
}

public static void main(String[] args) {
int[] prices = {1, 2, 3, 7, 5, 8, 9, 4, 6, 10, 12 };
System.out.println(new MaxLoss().maxLoss(prices));
}
}
</pre><pre title="CodeMonkey98658" input="yes">
</pre>

<pre lang="" line="1" title="CodeMonkey21736" class="run-this">class Main {

public static int compareVal(String a, String b) {
int compareVal = a.compareTo(b);
if(compareVal == 0) {
return 0;
} else if(compareVal < 0) {
return -1;
} else {
return 1;
}
}

public static int compareVersions(String versionA, String versionB) {
String[] aParts = versionA.split("\\.");
String[] bParts = versionB.split("\\.");

int numComparisons = Math.min(aParts.length, bParts.length);
for(int i = 0; i < numComparisons; ++i) {
int compareVal = compareVal(aParts[i], bParts[i]);
if(compareVal != 0) {
return compareVal;
}
}
if(aParts.length < bParts.length) {
for(int i = numComparisons; i < bParts.length; ++i) {
if(Integer.parseInt(bParts[i]) != 0) {
return -1;
}
}
} else if(aParts.length > bParts.length){
for(int i = numComparisons; i < aParts.length; ++i) {
if(Integer.parseInt(aParts[i]) != 0) {
return 1;
}
}
}
return 0;
}

public static void main(String[] args) {
System.out.println(compareVersions("1", "1"));
System.out.println(compareVersions("1", "0"));
System.out.println(compareVersions("1", "1.0"));
System.out.println(compareVersions("1.0", "1"));
System.out.println(compareVersions("1.1", "1.1.0.1"));
}
}
</pre><pre title="CodeMonkey21736" input="yes">
</pre>