DEV Community: Ankan Bhattacharya

Backend As A Service: A Beginner's Guide

Ankan Bhattacharya — Fri, 26 May 2023 03:26:24 +0000

After hearing the BaaS or Backend As A Service, the first thing that might come to your mind is "Leave BaaS, what the hack is even a backend?".

So, actually to answer your question & keep you away from the complexities of What is a backend?, actually this BaaS thing was developed. But to understand that, let's get a more in-depth look at What is a Backend?.

Backend

Going by the text-book backend is the place where data is processed and sanitised for a particular software. But in reality, it's much more. It contains authentication, payment systems & verification, image uploading, data accessing, etc. In short whenever you login to Google or search for something or maybe post an image on Instagram once you click the action button an HTTP request is sent over to a computer popularly known as cloud computer or cloud server where it processes some data and maybe stores something on the database and sends some data back that is showed to you. That might be an OK message or acknowledgement of something, etc.

This is the simplest representation of how a very simple app architecture works.

What was the problem?

Building a backend server on your own is quite a tough job because it needs features like authentication, efficient database interaction, and proper sanitised data processing and responses. Now, you can learn it and then implement it but it is always not very feasible especially if you are in a hurry of building a product or maybe you are simply a frontend developer and is much interested in the backend of things.

What's the solution?

The very simple solution can is if somebody can provide us with a service that would host the backend, databases, data processing, authentication, image buckets, rate limiting, etc that a robust and bulletproof backend should have. And simply the service that provides all these features is called a Backend As A Service (BaaS).

A BaaS can integrate with any type of app like a web app or mobile app & provide you SDKs or APIs to communicate and interact with them.

Main Features:

Seamless Integration.
No proper Backend experience is required.
Low Cost of maintenance.
Very Efficient.
Cross Platform Support.
A good-looking Admin Panel.

Benefits:

Now every frontend devs can be full-stack guys who can integrate the backend right out of the box.
Companies do not need to hire a dedicated backend dev for small apps or just prototypes.
Highly cost-efficient as you mostly pay for what you use.
Also you need not maintain your own infrastructure.
The code that runs behind these services is highly efficient, reliable and secure.

Some downsides:

Not very good for very complex projects where you have a ton of Microservices along with some messaging queues and various databases.
Some BaaS also have a vendor lock-in system i.e., once you start using it you cannot move out & for complex use cases they can be really expensive. If you wanna know more about vendor lock-in you can comment down below.
Database relationships like relational queries can be difficult at times.

Some very popular BaaS:

Firebase
AWS Amplify
Appwrite (Kinda Open Source Source alternative to Firebase but also has a hosted version currently in Beta)
Supabase
Pocketbase (Open Source alternative to Firebase written in Golang and powered by SQLite database).

BONUS:

Appwrite is organising a Hackathon. Visit here to know more. Also, I might bring some tutorials on how to use BaaS in your projects if you ask for them in the comment section.

If you found something useful make sure to drop a ❤️. And 👋 for now...😃😃

Majority Element (Leetcode)

Ankan Bhattacharya — Wed, 26 Oct 2022 06:01:16 +0000

Problem Statement

Given an array nums of size n, return the majority element.

The majority element is the element that appears more than ⌊n / 2⌋ times. You may assume that the majority element always exists in the array.

Approach

The problem statement states that we need to find the majority element or the element that has the highest frequency in the array. But also the frequency of that element needs to be more than the half of the length of the array.

Here one of the naive approaches can be using a hashmap. Just store the frequencies in a key value pair format, and then loop over the hash map & detect the most frequent element. This approach would give a time complexity of O(n) and a space complexity of O(n).

Here kicks in a better algorithm popularly known as Boyre-Moore's Voting Algorithm. The algorithm states:

First take a candidate element and initiate a count as well.
Now the next step is to loop over the array.
While looping if the element is equal to the candidate, we increment the count by one, else we decrement the count by one.
And if at any point the count reaches 0, then we update the candidate with the current element.
Finally at the end if we want to verify, then we can count the frequency of the final candidate and check if its frequency is more than the 1/2 the length of the array.

Time Complexity of this approach is O(n) but the space complexity is O(1) which is quite an improvement.

Intuition

First let's consider an array:

[3, 3, 3, 2, 2]

Now if we start counting the elements then at the end we would be having candidate as 3 and the count as 1. This proves that if there is a majority element then at the end one element with count at least one would definitely remain as the final result as the number of that majority element is greater than half the length of the array.

Code

function majorityElement(nums: number[]): number {
    let candidate = nums[0];
    let currentCount = 0;

    for(let i=0; i<nums.length; i++){

        // * According to moore's algorithm if value at current position is equivalent to candidate, we increment the currentCount
        if(candidate === nums[i]){
            currentCount++;
        }
        //  * According to moore's algorithm if value at current position is not equivalent to candidate, we decrement the currentCount
        else {
            currentCount--;
        }

        // * If the currentCount is equal to 0 we update the candidate as the number at current position also we increment the currentCount
        if(currentCount === 0){
            candidate = nums[i];
            currentCount++;
        }
    }

    // * NOTE: According to Moore's algo, if the currentCount is less than or equal to zero, we can conclude that no majority element exists in the array.

    let candidateCount = 0;

    // * We just verify here that the count of the selected candidate is actually greater than half of length of the array.
    for(let i of nums){
        if(i === candidate) candidateCount++;
    }

    if ((candidateCount) <= (nums.length / 2)) return -1;

    return candidate;
};

Result

Conclusion

If you have gained or learned anything from the above given explanation do not forget to give a like ❤️ to the post. Follow me for more such posts and also my social handles are given in my profile, reach me out there.

Square Root of A Non-Negative Integer (Leetcode)

Ankan Bhattacharya — Wed, 26 Oct 2022 04:48:30 +0000

Problem Statement

Given a non-negative integer x, compute and return the square root of x.

Since the return type is an integer, the decimal digits are truncated, and only the integer part of the result is returned.

Note: You are not allowed to use any built-in exponent function or operator, such as pow(x, 0.5) or x ** 0.5.

Approach

First of all the problem statement says we need to find the square root of a number in an integer format without using a built in function like sqrt().

So, if we think a bit intuitively, we can deduce that square of a number cannot be more than half of that integer.

Now as we know the above given fact, one of the approaches would be iterating over each and every number from 1 till ceil(number / 2). And finding out the num whose square is nearest, yet not more than the given number. This approach would have a time complexity of O(n).

But we might just have a better approach than this using an algorithm popularly known as binary search.

Steps of solving the problem using binary search:

First of all if the passed number is lower than 0 then return -1, else if its less than or equal to 1 then return the number itself.
Now take a lower bound of 1 and upper bound as 2 is the number is 2 else ceil(number / 2). Also initiate a sqrt variable with -1 that will keep the track of nearest possible square root.
After this run a util lower bound <= upper bound.
- Now find the mid value by using a formula mid = lb + floor((ub - lb) / 2).
- Check if mid * mid == number and if so set sqrt to mid and break the loop.
- If the mid * mid < number, we can say that it might be the number that we were searching for so we will set sqrt to mid but we also know that we might find a bigger number whose square could be equal or closer to the given number. So we will set the lb = mid + 1 hence reducing our search area.
- Else we know that we need to find a smaller number than this and hence we make ub = mid - 1.
Finally return the sqrt as the square root of the number.

Time complexity of the above given approach is O(log n).

Code

Here we have Typescript to implement the above given approach. But you can obviously use your own favourite language.

function mySqrt(num: number): number {
    if(num < 0 || !Number.isInteger(num)) return -1;

    if(num <= 1) return num;

    let lb = 1;
    let ub = num === 2 ? num : Math.ceil(num / 2);

    let sqrt = -1;

    while(lb <= ub){
        const mid = lb + (Math.floor((ub - lb) / 2));

        if((mid * mid) === num) {
            sqrt = mid;
            break;
        }

        else if ((mid * mid) < num) {
            sqrt = mid;
            lb = mid + 1;
        }

        else ub = mid - 1;
    }

    return sqrt;
}

Result

Single Number

Ankan Bhattacharya — Tue, 15 Feb 2022 09:46:06 +0000

Problem Statement

Given a non-empty array of integers nums, every element appears twice except for one. Find that single one.

You must implement a solution with a linear runtime complexity and use only constant extra space.

Approach

First if there are no elements in the list return None.
Keep track of numbers occurring once in singleSet and multiple times in multipleSet.
Now go over each element in singleSet, and return the first element in singleSet.

Algorithm

Code

class Solution:
    def singleNumber(self, nums: list[int]) -> int:
        if len(nums) < 1: return None

        singleSet: set = set()
        multipleSet: set = set()

        startingPoint: int = 0
        endingPoint: int = len(nums) - 1

        while startingPoint <= endingPoint:
            if nums[startingPoint] in singleSet:
                singleSet.remove(nums[startingPoint])
                multipleSet.add(nums[startingPoint])

            elif nums[startingPoint] not in multipleSet:
                singleSet.add(nums[startingPoint])

            if startingPoint == endingPoint:
                startingPoint += 1
                endingPoint -= 1
                continue

            if nums[endingPoint] in singleSet:
                singleSet.remove(nums[endingPoint])
                multipleSet.add(nums[endingPoint])

            elif nums[endingPoint] not in multipleSet:
                singleSet.add(nums[endingPoint])

            startingPoint += 1
            endingPoint -= 1

        for num in singleSet:
            return num

        return None

Leetcode Result

So that's it... make sure if you liked the post and got to learn something, like the post and follow us. If you want me to improve at some point... leave that in the comment...

Happy Number

Ankan Bhattacharya — Thu, 10 Feb 2022 18:48:42 +0000

Problem Statement

Write an algorithm to determine if a number n is happy.

A happy number is a number defined by the following process:

Starting with any positive integer, replace the number by the sum of the squares of its digits.
Repeat the process until the number equals 1 (where it will stay), or it loops endlessly in a cycle which does not include 1.
Those numbers for which this process ends in 1 are happy.
Return true if n is a happy number, and false if not.

Approach

First of all we need to check if the number is already 1. If it is so, return True.
Now if it is not so we dedicate a list of numbers to keep the track of the numbers that we already visited. If we visit them again, naturally we are in a loop and we cannot visit 1. Hence return False.
Else its obvious we will visit 1 and one we hit 1 return True.

Algorithm

Code

class Solution:
    def isHappy(self, n: int) -> bool: 
        #Check if the number is already 1 
        if n == 1: return True

        numArray: list[int] = []

        #Now loop through until the number becomes 1 or it is in numArray
        while n not in numArray:
            numArray.append(n)
            tempNum: int = 0

            while n > 0:
                tempNum += ((n%10) * (n%10))
                n //= 10

            if tempNum == 1: return True

            n = tempNum

        #If this statement hits, then it's a false
        return False

Leetcode Result

So that's it... make sure if you liked the post and got to learn something, like the post and follow us. If you want me to improve at some point... leave that in the comment...

Max Level Sum of A Binary Tree

Ankan Bhattacharya — Sat, 05 Feb 2022 10:31:33 +0000

Problem Statement:
Given the root of a binary tree, the level of its root is 1, the level of its children is 2, and so on.

Return the smallest level x such that the sum of all the values of nodes at level x is maximal.

Approach

This was a problem which had some quite interesting solving... In this approach I used a BFS. I took one row at a time found its sum and compared it with the previous sum. If its greater than the previous one then I replaced the max Level with the current Level. Finally at the end of the looping I returned the max Level.

Algo Images

Code

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

class Solution:
    def maxLevelSum(self, root: TreeNode) -> int:
        if root == None: return None

        currentLevel: int = 1
        maxLevel: int = None
        maxSum: int = None

        BFSQueue: list[TreeNode] = [root]

        while len(BFSQueue) > 0:
            currentLength: int = len(BFSQueue)
            currentSum: int = 0

            for i in range(currentLength):
                currentNode: TreeNode = BFSQueue.pop(0)
                currentSum += currentNode.val

                if currentNode.left != None: BFSQueue.append(currentNode.left)
                if currentNode.right != None: BFSQueue.append(currentNode.right)

            if (maxSum == None) or (maxSum < currentSum):
                maxSum = currentSum
                maxLevel = currentLevel

            currentLevel += 1

        return maxLevel

Result Image

If you got to learn something from this post make sure you like the post and click on the follow button for more such content.
Also if you have some suggestions and want to improve it make sure you comment down below...