HackerRank Solution: Classes - Dealing with complex numbers Python

Question: Dealing with complex numbers – Hacker Rank (Python Classes)

For this challenge, you are given two complex numbers, and you have to print the result of their addition, subtraction, multiplication, division, and modulus operations.
The real and imaginary precision parts should be correct up to two decimal places.

Input Format:

One line of input: The real and imaginary part of a number separated by a space.

Output Format:

• C + D
• C - D
• C * D
• C / D
• Mod(C)
• Mod(D)

For complex numbers with non-zero real (A) and complex part (B), the output should be in the following format:
A + Bi
Replace the plus symbol (+) with a minus symbol (-) when B < 0.

2 1
5 6

7.00+7.00i
-3.00-5.00i
4.00+17.00i
0.26-0.11i
2.24+0.00i
7.81+0.00i

__add__-> Can be overloaded for + operation

__sub__ -> Can be overloaded for - operation

__mul__ -> Can be overloaded for * operation

Possible solutions

Now let us move toward the solutions. We will try to solve the problem using two different methods.

Solution-1: Using if-else statements

Here is one possible solution for the question python classes: dealing with complex numbers using if else statement:

import math

# Defining the class
class Complex(object):
    def __init__(self, real, imaginary):
        self.real = real
        self.imaginary = imaginary
        
    def __add__(self, no):
        return Complex(self.real + no.real , self.imaginary + no.imaginary)
        
    def __sub__(self, no):
        return Complex(self.real - no.real , self.imaginary - no.imaginary)       
        
    def __mul__(self, no):
        prod = complex(self.real , self.imaginary)*complex(no.real , no.imaginary)
        return Complex(prod.real , prod.imag)

    def __truediv__(self, no):
        div = complex(self.real , self.imaginary)/complex(no.real , no.imaginary)
        return Complex(div.real , div.imag)


    def mod(self):
        m = math.sqrt(self.real**2 + self.imaginary**2)
        return Complex(m,0)

    def __str__(self):
        if self.imaginary == 0:
            result = "%.2f+0.00i" % (self.real)
        elif self.real == 0:
            if self.imaginary >= 0:
                result = "0.00+%.2fi" % (self.imaginary)
            else:
                result = "0.00-%.2fi" % (abs(self.imaginary))
        elif self.imaginary > 0:
            result = "%.2f+%.2fi" % (self.real, self.imaginary)
        else:
            result = "%.2f-%.2fi" % (self.real, abs(self.imaginary))
        return result
if __name__ == '__main__':
    c = map(float, input().split())
    d = map(float, input().split())
    x = Complex(*c)
    y = Complex(*d)
    print(*map(str, [x+y, x-y, x*y, x/y, x.mod(), y.mod()]), sep='\n')

The __init__ method is the constructor of the class. The __add__ method overloads the + operator and returns a new Complex object that represents the sum of the two complex numbers. The __sub__ method overloads the - operator and returns a new Complex object that represents the difference between the two complex numbers.

Solution-2:

Here is another possible solution for the same problem.

import math
class Complex:
    def __init__(self, real, img):
        self.r = real
        self.i = img

    def __str__(self):
        return f'{self.r:.2f}{self.i:+.2f}i'

    def __add__(self, other):
        return Complex(self.r + other.r, self.i + other.i)

    def __sub__(self, other):
        return Complex(self.r - other.r, self.i - other.i)

    def __mul__(self, other):
        real = self.r * other.r - self.i * other.i
        img = self.r * other.i + self.i * other.r
        return Complex(real, img)

    def __truediv__(self, other):
        a, b = self, other
        real = (a.r*b.r + a.i*b.i) / (b.r**2 + b.i**2)
        img = (b.r*a.i - a.r*b.i) / (b.r**2 + b.i**2)
        return Complex(real, img)

    def mod(self):
        # by the way modulus is not a complex num
        return Complex(math.sqrt(self.r ** 2 + self.i ** 2), 0)

if __name__ == '__main__':
    c = map(float, input().split())
    d = map(float, input().split())
    x = Complex(*c)
    y = Complex(*d)
    print(*map(str, [x+y, x-y, x*y, x/y, x.mod(), y.mod()]), sep='\n')

The __init__ method is the constructor of the class. It takes two arguments, real and img, and sets them as the instance variables self.r and self.i respectively. The __str__ method returns a string representation of the complex number in the required format, with a precision of 2 decimal places. The __add__ method overloads the + operator and returns a new Complex object that represents the sum of the two complex numbers. The __sub__ method overloads the - operator and returns a new Complex object that represents the difference between the two complex numbers.

Summary

In this article, we solved the "Classes: Dealing with complex numbers" using classes on HackerRank. We solved this problem using two different methods as given above.

Further Readings

Question on Hacker Rank: Classes: Dealing with Complex Numbers