Free Question Bank » Articles

Interview Questions on C Programming

admin — Tue, 12 May 2009 02:54:54 +0000

What is the difference between the declaration and the definition of a variable?The definition is the one that actually allocates space, and provides an initialization value, if any.
There can be many declarations, but there must be exactly one definition. A definition tells the compiler to set aside storage for the variable. A declaration makes the variable known to parts of the program that may wish to use it. A variable might be defined and declared in the same statement.

Do Global variables start out as zero?
Un initialized variables declared with the “static” keyword are initialized to zero. Such variables are implicitly initialized to the null pointer if they are pointers, and to 0.0F if they are floating point numbers.
Local variables start out containing garbage, unless they are explicitly initialized.
Memory obtained with malloc() and realloc() is likely to contain junk, and must be initialized. Memory obtained with calloc() is all-bits-0, but this is not necessarily useful for pointer or floating-point values (This is in contrast to Global pointers and Global floating point numbers, which start as zeroes of the right type).

Does C have boolean variable type?No, C does not have a boolean variable type. One can use ints, chars, #defines or enums to achieve the same in C.


 #define TRUE 1  
 #define FALSE 0  
 enum bool {false, true};

An enum may be good if the debugger shows the names of enum constants when examining variables.

Where may variables be defined in C?Outside a function definition (global scope, from the point of definition downward in the source code). Inside a block before any statements other than variable declarations (local scope with respect to the block).

To what does the term storage class refer? What are auto, static, extern, volatile, const classes?This is a part of a variable declaration that tells the compiler how to interpret the variable’s symbol. It does not in itself allocate storage, but it usually tells the compiler how the variable should be stored. Storage class specifiers help you to specify the type of storage used for data objects. Only one storage class specifier is permitted in a declaration this makes sense, as there is only one way of storing things and if you omit the storage class specifier in a declaration, a default is chosen. The default depends on whether the declaration is made outside a function (external declarations) or inside a function (internal declarations). For external declarations the default storage class specifier will be extern and for internal declarations it will be auto. The only exception to this rule is the declaration of functions, whose default storage class specifier is always extern.
Here are C’s storage classes and what they signify:

auto – local variables.
static – variables are defined in a nonvolatile region of memory such that they retain their contents though out the program’s execution.
register – asks the compiler to devote a processor register to this variable in order to speed the program’s execution. The compiler may not comply and the variable looses it contents and identity when the function it which it is defined terminates.
extern – tells the compiler that the variable is defined in another module.

In C, const and volatile are type qualifiers. The const and volatile type qualifiers are completely independent. A common misconception is to imagine that somehow const is the opposite of volatile and vice versa. This is wrong. The keywords const and volatile can be applied to any declaration, including those of structures, unions, enumerated types or typedef names. Applying them to a declaration is called qualifying the declaration?that’s why const and volatile are called type qualifiers, rather than type specifiers.

const means that something is not modifiable, so a data object that is declared with const as a part of its type specification must not be assigned to in any way during the run of a program. The main intention of introducing const objects was to allow them to be put into read-only store, and to permit compilers to do extra consistency checking in a program. Unless you defeat the intent by doing naughty things with pointers, a compiler is able to check that const objects are not modified explicitly by the user. It is very likely that the definition of the object will contain an initializer (otherwise, since you can’t assign to it, how would it ever get a value?), but this is not always the case. For example, if you were accessing a hardware port at a fixed memory address and promised only to read from it, then it would be declared to be const but not initialized.
volatile tells the compiler that other programs will be modifying this variable in addition to the program being compiled. For example, an I/O device might need write directly into a program or data space. Meanwhile, the program itself may never directly access the memory area in question. In such a case, we would not want the compiler to optimize-out this data area that never seems to be used by the program, yet must exist for the program to function correctly in a larger context. It tells the compiler that the object is subject to sudden change for reasons which cannot be predicted from a study of the program itself, and forces every reference to such an object to be a genuine reference.
const volatile – Both constant and volatile.

The “volatile” modifier
The volatile modifier is a directive to the compiler?s optimizer that operations involving this variable should not be optimized in certain ways. There are two special cases in which use of the volatile modifier is desirable. The first case involves memory-mapped hardware (a device such as a graphics adaptor that appears to the computer?s hardware as if it were part of the computer?s memory), and the second involves shared memory (memory used by two or more programs running simultaneously). Most computers have a set of registers that can be accessed faster than the computer?s main memory. A good compiler will perform a kind of optimization called ?redundant load and store removal.? The compiler looks for places in the code where it can either remove an instruction to load data from memory because the value is already in a register, or remove an instruction to store data to memory because the value can stay in a register until it is changed again anyway.
If a variable is a pointer to something other than normal memory, such as memory-mapped ports on a
peripheral, redundant load and store optimizations might be detrimental. For instance, here?s a piece of code that might be used to time some operation:
time_t time_addition(volatile const struct timer *t, int a) { int n; int x; time_t then; x = 0; then = t->value; for (n = 0; n < 1000; n++) { x = x + a; } return t->value - then; }
In this code, the variable t->value is actually a hardware counter that is being incremented as time passes. The function adds the value of a to x 1000 times, and it returns the amount the timer was incremented by while the 1000 additions were being performed. Without the volatile modifier, a clever optimizer might assume that the value of t does not change during the execution of the function, because there is no statement that explicitly changes it. In that case, there?s no need to read it from memory a second time and subtract it, because the answer will always be 0. The compiler might therefore ?optimize? the function by making it always return 0. If a variable points to data in shared memory, you also don?t want the compiler to perform redundant load and store optimizations. Shared memory is normally used to enable two programs to communicate with each other by having one program store data in the shared portion of memory and the other program read the same portion of memory. If the compiler optimizes away a load or store of shared memory, communication between the two programs will be affected.

What does the typedef keyword do?This keyword provides a short-hand way to write variable declarations. It is not a true data typing mechanism, rather, it is syntactic “sugar coating”.
For example


 typedef struct node 
 { 
   int value; 
   struct node *next; 
 }mynode;

This can later be used to declare variables like this


 mynode *ptr1; 
 and not by the lengthy expression 
 struct node *ptr1;

There are three main reasons for using typedefs:

It makes the writing of complicated declarations a lot easier. This helps in eliminating a lot of clutter in the code.
It helps in achieving portability in programs. That is, if we use typedefs for data types that are machine dependent, only the typedefs need to change when the program is ported to a new platform.
It helps in providing better documentation for a program. For example, a node of a doubly linked list is better understood as ptrToList than just a pointer to a complicated structure.

What is the difference between constants defined through #define and the constant keyword?A constant is similar to a variable in the sense that it represents a memory location (or simply, a value). It is different from a normal variable, in that it cannot change it’s value in the proram – it must stay for ever stay constant. In general, constants are a useful because they can prevent program bugs and logical errors(errors are explained later). Unintended modifications are prevented from occurring. The compiler will catch attempts to reassign new values to constants.
Constants may be defined using the preprocessor directive #define. They may also be defined using the const keyword.
So whats the difference between these two?


 #define ABC 5 
 and 
 const int abc = 5;

There are two main advantages of the second one over the first technique. First, the type of the constant is defined. “pi” is float. This allows for some type checking by the compiler. Second, these constants are variables with a definite scope. The scope of a variable relates to parts of your program in which it is defined.
There is also one good use of the important use of the const keyword. Suppose you want to make use of some structure data in some function. You will pass a pointer to that structure as argument to that function. But to make sure that your structure is readonly inside the function you can declare the structure argument as const in function prototype. This will prevent any accidental modification of the structure values inside the function.

What are Trigraph characters?These are used when you keyboard does not support some special characters


     ??=    # 
     ??(    [ 
     ??)    ] 
     ??<    { 
     ??>    } 
     ??!    | 
     ??/    \ 
     ??'    ^ 
     ??-    ~

How are floating point numbers stored? Whats the IEEE format?IEEE Standard 754 floating point is the most common representation today for real numbers on computers, including Intel-based PC’s, Macintoshes, and most Unix platforms.
IEEE floating point numbers have three basic components: the sign, the exponent, and the mantissa. The mantissa is composed of the fraction and an implicit leading digit (explained below). The exponent base(2) is implicit and need not be stored.
The following figure shows the layout for single (32-bit) and double (64-bit) precision floating-point values. The number of bits for each field are shown (bit ranges are in square brackets):


                  Sign   Exponent   Fraction   Bias  
 -------------------------------------------------- 
 Single Precision 1 [31] 8 [30-23]  23 [22-00] 127  
 Double Precision 1 [63] 11 [62-52] 52 [51-00] 1023

The sign bit is as simple as it gets. 0 denotes a positive number; 1 denotes a negative number. Flipping the value of this bit flips the sign of the number.
The exponent field needs to represent both positive and negative exponents. To do this, a bias is added to the actual exponent in order to get the stored exponent. For IEEE single-precision floats, this value is 127. Thus, an exponent of zero means that 127 is stored in the exponent field. A stored value of 200 indicates an exponent of (200-127), or 73. For reasons discussed later, exponents of -127 (all 0s) and +128 (all 1s) are reserved for special numbers. For double precision, the exponent field is 11 bits, and has a bias of 1023.
The mantissa, also known as the significand, represents the precision bits of the number. It is composed of an implicit leading bit and the fraction bits. To find out the value of the implicit leading bit, consider that any number can be expressed in scientific notation in many different ways. For example, the number five can be represented as any of these:


         5.00 × 100 
         0.05 × 10 ^ 2 
         5000 × 10 ^ -3

In order to maximize the quantity of representable numbers, floating-point numbers are typically stored in normalized form. This basically puts the radix point after the first non-zero digit. In normalized form, five is represented as 5.0 × 100. A nice little optimization is available to us in base two, since the only possible non-zero digit is 1. Thus, we can just assume a leading digit of 1, and don’t need to represent it explicitly. As a result, the mantissa has effectively 24 bits of resolution, by way of 23 fraction bits.
So, to sum up:


 1. The sign bit is 0 for positive, 1 for negative.  
 2. The exponent's base is two.  
 3. The exponent field contains 127 plus the true exponent for single-precision,  
    or 1023 plus the true exponent for double precision.  
 4. The first bit of the mantissa is typically assumed to be 1.f, where f is the  
    field of fraction bits.

When should the register modifier be used?The register modifier hints to the compiler that the variable will be heavily used and should be kept in the CPU?s registers, if possible, so that it can be accessed faster. There are several restrictions on the use of the register modifier.
First, the variable must be of a type that can be held in the CPU?s register. This usually means a single value of a size less than or equal to the size of an integer. Some machines have registers that can hold floating-point numbers as well. Second, because the variable might not be stored in memory, its address cannot be taken with the unary & operator. An attempt to do so is flagged as an error by the compiler. Some additional rules affect how useful the register modifier is. Because the number of registers is limited, and because some registers can hold only certain types of data (such as pointers or floating-point numbers), the number and types of register modifiers that will actually have any effect are dependent on what machine the program will run on. Any additional register modifiers are silently ignored by the compiler. Also, in some cases, it might actually be slower to keep a variable in a register because that register then becomes unavailable for other purposes or because the variable isn?t used enough to justify the overhead of loading and storing it. So when should the register modifier be used? The answer is never, with most modern compilers. Early C compilers did not keep any variables in registers unless directed to do so, and the register modifier was a valuable addition to the language. C compiler design has advanced to the point, however, where the compiler will usually make better decisions than the programmer about which variables should be stored in registers. In fact, many compilers actually ignore the register modifier, which is perfectly legal, because it is only a hint and not a directive.

When should a type cast be used?There are two situations in which to use a type cast.
The first use is to change the type of an operand to an arithmetic operation so that the operation will be performed properly.
The second case is to cast pointer types to and from void * in order to interface with functions that expect or return void pointers. For example, the following line type casts the return value of the call to malloc() to be a pointer to a foo structure.


 struct foo *p = (struct foo *) malloc(sizeof(struct foo));

A type cast should not be used to override a const or volatile declaration. Overriding these type modifiers can cause the program to fail to run correctly. A type cast should not be used to turn a pointer to one type of structure or data type into another. In the
rare events in which this action is beneficial, using a union to hold the values makes the programmer?s intentions clearer.

Can structures be assigned to variables and passed to and from functions?Yes, they can!
But note that when structures are passed, returned or assigned, the copying is done only at one level (The data pointed to by any pointer fields is not copied!.

Latest Microsoft Interview Questions

admin — Tue, 12 May 2009 02:53:53 +0000

Given a Parent -Child binary tree ,build the child -sibling version of it? Minimize the space requirements wherever possible.

Given a binary tree build a linked list of all its nodes such that the nodes of a level appear before the nodes of the next level?

Given an infinite stream of bits with the bits being appended at the highest significant position. give an algorithm to to say whether the number formed by using the sequence of bits that had been processed till then, is divisible by 3 or not?

Given a string S of words and no of character per line m ,with m being greater than the longest word in S,print S in a set of lines so that each line contains no more than m characters and no word split between 2 lines.

Given an expression remove the unnecessary brackets in it with out creating an ambiguity in its execution.

input output

ex1: (a+(b)+c) a+b+c 
 ex2: (a*b)+c a*b+c

Propose a tree based data structure to identify a node with nth rank with maximum efficiency .

Given a string S of alphabets and 2 characters a,b find the minimum distance between instances of them such that position of a <= position of b.

Given an array of size n with first l positions filled with characters and a string s ,replace all the instances of ’%’ with this string s,given that the length of the array is sufficient to handle these substitutions.
input output
eg: abcdef%ghi%—— and “ppp” abcdefpppghippp

Given a binary tree verify whether it is a binary search tree or not?

Write a C code to merge 2 binary search trees and do the same 2 merge linked lists.How is the former different when compared to the later.(Discuss the issues)

Yahoo Interview Questions

admin — Tue, 12 May 2009 02:52:52 +0000

Design classes for the following problem. (C++)

A Customer Can have multiple bank accounts A Bank account can be owned by multiple customers When customer logs in he sees list of account, on clicking on an account he sees list of transactions.

Solution :

Customer class, Account class, Transaction class
Customer class contains an array of pointers to the account classes
Account class contains an array of pointers to its owner customer classes
Account class also contains an array of transactions associated to it.
Transaction class contains id or pointer the customer who did that transaction
In customer class write a function with prototype

for (i in Accounts )
{
 cout << i.AccountName << endl;
}
cin >> id;
for(i in Accounts[id].transactions )
{
 cout << i.TransDetails << endl;
}

Yahoo Interview Round 1:

How to call a C++ function which is compiled with C++ compiler in C code?

Solution: The C++ compiler must know that f(int,char,float) is to be called by a C compiler using the extern “C”construct:
The extern “C” line tells the compiler that the external information sent to the linker should use C calling conventions and name mangling (e.g., preceded by a single underscore). Since name overloading isn’t supported by C, you can’t make several overloaded functions simultaneously callable by a C program.
```
// This is C++ code
// Declare f(int,char,float) using extern "C":
extern "C" void f(int i, char c, float x);
...
// Define f(int,char,float) in some C++ module:
void f(int i, char c, float x)
{
   .....
}
```
When you deliver your C++ headers and C++ library of a class (what all can you change in the class so that application using your class does not need to recompile the code)
How do you initialize a static member of a class with return value of some function?
Solution :
Static data members are shared by all object instances of that class. Each class instance sees and has access to the same static data. The static data is not part of the class object but is made available by the compiler whenever an object of that class comes into scope. Static data members, therefore, behave as global variables for a class. One of the trickiest ramifications of using a static data member in a class is that it must be initialized, just once, outside the class definition, in the source file. This is due to the fact a header file is typically seen multiple times by the compiler. If the compiler encountered the initialization of a variable multiple times it would be very difficult to ensure that variables were properly initialized. Hence, exactly one initialization of a static is allowed in the entire program.
Consider the following class, A, with a static data member, _id:
```
  //File: a.h
   class A
   {
      public:
      A();
      int _id;
   };
```
The initialization of a static member is done similarly to the way global variables are initialized at file scope, except that the class scope operator must be used. Typically, the definition is placed at the top of the class source file:
```
   // File: a.cc
   int A::_id;
```
Because no explicit initial value was specified, the compiler will implicitly initialize _id to zero. An explicit initialization can also be specified:
```
// File: a.cc
 int A::_id = 999;
```
In fact, C++ even allows arbitrary expressions to be used in initializers:
```
      // File: a.cc
   int A::_id = GetId();
```
How can one application use same API provided by different vendors at the same time?
If you are given the name of the function at run time how will you invoke the function?
Solution :
- Compile your program with –export-dynamic on the gcc command line
- Link with -ldl (dynamic library handling, needed for dlopen and dlsym
- Call dlopen() with a null parameter, meaning you aren’t loading symbols from a file but from the current executable
- Call dlsym() with the name of the function you’ll be calling. Note that C++ modifies function names, so If you’re trying this with C++, you’d have to either declare this function as extern “C”, or figure out what name the function has after compiling. (On unix, you could run nm -s on the object file for this).
- If dlsym() returns non-null, use the returned value as a function pointer to invoke your function.

Yahoo Interview Round 2:

When will you use shell script/Perl ahead of C/C++?
How does yahoo handles billions of requests, does it create a thread per request or a process?
How does HTTP works?
Solution :HTTP Is a request-response protocol.
For example, a Web browser initiates a request to a server, typically by opening a TCP/IP connection. The request itself comprises o a request line, o a set of request headers, and o an entity. The server sends a response that comprises o a status line, o a set of response headers, and o an entity. The entity in the request or response can be thought of simply as the payload, which may be binary data. The other items are readable ASCII characters. When the response has been completed, either the browser or the server may terminate the TCP/IP connection, or the browser can send another request.
How to count number of unique music titles downloaded from a log file which contains an entry of all music title downloaded?
What is the difference between COM and CORBA?
Solution :COM is linked to Microsoft and CORBA to UNIX,Moreover, COM objects require installation on the machine from where it is being used .CORBA is ORB (Object request broker) , and also its a specification owned by OMG, which is open. Not owned by a company. So we cannot say that it only belongs to Unix. Corba servers can run on windows NT, and CORBA clients can run on Unix.
What is web service?
Solution :Web Service is defined as “a software system designed to support interoperable Machine to Machine interaction over a network.” Web services are frequently just Web APIs that can be accessed over a network, such as the Internet, and executed on a remote system hosting the requested services.

Google Fresher Interview Questions – round 5 (management round)

admin — Tue, 12 May 2009 02:51:20 +0000

Tell me an achievement that you have done in your non academics

Tell me about one of your project

Take a feature of C++ and tell me how you have implemented it in one of your project

By taking one of your project as example tell me how you have taken care of software engineering where you would have handled more data

There is a routine already written to find the subtraction of two sets ( set A – set B) . Write test cases for testing it.Tell me how do you test the test cases you have written?

There is a printed book. The page numbers are not printed. Now the printing of page numbers is being done separately. If the total number of digits printed is 1095 then how many pages does the book have?

Google Fresher Interview Questions – round 4

admin — Tue, 12 May 2009 02:47:54 +0000

Given n non overlapping intervals and an element. Find the interval into which this element falls.

Solution:
we can extend binary search to intervals.(Assuming the intervals are sorted)
consider interval [a,b].
if (a-x)(b-x) <=0
then x belongs to [a,b].
else
if x>a
element can be present only in the intervals to its right.
so select the middle interval among them to it’s right
and repeat the procedure.
else
element can be present only in the intervals to its left.
so select the middle interval among them to it’s left
and repeat the procedure.

The complexity of this problem is log(N) where N is the number of sorted non-overlapping intervals.

Worst case is take all intervals one at a time and see whether the element lies in the interval or not.It will take O(n). So please give a solution that will do better than O(n).

Now given that the n intervals are overlapping then how do you solve? The interviewer was concentrating more on the complexities (running, memory ..)

Solution:
If the above intervals are overlapping ,then they can be merged in O(N) and then the exact intervals can be resolved later.Otherwise ,we can identify one correct interval and then linear search on its left and right neighbourhood to find the other solutions.

Write code for Random Sort?

Algorithm  is explained:

Given an input array of size n. Random sort is sampling
a new array from the given array and check whether the
sampled array is sorted or not. If sorted return else
sample again. The stress was on the
code.

Google Fresher Interview Questions – round 3

admin — Tue, 12 May 2009 02:47:30 +0000

Write C++ class for the game Connect Four. [Connect Four (also known as Plot Four, Four In A Row, and Four In A Line) is a two-player board game in which the players take turns in dropping discs into a seven column grid with the objective of getting four of one's own discs in a line.]

Given a stack and an input string of 1234.At any point you can do anyone of the follow

i. take the next input symbol and Enque.
ii. you can pop as many as you can. When ever you
pop an element it will be printed
            (you cannot pop from an empty stack)

How many such permutations are possible on an input of size N?

Solution:
It is Nth catalan number.For a detailed solution look at question5 of Stacks and Queues

Give an example of one permutation that this data structure cannot generate.

For Example:

1234 is input.

First push all 1,2,3,4 on to stack and pop all.
    output will be 4321.

It means that this data structure can generate 4321.

Solution:
3124
for a detailed solution please look at question7 of the post
Stacks and Queues

Question 2 was pretty easy right? Now do again the same question but the data structure this time around is a Deque.

Input: 12345
Data Structure: Deque ( Doubly Que )

Note: Deque is a data structure into which you can do enque
    and deque from both sides.Some thing like this
__________________________________
enque ---> <----enque dequeue <---- ----->dequeue
__________________________________

Solution:
It is N!. Guess why?(no constraints).Convince yourself by proving that every permutation can be generated by a set of valid operations.This prove can be using the principle of strong mathematical induction.So for this specific input the answer is 120.

Classic Egg Puzzle Problem You are given 2 eggs.You have access to a 100-store building. Eggs can be very hard or very fragile means it may break if dropped from the first floor or may not even break if dropped from 100 th floor.Both eggs are identical.You need to figure out the highest floor of a 100-store building an egg can be dropped without breaking. Now the question is how many drops you need to make. You are allowed to break 2 eggs in the process.

Solution:
Let “d” be the number of drops required to find out the max floor.we need to get the value of d.

let’s say if we drop from height d then if it breaks then we have d-1 floors to check for the second egg . so max of “d” drops, so first we will drop it from height “d” if it doesn’t break at a height “d” then we are left with “d-1″ drops,so lets drop it from d + ‘d-2′ + 1 height suppose if it break there then you are left with ‘d-2′ drops.
and so on until that sum is less than 100, it’s like a linear search,

in equations,

(1+(d-1))+ (1+(d-2)) + …. >= 100

here we need to find out d

from the above equation

d(d + 1)/2 >= 100

from above d is 14

Google Fresher Interview Questions – round 2

admin — Tue, 12 May 2009 02:46:43 +0000

What is Bottom up parsing and what is top down parsing?

Solution:

Bottom-up parsing is a strategy for analyzing unknown data relationships that attempts to identify the most fundamental units first, and then to infer higher-order structures from them. It attempts to build trees upward toward the start symbol. It occurs in the analysis of both natural languages and computer languages.

Top-down parsing is a strategy of analyzing unknown data relationships by hypothesizing general parse tree structures and then considering whether the known fundamental structures are compatible with the hypothesis. It occurs in the analysis of both natural languages and computer languages. Please refer to these links for much better information.

http://en.wikipedia.org/wiki/Bottom-up_parsing

http://en.wikipedia.org/wiki/Top-down_parsing

What is a symbol table?

Solution:
In computer science, a symbol table is a data structure used by a language translator such as a compiler or interpreter, where each identifier in a program’s source code is associated with information relating to its declaration or appearance in the source, such as its type, scope level and sometimes its location.
Check out
http://en.wikipedia.org/wiki/Symbol_table

There is a portal with two billion users registered. If you store all the 2 billion users in a conventional databases it will take more time to retrieve the data about a particular user when that user tries to login. How do you handle this situation to make sure that the user gets the response quickly.

Solution:
Every row has a primary key. Suppose the primary key for this
particular database is the name of the user then we can sort the names based
on alphabets and do secondary indexing based on the starting alphabet . If
the data is uniformly distributed we can go for multilevel indexing or
hashing.Similarly if we have a registration number as the primary key then
we can sort the table based on registration number and then do indexing
either secondary level or multilevel or apply hashing techniques based on
the distribution of data. Many efficient algorithms are available for
indexing and hashing.

There are 8 identical balls. One of them is defective. It could be either heavier of lighter. Given a common balance how do you find the defective ball in least number of weighings.

Solution:
Weigh 3 balls against 3 others.
Case A: If, on the first weighing, the balls balance, then the defective is among the 2 remaining balls and can be determined using 2 weighings making it a total of 3.

Case B:

Step1: If, on the first weighing, the balls don’t balance.
If the balls do not balance on the first weighing, we know that the odd ball is one of the 6 balls that was weighed. We also know that the group of 2 unweighed balls are normal, and that one of the sides, let’s say Side A, is heavier than the other (although we don’t know whether the odd ball is heavy or light).
Step 2 : Take 2 balls from the unweighed group and use them to replace 2 balls on Side A (the heavy side). Take the 2 balls from Side A and use them to replace 2 balls on Side B (which are removed from the scale).

I. If the scale balances, we know that one of the 2 balls removed from the scale was the odd one. In this case, we know that the ball is also light. We can proceed with the third weighing amd determine the lighter of the 2 balls ,hance the defective.

II. If the scale tilts to the other side, so that Side B is now the heavy side, we know that one of the three balls moved from Side A to Side B is the odd ball, and that it is heavy. We proceed with the third weighing and determine the heavier one ,the defective.

III. If the scale remains the same, we know that one of the two balls on the scale that was not shifted in our second weighing is the odd ball. We also know that the unmoved ball from Side A is heavier than the unmoved ball on Side B (though we don’t know whether the odd ball is heavy or light).

Step 3 (for Case B): Weigh the ball from Side A against a normal ball. If the scale balances, the ball from Side B is the odd one, and is light. If the scale does not balance, the ball from Side A is the odd one, and is heavy.

You have all the English words with you. you would like to manage a dictionary so that you can look up when ever you have doubt. Which data structure would you like to use and why?

Solution:
Dozens of different data structures have been proposed for implementing dictionaries including hash tables, skip lists, and balanced/unbalanced binary search trees — so choosing the right one can be tricky. Depending on the application, it is also a decision that can significantly impact performance. In practice, it is more important to avoid using a bad data structure than to identify the single best option available.As the frequency of look ups for a word is also important,weighted binary search tree with weights in proportion to the frequency of lookups and determining the depth, can be effective.

Asked me about all the details of hash table and heaps.

Write code for finding number of zeros in n!

Solution:

A zero in n! typically occurs when a multiple of 5 gets multiplied to an even number.We use this simple yet effective information to solve this problem.In the first n natural numbers,those divisible by 5 are always less than the no of even numbers.So it all boils down to the power of 5 in the prime factorization of n! .
This simple formula works for finding it floor(n/5)+floor(n/25)+floor(n/125)+……

function zeros(int n)
{
  int count=0,k=5;
while(n>=k)
{
 count+=n/k;
        k*=5;
}
return count;
}

this count is the number of o’s in n!.

Google Fresher Interview Questions – round 1

admin — Tue, 12 May 2009 02:46:09 +0000

Asked about my project. Prepare well to answer any type of questions that may arise in your project.They will just ask to explain about any one of the projects listed in your resume.

In a plane, n points are given i.e. the input is (x1,y1), (x2,y2)… (xn,yn). Now given these n points.Find the maximum number of collinear points.
Solution:
The duality algorithm would work. Find the point of intersection with maximum no of lines incident on it in the dual plane. It works in O(n^2).

Write the code for finding the min of n number.

I gave:

for(i=0;iGiven that n numbers are from random sampling how many times (probability) does the line (i) be executed 
Solution: 
min=a[0];
for(i=1;iOnce the variable min is initialized,the probability of a[i] < min is 1/2. So the expected number of occurances of equation i is (n-1)/2 .

Google Interview Questions – round 5

admin — Tue, 12 May 2009 02:44:52 +0000

If you get into Google, which products are you going to work on?

What is TCP, UDP. what is reliability, unreliability, give examples of these?

Solution:
Click Here To Read About TCP
Click Here To Read About UDP
Click Here To Read About Reliability

What is http protocol?

Solution:
Click Here To Read About HTTP

How does Google search engine works?

What is indexing, what is the input and output to it. how Google does that?

Google Interview Questions – round 4

admin — Tue, 12 May 2009 02:44:04 +0000

Three strings say A,B,C are given to you. Check weather 3rd string is interleaved from string A and B.

       Ex: A="abcd" B="xyz" C="axybczd". answer is yes.

Solution:

bool test(A,B,C)
{
  i=j=k=0;
  while(k < C.size())
  {
    if(i < A.size() && C[k]==A[i])
     {i++,k++;
     }
    else if(j < B.size() && C[k]==B[j])
    {
      j++,k++;
    }
    else
    return false
  }
  return (i == A.size() && j == B.size());
}

The above algorithm doesn’t work when C[k]=A[i]=B[j], essentially throwing one in to a dilemma whether to accept the character from A or B.

Given two sorted arrays A and B.

Find the intersection of these arrays A and B.
Solution:The intersection can be found by using a variation of merge routine of the merge sort.
If array A is small and array B is too large. how will you proceed for getting intersection of those two arrays?
Solution:In this case for each entry of smaller array,we can run a binary search routine on the larger one to know its presence.