The field of artificial intelligence and natural language processing has witnessed significant advancements with the emergence of Large Language Models (LLMs) like GPT. These models, powered by ...

The Real Future: Stateful LLMs

Co-Founder of Scaler & InterviewBit. “Another positive outcome we see from trends picked up by Scaler’s Hiring Survey 2023 is that this is perhaps the best time to upskill and build the foundation of a promising career in the Indian tech sector.

Quiet hiring. Majority of tech companies relying on upskilling to bridge talent gap: Report

Scaler (by InterviewBit), one of India's fastest-growing edtech startups, today announced the introduction of its GPT-4 powered AI teaching assistant for learners. By integrating ChatGPT functionalities into the Scaler Academy program,

Scaler introduces GPT-4 powered AI teaching assistant to enhance learner experience

Abhimanyu Saxena, Co-founder of Scaler & InterviewBit, said, "While being mindful and empathetic towards the busy schedules of working professionals who undertake tech upskilling courses, it is crucial to provide them with an outcome-driven and high ...

Edtech Startup Scaler Introduces GPT-4 powered AI Teaching Assistant

Ed-tech startup, Scaler by InterviewBit has announced the introduction of its GPT-4 powered AI teaching assistant for learners. By integrating ChatGPT functionalities into the Scaler Academy ...

By integrating ChatGPT functionalities into the Scaler academy programme, the tech upskilling ‘soonicorn’ aims to reduce the doubt resolution turnaround time of the learners and enhance their learning outcomes.

Scaler introduces GPT-4 powered AI teaching assistant to 'enhance learner experience'

However, with the launch of our GPT-4 powered AI teaching assistant and the THR feature, learners can now have their doubts and queries addressed instantly,” Abhimanyu Saxena, co-founder of Scaler & InterviewBit, said.

Indian Edtech Startup Scaler Introduces GPT-4 Powered Teaching Assistant

Bengaluru: Scaler (by InterviewBit), one of India's fastest-growing edtech startups, inaugurated the campus of its four-year residential undergraduate computer science program, Scaler School of Technology  (SST),

Scaler School Of Technology Inaugurates First Bengaluru Campus

The case involves Interviewbit Software Services, a private limited company operating the transformative upskilling platform ‘Scaler’. The applicant seeks clarification on the applicable GST rate for their services under the mentioned scheme and ...

GST on Services Provided under Market Led Fee-based Services Scheme

At the inauguration of the Scaler School of Technology campus, Amod Malviya, Co-Founder of Udaan and Prasanna Sankar, Co-Founder and CTO of Rippling, addressed the incoming students by sharing tips, tricks and truths motivating them to make the best of their next four years of engineering education.

Scaler School of Technology launches its first campus in Bengaluru

InterviewBit

interviewbit

I am an MCA student. I am preparing for software developer interviews. This is my first post. I want to share the online resources I follow to prepare for DSA & problem-solving rounds. A few of the resources are common. But still wanted to list them as they help me a lot in finding the questions I need to prepare for. Geeks For Geeks This I think most common website that every computer science students know. It is really helpful in finding the question set for overall software job interview rounds. I like the explanation that they give most of the time. The posts are community driven. For some problem-solving questions, I  found it hard to understand the original article describing the solution. But the comments or other online resources were available. So it was not much trouble. You can find it here. Abdul Bari This is the Youtube channel of Abdul Bari. He is a master of algorithms. At least he is one of the top teachers who explain algorithms in a simple manner. The youtube videos are really useful in understanding basic concepts of algorithms. It is not directly related to interview rounds. But as a computer science student I need to have the basics clear before I prepare for interview questions. I love this channel. You can watch him here. Interviewbit We can get questions set by the company. I can select questions for companies like Microsoft, Google or Amazon. I am not aiming that big. I am still doing MCA. But it is a good option to prepare & practice using their platform. Explanations of the questions are not good sometimes. That is one disadvantage. You can find it here. Web3Spot.com This is not a typical interview or problem-solving-related website. This is more of a computer science/software development-related blog. But I found a lot of LeetCode / InterviewBit problem explanations that were really easy to understand with simple examples. The data structure or problem-solving-related posts are in Data Structure/Problem Solving category. And there are scattered posts on pattern-searching algorithms which I found useful. You can find it here. These are some of the websites I started using for my preparation. These are all free to use. Maybe I will post more about how my preparation is going.

Useful Resources for Data Structure & Algorithm Practice

The greatest common divisor (GCD) is the largest positive integer that is also a common divisor of a given set of positive integers. It is also known as the highest common factor (HCF) or the greatest common factor (GCF). The greatest common divisor of a pair of positive integers (a, b) is defined as the greatest positive number that is both positive integers' common factor (a, b). The GCD of any two numbers is never negative or zero since the smallest positive integer shared by any two numbers is always 1. let's take two numbers 75 and 30 so the highest number that can divide both numbers will be 15. For example: The numbers that can divide both 75 and 30 are [1,3,5,15] so the highest number among these is 15 so it will be the GCD of 75 and 30. Explanation: let's take two numbers 128 and 32 so the highest number that can divide both numbers will be 32. Example 2: The numbers that can divide both 128 and 32 are [1,2,4,8,16,32] so the highest number among these is 32 so it will be the GCD of 128 and 32. Explanation: Calculate the GCD of Two Numbers in C We may deduce from the examples above that the largest number that can divide both numbers is less than the smallest number that can divide both input numbers. As a result, we may create a naive method in which we test each number beginning with the lowest number between both the two integers and making our way up to 1. As a result, the will be whatever number comes first and entirely divides both input numbers. GCD of the two numbers Example: Input Numbers: N1 = 132 & N2 = 24 Smallest Number: N2 = 24 We will start a loop from 24 that will end at 1. We will then find the first number that will completely divide both numbers N1 and N2, in this case, it is 12. So the GCD of N1 and N2 will be 12. Algorithm of the above approach to find GCD: Declare two variables num1 and num2. Initialize both variables. Find the minimum number between both the number and store it in a different variable(minNum). Start a loop from minNum to 1. Now check if the num1 and num2 are divisible by the current iterating number and then store the result of it in another variable and come out of the loop. If they are not divisible then continue the same step. Print the result. C Program of the above algorithm { } { }        
    } } #include <stdio.h> int main() int num 1 , num 2 , i; // Accepting and storing input of two numbers from user printf ( "Enter two numbers: " ); scanf ( "%d " , &num 1 ); scanf ( "%d " ,  &num 2 ); int minNum= 0 ; int result = 1 ; // Calculating smallest number among num 1 and num 2 if (num 1 <num 2 ){ minNum = num 1 ; } else { minNum = num 2 ; // loop from minNum to 1 for ( i = minNum; i > 1 ; --i ) // check if both num 1 and num 2 is divisible by i or not // store the outcome and break out of the loop if (num 1 %i == 0 && num 2 %i == 0 ){ result = i; break ; // Print the result printf ( "GCD of %d and %d is %d" , num 1 , num 2 , result); return 0 ; You can run this code on . Interviewbit 132, 24 Input: GCD of 132 and 24 is 12. Output: The smallest number among 132 and 24 is 24 so the loop starts from 24 and checks if 132 and 24 are divisible by 24 or not since both are not divisible so the loop will continue to run and now it will check for 23 and so on until the loop reaches to 12 where both numbers will be divisible by 12 so it will store the result and break out of the loop and then print the result. Explanation: Since the loop is running for the smallest number(n) to 1 so the time complexity will be O(n). Time Complexity: It's not taking any extra space other than some variables which are unrelated to the input so the space complexity of this algorithm will be O(1). Space Complexity: We can reduce the time complexity of this algorithm by using an efficient approach. Efficient Approach: Euclidean Algorithm The following facts serve as the foundation for the algorithm: GCD does not change when we subtract a smaller number from a bigger number (we reduce a larger number). So, if we continue to subtract the larger two values, we obtain GCD. Instead of subtracting, divide the smaller integer, and the procedure will terminate when we discover the remainder 0. We may begin by determining the lowest integer between 2 and using that number as the divisor. The greatest component will be our dividend. Then we divide it till the remainder reaches zero. If the remainder exceeds zero. The remainder will then become a divisor, and the current divisor will become a dividend. And must be repeated till the remainder equals zero. Given two numbers: N1=132, N2=24. See the following image for a better understanding Example: In the figure above, we divide the integer till we receive a residual of 0. When the remainder equals zero, the current divisor is the GCD. Algorithm of this Approach: Define a function that takes two arguments divisor and dividend. Now in the function check if the divisor divides the dividend entirely or not. Return the divisor if it divides it entirely otherwise. Recursively invoke the function by supplying the divisor as the remainder of the divisor and dividend. In addition to the dividend as the current divisor. C program for the above algorithm { { } } { dividend = num1; dividend = num2;
    } divisor = num1; divisor = num2;
    } } #include <stdio.h> //Function to calculate GCD int gcd( int divisor, int dividend) //Calculating remainder int remainder = dividend % divisor; // Base condition // If remainder is 0 then divisor will be GCD if ( remainder == 0) return divisor; //Recursive call to find GCD return gcd( remainder, divisor); int main() int num1, num2; //Accepting and storing input of two numbers from user printf( "Enter two numbers: " ); scanf( "%d " , &num1); scanf( "%d " ,  &num2); int dividend, divisor; //dividend will be the number which is gretest among the input if (num1 > num2){ } else { //Divisor will be the number which is lowest among the input if (num1 < num2){ } else { //Calling function to calculate GCD int ans = gcd(divisor, dividend); // Print the result printf( "GCD of %d and %d is %d" , num1, num2, ans); return 0 ; You can run this code on . Interviewbit 132, 24 Input: GCD of 132 and 24 is 12. Output: O(log(min(num1,num2)) which is equivalent to O(log(n)). Time Complexity: O(1), no extra space is used other than some variables. Space Complexity: Conclusion: GCD (Greatest Common Divisor) is a mathematical tool that specifies the number that may divide both integers. We've seen the Java code that was utilized to implement the algorithm. We also comprehended the algorithm's analysis in order to assess how optimal the algorithm is. The best method for calculating the GCD of two integers (Euclid's Algorithm) significantly reduces complexity during competitive programming.

How to Get the GCD Of Two Numbers in C

The Knock Last October, I got a knock from an Amazon recruiter on LinkedIn. It was about the software engineering opportunities at Amazon. Coincidentally, back then, I was willing to relocate to a different country and move out of Singapore. The prolonged covid restrictions took a toll on me, and I was like enough is enough! I am getting out of here! So, when I got the message from the recruiter, I decided to go for the interview. Apart from Amazon, I also interviewed with a few other companies. But today, let’s talk about the interview experience with Amazon for an SDE II role, along with some personal suggestions from my side. At the end of the post, I will also briefly share my preparation strategy for the interview. The Recruiter Call The very first step in the process was a call with the recruiter. Upon getting to know of my interest, the recruiter took no time to schedule a call. It was short and to the point. She asked typical introductory questions about my current role and responsibilities, my interest in Amazon, and when I could start. After talking about the typical stuff, she asked a few basic questions about data structures and algorithms. I didn’t quite expect that from the call. I guess the motivation is to reduce the chances of wasting interviewers’ time! At the end of the call, the recruiter told me that she would send me a link to the – the infamous Amazon online test on coding, leadership principles, and system design. I got the email with the test link right after the call. I had a week to finish the test. Online Assessment (OA) In an initial call like this one, sometimes recruiters ask about expected salary. Try to avoid answering this question. Remember, it is too early to discuss compensation. You can always say that you have not done any research yet. So, it is better to discuss the topic at a later point in time. 💡 Tip The Online Assessment I sat for the OA after a few days. It was an hour and a half long. I took a quiet corner at my home, removed all distractions, and clicked the ‘begin’ button. Here are the notable points of the assessment – There were three sections – coding, system design, and leadership principles. The coding part had two problems. The first one was like a LeetCode easy, but the optimal solution for the next one was in the medium-hard range. I think the second problem can easily be used in an onsite round. The system design section had a few multiple-choice questions. Nothing really surprising. Difficulty-wise, these should be easy for people with a fundamental understanding of large-scale system design. The last part was the questions on leadership principles. It was a set of which-one-would-you-prefer questions. Your task is to show your preferences. There are, of course, no right or wrong answers. The part on leadership principles was the most surprising and exhausting one. Yeah, I understand that these principles are like the Bible to Amazon, and the engineers there live by the principles. But in my view, asking leadership-related questions in an online assessment adds little value to the process. Such questions make sense when discussed in person. In an online test, you have no way to evaluate what the candidate is thinking. And there is no scope for a solid discussion. Do not expect that the online assessment will be straightforward, rather expect surprises. This will help you avoid being caught off-guard during the test. 💡 Tip The (Virtual) Onsite Rounds The next week, I had a call with the recruiter. She explained to me the next steps. Ideally, the next step would be a phone interview with an engineer. But for me, they decided to directly move to the onsite rounds. After a few back-and-forth emails, my onsite was scheduled after three weeks. It was a circuit of four interviews, spanning over two days, two rounds each day. The interviews would be conducted over Chime, Amazon’s in-house communication platform. Let’s briefly discuss each interview session. Round 1 Chronologically, the round went like this – Quick introduction. Questions on the leadership principles. Follow-up discussion on the previous questions. A coding problem that required DFS. It was a LeetCode easy. The introduction took around 5 minutes. The discussion on leadership principles was around 20 minutes. For the coding part, we had half an hour. An interesting thing about the interview was that the interviewer asked me to write pseudocode. He didn’t care for syntactically correct code as one can always look it up. I didn’t bother much and did what he asked. The questions on the leadership principles led to a nice conversation about my past experiences. The interviewer was able to relate to a lot of stuff that I was talking about. Personally, I enjoyed the discussion. Round 2 Similarly, this round was straightforward – An introduction. Questions and discussion on the leadership principles. A medium difficulty coding problem that again required DFS. In this round, timings for the three parts were pretty much the same as the previous round. Round 3 Unfortunately, this round was not so smooth – I was disconnected from the call four times in the first ten minutes. For the fifth time when I joined, the interviewer seemed really pissed off –  they asked me whether I wanted to reschedule the interview, to which I said . no Fortunately, it didn’t drop again for the rest of the interview. Just like the other interviews, the interviewer asked me a few situational questions on leadership principles and then moved to a coding problem. Surprisingly, this was also a DFS problem of LeetCode medium difficulty. Since there were hiccups in the round, we had around 15 minutes for the coding problem. This was not a very ideal situation. But to be honest, unpredictability is a part of the interview game. 💡 Arrange a stable internet connection for your interviews. And most importantly, have a backup, no matter how strong your network is! Tip Round 4 The last round was the system design round which went like this – A quick introduction with the interviewers. There were two interviewers in this round, and one of them was a shadow interviewer. But he also asked questions. A discussion related to leadership principles. A typical system design problem. After the 5 minute introduction and the 25 minutes of leadership-related discussion, we had around half an hour for the system design portion. Unfortunately, it was not very interactive. The interviewers just listened to what I had to say and nodded. They asked 2–3 questions at the end, but there was little time to discuss anything. In my view, there should be a more extensive system design discussion in such a round. In all of the onsite rounds, the discussion on the leadership principles was quite extensive, and sometimes a bit repetitive. These discussions used up a significant amount of time from each of the rounds, which reduced the weight of the technical part. In my experience, the Amazon rounds were the least tech-heavy compared to all the interviews I have ever had with other companies. But as long as this method works for them, it’s justified. 💡 Be prepared to of your work and experiences. It is better to recollect your memories on the stuff you have worked on. Remember that the interviewers are also engineers, just like you. They will relate to your experience if you tell them good stories. Tip tell stories The Preparation Before ending the post, let me briefly share my preparation. It was very straightforward – For coding, I solved problems from LeetCode. I took a one-month subscription which was quite useful. For system design, my primary resources were — the by Alex Xu, , and different company blogs, like , , , , etc. System Design Interview: An Insider’s Guide this excellent YouTube channel Netflix Uber Twitter Discord For leadership principles, I followed the most popular technique – create a spreadsheet with at least two examples for each of the leadership principles, go over the sheet a few times before the interviews, and keep a map in your mind. 💡 Do not gather too many resources for your preparation. It might overwhelm you. Make a concise list of preparation materials and go through them completely. Do not waste time by frequently jumping in between different materials which will distract you. Tip The End In the following week, I got a positive reply from the recruiter. But due to better offers in hand, we parted ways. Overall, this was my experience with Amazon. In the upcoming posts, I will share similar experiences with other companies, along with my preparation strategies. Thanks a lot for reading! Also published here

5 Useful Tips from My Amazon SDE II Interview Experience 

5 consejos útiles de mi experiencia de entrevista en Amazon SDE II

5 conseils utiles tirés de mon expérience d'entretien avec Amazon SDE II

मेरे अमेज़ॅन एसडीई II साक्षात्कार अनुभव से 5 उपयोगी टिप्स

Amazon SDE II インタビューの経験から得た 5 つの役立つヒント

5 dicas úteis do My Amazon SDE II Interview Experience

5 Mẹo hữu ích từ Trải nghiệm phỏng vấn Amazon SDE II của tôi

我的 Amazon SDE II 面试经验中的 5 个有用提示

What is a Constructor? Constructor is the special method that is defined in the class with the name same as the class name. A is like a method having no return type. Constructors play the most important part in object initialization, and in this article, we have listed the constructor interview questions in java. We also have listed the importance of constructors in java, some constructor code snippets, etc that help you to answer the questions asked in your from the constructor topic. java constructor java interview Why are constructors needed? Explain in detail Suppose we have a class named Student. And we have instance variable name and roll_number. class Student{
String name;
int rollNo;
} Now if we create 1000 objects, then JVM will initialize these values with its default type Name = null and rollNo = 0. Identifying these individual objects is not possible and assigning values to each of the objects will increase code and that is a bad programming practice.  So to avoid this kind of thing, constructors are used. So the purpose of the java constructor is to initialize the value to the instance variables of the class. What are the different types of Constructors available in java? Define. There are 3 different types of constructors available in java. Default Constructor. No-Argument Constructor. Parameterized Constructor. Default Constructor is the constructor that was created by the JVM during the runtime if no constructor is defined in the class. The main job of the default constructor is to initialize the values to the instances to their default type. What is the default constructor in java? Default Constructor in java example - class DefaultConstructor{ int id; String name; } Now for this class, if we create the object then internally JVM creates a default constructor and assigns a default value. DefaultConstructor df= new DefaultConstructor();
So now if we print the value then we will get - Print = = 0. = null. df.id df.name No-Argument Constructor is the constructor that the programmer will explicitly define to initialize the value to the instances. What is a No-Argument constructor in java? Example - class NoArgConstuctor{ int a; int b;

//No Argument Constructor
NoArgConstuctor(){
a = 10;
b = 20;
}

} What is parameterized constructor in java? Parameterized constructor is the constructor in which the constructor accepts the parameter to initialize the instances.
Example - class ParameterizedConstuctor{
String name;
int age;
//Parameterized Constructor
ParameterizedConstuctor(String name, int age){
this.name = name;
this.age = age;
}
} In the above code snippet, this keyword is their. And “this” keyword is used to refer to the current object. What are the Rules for defining the constructor? Several rules need to be followed for defining constructors. And those are The name of the constructor must be the same as the class name. There should be no return type of constructor applicable in java. The only applicable modifiers for the constructors are - a. public b. default c. protected d. private Constructors can accept any number of parameters. Modifiers like - final, synchronized, static, and abstract are not allowed in the constructor. The constructor doesn’t support the return statement inside its body. Constructors can throw exceptions. It is legal to use a throws clause with the constructor. The constructor must not form recursion. When can we use a private constructor? In this case, when we don’t want to create objects of the particular class from outside, then we can use constructors as private. By declaring constructors as private, we are only allowed to create the objects within the class only. Singleton classes are a good example where private constructors are used. What will be the default access modifier of the constructor if we don’t explicitly define it? The access modifier of the constructor by default will always be the same as the class modifier. If the class is public, then the constructor will also be public. If the class will be private, then the constructor will also be private. And similarly applicable to another supported access modifier. Identity the output of the below code snippet and state the reason. class InterviewBit{
InterviewBit(){
System.out.println(" Welcome to InterviewBit ");
}
}
class ScalerAcademy extends InterviewBit{
ScalerAcademy(){
System.out.println(" Welcome to Scaler Academy by InterviewBit");
}
}
class Main{
public static void main(String[] args) {
ScalerAcademy sc = new ScalerAcademy();
}
} The above code will print - Welcome to InterviewBit.
Welcome to Scaler Academy by InterviewBit. It will print this output because in the constructor if we don’t specify the or keyword in the first line then, the JVM will automatically put this while execution. JVM does this because it is inheriting from the other class and the functionality will be implemented in the derived class also. So assigning the default values to the instances of the base class, JVM adds the keyword by default. super() this() super() Consider the code below and state it is valid or invalid. And the reason for the answer. class InterviewBit{
InterviewBit(){
System.out.println(" Welcome to InterviewBit ");
}
}
class ScalerAcademy extends InterviewBit{
ScalerAcademy(){
this();
System.out.println(" Welcome to Scaler Academy by InterviewBit");
}
}
class Main{
public static void main(String[] args) {
ScalerAcademy sc = new ScalerAcademy();
}
} The above code of invalid because we are again the same constructor in the Scaler Academy constructor.  This will form a recursion in the constructor and that is not allowed in the constructor. So it will give a compile-time error saying - recursive constructor invocation. Can we use 2 constructors in the same class in java? Yes we can use any number of constructors in the same class with the condition that- Parameters of the constructors must be different. There should not be forming any kind of recursion in the constructor. Example- Consider these 2 constructors of the same class InterviewBit. InterviewBit(){
    this("Scaler"); // Calling parameterized constructor 
    System.out.println(" No Argument Constructor");
}
InterviewBit(String name){
    this(); // Calling no-arg constructor
    System.out.println(" Constructor with Parameters.");
} This type of code is not allowed. Because it will form a recursion. No-arg constructor will call the parameterized constructor and parameterized will call the no-arg constructor. Can we override a constructor in java? No, the Constructor overloading concept is not applicable in java. Can a constructor be final in java? No Constructor cannot be final. It is because final keywords are used to stop overriding the method to the derived class. But in the constructor, the Overriding concept is not applicable so there is no need to write the final keyword. So if we write the final keyword in the constructor then we will get a compile-time error saying - required return type. Because the compiler treats it as the method. Can a constructor be static in java? No. the java constructor cannot be static. It is because static keywords are used when we want to make the member belong to the class, not for the object. But constructors are meant for initializing the objects. So the compiler will treat it as a method. So the error we get is- required return type. Difference between super(), super and this(), this. super() and this() are the constructor calls. It is only used to call the constructor of the parent class or current class. Whereas ‘super’ and ‘this’ is the keyword used for referring to the instance members of the own class or base class. Example -  Consider the below code- class InterviewBit{
    String message = " Welcome to InterviewBit";
}
public class Scaler extends InterviewBit
{
    String message = " Welcome to Scaler Academy";
    public void printMethod(){
        //this will print the message variable of the current class.
        System.out.println(this.message);

        //this will print the message variable of Base class.
        System.out.println(super.message);
    }
	public static void main(String[] args) {
		Scaler sa = new Scaler();
		sa.printMethod();
	}
} In the code snippet, ‘this.message’ will print the message “Welcome to Scaler Academy” and ‘super.message’ will print “Welcome to InterviewBit”. So this is how these both keywords are used to refer to the instance members of the base and derived classes. What are destructors? Do we have a destructor in java? Destructors are used to deallocate the memory acquired by the program. Or we can say that the memory required by the program during its runtime, destructor releases that memory, so that memory can be utilized by the other programs. And we don’t have the concept of destructor in java. Because the job of releasing the memory is handled by the garbage collection in java. What is constructor chaining in java? When one constructor is called from another constructor, then that can be said as constructor changing. Calling a constructor not necessary from others is not necessarily for the same class. It can be done for the parent class as well. : Consider the below image. Example For the above image, consider the below code for initialization of an object with the value values of these instance variables- class EmployeeAddess{
    int pinCode;
    String address;
    String mobNo;
    EmployeeAddress(int pinCode, String address, String mobNo){
        this.pinCode = pinCodel
        this.address = address;
        this.mobNo = mobNo;
    }
}
class Employees extends EmployeeAddress{
    int ID;
    String name;
    String designation;
    String department;
    Employee(int ID, String name, String designation,String department,
                    int pinCode, String address, String mobNo){
        
        //Calling Constructor for Base class to initialize the object.
        //This can be a constructor chaining.
        super(pinCode, address, mobNo);
        this.ID = ID;
        this.name = name;
        this.designation = designation;
        this.department = department;
    }
}
public class Main{
    Employee emp = new Employee(101, "XYX", "SDE", "Cloud", 123456, "no 150, xys, xys, INDIA", "999999999");
} In the above code, We are creating the object of Employee class with the Employee details and its address. An Employee address class is inherited by the Employee class. Now for instantiating the object value for the address, we are not explicitly assigning the values of employee address. Instead, we are using the Employee Address class constructor for doing that. And using the super(arguments) we are forming a chain of constructors to initialize the values. So this is what constructor chaining is all about. Identify the output of the program and state the reason for your answer. class InterviewBit{
void InterviewBit(){
System.out.println(" Java Constructor interview questions by InterviewBit");
}
int InterviewBit(int val){
System.out.println(" Java Constructor. And Value = "+val);
}
}
public class Main{
InterviewBit ib1 = new InterviewBit();
InterviewBit ib2 = new InterviewBit();
} The above code will print nothing because InterviewBit() is not the constructor here. Void and int keywords are used so it becomes the method. So we are not calling the method. That's why it will not print anything. Because to execute methods, we need to explicitly call it by the object. Write a java program to copy the values of the object to a new object using the constructor. class Rectangle{
    int length;
    int breadth;
    Rectangle(int length, int breadth){
        this.length = length;
        this.breadth = breadth;
    }
    
    //Overloaded Constructor for copying the value of old Object to new object
    Rectangle(Rectangle obj){
        this.length = obj.length;
        this.breadth = obj.breadth;
    }
}
public class Main{
    Rectangle obj1 = new Rectangle(10, 5);
    
    //New Object of rectangle class will be created with the value from obj1. 
    Rectangle obj2 = new Rectangle(obj1);
} In the above code, we have overloaded the constructor of the rectangle class. And that constructor will handle initializing the value to the new object from the old object received in the parameter.

Java Constructor Interview Questions

The problem of determining whether a graph is or not is very significant not just for interviews, it also helps in solving real-life problems. For example, we use it when football leagues are being hosted to see which player has played for what organizations and various other examples can be stated. This discussion focuses on the problem of determining whether a graph is bipartite or not. bipartite We need an in-depth understanding of the bipartite graph and graph coloring to solve this problem along with the knowledge of BFS, DFS, and cyclic-acyclic graphs. So, let’s first check out some definitions related to it: A graph that has even 1 cycle i.e. it is closed in a cyclic way is called a whereas if there is no closed shape in a circular fashion in a graph then it is called an acyclic graph. If there is a closed shape in an undirected graph, it will definitely be a cycle whereas, for a directed graph, this might not be true. This is also shown in the images below: Cyclic and Acyclic Graphs: cyclic graph The image shows that an undirected graph with a closed shape will be cyclic but a directed graph may or may not be cyclic. For a directed graph to be cyclic, the directions of the edges should enclose in a cyclic manner. If we have only 2 colors (say Red and Blue) and we can color every vertex of the graph such that both the vertices of every edge of the graph are not the same colored then the graph is 2-colorable. In simple words, we can say that the alternate vertices should have the same color or 2 adjacent vertices should not have the same color. Colorable Graph: In the above image, the first graph is 2-colorable as no 2 adjacent vertices are colored the same. In the second graph, the adjacent vertices V1 and V5 have the same color, hence the Graph is not 2-colorable. From the above image, we can see that the Cyclic graph with an even number of edges is 2-colorable and the cyclic graph with an odd number of edges is not 2-colorable. This is true for all the graphs having cycles because the vertices get divided into pairs (one vertex will be red-colored and the other will be blue colored) in case of Even Sized Cycle (Cycle with even edges/vertices) but one vertex is left off when we have an Odd-Sized Cycle (Cycle with odd edges/vertices). Also, for a graph with multiple cycles to be a 2-colorable graph, all the cycles must be Even Sized Cycles. This is shown in the image below: Non-bipartite graph because of the presence of an Odd Sized Cycle. So, we have understood the colorable nature of Cyclic Graphs. What about acyclic graphs? Let us look at some examples shown below: The images show various acyclic graphs and they are all 2-colorable. In general, all acyclic graphs are 2-colorable. The reason behind this is very simple. When a graph is cyclic, there are neighbors in both directions and when an odd-sized cycle is present, the neighbor of one of those sides happens to be of the same color. In an acyclic graph, there might be neighbors in 2 directions but the directions in an acyclic graph tend to be the same linearly. Hence, we can say that all acyclic graphs are always 2-colorable. So, finally, we can set some rules (from our observations) for a graph to be 2-colorable: If a graph is cyclic then for it to be a 2-colorable graph, all its cycles should be Even Sized Cycles. The extension of the above point is that all the Cyclic graphs that have even one Odd Sized cycle will be non-2-colorable. All the acyclic graphs are 2-colorable. Now, let us come to our question i.e. Bipartite Graphs. Bipartite Graph: If the vertices of a graph can be divided into 2 such subsets that are mutually exclusive (intersection should be null set) and mutually exhaustive (union is set of all vertices) and the edges are across the 2 sets, not within the same set, then it is said to be bipartite. Bipartite Graph Example Non-Bipartite Graph Example (As we can see, there is an edge V0-V4 for which the vertices lie in the same set. You may try to make any possible set but will always find an edge that is within the same set. Hence, the above graph is non-bipartite.) So, have you observed something from the above examples? It can be observed that the 1st graph that was bipartite was also 2 colorable. Also, the second graph is not bipartite and it is not 2-colorable also. Hence, we can say that a bipartite graph is nothing but a 2-colorable graph. Quick Observations: Since a graph with Odd-Sized Cycle is never 2-colorable, it is right to say that it will never be bipartite. Moreover, if there are multiple cycles in a graph, all have to be Even-Sized Cycles (number of edges should be even) for the graph to be bipartite. If a graph is acyclic (without a cycle), it will definitely be bipartite as it is always 2-colorable. If a graph has a self-loop i.e. a vertex of a graph has an edge to itself, it is non-bipartite because we cannot color the same vertex with 2 different colors. Approach 1: Assigning colors to each vertex (BFS) Problem Statement: We have to determine whether a graph given to us is bipartite or not. We have studied above that a 2-colorable graph is bipartite. So, let us try to color every vertex of the graph one by one by taking care that the neighbors should not have the same color. If we are able to color the graph successfully using 2-colors, the graph will be bipartite else not. Thought Process - Algorithm: Pick 2 numbers depicting 2 colors to be done on the vertices of the input graph. (Let us say the numbers are 1 and 2 and uncolored vertex will be depicted by number 0) Pick any vertex as a source vertex of the graph and color it using the first color i.e 1. Color all the adjacent vertices of the source vertex with the second color and color their adjacent vertices with the first color again and so on. (Use a color array of size equal to the number of vertices to maintain which vertex has what color). This is done to know the color of all the adjacent vertices when we are about to color one vertex. If all the vertices are colored successfully without violation of 2-colorable graph i.e. if we don’t have the situation of coloring 2 adjacent vertices with the same color, then it is bipartite otherwise, as soon as a vertex is found having the same color as adjacent vertex, return false that the graph is not bipartite. Also, don’t forget that the graph can be unconnected. So, do this procedure for every component of the graph. C++ Code Using Adjacency Matrix As the Input Input: The graph will be input to us in the form of an adjacency matrix of size V x V where V is the number of vertices in the graph. It will be a binary matrix depicting whether there is an edge from a vertex V1 to another vretx V2 or not. An example of the input is shown below:** ** The above image depicts an example of the input matrix. There is an edge from V0 to V1 hence we have Matrix[V0][V1] = 1 and so on. #include<bits/stdc++.h>
using namespace std;
// colors:
// red = 1 and blue = 2;
bool isBipartiteHelper(int graph[100][100],int vertices, int src, vector<int> colors) {
    //coloring the source vertex red 
    colors[src] = 1;

    // queue needed for BFS Traversal
    queue<int> que;
    que.push(src);

    while(!que.empty()) {
        int front = que.front();
        que.pop();

        // If self Loop exists, then adjacency matrix 
        // will have 1 in the diagonal element
        // and we have to return false in case of  adjacency matrix
        if(graph[front][front] == 1) return false;

        for(int i=0;i<vertices;i++) {

            // edge exists and the adjacent vertex i is uncolored
            if(graph[front][i] == 1 && colors[i] == 0) {
                if(colors[front] == 1) colors[i] = 2; //color     alternatively
                else colors[i] = 1;
                que.push(i);
            } else if(graph[front][i] == 1 && colors[i] == colors[front]) { //edge exists and same color of adj vertex
                return false;
            }
        }
    }

    return true; //all vertices of this component can be colored
    // as per the rule of 2-colorable graph 
}

bool isBiPartite(int Graph[100][100], int vertices) {
    vector<int> colors(vertices,0);

    // Assume i to be a source vertex of current component
    for(int i=0;i<vertices;i++) {
        // If i is uncolored
        if(colors[i] == 0) {
            // if any component is non bipartite, graph is also non bipartite
            if(isBipartiteHelper(Graph,vertices,i,colors) == false) return false;
        }
    }

    return true; //if all the components are bipartite then the entire graph is bipartite
}
int main() {
   
    int vertices;
    cin>>vertices;

    int Graph[100][100];

    for(int i=0;i<vertices;i++) {
        for(int j=0;j<vertices;j++) {
            cin >> Graph[i][j];
        }
    }

    cout<<"The given graph ";
    if(isBiPartite(Graph,vertices) == true) 
         cout<<"is bipartite\n";
    else cout<<"is not bipartite\n";
    return 0;
} Try the code with InterviewBit Output: Analysis of the approach: The code covers the corner case of a graph having a self-loop but the code does not cover the case of a graph having parallel edges i.e. multiple edges between the same pair of vertices as shown below: The case of a graph being divided into multiple unconnected components is covered. The time complexity is O(V2) because we are traversing an adjacency matrix of size V x V. Time Complexity: The graph is represented using O(V2) space using the adjacency matrix but this is not the space complexity. Other than that, O(V) space is the auxiliary space used for storing the colors on each vertex. Space Complexity: (V is the number of vertices in the above complexities.) Let us look at an optimized way to solve this problem using the same approach as above. To optimize the solution, we will use an adjacency list as input in place of a matrix. C++ Code Using Adjacency List Input: The input will be an adjacency list. Now, the user has to input all the edges in the form of source-destination vertex pairs. Also, we have considered the graph to be undirected in this case. So, if the user enters an edge V0-V1 thinking that there is an edge from V0 to V1, there will also be an edge from V1 to V0 that will be inserted automatically because of the consideration that the graph is undirected. #include <bits/stdc++.h>
using namespace std;

// colors: red = 1 and blue = 2
bool isGraphBipartite(vector<int> list[], int vertices) {
    
    // make a vector for storing
    //  colors of all the vertices
    // Since all the vertices are 
    // initially uncolored,
    // fill the vector with 0s
 
    vector<int> colors(vertices,0);

    // queue of pair will be made
    // as we will store the vertex
    // along with its color

    queue<pair<int,int> > que;
    
    // The same logic for non connected components
    // that we did using adjacency matrix
    // will be applied here

    for(int i=0;i<vertices;i++) {

        // check whether the taken
        // source vertex for current
        // component is not colored
        // If found uncolored
        // apply BFS on the component

        if(colors[i] == 0) {
            
            pair<int,int> srcVertex;
            srcVertex.first = i;
            srcVertex.second = 1;
            que.push(srcVertex);
            colors[i] = 1; //color the source vertex of current component red
            
            // BFS on current component of the graph
            while(!que.empty()) {
                pair<int,int> front = que.front();
                que.pop();

                int currVertex = front.first;
                int currVertexColor = front.second;

               // traversing adjacent vertices of current vertex
                for(int adjVtx: list[currVertex]) {
                    if(colors[adjVtx] == currVertexColor) return false;
                    else if(colors[adjVtx] == 0) {
                        if(currVertexColor == 1) colors[adjVtx] = 2; //coloring alternatively
                        else colors[adjVtx] = 1;
                        
                        pair<int,int> adjPair;  
                        adjPair.first = adjVtx;
                        adjPair.second = colors[adjVtx];
                        que.push(adjPair); 
                    }
                }
            }
        }
    }

    return true;
}
int main() {
   int vertices, edges;
   cin>>vertices>>edges;

   vector<int> list[vertices];

   for(int i=0;i<edges;i++) {
       int sv,av;
       cin>>sv>>av;

       list[sv].push_back(av);
       list[av].push_back(sv);
   }

   cout<<"The given graph is";
   if(isGraphBipartite(list,vertices) == true)       
        cout<<" bipartite\n";
   else cout<<" not bipartite\n";

   return 0;
} Output: Analysis of Approach: This code just uses an adjacency list instead of a matrix. The self-loop case is covered and the multiple unconnected components case is also covered in this code. However, the case of  a graph having parallel edges is not covered. As already discussed above, the time complexity is O(V+E). Time Complexity: Space Complexity: Used adjacency matrix to store the graph but the auxiliary space is O(V) i.e. storing the colors at each vertex. Try to solve this problem by the same approach i.e. coloring all the vertices but with DFS (Recursion) rather than BFS.  This means that you have to apply the same approach of coloring the graph but, we have used BFS to do so. You should try this out using recursion (DFS) now. Follow up for this approach: Approach 2: Visiting Levels Approach (BFS) Algorithm: The approach is based on checking the cycles in the graph. If the graph is acyclic, we will return true because acyclic graphs are 2-colorable and hence bipartite but if there is a cycle, we need to find whether it is of odd length or even. If the cycle is of odd length, the same vertex will be visited again on different levels in the Euler tree (recursion tree) whereas if the cycle is of even length, the same vertex will be visited again on the same level. As shown above, we are traveling using BFS and exploring all the unvisited adjacent vertices of a source vertex. In the case of the first graph i.e. a graph with Odd Sized Cycle, V4 is visited on Level 2 and Level 3 of the same BFS Tree whereas, in the case of a graph with Even Length Cycle, the vertex that is visited again (V3 in this case) is visited at the same level. So, in the case of an odd length cycle, the vertex that determines the cycle will be at two different levels whereas, in the case of an even length cycle, it will be at the same level. So, once we get a vertex that repeats itself (it will happen in a cyclic graph), we check when the vertex was last visited, was its level the same or not. Again, do not forget that the graph can be divided into multiple unconnected components. So, BFS will be applied to each component. C++ Code for Second Approach Input: The input will be an adjacency list. Now, the user has to input all the edges in the form of source-destination vertex pairs. Also, we have considered the graph to be undirected in this case. So, if the user enters an edge V0-V1 thinking that there is an edge from V0 to V1, there will also be an edge from V1 to V0 that will be inserted automatically because of the consideration that the graph is undirected. When applying BFS, we do not push just the vertex into the queue, we push it with the Level on which it is being visited, and also, it is marked visited. So, when we encounter the same vertex again, we will see what was the Level on which it was previously visited. If the Level is the same as that of the current visit, the component of the graph is Even Cycled and this component is bipartite but not the entire graph. For the entire graph to be bipartite, all the components should either be acyclic or of Even Length Cycles. Thought Process: #include<bits/stdc++.h>
using namespace std;

bool isComponentBipartite(vector<int> list[],int src,vector<int> &visited) {
    queue<pair<int,int> > que; //this pair corresponds to vertex -> level
                               // which means vertex and the level in which
                              //  it appeared in the recursion tree
                              // of BFS

    pair<int,int> srcPair;
    srcPair.first = src;
    srcPair.second = 0; //initially source is at 0 level in recursion tree
    que.push(srcPair);

    // Apply BFS
    while(!que.empty()) {
        pair<int,int> front = que.front();
        que.pop();

        if(visited[front.first] != -1) { //if the vertex (i.e. front.first) is already visited 
            //since the vertex is already visited, check if the levels are not same
            if(visited[front.first] != front.second) { 
                return false; //odd length cycle detected
            }
        } else {
            visited[front.first] = front.second;
        }

        //now visit all the adjacent vertices
        for(int adj : list[front.first]) {
            if(visited[adj] == -1) {
                pair<int,int> adjPair;
                adjPair.first = adj;
                adjPair.second = front.second + 1;
                que.push(adjPair);
            }
        }
    }

    return true; //either no cycle detected or all cycles were even length
}

int main() {
    int vertices,edges;
    cin>>vertices>>edges;

    vector<int> list[vertices];
    
    for(int i=0;i<edges;i++) {
        int sv;
        int dv;
        cin>>sv>>dv;

        //since non-directed graph, edges will be bi-directional
        list[sv].push_back(dv);
        list[dv].push_back(sv);
    }

    //initially no vertex is visited and hence all are at level -1
    vector<int> visited(vertices,-1);
  
  //for non connected components as we need to check whether every component is bipartite or not
  for(int i=0;i<vertices;i++){
    if(visited[i] == -1){
        bool ans=isComponentBipartite(list,i,visited);
        if(ans == false){
            cout<<"The graph is not bipartite";
                return 0;
        }
      }  
    }
      
    cout<<"Graph is bipartite";
    return 0;
} Output: This code does not cover the case of a graph being divided into multiple components. Quick Note: Since we have used an adjacency list for graph traversal (BFS), the time complexity is O(V + E). This is the same as the Coloring Approach i.e. if we would have used the adjacency matrix, the Complexity would have been O(V2). So, we used the adjacency list directly this time to optimize the solution. Time Complexity: In BFS, we are using a queue that can store at maximum all the V vertices. Hence the space complexity can be termed O(V). O(V + E) is the space of the adjacency list but not the space complexity as it was input space. Space Complexity: Conclusion So, we have learned 2 different methods of detecting whether a graph is bipartite or not. You may use any approach that you find intuitive as both are the same in terms of complexities (time and space). However, the Graph Coloring Approach is used more as it is easier to understand and explain and shows the relation of a bipartite graph with a 2-colorable graph more clearly.

How to Check if a Graph is Bipartite in C++

Problem statement We are given a sentence that needs to be reversed using the method of recursion. By reversing, we mean the interchange of characters starting from the right to the left, i.e. interchanging (i)th character with (n-i)th character, where n is the length of the given string. Example coding is awesome. Input: emosewa si gnidoc Output: Recursion is easy ysae si noisruceR Input: Output: Recursive Algorithm An easy way to solve the problem is through simple iteration by just using a for loop with i from index 0 to n/2 and then character interchanging with n-i. But here, we will look into the solution of the problem using recursion. Since a solution using recursion involves the idea to represent a problem in terms of one or smaller problems. It mainly consists of three main things: Induction hypothesis. Base condition. Generating the solution assuming the hypothesis to be correct. Let say we have a string of length n and let's assume that reverseFunction() is the function that takes a string as an input and returns the string which is the reverse of the input string. Induction Hypothesis: When n=0 or n=1 (empty string) return input string only. Since the reverse of a single character or an empty string is itself only. Base condition: Now we need to calculate the reverse of a string of length n and we have the reverse of the string with length n-1. Therefore, the reverse of the string with length n will be the reverse of a string with length n-1 with the additional character attached at last. Generating the solution: For string s of length n, Rev(s,i) will return the reverse of the string from index i to n. Rev(s,0) = Rev(s,1)+s[0]. Let’s say s=”APPLE” Rev(s,0) = “ELPPA”, while Rev(s,1) = “ELPP” and s[0]=”A”. Therefore Rev(s,0) == rev(s,1) +s[0]. - Example Let F(s,0) be the reverse function.
Where s=”APPLE” , n=5.
F(s,0) => F(s,1)+”A”. => “ELPP” + “A” = “ELPPA”.
F(s,1) => F(s,2) + “P” => “ELP”+”P” = “ELPP”
F(s,2) => F(s,3) + “P” => “EL” + ”P” = “ELP”
F(s,3) => F(s,4) + “L”  => “E”+”L” = “EL”
F(s,4) => F(s,5) + “E” => “E”. Java Implementation The algorithm involves the use of the recursive reverse function which works on the above induction hypothesis and recursion. It basically uses the substring function of strings and concatenates the string in every recursive call. import java.util.*;
public class Main
{
    static String reverseFunction(String s){
        if( s.length()==0 ){
            return new String();                         // Base Case
        }
        return reverseFunction(s.substring(1)) + s.charAt(0);       // recursion call
    }
// Tester Code / Input Code

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		sc.nextLine();
		while(n-->0){
		System.out.print("Input: ");
		String s = sc.nextLine();
		System.out.print("Output: ");
		System.out.println(reverseFunction(s));
		
		}
	}
} Note: Since the String in java is completely immutable every time we append the solution string in every recursive call, java internally generates a new string with the content of the joined string. This increases the worst-case time complexity from O(n) to O(n^2), where n is the length of the input string. One solution to the above problem is to use an inbuilt string class of java that is mutable i.e. StringBuilder, which cuts/appends the string in O(1) time. Therefore, java code using class with time complexity O(n) is as follows: StringBuilder import java.util.*;
public class Main
{
    static StringBuilder reverseFunction(String s){
        if( s.length()==0 ){
            return new StringBuilder();          // Base case
        }
        return reverseFunction(s.substring(1)).append(s.charAt(0));     // recursive call
    }

// Tester Code / Input Code

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		sc.nextLine();
		while(n-->0){
		System.out.print("Input: ");
		String s = sc.nextLine();
		System.out.print("Output: ");
		System.out.println(reverseFunction(s));
		
		}
	}
}

Output: -
2
Input: Hello World!
Output: !dlroW olleH
Input: Reverse it.
Output: .ti esreveR Another better solution/algorithm to avoid concatenation of string in every recursive call is to use another parameter that will take input i as an integer such that the function will give the reverse of the string starting from the index i to the end of the string. Java code for the following is given below: import java.util.*;
public class Main
{
    static String reverseFunction(String s, int i){
        if(i==s.length()){
            return "";                               		// base case
        }
        return reverseFunction(s,i+1)+s.charAt(i);   // recursive call
    }


// Tester Code / Input Code

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		sc.nextLine();
		while(n-->0){
		System.out.print("Input: ");
		String s = sc.nextLine();
		System.out.print("Output: ");
		System.out.println(reverseFunction(s,0));
		}
	}
} The complexity can further be improved by the use of the StringBuilder class in the recursive call to append the character since the use of string makes a new string in every recursive call. The implementation for that is given below. import java.util.*;
public class Main
{
    static StringBuilder reverseFunction(String s, int i){
        if( i == s.length() ){
            return new StringBuilder();
        }
        return reverseFunction(s,i+1).append(s.charAt(i));
    }
// Tester Code / Input Code

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		sc.nextLine();
		while(n-->0){
		System.out.print("Input: ");
		String s = sc.nextLine();
		System.out.print("Output: ");
		System.out.println(reverseFunction(s,0));
		}

		}
	}
} Output: C++ Code Implementation Since the string in C++ is mutable. Therefore, we don’t need to implement the strings with any different classes. Thus, the first implementation with input string as only recursive function parameter is as follows: #include <stdio.h>
#include <string>
#include <iostream>
using namespace std;
static string reverseFunction(string &s){
    if (s.length()==0) return s;
    string rest = s.substr(1);
    return reverseFunction(rest) + s[0];
}


int main()
{
    string s;
    s= "Interviewbit is Cool";
    cout<< "Input string is : "<<"\""<<s<<"\""<<endl;
    cout <<"Output reversed string is : "<<"\""<< reverseFunction(s) <<"\""<< endl;
    

    return 0;
} You could also try running this code on an . online C++ compiler Output: Input string is : "C++ is Cool" Output reversed string is : "looC si ++C" The second implementation which doesn't make use of the rather take an extra integer input is as follows: substr function #include <stdio.h>
#include <string>
#include <iostream>
using namespace std;
static string reverseFunction(string s , int i){
    if (i==s.length()) return "";
    return reverseFunction(s,i+1) + s[i];
}


// Input Code/ Tester Code
int main()
{
    int n;
    cin >> n ;
    while (n-- > 0) {
    string s;
    getline( cin , s );
    cout << reverseFunction(s,0) << endl;
    }
    return 0;
}

How to Reverse a Sentence Using Recursion in C++ and Java

Computer programming is one of the hot industries in the world. It pays good paychecks but also it gives you job security in times of pandemic too 😃. This industry has grown by 66% in the US in 10 years and expected to grow by 20% annually. You want to be part of this amazing industry, but don’t know how to do programming or how to code. That’s OK. Everyone has the same doubt when they are beginning. In this blog, I will share with you some of my tips that my mentors gave me when I was starting, which I think useful to share with beginners. Throughout the blog, I will use the programming and coding words interchangeably, for sake of simplicity. So let’s begin….😉 #Advice No1: You don’t need to learn every programming language or technology. Professionals even, don’t learn each and every language/technology. Remember this advice will prevent you from burnout. How to Start Programming Hang out with people with the same interest - who want to learn to program. Step 1: This is the most important step than straightly jumping on learning any programming language. You may ask, what the benefit of this step? This step will help you keep motivated throughout your journey. I have seen most of the beginners when they start learning any programming language. At first, they are very enthusiastic but as they go on through learning - whether they are learning from a course or a book. They get bored. They don’t have that much enthusiasm that they have at the beginning and as a result, they start procrastinating. And here is what, your coding group buddies will help in 😉 . When we tend to work or learn something in a group, as we go further we get more enthusiastic and more motivated to learn and achieve more. Your coding buddies will help you in the same way. When they discuss a programming problem in a group and you realise that you are not able to solve the problem whereas others are able to solve the problem, you will get embarrassed, then you feel, you have to be like them or more than them and, and that’s the motivation, you continue learning with more energy than you were at before. That’s the power of learning in a group. 💪 Well, how to find these coding buddies 🤔? You can start following professional programmers on social media like YouTube, Twitter, Instagram, etc. Mostly nowadays they all have discord servers. You can join their servers (for free) and able to meet awesome people hanging there, and most probably you will find your coding buddies there, too 😉 Another way to find coding buddies is to go to programming events / online events and meet people or you can make a WhatsApp group of your college classmates, who are passionate about coding. And most probably you will also find a mentor for yourself. Decide what you want to become. Step 2: There are a lot of technologies out there in the market for different domains of computer science - Web development, cloud computing, blockchain, etc, and it’s not possible to learn all these technologies for any human being on this planet. So first decide what is your end goal is, what you want to become. You can search about different domains of computer science or I will also write a blog on this topic with salary expectations, on your demand. You may fall in these 3 categories, there are many categories in the industry  but I am taking the overall picture : If you want a job within a year or two, then you just need to focus on one programming language, I prefer C++ because it’s faster than other languages. Know some basics of the language and then learn Data Structures & Algorithms (DSA). 1. Want a job within a year: When you apply for a job, companies don’t see how much or what projects you have made, but they see whether you are a problem solver or not. DSA is the only key point that can prove that you are a problem solver. Learn DSA from anywhere of your choice, there’s the tone of free and paid DSA course on the internet. After learning DSA practice on sites like LeetCode, InterviewBit, etc. These sites are interview-based sites, here you can find questions that were asked in the coding interview round of different product or service-based companies. The more you practice the more confidence you get, in cracking an interview. You may want to make a mobile app or a web app or social networking sites like  Instagram or Facebook, just for fun. Then I will suggest you learn Python or JavaScript. Then you can learn SQL or MongoDB - databases as per your requirements. These are the common requirements for a web app or an android app. 2. Want to develop Apps, just for fun: Python and JavaScript are used as the backend for app to run continuously on the server. For web App - I will suggest HTML,CSS,JavaScript. HTML, CSS are used to make frontEnd - the interface you are seeing is the frontEnd, of an application, whereas JavaScript is used to make frontEnd interactive. It’s not very hard, you can learn frontEnd within a month or so. Afterward you can also learn Reactjs, Angular.js, Vue.js - these are frontEnd libraries and frameworks, to enhance your front-end skills 😃. This is where I lie 😄. If you want to be a software developer then first learn a programming language and make a stronghold on it. I suggest you learn C++ first as it fastest programming language and as well many other programming languages like Java has evolved from C++ only. Many other programming language or run-time environment also uses C++ under the hood like CPython, Node.js. 3.Want to be a software developer and have plenty of time: C++ developer has a higher salary than any other programming language developer. #FunFact: It will be really helpful for you if you have a strong grip on C++. It will help you to understand DSA in greater depth. It will take few months to learn it because it is your first programming language but it will also help you to learn a new programming language (if you decide to learn in the future) within a day or a week because concepts are the same in every programming language, the only syntax is different. After learning your first programming language, learn DSA. As stated in category 1 that DSA is very important because, in the end, you want to do a job as a software developer, na!!. #Advice No2: Don’t try to learn two programming languages simultaneously. Lots of beginners make this mistake and hence they are not able to make clear concepts in any of the programming languages. Spend time on learning one language, the more time you spend, the more benefit in the long run. Choose a project This is the most crucial step. If you don’t do this, then no one can believe you that you know to program. #Advice No3: Learn technologies as per your project requirements. This is one of the pieces of advice given by my mentor. He said that it’s not possible to learn every technology it can take you ages, learn technologies as per your project requirements. If you start learning every technology then you will keep on learning and you will not able to implement it practically. Now decide which project do you want to make. For example, you can make, a simple calculator, a Coffee ordering app, or a game😃. #Advice No4: No need to make the full-fledged project, that the public will use. Start with a simple project. After making some simple projects, make 2-3 medium-level projects from which you can learn something new while developing it. In last, one last piece of advice I will like to give : #Advice No5: Practice, Practice, Practice. Practice makes everyone perfect. If you follow these steps sincerely, then I can guarantee you that you will become a better programmer, even within a year. I will also post a roadmap for learning your first programming language, so stay in tune 😉

Powerful Tips To Help You Learn Programming Language

) Written By Esco Obong (@ escobyte on Twitter , Senior Software Engineer @ Uber , Founder of Algorythm study group on Facebook and Black Software Engineers Career Support Group on LinkedIn . This was me in 2015 ☠️. A startup I had joined as “founding employee” after we raised a $500k seed round from a prototype was shut down six months later and we were looking for new roles. I secured an interview with through a referral from one of the startup founders (also GIPHY but I wasn’t interested for some reason. Since then they sold to Facebook 🤦) Codecademy On the phone with Codecademy they said “don’t worry we don’t ask crazy algorithms questions or anything like that”. I took that to mean I didn’t need to study algorithms at all 🤣. During the on-site interview, I got two rounds of algorithms questions that were extremely basic in hindsight. I remember one of them was asking how to traverse from point A to point B in a grid. I had no clue how to do that so I was just doing random shit. I landed on an infinite loop… I actually wrote on the board: while “ while (true) {…” In the loop, the point changed direction on each iteration depending on if it hit a wall and would eventually manually break the loop if the target was found. The interviewer must’ve been like WTFFF, but he kept his cool and kept entertaining my different ideas. while That fiasco opened my eyes to the types of questions I needed to be able to answer. Two and a half months later I passed phone screens at Google, Uber, Shutterstock and Rent the Runway. I did the on-site interviews for Shutterstock, Rent the runway, and Uber and passed all of them. Google rescheduled my interview to be two weeks later than what I told them in the last minute. By that time I already had three offers and was pretty excited about Uber so I pulled the trigger and joined Uber. I went from 0 → 100 in just a few months and I didn’t do anything special aside from studying consistently. That’s why I strongly believe any engineer can get good at these DS & Algo questions and get into F.A.A.N.G. or similar high paying roles. At first, I felt I wasn’t really qualified because I had to study so hard to pass my interviews. In 2019, after having run my own consulting firm and startup for almost 2 years, I decided to go back into full-time work and found myself in the same position as I was in 2015. This time, I had a larger network of friends at Uber and other top companies like Google and Facebook that gave me insight into the real deal. They had to study just as hard. Even the ones that didn’t drop out of college like I did. all The ones who stayed and completed their Algorithms’ courses and had gotten their Computer Science degrees, they all still needed to study hard. I discarded this notion of the mythical engineer who can on a whim pass a tech interview and started to appreciate the reality of the situation, that tech interviews are like the SAT’s they give in school. It doesn’t matter that you spent four years learning all of the content in high school, you still need to prep if you want to ace the test. Just like with the SATs all of your past work and grades don’t contribute to the score. Your success depends entirely on how well you perform on the test. Once I realized the truth, that everybody needs to study, it was enough motivation for me to put in the hard work since I realized that’s what my competition was doing. Through that motivation, I formed a process for studying that helped me pass every tech screen and on-site interview I did in 2019. I, a college dropout, passed technical screens for Stripe, Coinbase and Triplebyte. I passed screens and on-site interviews for Google, Amazon, Uber (again), Reddit, Squarespace and Braze. A 100% pass rate wasn’t expected and isn’t likely to continue to happen, but I believe focusing on the fundamentals helps approach that goal. Google sends you swag when you pass the interview and match with a team It wasn’t a smooth transition. When I first started preparing for interviews, it took me over 2 hours to solve what would now be called a “leetcode easy” and at the time it felt impossible! I truly believed that I just wasn’t naturally smart enough and would have to study even harder to get to the same level where I could solve the problem at the same speed as a Google engineer. ALMOST I got one thing right, you do need to practice. What I didn’t realize is that this level of difficulty and frustration in the beginning is to be expected by everyone just starting out, those Google engineers. including I’m still the same person. The only difference between now and then was practice, practice, practice. Most of the time it’s not enough to just provide a working solution to problems during the interview. You have to do it within a certain time limit and the code has to run at a certain level performance described by time & space complexity. A common question people have is “how do I study”? It’s hard to know where to start, what to do next, if you’re making progress and even harder to stay on track. To solve a lot of these issues when I was studying, I created a Trello board with all the topics I wanted to cover. The board helped me focus on the most important topics I should be studying and manage my time to keep progress consistent. I made a post about the Trello board on LinkedIn and it went viral. A Trello PM contacted me about creating an official Trello template for it which can be found here: . Interview Study Tracker The tracker provides a template for how to study. It requires identifying a list of topics and searching for two or more resources that can teach you about the topic. Then assigning yourself 2–3 practice questions to solidify your understanding. It can be from any source, the most important thing is the content itself. I found most of my content with simple google searches using the topics as the keyword. Learning the same thing from different perspectives helps you understand it better. For example, I would read an article on about binary search trees and also read chapters in Cracking the Coding Interview about them. Then I would do 2–3 practice questions or enough to feel comfortable before moving on. geeksforgeeks.org My copy of “Cracking The Coding Interview 6th Edition” signed by Gayle Laakmann McDowell List of Study Topics Below is a list of nearly all of the data-structures and algorithms that you can come across during a tech interview along with a very brief description and some resources to get started building your study plan. The goal is to provide a starting point for you to build your plan and not to explain in detail what each topic is. Part of your plan is finding resources to learn more about each topic from different perspectives. If you haven’t heard of some data-structures in the list or haven’t learned much about them before, they might seem complex but as you progress, you’ll soon experience the same feelings you had before and after you understood Arrays. Think about how complex the concept of an Array is to a non-programmer and how basic it is to even the most junior developers. These data-structures are just the basic building blocks that help you create algorithms… they actually make things simpler once you take the time to understand them. Just as an Array handles a lot of the work required to maintain an ordered list of elements, these data-structures have functions and containers for efficiently working with data. Basic Data-Structures These are considered basic. Everyone should know how they work, when to use them, and the reasoning behind their tradeoffs: how to implement them Array Set Hashmap LinkedList Stack Queue Tree Graph If this list seems long, don’t worry. A lot of these data-structures are closely related and even build upon each other so you’ll be able to learn them all quicker than you might think. Hashmaps build upon Arrays. Stacks build upon LinkedLists or Arrays. Queues build upon LinkedLists. Trees share concepts of “nodes” and “links” from LinkedList. Graphs also share the same concepts. They also have a lot of similarities to trees. All trees are technically graphs too so you can apply a lot of the same techniques to them. Advanced Data-Structures After mastering the basic data-structures, knowing these more advanced ones will give you a higher chance of success. Some come up very often during interviews like Heaps and Binary Search Trees. LRU Caches and Tries come up less frequently but are becoming more common. Disjoint Sets and Skip Lists rarely come up, but even if not explicitly asked about them, they can be powerful tools to help you come up with quick and performant solutions. Heap (a.k.a Priority Queue) LRU Cache Binary Search Tree (AVL, Redblack) Disjoint Set Trie Skip List As we go into more advanced data-structures you’ll see they are usually made using the basic ones as building blocks. Getting a good understanding of the basic data-structures will make learning these advanced ones much easier. You’ll think of them in terms of the smaller structures you already know rather than big new complicated structures. Heaps, also known as Priority Queues are a type of tree that behave like a queue. Binary Search Trees (BSTs) are another type of tree that make it faster to search for nodes. AVL and Redblack are two popular specific types of balanced BSTs. An LRU Cache is a memory efficient cache built with a Hashmap and LinkedList. A Trie is another type of tree that makes prefix/substring searches fast. Disjoint Sets are a special type of set that separate its members into non-overlapping subsets, useful for the Union Find algorithm. A Skip List is an optimized version of a LinkedList that reduces the time it takes to find certain nodes. Basic Searching/Traversal Algorithms All data structures are meant to hold information. Some structures need specials ways to access this information efficiently that are more involved than simply accessing an array index or hashmap key. Data-structures that hold collections of data such as Trees and Graphs use a few basic algorithms to access the information within. Breadth First Search (BFS) Depth First Search (DFS) Binary Search Advanced Searching/Traversal Algorithms There is a ton of research in this field, but for the purposes of a tech interview, the most advanced searching algorithms you’ll likely come across in order of frequency are: Quick Select Dijkstra Bellman-Ford A-star Sorting Algorithms Sorting is a common tool used to increase the performance of a solution. There are many sorting algorithms, but the most popular for interviews are listed below. Know how to implement all of these without looking anything up. Quick Sort Merge Sort Topological Sort Counting Sort Important Topics Recursion is an extremely important topic that doesn’t come up as much in day to day software engineering as it does during interviews. Bit manipulation may seem scary at first, but once you take time to understand the binary number format and operations you’ll realize how simple it is. Recursion Greedy Algorithms Dynamic Programming Bit Manipulation (AND, NOT, OR, XOR) Common Patterns These patterns can be used to solve many similar algorithms questions Backtracking Two Pointers Sliding Window Divide & Conquer Reservoir sampling Math based problems Permutations / Combinations Power Set Other Common Problems String to Integer Integer to String Adding huge numbers (that can't fit in memory) Addition/Subtraction/Multiplication/Division without using operators Practice Self Practice Studying means nothing without practice. Every time you learn a new topic from your study plan, you should put it to use. That’ll help you remember it longer and also give a deeper understanding. Do a few practice questions for every topic you finish. Sites like leetcode.com let you search for practice questions using tags like “trees” or “graphs”. Practice should happen in two phases. The first is when you learn the topic for the first time. During this phase you should focus on really understanding whats involved and why your solution works. The second phase is after you’re comfortable with the concepts. At this point you should time yourself and aim for faster and faster solution times. During an interview you’ll be expected to solve a problem within 15–45 minutes depending on the difficulty of the question. When you start out, it’ll likely take hours for you to do the first one. Over the first few weeks that time should start to come down. After a month or two of consistent practice (not just time passing), you should start being able to solve a decent amount of problems on time. Sometimes an entire interview question will only involve implementing a single data-structure such as an LRU Cache or a Trie. Other times it’ll only involve implementing a single operation on a data-structure such as the delete operation on a Binary Search Tree. Practice implementing all of the data-structures mentioned earlier in this article until you don’t need to look anything up and you will have a very easy time with these questions during the real interview. Focus on understanding why its implemented the way it is rather than trying to remember the exact code. Implement from understanding of what needs to happen next and not from memory. You probably won’t be asked to implement an Array or balanced BSTs like AVL or Redblack trees but you should know how they work. Assisted Practice (Mock Interviews) Practicing topics and questions alone isn’t enough. During the interview you’ll be interacting with a real person who is judging your skills in real-time. The situation is more stressful than when you study at home. To get around the awkwardness and anxiety of a real interview, you should do many practice interviews beforehand. This will help you be comfortable so that you can focus on the interview question rather than being distracted by non-technical things. These types of practice interviews are called Mock Interviews. You can have a friend help you or find a service online that’ll match you with an interviewer. Knowing when you’re ready You’ll never feel “ready” no matter how long you study. Theres always more topics to dive deeper into or weak areas that could use more practice. There is definitely an element of luck in the whole process. It’s very possible that you get a question on a topic you haven’t prepared for at all or are really weak on. It’s also possible that you get all questions on topics you’re really strong in since two months ago and didn’t need to spend that extra time studying to pass. You can’t prepare for every possible outcome, but your chances of success get higher than everyone else’s with more practice. Keeping track of your progress and getting feedback is very important in knowing when you’re truly ready to perform on the real interview without relying on just emotion. Keep track of your completion times when you do practice questions and aim for at most 40 minutes to complete most medium level questions and 1 hour to complete hard level questions on sites like leetcode.com or hackerrank.com. Realize that you must pass every edge case for it to count on those sites but luckily this isn’t the case for real interviews! Most interview code is evaluated on a small set of edge cases and small errors get passed or considered to be irrelevant all the time. The point of evaluation isn’t to be so strict as to expect perfection, but they need to see enough to be convinced. Do at least three mock interviews before you do the real one. Only move forward when you can consistently perform well during practice. If you follow the above, knowing when you’re ready is easy. You might still feel you aren’t but you’ll know for sure because you’re hitting your completion times and have passed many mock interviews. Being ready means you’ve proved undoubtedly through practice that you can pass interviews that ask the same types of difficult questions under the same time limits. This article only focuses on data-structures and algorithms questions. System Design and Behavioral questions also play a large role in the hire decision. I’ll leave those topics for another article. Resources Books Cracking the Coding Interview 6th Edition Elements of Programming Interviews JavaScript Algorithms Websites www.geeksforgeeks.org www.educative. www.brilliant.org www.algoexpert.io Bootcamps www.interviewkickstart.com www.outco.io Practice Self leetcode.com www.hackerrank.com Assisted www.interviewbit.com www.pramp.com All of the topics you need to know along with resources explaining them are freely available online. Google searching any of the topics mentioned in this article, even the obscure ones like “two pointers” will yield a wealth of information about them. You don’t need a special college education, lucky genes or a long track record of success to get a job at a top tech company. The only thing you need is to dedicate time to consistent study and practice. This article was inspired by a few related questions asked in the Facebook study group for black software engineer s At the time of writing, we have 1,500+ black software engineers studying and helping each other with data-structures and algorithms. If you are an underrepresented person of color in tech who needs help studying or is in a position to help others study, please join us! Otherwise please share the group with someone who has the time or needs the help. Also published at https://escobyte.medium.com/how-to-study-for-data-structures-and-algorithms-interviews-at-faang-65043e00b5df

How to Prepare Yourself For Data Structures and Algorithms Interviews at FAANG

The biggest question you should ask yourself before read further is "What is coding?". So coding is the process of assigning a code to something for classification or identification. Basically there are 3 levels of coding: Beginner Intermediate Expert So, let's start the journey with some gaming and believe me you will learn a lot through these games. Yes, Definitely coding. CodeMonkey CodeMonkey is a fun and educational game-based environment where kids learn to code without any prior experience. After completing CodeMonkey's award-winning coding courses, kids will be able to navigate through the programming world with a sense of confidence and accomplishment. CODEWARS Codewars is an educational community for . On the platform, software developers train on programming challenges known as . These discrete programming exercises train a range of skills in a variety of programming languages, and are completed within an online . computer programming kata integrated development environment On Codewars the community and challenge progression is , with users earning ranks and honor for completing kata, contributing kata, and quality solutions. gamified So, as you have played some games , now you can jump on some  Coding websites. BEGINNER 1.GEEKSFORGEEKS GeeksforGeeks was created with a goal in mind to provide well written, well thought and well-explained solutions for selected questions. The core team of five super geeks constituting of technology lovers and computer science enthusiasts have been constantly working in this direction. 2.HackerRank HackerRank is a place where programmers from all over the world come together to solve problems in a wide range of Computer Science domains such as algorithms, machine learning, or artificial intelligence, as well as to practice different programming paradigms like functional programming. INTERMEDIATE 1. HACKEREARTH HackerEarth provides enterprise software that helps organisations with their technical hiring needs. HackerEarth is used by organizations for technical skill assessment and remote video interviewing. In addition to that HackerEarth also has a community and since inception built a base of 4M+ developers. In the community, HackerEarth is known for having conducted 1000+ and 10,000+ to date. hackathons programming challenges HackerEarth has raised $11.5 million in funding over three rounds[3]. Today, more than 750 customers worldwide use its technical coding assessments platform, including Amazon, Walmart Labs, Thoughtworks, Societe Generale, HP, VMware, DBS, HCL, GE, Wipro, Barclays, Pitney Bowes, Intel, and L&T Infotech.HackerEarth is backed by GSF Global and Angelprime. [6] 2.LEETCODE It’s a website where people–mostly software engineers–practice their coding skills. There are 800+ questions (and growing), each with multiple solutions. Questions are ranked by level of difficulty: easy, medium, and hard. Similar websites include HackerRank, Topcoder, InterviewBit, among others. There’s also a popular book, “Cracking the Coding Interview,” which some call the Bible for engineers. The Blind community uses a mix of these resources, but based on mentions, LeetCode seems to be the most popular. Our active users cite the following reasons for preferring LeetCode: more questions, better quality, plus a strong user base. EXPERT 1.CODEFORCES Codeforces is a website that hosts contests. It is maintained by a group of competitive programmers from led by Mikhail Mirzayanov. Since 2013, Codeforces claims to surpass Topcoder in terms of active contestants. As of 2018, it has over 600,000 registered users. Codeforces along with other similar websites are used by top sport programmers like Gennady Korotkevich, Petr Mitrichev, Benjamin Qi and Makoto Soejima, and by other programmers interested in furthering their careers. competitive programming ITMO University 2.CODECHEF CodeChef is a competitive programming community of programmers from across the globe. CodeChef was started as an educational initiative in the year 2009 by Directi, an Indian software company. Apart from its monthly coding contests for the community, CodeChef has many initiatives for Schools, Colleges and Women in competitive programming. CodeChef is credited with hosting the India regionals of the prestigious ICPC for college students, as well as for IOI for school students in India. In 2020, CodeChef’s custodianship was changed from Directi (founded by Bhavin Turakhia) to (Gaurav Munjal, CEO). CodeChef and its various initiatives have been managed and run by its Business Unit Head Anup Kalbalia. Unacademy CONCLUSION That's all for today. The coding levels are divided by me on my personal opinion. I have personally visited and tried problems on all these sites. Coding is like an art. It requires patience and hard work. Going step-by-step is the best method. ALL THE BEST AND KEEP CODING!

Coding Games and Websites to Help You Learn Programming

Whiteboard coding interviews can cost you a job wow this article did have quite a few claps, getting closer to 17k! I’m grateful to everyone who showed support! Just to give you an update, I’m now a software engineer at ASOS and could not be happier than this. Well actually I’ll be even happier in a few days, when my first kid will be born 😍I have many ideas for new articles, I will just need to find the time to write them. Want to get notified? is the best way! march 2019: Adding me on Twitter Recently I’ve been quite close to getting a job at one of the . I went through the screening process and the smoothly but I failed to pass one of the final stages, a set of one to one, or two to one, interviews: Big 5 take-home assignment : algorithms. Whiteboard coding interview Technical interview: , CS, React. JavaScript Culture fit: that. : this maybe in another article :P Second whiteboard interview It went wrong There are a few mistakes that contributed to this temporary debacle. I may have passed the technical test and the culture fit (let’s just assume that) but I admittedly performed badly at the whiteboard coding interviews. Thinking in retrospective about that day I couldn’t expect any different outcome.The truth is: . I’m not prepared to do whiteboard interviews Whiteboard interviews ( ) The whiteboard interview is, in some ways, a hybrid of a technical test of the depth of your knowledge and also a social exercise source We all know what it is, right? it’s not much about the code, it’s about your solving abilities, it doesn’t matter if etc etc… I’m a frontend developer, I generally don’t implement interview-like algorithms on the fly or articulate my thought process while I code, I sort of make interactive UIs most the time with algorithms. When I need to implement one that I didn’t use for a while, I just start researching. How much do these tests tell about a candidate anyway? even said: Someone In real life, you would rarely just whip up an off-the-cuff algorithm from memory in the middle of a coding session. You are almost always going to use an existing library, which has its own test suite, and has survived the scrutiny of other developers. The only world where you would actually need to be able to recall an algorithm would be a post-apocalyptic one, where the hard drives of all the computers connected to the internet were fried, and all copies of foundational academic papers and computer science textbooks had been reduced to ashes. My opinion tend to match the one of the aforementioned author although I like to believe that such a skill (being good at whiteboard interviews) is about having a set of very good to have other skills, soft and hard. Mitigating circumstances first I’ll make this list because you may relate to some of them but most of all I still have to vent a little bit 😄 I didn’t do the interview in my first language. Under the spotlight, it gets harder. I’m a self taught frontend developer. I lack an academic preparation. I didn’t do many interviews in my career. And not many of them had whiteboard interviews kind of tests. I don’t do much public speaking. Unfortunately, at the moment, not much. You could object that none of these are actually mitigating circumstances and you would be right. By definition, mitigating circumstances are out of our control: the truth is that I could , , , . improve my English do more CS do more interviews do more public speaking I’m gonna try to solve that first whiteboard test the way I should have done that day and I’m going to try to report the process here. The Test ['Tokyo', 'London', 'Rome', 'Donlon', 'Kyoto', 'Paris']

// YOUR ALGORITHM

[    [ 'Tokyo', 'Kyoto' ],    [ 'London', 'Donlon' ],    [ 'Rome' ],    [ 'Paris' ]] That’s it. If you rotate the letters of each city you may or may not match another city. In case you do, put them together in a array on their own. At work you’re escaping labyrinths of thousands of lines of code on a daily basis, how difficult is to show these people how to solve this simple and even kinda funny problem? Hold my beer. Yeah… Let’s pretend it went slightly differently. The perfect whiteboard interview Catchy paragraph title, although wrong. This is just the way I could have solved this test, both code and thought articulation. Who know how many other ways there are! thank you very much. I’ll gladly solve this problem for you (little bow) Me: First question, do the letters just ‘rotate’ or they can be randomly mixed up? Me: (to protect the privacy of the interviewers, I changed their name into a fancy one): Just rotate. First letter goes last, etc. Larry One at a time. IMPORTANT NOTE There are a few comments of people proposing their solution to this problem. First of all thank you, one day I’m gonna look at them all and do something with them :) But it’s not the point of the article to get the most performant solution out of this. Also please pay attention to my last question to the interviewer. Many skip this part when they comment with their solution: letters rotate If you do so, combinations like and would match: they shouldn’t. Tokyo matches only with: okyoT, kyoTo, yoTok, oToky. See? 5 letters, 5 possible combinations. There’s an hint for you there. Let’s continue. one by one. It’s not enough to .split and .sort the letters. tokyo yookt right. Me: right. Larry: Right! I guess to start I would need a way to rotate the letters of each city. Tokyo would became okyoT, then kyoTo, oh cool! we’ve got kyoto now! Ok, I’m going to need a function to do that. Me: I also need a way to loop through the input cities, ‘rotate’ the letters, do some matching and lastly grouping them together. I see that the input and the output are both arrays and they both contains the same values, the only difference is the depth of the two arrays, a flat one and an array of arrays. Me: I’m gonna write some pseudocode now to validate my thoughts. Later I’m going to test it too, cause I’m that good. 😏 Still me: function groupCitiesByRotatedNames(cities) {

  // use a variable to contain the output.  let output = [];

  // loop through each of the cities  //  rotate the name in any possible combination  //  check if the output contains a city that matches a combination  //   add that city to the array containing the match  //   otherwise add the city to the output as a new array

  return output;} Me, confident as a rockstar: let’s pseudotest my pseudocode (😛). const input = ["Tokyo", "London", "Rome", "Donlon", "Kyoto", "Paris"];

console.log(groupCitiesByRotatedNames(input));

// That's how it would build up. The final output would be the last array:

// [//     ["Tokyo"]// ]

// [//     ['Tokyo'],//     ['London']// ]

// [//     ['Tokyo'],//     ['London'],//     ['Rome']// ]

// [//     ['Tokyo'],//     ['London', 'Donlon'],//     ['Rome']// ]

// [//     ['Tokyo','Kyoto'],//     ['London', 'Donlon'],//     ['Rome']// ]

// [//     ['Tokyo','Kyoto'],//     ['London', 'Donlon'],//     ['Rome'],//     ['Paris']// ] Let’s start implementing this algorithm. First, the utility to rotate the letters of the city names. I will create a utility function: Me: let’s make this function a bit smoother (and less readable). Overconfidence at its peak. Right! I like the reduce method, I’m gonna use it again! (It’s also very functional-programmy so it’s cool to use in an interview 😎) Me: The method applies a function against an accumulator and each element in the array (from left to right) to reduce it to a single value ( ). **reduce()** MDN Our single value being the desired output. Let’s sum up what this algorithm does: We check for each city in the cities array, we rotate the name and we match every combination with the accumulator value. If we find something we add the new city to the array containing the matches (with ) otherwise we just a new array containing our new city. Array.splice push Et voila’: All together now! . Get the Gist here but this is what came to my mind that day.(It’s complexity is quadratic while you may want to solve it with an algorithm that takes linear time O(n)). This solution is not the best one My actual whiteboard interview I started from the solution. I said, ok, I’m gonna need a reduce method. I immediately approached the board to write actual code without really knowing the plan. I did have an idea of the solution, pretty much the one I wrote in the previous chapter, but I didn’t it, I didn’t really it consistently to my poor interviewers. So I got lost in the code, I lost the the train of my thoughts several times, I also stumbled on syntax errors, in a mix of poor written pseudocode and actual code. There was no way to turn the tide at this point. A performance like this can make a lot of damage to the outcome of the interviews, especially if you let this affect the rest of the process on your side. articulate explain What should I do now Practice, practice, practice. Get a whiteboard, pick a problem and talk out-loud to the air and write, do that a lot. Practice the whiteboard interview, learn the routine. Your routine, any routine. Learn it like a song on the guitar, a card trick or whatever dangerous stunt with your skate. You need to prepare a speech, it’s like a presentation. It’s like a presentation with variables. A variable is the problem. I’ll go like this: I’ll spend some time analysing the requirements (1 min) I’ll formulate questions if necessary and get answers (3 min). I’ll pause and think of a direction to take (few min, don’t be afraid to stay silent for a while). I will propose initial solutions and get feedback from the interviewers (5 min). I will pause again and choose a solution (2 min). I will write pseudocode (5 min) I will test my pseudocode (5 min) I’ll finish by transforming the pseudocode into actual code. (until necessary) In around 30 min I will have solved the problem in a enjoyable and ordinated way. Conclusion PS There is also an interesting discussion around this article here: https://dev.to/albinotonnina/how-to-lose-a-it-job-in-10-minutes-35pi Resources ! wrote a wonderful comment and she allowed me to paste here a list of resources that she put together following some whiteboard interviews. I found this list very very useful! Update Evana Mp She says: After this experience, I made a list of resources which I collected from many web Q&As related to this and in order of priority this is the list of books, sites, and courses I will be working with: Books: Cracking the coding interview Introduction to Algorithms Programming Interviews Exposed Clean code Algorithm Design Manual How to Think About Algorithms Programming Pearls Data Structures And Algorithms Made Easy In Java 2nd Edition 2nd Edition Websites: InterviewBit HackerRank Codewars Codefights AlgoExpert CarrerCup Interview Cake LeetCode Geeks for geeks Pramp HackerEarth HiredInTech Courses: Coderust 2.0 Thanks for reading And Thanks and for proof-reading this :) Adam Mackintosh Josh Comeau Hello, my name is Albino Tonnina, I’m a frontend engineer who does bad whiteboard interviews at the moment and works in London, you can find me on or or or around the city. Twitter Github Instagram My latest articles: Designers are from Saturn, developers are from Jupiter: or, why communication matters Speaking of web layouts…introducing the Magic Hat technique 🎩✨

Stories, News & Mentions about INTERVIEWBIT

Interviewbit’s Stories on HackerNoon

Interviewbit's News & Mentions