CareerCup

Car Parking is constant in Space. A Car comes and you part it. It goes and its place is taken by another car. There is no such thing as shuffling or FIFO so the answer should be Array. Design Pattern ??

MultiMaps are also a useful tool

Store in a HashMap.

Now override the HashCode method for this String Object. HashCode should work on the principle of the sorted value of the Anagram hence all Anagrams will give you the same HashCode value.

Now override the Equals() method and let it work on the basis of the normal String comparison.

Hence all Anagrams are stored at the same Map location in buckets.

There is no other way out. Create a class with an embedded hashMap, searching a name by number is trivial. Deleting all numbers with name is a linear scan over the HashMap and can be implemented as an overridden method.

@Biru : Good answer.

Good one.

This problem is given in "Programming Interview Exposed". You can use recursion to solve it. Shamelessly copying the code :)

void doPrintTelephoneWords( int[] phoneNum, int curDigit, char[] result ){
if( curDigit == PHONE_NUMBER_LENGTH ){
    System.out.println( new String( result ) );
   return;
}
for( int i = 1; i <= 3; i++ ){
   result[ curDigit ] = getCharKey( phoneNum[curDigit], i );
    doPrintTelephoneWords( phoneNum, curDigit + 1, result );
     if( phoneNum[curDigit] == 0 || phoneNum[curDigit] == 1) 
     return;
}
}

static final int PHONE_NUMBER_LENGTH = 7;
void printTelephoneWords( int[] phoneNum ){
  char[] result = new char[ PHONE_NUMBER_LENGTH ];
 doPrintTelephoneWords( phoneNum, 0, result );
}

Use Recursion. Assume 1 = A,B,C,D,E than your Algorithm will give On^5 complexity.

That works on the range of Instruction Offsets where the Exceptions can occur. If the exception occurs in that range the handler catches it.

Theoretically O(1) if no collisons are there. Worst case O(N) if you override hashcode to return the same value for all objects.

No issues. It is not the wrong answer the thing is on a modern 64 bit OS you can have more and more Virtual memory depending on the number of Processes and available HD.

Yes, if you know the length of the Array Binary search gives LogN complexity.

I am intentionally not checking for the end of the array. In case you know the end of the array easy solution is to do a Binary search, isn't it ?

If it uses linear search what's the big deal in that question ?? You will do it on O(N) complexity. My solution will do in less searches. May be there is a better solution as well. Let's wait and see :-)

Serialize/Deserialize the Object to a Database.

Each JVM downloads the object from DB->locks the DB Row till the instance is used->Writes back the object to DB->Unlocks the row from Database.

What is the Algorithm you have used to search for the first 1 ?

Each try-catch-finally block is associated with an Exception handler in the JVM. If there is no exception handler in the thread where exception happens the thread exits and it's status is returned to the JVM.

Array is of unknown size ??

find_first() uses linear search ??

Since the Array is of unknown size you cant use Binary search. Use a variation of it. Assume 1st element is 1, if it is not search for the 2nd element, if that is not 1 search for 4th. Like this you search elements at 1,2,4,8,16,32... location till you find the first 1. Assume you find the first 1 at Kth location than you do a linear search from k/2th location till you find first 1.

Question is meaningless with the use of Modern API's in C++/Java.

3 answers
1. Use complex pointers in C to revers each word in place.
2. Push each word on the stack and pop them out.
3. Revers the entire string and than revers indivdual words.

@Adi's answer is a good one. To sum it up take a large array. The array should be large enough to accomodate your Hash Values. Each Array entry will point to a link list which will store elements corresponding to that hash value.

The obvious hint for this question is Concurrency. Both Single processor/shared memory hint that it is better to divide the tasks into multiple processes and let the OS try to execute them in parallel(single CPU will not let that happen). Depending on the tasks they might or might not execute in less than 8 hours.

The below URL has information on this : In a nutshell it searches all recent tweets with keywords that might become popular and keeps track of retweets etc.

ignitesocialmedia(dot)com/twitter-marketing/trending-on-twitter-a-look-at-algorithms-behind-trending-topics/

Ok Dear : Solve the below condition

Array content = {10,56,17,23,99,819}
starting index = 1;
ending index = 4;
Answer = 56+17+23+99

You have no idea what is going on :-)

Total Virtual memory depends on the number of processes.

Older OS would alloy 3 times memory as Virtual available there is no restriction.

Use Recursion : Pass the value of the range and keep increasing the range

int sum(int i, int j, int[] array)
{
  if( i <=j)
    {
       return array[i] + sum(i+1,j,array);
     }
     else
        return 0;

}