Tags

Showing posts with label Interview tips. Show all posts
Showing posts with label Interview tips. Show all posts

May 29, 2012

How to print multi-digit numbers like a 7-segment display

During an interview , many interviewers like to ask very simple coding questions. This is usually to check how fast the interviewee can do a context switch in her mind, her ability to think about some very basic problem, etc.
So, let’s tackle a few of such coding problems in this post. I am using Java as the programming language in this example,

The idea was to help some people which started preparing for interview. I hope you find some value in it.

This is simple java program to display number in 7 segment format

Example :123 should be display in following format, and in one line.
_ _
| _| _|
| |_ _|

1 - Set up your initial data for each number. You could do this as a 2d array (dimension 1: digit, dimension 2: line)
For example:
numbers[0][0] = "|-|"
numbers[0][1] = "| |"
numbers[0][2] = "|_|"

numbers[1][0] = "  |"
numbers[1][1] = "  |"
numbers[1][2] = "  |"

2 - For each line that makes up the character, scan across each digit in your input and write the appropriate string. This will build up the characters line by line.
        public class DigitalDisplay {
            /**
             * @param args
             */
        public static void main(String[] args) {
        String [][] num=new String[4][3];
        num[0][0]="|-|";  //this will display complete "0"
        num[0][1]="| |";
        num[0][2]="|_|";

        num[1][0]=" |";
        num[1][1]=" |";
        num[1][2]=" |";

        num[2][0]=" -|";
        num[2][1]=" _|";
        num[2][2]=" |_";

        num[3][0]=" -|";
        num[3][1]=" _|";
        num[3][2]=" _|";
        int[] input = {2,1,3}; 
        for (int line = 0; line < 3; line++)
        {          
            for (int inputI=0; inputI < input.length; inputI++)
            {
                int value = input[inputI];
                System.out.print(num[value][line]);
                System.out.print("  ");
            }          
            System.out.println();
        }
    }
}

**OUTPUT**

 -|   |   -|  
 _|   |   _|  
 |_   |   _|  

Feb 22, 2012

How to Iterate Over a Map in Java

There are several ways of iterating over a Map in Java.
following techniques will work for any map implementation HashMap, TreeMap, LinkedHashMap, Hashtable etc.

Method #1: Iterating over entries using For-Each loop.
This is the most common method and is preferable in most cases.

Map map = new HashMap();
for (Map.Entry entry : map.entrySet()) {
    System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());
}
For-Each loop will throw NullPointerException if you try to iterate over a map that is null, so before iterating you should always check for null references.

Method #2: Iterating over keys or values using For-Each loop.
Map map = new HashMap();

//iterating over keys only
for (Integer key : map.keySet()) {
    System.out.println("Key = " + key);
}

//iterating over values only
for (Integer value : map.values()) {
    System.out.println("Value = " + value);
}
This method gives slight performance advantage over entrySet iteration and is more clean.

Method #3: Iterating using Iterator.

Map map = new HashMap();
Iterator> entries = map.entrySet().iterator();
while (entries.hasNext()) {
    Map.Entry entry = entries.next();
    System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());
}
Without Generics:

Map map = new HashMap();
Iterator entries = map.entrySet().iterator();
while (entries.hasNext()) {
    Map.Entry entry = (Map.Entry) entries.next();
    Integer key = (Integer)entry.getKey();
    Integer value = (Integer)entry.getValue();
    System.out.println("Key = " + key + ", Value = " + value);
}
f you need only keys or values from the map use method #2. If you are stuck with older version of Java (less than 5) or planning to remove entries during iteration you have to use method #3. Otherwise use method #1.

Check if one string is a rotation of other string

Two string s1 and s2 how will you check if s1 is a rotated version of s2

For Example:
if s1=avs then the following are some of its rotated versions:
vsa
sav
vas
where as "vas" is not a rotated version.
algorithm checkRotation(string s1, string s2) 
  if( len(s1) != len(s2))
    return false
  if( substring(s2,concat(s1,s1))
    return true
  return false
end
In Java:
boolean isRotation(String s1,String s2) {
    return (s1.length() == s2.length()) && ((s1+s1).indexOf(s2) != -1);
}

Inheritance versus composition

IS-A is tied to inheritance of one class by another class and HAS-A is tied to member instance variable of another class.

1) Both IS-A and HAS-A offer code reuse
Both result in the re-use of code already written in another class.

2) Run time polymorphism can be achieved with IS-A and not with HAS-A
Since IS-A is tied to inheritance so run-time polymorphism is achievable through IS-A relationship.

3) IS-A results in increased coupling between two classes but HAS-A usually draws a line on coupling
IS-A should be used when cohesion is to be increased but HAS-A has no visible effect on cohesion

4) The container class manages the lifecycle of contained class’s object in HAS-A relationship but the super class doesn’t play any role in the lifecycle of sub class’s object in IS-A relationship.

5) HAS-A relationship is closely related to another term named as Delegation.
When the container class invokes some method on the contained class’s object then the container is said to have delegated the call to container object.

6) IS-A can be visualized as a parent-child or vertical relationship.
HAS-A can be visualized as sibling or horizontal relationship.
Use IS-A relationship for closely related classes with sub class being more specific version of super class and use HAS-A relationship for possession kind of relationships

Feb 20, 2012

Frequently Asked Question about strings



Q: Why is String class immutable?

Ans: As string objects are used the most hence to avoid placing synchronization blocks at every place where multiple threads should not access string object simultaneously, String class was made immutable
Q: What is the difference between String, StringBuffer and StringBuilder?
Ans: String is immutable. StringBuffer provides immutability but has synchronized methods and StringBuilder class has similar features as StringBuffer but has non-synchronized methods
Q:What is the difference between a String object created on String pool and on the heap? Or What will be the result of following statements?
1) “abc” == “abc”
2) new String(“abc”) == new String(“abc”) 
Ans: The second object created with same content using String literal means both are pointing to same object in pool. But if created using new operator then each one takes new memory space even if they have same characters
 Q: Which new feature has been added to JDK 7 regarding Strings?
Ans: Strings can now be used in Switch/Case statements
Q: What happens when concatenation operator is used with Strings as shown in 1 and 2 below:
1) String str1 = “abc”;
String str2 = “def”;
String str3 = str1 + str2;
2) String str4 = “abc” + “def”;
Ans:  1) doesn’t result in such optimization and hence creates more number of String objects 
2)results in compiler optimization and hence the statement becomes String str4 = “abcdef”; after compilation




Jan 24, 2012

Design patterns for Java Interview


Before you appear for an interview, be ready with 8-10 design patterns with examples from your projects and be confident to answer questions about how you implemented those design patterns. Here I am providing a list of some common design patterns which a candidate can talk about in a Java interview.

1) Flyweight: As discussed above, it’s a part of JDK and hence is used by every Java program.
2) Iterator: All collection classes provide the feature of an iterator to iterate their elements. Moreover, I have also seen custom classes in my projects where the feature of iterator is custom built for those classes.
3) DAO (Data Access Object) : This is also one of the common design pattern seen in many applications which use SQL commands to interact with the datasource/database. Usually a DAO class has methods which invoke the SQL queries for CRUD operations on the database tables thus avoiding the need to write and maintain SQL queries in multiple classes for the same database tables.

4) DTO (Data Transfer Object) : This design pattern represents the data which is actually stored in the database tables in terms of Java classes and is accepted as argument by various methods of the DAO classes. This design pattern usually translates to POJO classes corresponding to database tables and their columns.
5) Factory: If you have used DAO then it is very likely that you have also seen factory design pattern being used as a factory class is written for generating the DAO’s.
6) Abstract Factory: This design pattern represents a factory of factories. When you have many closely related factory classes, you will write an interface which all those factories implement and thus can be generically referenced. You will write a class which will have methods to return the appropriate factory depending upon the need.
7) MVC: This is also one of the famous design patterns and should not be missed in Java interview.
8) Front Controller: This design pattern is closely associated with MVC design pattern and is used to write the single point of contact for any request that comes from the users. The controller then dispatches the request to appropriate handler depending upon the arguments being passed along with the request.
9) Singleton: Though Singleton design pattern looks to be easy to understand and get away with any Java interview but one can be grilled like anything on this design pattern. There is so much to ask on Singleton that a candidate can be judged only by asking questions on Singleton. This is because the interviewer can associate Inheritance, Reflection, Serialization, Collections, Polymorphism, Cloning and other Java concepts with Singleton.
Still if you were to choose only five design patterns for an interview due to time constraints then I would advise the following list:
1) Singleton
2) DAO (Data Access Object)
3) DTO (Data Transfer Object)
4) MVC (Model View Controller)
5) Factory


Feb 9, 2010

General Guidelines in Answering Interview Questions



Everyone is nervous on interviews. If you simply allow yourself to feel nervous, you'll do much better. Remember also that it's difficult for the interviewer as well. In general, be upbeat and positive. Never be negative. Rehearse your answers and time them. Never talk for more than 2 minutes straight. Don't try to memorize answers word for word.
Use the answers shown here as a guide only, and don't be afraid to include your own thoughts and words. To help you remember key concepts, jot down and review a few key words for each answer. Rehearse your answers frequently, and they will come to you naturally in interviews. As you will read in the accompanying report, the single most important strategy in interviewing, as in all phases of your job search, is what we call: "The Greatest Executive Job Finding Secret." And that is...
Find out what people want, than show them how you can help them get it.
Find out what an employer wants most in his or her ideal candidate, then show how you meet those qualifications.
In other words, you must match your abilities, with the needs of the employer. You must sell what the buyer is buying. To do that, before you know what to emphasize in your answers, you must find out what the buyer is buying... what he is looking for. And the best way to do that is to ask a few questions yourself.
You will see how to bring this off skillfully as you read the first two questions of this report. But regardless of how you accomplish it, you must remember this strategy above all: before blurting out your qualifications, you must get some idea of what the employer wants most. Once you know what he wants, you can then present your qualifications as the perfect “key” that fits the “lock” of that position.
Other important interview strategies:
·         Turn weaknesses into strengths (You'll see how to do this in a few moments.)
·         Think before you answer. A pause to collect your thoughts is a hallmark of a thoughtful person.
As a daily exercise, practice being more optimistic. For example, try putting a positive spin on events and situations you would normally regard as negative. This is not meant to turn you into a Pollyanna, but to sharpen your selling skills. The best salespeople, as well as the best liked interview candidates, come off as being naturally optimistic, "can do" people. You will dramatically raise your level of attractiveness by daily practicing to be more optimistic.
Be honest...never lie.
Keep an interview diary. Right after each interview note what you did right, what could have gone a little better, and what steps you should take next with this contact. Then take those steps. Don't be like the 95% of humanity who say they will follow up on something, but never do.