CareerCup

public class SortedButRotted {
	//sorted but rotted means, sorted elements but rotted by one or two places
	public static void main(String args[]){
	int arr[]={ 4, 4, 5, 5, 5, 6, 1, 1, 2, 2, 3, 3, 3};
	int a=0;
	
	System.out.println(4>=5);
	for(a=0; a<arr.length-1;a++){
		if(arr[a]<=arr[a+1]){
			continue;
		}else{
			break;
		}
	}
	if(a !=(arr.length-1))
		System.out.println("pivot--"+arr[a+1]);
	}

}

public class LongestPalindrome {

	public static void main(String[] args) {
		String str = "ABCBAHELLOHOWRACECARAREYOUIAMAIDOINGGOOD";
		System.out.println("Longest Palindrome: "+longestPalindrome(str));
	}
	public static String longestPalindrome(String str){
	
		String longestPalindrome = null;
		if(null==str)
			return null;
		else{
			longestPalindrome=str.substring(0,1);
			for(int i=0;i<str.length()-1;i++){
				String palindrome=expand(str,i,i);
				if(palindrome.length()>1)
				System.out.println(palindrome);
				if(palindrome.length()>longestPalindrome.length()){
					longestPalindrome=palindrome;
				}
				
				palindrome=expand(str,i,i+1);
				if(palindrome.length()>1)
				System.out.println(palindrome);
				if(palindrome.length()>longestPalindrome.length()){
					longestPalindrome=palindrome;
				}
			}
		}
		return longestPalindrome;
		
	}
	static String expand(String str, int left, int right){
		if(left>right)
			return null;
		else{
			while(left>=0 && right<str.length()&&str.charAt(left)==str.charAt(right)){
				right++;
				left--;
			}
		}
		return str.substring(left+1,right);
		
	}
}

public static void HashTableUse(String str){
		LinkedHashMap <Character, Integer> ht=new LinkedHashMap <Character, Integer>();
		String finalo=new String();
		for(int i=0;i<str.length();i++){
			if(ht.containsKey(str.charAt(i))){
				ht.put(str.charAt(i), ht.get(str.charAt(i))+1);
			}else
				ht.put(str.charAt(i), 1);
		}
		System.out.println(ht);
		for(Map.Entry<Character, Integer> entry: ht.entrySet()){
			finalo=finalo+entry.getValue()+entry.getKey();
		}
		System.out.println(finalo);
	}

public class RepeatedCharAsCount {
	public static void main(String[] args) {
		String str="aaabbbbccccdddddddddddddddd";
		String finalo = new String();
		int count=1,i;
		for(i=0;i<str.length()-1;i++){
			if(str.charAt(i)==str.charAt(i+1))
				count++;
			else{
				finalo=finalo+count+str.charAt(i);
				count=1;
				
			}
		}
		finalo=finalo+count+str.charAt(i);
		System.out.println(finalo);
	}

}

public class ShortStringIsPartOfMainString {

	public static void main(String[] args) {
		String mainStr="abcabcabd";
		String shortStr="abcabd";
		int j = 0;
		boolean bool=false;
		if(mainStr.length()>shortStr.length()){
		for(int i=0;i<mainStr.length();i++){
			if(j<shortStr.length()&&mainStr.charAt(i)==shortStr.charAt(j)){
				j++;
				if(j==shortStr.length()){
					System.out.println("Yes string is present in main");
					bool=true;
					break;
				}
			}else{
				j=0;
			}
				
		}
		if(!bool)
		System.out.println("String not present in main");
		}else
			System.out.println("Main string is smaller than short one");
	}

}

Complexity is O(n)

public void FirstNonRepeatedCharacter(String str){
		HashSet hs=new HashSet();
		boolean bool=false;
		for(int i=0;i<str.length();i++){
			if(!hs.add(str.charAt(i))){
				bool=true;
				System.out.println("First Non repitive char is "+str.charAt(i));
				break;
			}
		}
		if(!bool)
			System.out.println("None of chars are repeating");
}

Strings objects are immutable. Means we can not modify strings. Whenever we try to modify string object a new object is created internally. To understand the immutability of string we can take an example of string addition

String str="XYZ";
System.out.println(str.concat("ABC"));
System.out.println(str);

Here output of 1st sop will be XYZABC whereas for next sop output will be XYZ.
It indicates that a new string is created while we did concat on str but str is not changed.

And StringBuilder and StringBuffer are mutable.

Now difference between StringBuilder and StringBuffer. Although functionality wise there is no difference except StringBuffer are synchronized. If you are developing single threaded app and your string is getting modified frequently then to get best performance StringBuilder is best option in comparison to StringBuffer. Since StringBuffer is synchronized to its bit slow.

Brute Force

public static void maintainOrder(String str) {

		String finalStr=new String();
		for(int i=0;i<str.length();i++){
			if(!finalStr.contains(""+str.charAt(i))){
				finalStr=finalStr+str.charAt(i);
			}
		}
		System.out.println(finalStr);
	}

Guys the same question was asked by me as well in amazon interview. Whatever till now we all have mentioned here is not sufficient. What I have analysed, while answering these type of question do not give generalized statements. It should be more technical, related to performance, mime type, compatibility etc

there was one more condition that once you taken out water from the pool you can not put back.

See the water which has been thrown out is only 3L which is in step 4th that is 2, 0, 3

In Java its very simple if I use linkedhashmap to keep the alphabet as key and count as value.

But I can see only 3 Ltr wastage.

Fantastic answer.. I don't think it can be optimized more.