With Google Internships, GoogleInterns, apprentices, and residents help build products that create opportunities for everyone. Bring your insight, imagination, and a healthy disregard for the impossible. Together, we can build for everyone.
- At Google, we believe in collaboration and sharing ideas. Most importantly, you’ll need more
information from the interviewer to analyze & answer the question to its full extent.
- It’s OK to question your interviewer.
- When asked to provide a solution, first define and frame the problem as you see it.
- If you don’t understand – ask for help or clarification.
- If you need to assume something – verbally check it’s a correct assumption!
- Describe how you want to tackle solving each part of the question.
- Always let your interviewer know what you are thinking as he/she will be as interested in your process of thought as your solution.
- Also, if you’re stuck, they may provide hints if they know what you’re doing.
- Finally, listen – don’t miss a hint if your interviewer is trying to assist you!
- “We are not simply looking for engineers to solve the problems they already know the answers to;
we are interested in engineers who can work out the answers to questions they had not come
In Google Internships Interviewers will be looking at the approach to questions as much as the answer:
- Does the candidate listen carefully and comprehend the question?
- Are the correct questions asked before proceeding? (important!)
- Is brute force used to solve a problem? (not good!)
* Are things assumed without first checking? (not good!)
* Are hints heard and heeded?
* Is the candidate slow to comprehend / solve problems? (not good!)
* Does the candidate enjoy finding multiple solutions before choosing the best one?
* Are new ideas and methods of tackling a problem sought?
* Is the candidate inventive and flexible in their solutions and open to new ideas?
* Can questioning move up to more complex problem solving?
Google is keen to see really high quality, efficient, clear code without typing mistakes. Because all
engineers (at every level) collaborate throughout the Google code base, with an efficient code
review process, it’s essential that every engineer works at the same high standard.
The main areas software engineers willing to apply for Google Internships should prepare to succeed:
Algorithm Complexity: It’s fairly critical that you understand big-O complexity analysis. Again run some practice problems to get this down in application. Sorting: Know how to sort. Don’t do bubble-sort. You should know the details of at least one n*log(n) sorting algorithm, preferably two (say, quicksort and merge sort). Merge sort can be highly useful in situations where quicksort is impractical, so take a look at it.
Hashtables: Arguably the single most important data structure known to mankind. You absolutely should know how they work. Be able to implement one using only arrays in your favorite language, in about the space of one interview.
Trees: Know about trees; basic tree construction, traversal and manipulation algorithms.
Familiarize yourself with binary trees, n-ary trees, and trie-trees. Be familiar with at least one type of balanced binary tree, whether it’s a red/black tree, a splay tree or an AVL tree, and know how it’s implemented. Understand tree traversal algorithms: BFS and DFS, and know the difference between inorder, postorder and preorder.
Graphs: Graphs are really important in Google Internships. There are 3 basic ways to represent a graph in memory (objects and pointers, matrix, and adjacency list); familiarize yourself with each representation and its pros & cons. You
should know the basic graph traversal algorithms: breadth-first search and depth-first search. Know their computational complexity, their tradeoffs, and how to implement them in real code. If you get a chance, try to study up on fancier algorithms, such as Dijkstra and A*. Other data structures: You should study up on as many other data structures and algorithms as possible. You should especially know about the most famous classes of NP-complete problems, such as traveling salesman and the knapsack problem, and be able to recognize them when an interviewer asks you them in disguise. Find out what NP-complete means.
Mathematics: Some interviewers ask basic discrete math questions.
This is more prevalent at Google than at other companies because we are surrounded by counting problems, probability problems, and other Discrete Math 101 situations. Spend some time before the interview refreshing your memory on (or teaching yourself) the essentials of combinatorics and probability. You should be familiar with n-choose-k problems and their ilk – the more the better.
Operating Systems: Know about processes, threads and concurrency issues. Know about locks and mutexes and semaphores and monitors and how they work. Know about deadlock and livelock and how to avoid them. Know what resources a processes needs, and a thread needs, and how context switching works, and how it’s initiated by the operating system and underlying hardware. Know a little about scheduling. The world is rapidly moving towards multi-core, so know the fundamentals of “modern” concurrency constructs.
Coding: You should know at least one programming language really well, and it should
preferably be C++ or Java. C# is OK too, since it’s pretty similar to Java. You will be expected to
write some code in at least some of your interviews. You will be expected to know a fair amount
of detail about your favorite programming language.
Awards:- Paid Internships