CareerCup

public String[] anagramsEliminate(String intput[]){

ArrayList<String> listAnagram=new ArrayList<String>();
ArrayList<String> eliminatedList=new ArrayList<String>();
for(String s:intput){
//reverse it
Arrays.sort(s.toCharArray());
if(!listAnagram.contains(s)){
//not an anagram
listAnagram.add(s);
}
else{
eliminatedList.add(s);
}
}
return (String[])eliminatedList.toArray();
}
}

For the above solutions - I believe that your result will contain the sorted strings rather than the original ones

For the above solutions - I believe that your result will contain the sorted strings rather than the original ones

what about the space and time complexity?Can it take O(n^2)?

1. Create a hashmap <String, List<Integer>>
2. Iterate through the array of 100 strings
3. take a string, sort the chars and add it to the hashmap, add index of the string as first entry in the list.
4. iterate over all the values of the hashmap where list size is greater than one and remove those indexes from the array

Haven't tested this:

public ArrayList<String> eliminateAnagram(String[] inputArray){
  int n = inputArray.length;
  Map<String,Boolean> isAnagram = new HasMap<String,Boolean>();
  Set<String> candidates = new Set<String>();
  Set<String> ret = new Set<String>();
  ArrayList<String> ret = new ArrayList<String>();
  for(String str : inputArray) {
    char[] ca = str.toCharArray();
    Arrays.sort(ca);
    String sorted = new String(ca);
    if(seen.contains(sorted)) {
      isAnagram[str] = true;
    }
    else { seen.add(sorted); candidates.add(str); }
  }
 
  for(String candidate : candidates) {
    if(!isAnagram[candidate])
      ret.add(candidate);
  }

  return ret;
}

Hi There,

In total awe…. So much respect and gratitude to you folks for Amazon Interview Question for Software Engineers without missing any points on the Distributed vs Parallel computing. Kudos!

I know that you may answer as already in such case that you noticed that I open case 4914182641 in support center and that I need to wait their answer. But when I opened it, I start to search such problems with overdue payments on forums. And I found that everytime people said that they not get answer from support (from 48 hours to 1 week). I'm very affraid that in my case support cannot react same as I read it from forums. And that my account can be closed. It's really little sum (approx. 8 EUR for february) and very big time of use (many years). I create domain's there and buckets. And it's very affraid to lost account such way. Can you, please, help me?

Amazon S3 provides access to reliable and inexpensive data storage infrastructure. It is designed to make web-scale computing easier by enabling you to store and retrieve any amount of data, at any time, from within Amazon EC2 or anywhere on the web.

But nice Article Mate! Great Information! Keep up the good work!

Kind Regards,
Kevin

public ArrayList<String> eliminateAnagram(String[] inputArray)
	{
		ArrayList<String> anagramEliminatedList = new ArrayList();
		HashMap<String, Integer> anagramMap = new HashMap<String, Integer>();
		for(String str : inputArray)
		{
			char[] charArray = str.toCharArray();
			Arrays.sort(charArray);
			String sortedString = new String(charArray);
			if(anagramMap.containsKey(sortedString))
			{
				anagramMap.put(sortedString, anagramMap.get(sortedString) + 1);
			}
			else
			{
				anagramMap.put(sortedString, 0);
			}
		}
		
		for(Map.Entry<String, Integer> entry : anagramMap.entrySet())
		{
			if(entry.getValue() == 0)
			{
				anagramEliminatedList.add(entry.getKey());
			}
		}
		return anagramEliminatedList;
	}

def anagram(key_list):
    ana_dict = {}
    for str in key_list:
        key_anagram = ''.join(sorted(str))
        if not ana_dict.get(key_anagram):
            ana_dict[key_anagram] = str
    
    ana_dict.values()

static void eliminateAnagram(String s[]){
		ArrayList<String> s1=new ArrayList<String>();
		ArrayList<String> eli=new ArrayList<String>();
		String x;
		for(int i=0;i<s.length;i++)
		{
			char c[]=s[i].toCharArray();
			Arrays.sort(c);
			x=new String(c);
			if(!s1.contains(x))
			{
				eli.add(s[i]);
				s1.add(x);
			}else{
				continue;
			}
			
		}
		System.out.println(eli);
	}