DEV Community: Ditikrushna Giri

Nearest Smaller Element on Left of an Array

Ditikrushna Giri — Sun, 13 Feb 2022 08:11:07 +0000

In this post, we are going to explore a very common question on Stack. The questions are the following ;

Nearest Smaller Element on Left

Let's assume we have given an array/vector/list with some elements and our job is to figure out the nearest smaller element on the left side of the array.
For instance :

let list = [ 4 , 10 , 5 , 8 , 20 , 15 , 3 , 12]
result = [-1 , 4 , 4 , 5 , 8 , 8 , -1 , 3]

And the smaller element of right side of an array

let list = [4 , 10 , 5 , 8 , 20 , 15 , 3 , 12]
result = [3 , 5 , 3 , 3 , 3 , 15 , 3 , 12 ]

We will see two ways to solve the problems :

Brute-force approach (using nested loops)

In this approach we will use two loops. Outer loop will iterate over all the array items and inner loop will iterate over all the next elements of currently pointed by outer loop. Inner loop will check, if any smaller element will be found then loop will be terminated and if smaller element is not found then -1 will be added as result.

function nearestSmallerToLeft(list) {
  let result = [];
  for (let indexOne = 0; indexOne < list.length; indexOne++) {
    let flag = false;
    for (let indexTwo = indexOne - 1; indexTwo > -1; indexTwo--) {
      if (arr[indexOne] > arr[indexTwo]) {
        result.push(arr[indexTwo]);
        flag = true;
        break;
      }
    }
    if (!flag) {
      result.push(-1);
    }
  }

  return result;
}

Time Complexity of the above solution would be O(n^2)
Space Complexity would be : O(1) as we are not using any extra space .

Using stack

In case of this approach, we are using a stack. and the approach would be to start traversing elements of the given array from the start i.e., leftmost element and we will be putting the smallest element in the stack and whenever we get another smaller element then pop the stack and push the new element. Basically, we will be using a stack to keep values available to the left side and which are the smaller ones.


class Stack {
    constructor(){
        this.stack = [] ;
    }

    isEmpty() {
        return this.stack.length === 0;
    }
    push(element){
        this.stack.push(element);
    }
    pop(){
        if(this.isEmpty()){
            throw 'Stack UnderFlow';
        }
        return this.stack.pop();
    }

    top(){
        if(this.isEmpty())
        throw null ;
        return this.stack[this.stack.length-1];
    }
}


function nearestSmallerToLeft(list){
    const stack = new Stack();
    let result = [];

    for(let index = 0 ; index < list.length ; index++){

        if(stack.isEmpty()){
            result.push(-1);
            stack.push(list[index]);
        }
        else if(!stack.isEmpty()){
            while(!stack.isEmpty() && list[index]<stack.top()){
                stack.pop();
            }

            if(stack.isEmpty()){
                result.push(-1);
            }else{
                result.push(stack.top());
            }
            stack.push(arr[index]);
        }
    }

    return result ;
}

Time complexity of the above solution would be O(n) And the space complexity O(n) as we are using extra space for stack .

A short note on database design process

Ditikrushna Giri — Sun, 31 Oct 2021 09:54:37 +0000

Step - 1
Requirements Gathering

Understanding what you want to do, and what you have is essential before you can dive into designing a database.

Step - 2
Conceptual Design

We specify the entities, columns, and their relationship. We may use an entity relationship (ER) diagram to visualize the database.

The output is: A conceptual schema (described using a conceptual data model like ER model).

Step - 3
Logical Design

It’s concerned about data model mapping; mapping a conceptual schema (like ER model) into logical schema to provide a much detail description.

The output is: A logical schema (described using a logical data model specific to the DBMS like relational model).

Step - 4
Physical Design

It describes the details of how data is stored. You start by defining (already modeled) tables, how the data is stored, define relationships, … in DBMS.
This requires dealing with the DBMS, and could involve SQL.

The output is: An internal (physical) schema (described using a physical data model).

Multi Thread Model

Ditikrushna Giri — Mon, 02 Aug 2021 11:10:09 +0000

In multi thread model the server assigned incoming request to the new thread . Similar as a client server architecture the user generate a request while interacting with the application and then send to the server .

The every times a new request comes in the server map a new thread from thread pool to the incoming request then the thread is responsible for process that request and sending back the response .

The number of thread is equal to the number of thread used from the thread pools .

Now , the thread present in the thread pools are limited to the based on the resource available .

If we look closely we will find the limitation of multi thread model . Suppose we have millions of request coming in per second are the thread present in the thread pools are limited number there will be situation where all the thread are exhausted from the thread pools in that situation a incoming request has to wait until a thread process the last request and return back the result .

This is a situation of scalability which could be resolve by adding more resource and creating more thread inside the thread pools .

Limitation of Multi Thread Model :

In multi-thread model , for every request server creates a separate thread which handles that request .
If a thread acquired a lock in the shared resource and it is 'exclusive lock ' it will block other threads .

Are you using the right CSS units?

Ditikrushna Giri — Fri, 12 Mar 2021 14:52:27 +0000

How to pick which CSS unit to use in which circumstance. I wish this was an easy question to answer but it really is one of those depends type of questions but in this case . It does actually depend on something more than others.

So, In this article, we are going to generalize the above questions.

Note: There is always an exception to pretty much all of these rules these are just rules of thumb.

Are you declaring a font size ?

You probably want to go with rem they are relative units but in the case of rem, they are relative to the font size of the root element which is our HTML element most of the time that defaults to 16 px. rem are better than using pixels because they adapt to the user's system and browser preference whereas if you use pixels you going to locks things in and you can overwrite the user's preferences.

Are you declaring a width ?

This is one of the harder ones to answer because there are so many different things that you might be a width on but for the most part a percentage is a nice direction to go on often coupled with a max-width. There are times also where a viewport width might be a good unit to use but it can cause some trouble or some unintended consequences. Another unit that could be a really good fit is the ch unit

Are you declaring padding or margin ?

For the most part, going with either em or rem for these. It depends on whether you want the padding or margin to be consistent despite the element that you are setting it on or if you want it to adjust based on that element's font size.

Are you declaring a height ?

A percentage, rem, or viewport height all are a good fit.

Note: This is an incomplete article. Soon I am going to add more insight on it. If you are up for contribution please add your thought in the comment box.

Happy Learning ;)

Introduction to Docker

Ditikrushna Giri — Thu, 11 Mar 2021 06:11:34 +0000

Introduction:

Can you recall how many times have you faced this issue that a code works on a developer system but the same code does not work on the tester system?

Docker at a very basic level resolves this issue of an application working on one platform and not working on some other platform. However, there is much more to Docker.

Where does docker come into the picture?

At a very high level the following steps are the stages of a software devlopment life cycle :

Design
Development
Deployment
Testing/Release

Docker comes into the picture at the deployment stage of the software development lifecycle.

Docker helps in making the process of application deployment very easy and efficient and resolves a lot of issues related to deploying applications.

What is Docker?

Docker is the worlds leading software container platform.

What does this mean? Let's understand in an easy way.

Today, we talk about software it is not a single piece of code. However, it is an entire software stack a typical software application will consist of a group of front-end, back-end, databases, servers, libraries, and other environment-dependent components and we also have to ensure that all these components work on our different and wide range of platforms

It becomes very complex to ensure that each of ours software components works on every possible platform where the application is expected to run.

How to solve this problem ?

To solve this problem let us look at a similar problem that existed many many years ago in the shipping industry and that was how to transport different goods having different size, shape and requirements to a different location of the world again the situations become very complex. So, how did the shipping industry solve the problem? they solved the problem by using containers. So, containers are the standard boxes where the goods can be packaged in the standard way. Container made the shipping of goods very easy, efficient, and very cheap. And this revolutionized the shipping industry.

Coming to our problem: it looks like we have a similar kind of solution and the solution is again using containers and using a standard way of shipping these containers and here comes Docker.

Docker is a tool designed to make it easier to deploy and run applications by using containers and Containers to allow a developer to package up an application with all of the parts it needs, such as libraries and other dependencies, and ship it all out as one package.

Now, you can imagine a developer will package all the software and its components into a box which we call a container, and Docker will take care of shipping this container to all the possible platform in a standard way and this is how we resolve the issue of an application working on one environment and not working another. And you can see there is a clear separation of concerns a developer will now really focus on creating the code and the software and will package the software along with all its dependencies into a container and will not worry about how this will be deployed on what all platform it has to be deployed and so on and docker makes this process of deploying software.

Happy Learning ;)

Events and Event Emitter in Node.js

Ditikrushna Giri — Wed, 10 Mar 2021 11:45:27 +0000

One of the core concepts of a node is the concept of events. In fact, a lot of nodes' core functionality is based on this concept of events.

Definition:
The event is basically a signal that indicates that something has happened in our applications.

Example :
In node, we have a class called HTTP that we can use to build a web server so we listen on a given port, and every time we receive a request on that port that HTTP class raises an event. Now our job is to respond to that event which basically involves reading that request and returning the right response.

Let's see how we can work with the event emitter:

Step-1:
let's load the events modules :

const  EventEmitter  =  require('events');

Note: In terms of naming the first letter of every word in uppercase this is a convention that indicates that this event emitter is a class, not a function or simple value.

When we call the require function we get the event emitter class. Now, we need to create an instance of this class. And that can be done with the following piece of code

const emitter = new EventEmitter() ;

This emitter has a bunch of methods use this link for all list of events that offer emitter class.

Even though we have more than ten methods most of the time we use only two of these methods one is emit that we use to raise an event. If you do not know the meaning of the emit: means making noise or produce something in our case we are going to making noise in our application. We are signaling that an event has happened.

emitter.emit('')

We pass an argument that is the name of the event let say messageLogged in the future we are going to extend our loger module and every time we log a message we are going to raise an event called message logged

Now , if we run the following codes nothing is going to append :

const EventEmitter = require('events')
const emitter = new EventEmitter();
emitter.emit('messageLogged');

because we have raised an event here but nowhere in our application we have registered a listener that is interested in that event.
Listener: is a function that will be called when that event is raised.

Let's register a listener that will be called when the message log event is raised for that we will use the on method and that takes two arguments first one will be the name of the event in our case messageLogged and the second one is a callback function or the actual listener.

const EventEmitter = require('events')
const emitter = new EventEmitter();
//Register a listener 
emitter.on('messageLogged',function(){
  console.log("Listener is called")
});
emitter.emit('messageLogged');

Note: The order is important here if you register listener after calling the emit method nothing would have happened because when we call the emit method the emitter iterates over all the registered listeners and calls them synchronously.

This is the basis of raising events and handling them using event emitter class.

Happy Coding ;)