Forem: Alim Mohammad

Token Types Explained 🔑

Alim Mohammad — Mon, 19 Jan 2026 05:11:06 +0000

1. Access Token

What it is: A short-lived token (usually 15-30 mins) that grants access to protected endpoints.

User logs in → Gets access token → Uses it for 30 mins → Token expires → Must login again

Problem: User has to login again every 30 minutes! 😤

2. Refresh Token (🆕 To Implement)

What it is: A long-lived token (days/weeks) used ONLY to get new access tokens.

Why needed: Better user experience - they stay logged in without re-entering password.

Flow:

┌──────────────────────────────────────────────────────────────────────┐
│ │
│ LOGIN │
│ ────── │
│ User sends email + password │
│ ↓ │
│ Server returns: │
│ • access_token (expires in 30 min) │
│ • refresh_token (expires in 7 days) │
│ │
├──────────────────────────────────────────────────────────────────────┤
│ │
│ USING THE API (for 30 mins) │
│ ─────────────────────────── │
│ User sends: Authorization: Bearer │
│ Server: ✅ Allowed │
│ │
├──────────────────────────────────────────────────────────────────────┤
│ │
│ ACCESS TOKEN EXPIRES (after 30 mins) │
│ ───────────────────────────────────── │
│ User sends: Authorization: Bearer │
│ Server: ❌ 401 Unauthorized - Token expired │
│ │
│ User sends: POST /api/v1/users/refresh │
│ Body: {"refresh_token": "..."} │
│ Server: ✅ Returns NEW access_token (valid for another 30 min) │
│ │
├──────────────────────────────────────────────────────────────────────┤
│ │
│ REFRESH TOKEN EXPIRES (after 7 days) │
│ ───────────────────────────────────── │
│ User must LOGIN AGAIN with email + password │
│ │
└──────────────────────────────────────────────────────────────────────┘

3. Grant Token (OAuth2 Concept)

What it is: Part of the OAuth2 "Authorization Code Flow" - used when logging in via Google, GitHub, etc.

You probably DON'T need this unless you're implementing "Login with Google".

Flow:

User clicks "Login with Google"
↓
Google shows consent page
↓
User approves
↓
Google redirects back with a "grant code"
↓
Your server exchanges grant code for access_token

Shadowing in JavaScript

Alim Mohammad — Wed, 28 Aug 2024 06:10:02 +0000

Overview

Shadowing in a special concept in JavaScript that makes the methods belonging to the parent class redefinable in the child class.

Let us go with two of the darling games of 21st century which are pretty easy to guess, GTA and Red Dead Redemption, unless you are not a fan of open world bangers.

Back to our topic, I will give GTA the role of Parent Class and RDR takes the Child Class spot.

Code

class GTA {
  constructor() {
    this.openWorld = {};
  }

  addFeature(feature, value) {
    this.openWorld[feature] = value;
    return this.openWorld[feature];
  }
}

class RDR extends GTA {
  addFeature(feature) {
    super.addFeature(feature, true);  // Calls the parent class' method and adds the feature
    return true;
  }
}

var role = new RDR();
console.log(role.addFeature('ROLE_PLAYER'));  // This will return true
console.log(role.openWorld);  // This will now have 'ROLE_PLAYER' added to it with value true

Explanation:

super.addFeature(feature, true) calls the addFeature method in the GTA class, adding the feature to the openWorld object.

The addFeature method in RDR returns true, but it also ensures that ROLE_PLAYER is added to the openWorld object.

Closing Note

Looks like ROLE_PLAYER just rode into the wild open world with a value of true. Hope they're ready for the bugs they'll encounter—it's an open-world game, after all!

Why you should use Winston for Logging in JS

Alim Mohammad — Wed, 05 Jun 2024 05:17:26 +0000

Logging with Winston in JS

Winston JS is a popular open-sourced Javascript logging library used to write logs in code with support extending upto multiple transport. A transport helps the log to be present at multiple levels, be it storage at database level but logs on the console.

The transports can be either console, database, files or remote servers making it highly flexible to get logs as per the requirements. The core transports that are part of Winston are Console, File and HTTP while there is option to write logs in third-party transports like MongoDb, CouchDb and Redis. The additional transports are written by the members of Winston Community.

Moreover, there are different levels of a logger, set up in order of their priority in ascending order, specified by proposed standard of RFC 5424 in 2009.

Pictorial Representation of Levels

Setting Up Winston on Machine

Winston is available on npm to download and it is available to use on-the-go for those are looking for logging solution in their project.

npm i winston

Upon successful installation of winston, we can proceed further with importing the library in our project to use it when required. It will be imported and automatically an object will be created that will come into use to access methods and attributes which are part of the object.

const winston = require('winston');

Creating First Logger

Once we are set up with installation and import part of Winston, we can proceed with creating our logger. We have a function at our disposal that is assist in creating a logger with all the necessary properties feeded in the passed object.

const logger = winston.createLogger({
  transports: [
    new winston.transports.Console(),
    new winston.transports.MongoDB({
        "db" : "mongodb://localhost/user"
    })
  ]
});

As mentioned in the above code, logger is created with set of transports given in an array, however in program, transports can be added, removed or clear as per developers requirement.

const file = new winston.transports.File({ filename: 'combined.log' })
logger
  .clear()          // Remove all transports
  .add(file)     // Add file transport

Implementing Winston for Logging in a File

To obtain error logs in a file transport, we would be taking example of a full-fledged backend application based on Route-Controller-Service-Model Architecture.

Initial step comprises of creating a file transport in the index.js file.

winston.add(winston.transports.File, { filename: "root.log"})

Now that we have our transport setup for the file named root.log to get the logging performed. We wireframe the connectivity in routing file named route.js.

const express = require("express");
const app = express();

app.get('/', ()=> {
    throw new Error("Logging Error to the File");
})

Lastly, the invoking of error is performed that appends the error log to the file.

module.exports = (err, req, res, next) => {
    winston.error(err.message, err);
    res.status(500).send("Crashed into error");
}

Implementing Winston for Logging in a MongoDB Collection

On instances, we come across errors that we fancy storing in our database instead of writing them to out files or console. We can move to store them as a MongoDB document in our collection specified.

An additional winston-mongodb package is needed to work with the database.

npm i winston-mongodb

Similar to logging in a file, create a MongoDB transport in the index.js file.

winston.add(winston.transports.MongoDB, { db: "mongodb://127.0.0.1/test"})

The code for route and error logging can be the same as mentioned in section for logging for file but results can be altered on the basis of level provided and transport method picked.

Takeaways

Winston is used to log errors.
Winston offers multiple transport, place where log is stored.
Winston offers flexibility when it comes to writing logs.
Core transports that are bundled with Winston are Console, File and Http.
Third-party transports includes MongoDB, Redis etc.
Transports can be cleared, added or removed.
Levels can be set for log o

Breaking Down Redux

Alim Mohammad — Thu, 12 Oct 2023 10:20:19 +0000

Redux might be the hot catchword used with React or in general MERN based applications, highlighted as the goto state management tool.

Before moving further, it becomes a priority to understand what actually is a state. State can be defined as a simplistic JS Object that holds information accessible to all the components in an application.

Example - State

state = { username: '', password: '', result: '', status: 1 }

Features of Redux

Transparent: Redux is transparent in a sense that all the information the state holds must me explicitly available to other components of the application. In programmatic words, it is indeed 'global', that must make pretty clear top understand the purpose of Redux.
Independent: Redux does not require a user interface to rely on thus, giving the developer an independent experience.
Supportability: Redux has a toolkit named react-redux that is built on top of both the libraries and provides an abstract layer over redux to make the job easier for developer community.
Easy to learn: Being a newbie with a mountain of terminologies can be daunting but with more practice and understandability, redux ( or redux toolkit ) can be learned gradually.

Integrating Payment Gateways in MERN Applications

Alim Mohammad — Sun, 21 May 2023 21:08:26 +0000

In this article, we will be learning about integrating payment gateways in MERN applications as payment options that need to be available for the sake of e-commerce support.

There can be suitable options for payments such as Razorpay or Stripe. Let us get started with the tutorial:-

Working of Payment Gateway
Firstly, we understand how the payment mechanism works in MERN Stack along with an illustration.

When a user clicks on the Buy Option on an E-Commerce website, the product ID is passed to the server, the product price is checked and sent to the Razorpay API and an order ID is generated in the response.

The order ID is passed for the confirmation of the order. Upon completion of payment, Razorpay generates Payment ID, Order ID, Timestamp and Signature.

The details generated are verified on our server to make sure the payment is completed successfully.

Easy Steps to Integrate Payment Gateway using MERN

The first step is to create a Razorpay account where you can sign yourself up or log in to your existing email filling up the necessary details until the Razorpay dashboard pops up on your screen.
Keep in mind that if you are doing it for learning purposes, select Test Mode from Top Right.
Head over to Settings~>API Keys~> Generate Test Keys.
Once the keys are generated, copy and paste them into a blank text/document file and minimize the file.
Open command-> Create folder and cd folder navigate to the folder. Once we are done performing this, we create a folder named ‘server’ by writing ‘mkdir server’ and navigate inside.

Next, to create the node app we fire the command npm init which creates your web app with settings.
Later the npm i express dotenv razorpay cors command is written to install all the dependencies required for integrating the payment gateways app.
Now you can open the folder in vscode by writing ‘. code’.
Now we have to create an index file that we will import the necessities and work on routing.
The code given below can help you in integrating payment gateways into your MERN application.


const express = require("express");
const cors = require("cors");
const dotenv = require("dotenv");
const paymentRoute = require("./routes/payments");
//Initialize App
const app = express();


// Setting up enivronment variables
dotenv.config();

//Middlewares
app.use(express.json());
app.use(cors());

//Routing
app.use("/api/payment/",paymentRoute);

//Listening App
const port = process.env.PORT || 8080;
app.listen(port,()=> console.log(`Listening port ${port}`));

Now we will be creating a folder named routes in the root directly that comes in handy in importing the payment file. The payment file consists of the two APIs that are required for creating the order and verifying the order.

The given snippet explains the following:-

const router = require("express").Router();
const Razorpay = require("razorpay");
const crypto = require("crypto");

//Creating Order
router.post("/orders",async(req,res) => {
    try {
        const instance = new Razorpay({
            key_id: process.env.KEY_ID,
            key_secret: process.env.KEY_SECRET,
        });

        const options = {
            amount: req.body.amount * 100,
            currency:"INR",
            receipt:crypto.randomBytes(10).toString("hex"),
        }
        instance.orders.create(options,(error,order) => {
            if(error) {
                console.log(error);
                return res.status(500).json({message:"Something Went Wrong!"});
            }
            res.status(200).json({data:order});
        });

    } catch(error) {
        console.log(error);
        res.status(500).json({message:"Internal Server Error!"});
    }

});

//Verifying the payment
router.post("/verify",async(req,res) => {
    try {
        const {
            razorpay_orderID,
            razorpay_paymentID,
            razorpay_signature } = req.body;
        const sign = razorpay_orderID + "|" + razorpay_paymentID;
        const resultSign = crypto
        .createHmac("sha256",process.env.KEY_SECRET)
        .update(sign.toString())
        .digest("hex");

        if (razorpay_signature == resultSign){
            return res.status(200).json({message:"Payment verified successfully"});
        }

    } catch(error) {
        console.log(error);
        res.status(500).json({message:"Internal Server Error!"});
    }
});

module.exports = router;

We have successfully completed the backend portion of our app. Now create a react app in our root folder with npx create-react-app payapp and install axios by npm i axios for calling APIs.

Setting up the Front End for our Web App

Once we are done with the backend portion, we will switch to the creation of the front end which is going to be a sample e-commerce shoe store.

Open React App in your preferred code editor and paste this checkout page link as a script in index.html ->https://checkout.razorpay.com/v1/checkout.js

On setting up with our react app, we implement useState in react to create a shoe sample for our payment integration with Razorpay. The code looks something like this for App.js.

import axios from "axios";
import {useState} from "react";
import "./App.css";

function App() {
  const [shoe,setShoe] = useState({
    name: "Training Shoes",
    creator: "Nike",
    img: "https://images.pexels.com/photos/3490360/pexels-photo-3490360.jpeg?auto=compress&cs=tinysrgb&dpr=1&w=500",
    price: 500,
});

const initPay = (data) => {
  const options = {
    key : "************************",
    amount: data.amount,
    currency: data.currency,
    name: shoe.name,
    description: "Test",
    image:shoe.img,
    order_id: data.id,
    handler: async (response) => {
      try {
        const verifyURL = "https://localhost:8080/api/payment/verify";
        const {data} = await axios.post(verifyURL,response);
      } catch(error) {
        console.log(error);
      }
    },
    theme: {
      color: "#3399cc",
    },
  };
  const rzp1 = new window.Razorpay(options);
  rzp1.open();
};

const handlePay = async () => {
  try {
    const orderURL = "https://localhost:8080/api/payment/orders";
    const {data} = await axios.post(orderURL,{amount: shoe.price});
    console.log(data);
    initPay(data.data);
  } catch (error) {
    console.log(error);
  }
};

  return(
  <div className="App">
    <div className="shoe_container">
      <img src={shoe.img} alt="shoe_img" className="shoe_img" />
      <p className="shoe_name">{shoe.name}</p>
      <p className="shoe_creator">By {shoe.creator}</p>
      <p className="shoe_price">Price: {shoe.price}</p>
      <button onClick={handlePay} className="buyBtn">Buy Shoes</button>
    </div>
  </div>
  );
}

export default App;

On applying styling to the className in App.css, the sample frontend looks something like this with the handlePay async function calling the API and making the integrating payment gateways in MERN application successful.

Finally, we go to the terminal in the node project folder and node index.js, in the result of which if we click on buy now, we get an integrated payment gateway somewhat like this.

Testing and Debugging in MERN Applications

Alim Mohammad — Fri, 12 May 2023 08:04:41 +0000

Testing and Debugging in MERN Applications

In this article, Testing and Debugging in MERN Applications and the different techniques we can implement them are discussed. During the production of a project in an organization, there are various repetitive phases to ensure it performs efficiently in the absence of any bugs or anomalies. Also, we will discuss what technologies one must have under the sleeves to excel at testing and debugging.

Writing Unit Tests

You should follow the standard way of writing unit tests for modules and components present in your MERN application. The availability of numerous unit testing frameworks such as Mocha, Jest and Jasmine can be used to write unit tests.

Let us look at an example where components fetch data from an API, displays it and the unit test code verifies if the correct data is displayed on the user's end. We perform the unit test code below using Jest.

import React from 'react';
import { render } from '@testing-library/react';
import MyComponent from './MyComponent';

test('renders data correctly', () => {
  const data = { name: 'John', age: 30 };
  const { getByText } = render(<MyComponent data={data} />);
  const nameElement = getByText(/John/);
  const ageElement = getByText(/30/);
  expect(nameElement).toBeInTheDocument();
  expect(ageElement).toBeInTheDocument();
});

Using a Debugger

When facing issues with code, you can move to debuggers tools like Chrome DevTools, NodeJS Debugger or VSCode debugger that will help you know the issues in your code. Explore features like Browser Inspect, setting up breakpoints or examining the variables to utilise the debugging tools well.

Given below is the request timeout issue we have with our API that can be resolved using NodeJS debugger tool.

function getUsers(req, res) {
  // This API endpoint returns a list of users
  const users = [/* ... */];
  // Simulate a slow request that times out
  setTimeout(() => {
    res.json(users);
  }, 10000);
}

// Use the debugger to step through the code
debugger;
app.get('/users', getUsers);

Checking Logs

Logging is another way to find the issues in your code. Morgan and Winston are some of the important tools that are used to log information in your MERN application.

Below is one of the examples where we used Winston to log in order to get rid of the glitch where user session is expiring earlier than expected.

const winston = require('winston');

function handleUserSession(req, res) {
  const userId = req.session.userId;
  const sessionExpiresAt = req.session.expiresAt;
  const currentTime = new Date().getTime();
  if (currentTime > sessionExpiresAt) {
    // Session has expired
    winston.error(`User session expired for userId=${userId}`);
    req.session.destroy();
    res.sendStatus(401);
  } else {
    // Session is still valid
    res.sendStatus(200);
  }
}

Error handling middleware
ExpressJS is a framework that is credible for the usage of error-handling middleware in MERN applications. It catches and handles the exception in code, logs the error and returns the error messages back to the user.

In the following example, the API returns an error that does not gives a description, here the express middleware can be used as follow:

function handleError(err, req, res, next) {
  // Log the error
  winston.error(`Error: ${err.message}`);
  // Return an error message to the client
  res.status(500).json({ error: 'Internal server error' });
}

app.use(handleError);

API Testing

To test if your API endpoints are working correctly for hassle-free passage of data, tools like Postman and Insomnia can be used.

For example, you have an API endpoint that fetches some data from the database, here Postman can be used to test the endpoint if it is returning the data correctly.

GET http://localhost:3000/users

UI Testing

To identify the issues persisting in the UI components, testing can be performed with the help of tools like Jest, Enzyme and Cypress.

In the following example, we used Enzymen UI testing to test the component if it is being rendered properly using the keyword ‘expect’.

import React from 'react';
import { shallow } from 'enzyme';
import UserList from './UserList';

test('renders user list correctly', () => {
  const users = [{ name: 'John', age: 30 }, { name: 'Mary', age: 25 }];
  const wrapper = shallow(<UserList users={users} />);
  expect(wrapper.find('li')).toHaveLength(2);
  expect(wrapper.find('li').at(0).text()).toEqual('John (30 years old)');
  expect(wrapper.find('li').at(1).text()).toEqual('Mary (25 years old)');
});

Miscellaneous Uses

Among the methods discussed for Testing and Debugging of MERN applications, there are certainly more tools that we can follow to do the same such as:-

Linting can be used to catch and fix syntax errors and related issues. ESLint is one of the primary examples to perform linting.

Git and similar version control software can be used for branching and tracking the changes to the code. It can be used to move back to the already existing or previous versions of the software.

Monitoring tools like New Relic, and App Dynamics can be utilized to detect issues or check if the application performance is up to the mark.

Conclusion

In this article, we studied what is testing and debugging in MERN applications and how we can perform them. We also discussed the methods we can perform them such as unit tests, using a debugger or logger or testing our API, UI and similar methods.

Building RESTful APIs using MERN

Alim Mohammad — Wed, 10 May 2023 22:42:42 +0000

Building RESTful APIs using MERN

In this article, we will learn how to build RESTful APIs with MERN as API endpoints which is crucial to the functioning of a full-stack application. We will be making them from scratch with an explanation.

MERN is a popular web development stack used to build websites and webpages comprising services such as Database, Backend and Frontend. The main programming language used in this tech stack is Javascript, which helps in creating applications that are dynamic in nature.

How to build RESTful APIs in MERN stack

Firstly, let us get started with building APIs by installing all the required needs and dependencies that must be present on our system. In our next step, we have to install the basic dependencies like NodeJS and MongoDB in case they are not already installed in our system else we are good to go. Now that we are done installing dependencies, we must install the popular libraries of express and mongoose using the node package manager. The syntax of both can be defined as we install them each using our terminal.

npm install express
npm install mongoose

Now that the installation is done, we have to let the system know that we want to start creating our project and to fulfill that we write the npm init command to start with our project after which a package.json can be visible in the project folder consisting of all the relevant information about the project.

2. Build the RESTful API

To create a REST API for our web application, ExpressJS framework is used. The steps to build are:-

Once we have installed the Express library using the command, npm install -g express-generator globally that will let you create your express project anywhere from our system without any hassle.
Open the terminal and enter the given command: express myproject and in case the ‘myproject’ looks odd here with the command understanding, it is important to know that ‘myproject’ can be the desired user-provided name for creating an express project.
In order to install the necessary dependencies, run the npm installcommand to initiate the project. It is required if you are using any added packages such as Mongoose.
API is defined in this step that indicates how well the data is transferred or received across two or more connected endpoints. Another important feature to look up to is the router object, created for defining the API endpoints.
A method such as GET, POST, PUT, and USE sets up the middleware to function routes at the application level.

Example code for creating a RESTful API:-

const express =   require('express');
const router = express.Router();
router.get('/users', (req, res) => {
request for endpoint /users });

router.post('/users', (req, res) => {
request for endpoint /users });
module.exports = router;

As we discussed earlier Mongoose that it is a library that can be used for data models and schema but like most of the applications does not entirely need this, it completely depends upon the requirement of the user or project manager to include it. When it comes to the need of using MongoDB for our web application, we must create a connection by writing the following command.

mongoose.connect('mongodb://localhost/mydatabase')

In the above code snippet, you can be confused about what ‘mydatabase’ means, so it can be assumed as your choice of name for the project.

Authentication and Authorization of the Web Application

Now that we are done creating the web application, we must ensure the security and integrity of the project. You need to follow certain steps to ensure the security of the project

Implementation of JWT in the respective web application is a way to secure your API and it generates a token that can be put into use to make your API secure. They must be used along with other reliable techniques like cookies, and cross-site request forgery tokens to avoid any threats.

OAuth is a secure way but relies on third-party services like Google, Apple and Github for your authentication. Performing this technique assigns a token that can be used to access the API.

Conclusion

In this article, we saw how we can set up the dependencies and write RESTful APIs that can be used for the passage of data. We further learnt how to create a REST API in the MERN stack by following an ordered sequence of installing dependencies, creating API endpoints, and setting up authentication using JWT and OAuth.

Freecodecamp Markdown

Alim Mohammad — Sun, 02 Apr 2023 12:36:27 +0000

In this project, I used codepen to avoid the setup and it was mandatory by freecodecamp to share the link in order to proceed and obtain the front end libraries certification. So lets get started to how we can build this up.

We start by creating the text area used by the user and the output preview area that will reflect the changes. React was used with respective dependencies installed on settings page except some that I imported. Class component was used to complete the project.

End result obtained was a visually attractive page that lets you convert text into markdown format. Here is a glimpse of the same:-

https://gist.github.com/alimalim77/20a9195d44cf48bf890453e27bc28533

Dockerizing Rick and Morty

Alim Mohammad — Thu, 09 Mar 2023 10:11:10 +0000

Introduction

If you're a fan of Rick and Morty, you know that the show deals with some pretty complex concepts. From the multiverse to time-travel, the show often explores some pretty mind-bending ideas. So, it's no surprise that the show's characters might need a little help managing their applications. That's where Docker comes in. In this blog post, we'll explore how Docker can help Rick and Morty simplify their application management.

Dockerizing Rick

As a scientist, Rick is always experimenting with new technologies. But sometimes, managing all of those experiments can be a pain. That's where Docker comes in. With Docker, Rick can easily package his experiments into containers and run them anywhere without worrying about compatibility issues. Plus, if something goes wrong, he can easily spin up a new container and start over.

Dockerizing Morty

Morty may not be a scientist, but he still has his fair share of applications to manage. From his portal gun to his spaceship, Morty needs a way to keep everything organized. With Docker, Morty can package his applications into containers and run them anywhere with ease. Plus, if he needs to share an application with someone else, he can simply give them the container and know that it will run exactly the same as it does on his machine.

Dockerizing the Multiverse

Of course, Rick and Morty don't just deal with applications on their own world. They often travel to other dimensions and universes, each with their own set of technologies and requirements. With Docker, they can easily package their applications into containers that can run on any platform, regardless of the underlying technology. This means they can focus on exploring new worlds without worrying about compatibility issues.

Conclusion

In conclusion, Docker can be a powerful tool for managing applications, even in the wildest of universes. Whether you're a scientist like Rick or an adventurous teenager like Morty, Docker can help simplify your application management and keep your experiments running smoothly. So the next time you're dealing with a complex application, just remember: Dockerize it!

Read Constraints the Right Way

Alim Mohammad — Mon, 31 Oct 2022 08:26:25 +0000

In case you've found it rigid to observe what approach should be the optimal or how to get rid of the annoying time limit error, reading constraints in an important step towards a better approach for problem solving.

N denotes the number of operations for a range.

N == 10^5 - One of the most sought-after constraints in competitive programming and interviews and a boundary line solution to your code in the front of the interviewer. The Time Complexity encompassing under it are O(N), O(N*logN(base2)) and O(N*root(N))
N == 10^6 - The increment of a single power will bar the later one to keep only O(N) and O(N*logN(base2)) enclosed.
N >= 10^9 - The one supportive complexity at this point is O(logN) with all the other failing at such an insurmountable number of operations. Binary Search much?.
N == 10^3 - Apart from O(N), it extends its support to O(N^2) and O(N^2 * logN) solutions. This one is a Breath of fresh air to the beginners.
N == 10^2 - The cubic computations are allowed in this special case. Going the brute force might not be a sign of concern in this case. You can opt for O(N), O(N^2), O(N^3) and O(N^3*logN) solutions beforehand.
N <= 20 - Exponential complexity is accepted in this constraint with recursion and backtracking the goto approach for solving such problems.

Problem Categorization
If at an interview, the constraints can give you the hints on which method would be most suitable for to solve your problem at a single go: -


1. 10^2 - Brute force/ Greedy
2. 10^5 - Sorting/ Combinations on Binary Search 
3. 10^8 - HashMap/ Sliding Window/Two Pointer/Stack/Queue
4. 10^10 - Binary Search
5. 4-20 - Recursion/Backtracking

As obvious, all of them are going to support O(1) in case you are wizard enough at an interview. Hope this helps you with interview. Grind Hard till You Make It.

Leetcode Daily Challenge - Find the Duplicate Number

Alim Mohammad — Tue, 29 Mar 2022 06:54:38 +0000

Today's challenge on Leetcode in based on a problem oftenly asked in the interviews. It is a medium level problem and I came up with a couple of solutions for the problem using Sorting approach and Two Pointer Approach.

Find the Duplicate Number

Intuition

The intuition is pretty straightforward as compared to the actual implementation. However, the time space trade off is the actual crunch in this problem as there can be various ways to solve the the best one is the foremost demand always.

Logic: (Approach a)

This approach is the easiest of all as it takes the list and sorts it to check if we can find the element in O(nlogn), for the obvious sorting reasons.

Algorithm:

1. Sort the input list
2. Traverse through list
     if nums[i] == nums[i+1]
       return nums[i]
3. Return -1

Logic (Approach b)

The approach can be applied with the use of Floyd Circle algorithm which can be bifurcated into two parts. First where it is checked if there exists a cycle in the list.

Further, it is made sure with the use of indexing for the element that is repeated.

Code No. 1

class Solution:
    def findDuplicate(self, nums: List[int]) -> int:
        nums.sort()
        for i in range(1, len(nums)):
            if nums[i] == nums[i-1]:
                return nums[i]

Code No. 2

class Solution:
    def findDuplicate(self, nums: List[int]) -> int:
        turtle = 0
        hare = 0
        while True:
            if turtle >= len(nums):
                turtle = 0
            if hare >= len(nums):
                hare = 0
            if nums[turtle] == nums[hare] and turtle != hare:
                return nums[turtle]
            turtle += 1
            hare += 1
        return None

Leetcode Daily Challenge - Broken Calculator

Alim Mohammad — Wed, 23 Mar 2022 15:04:33 +0000

Today's challenge on Leetcode in based on a Maths/ Greedy Problem. It is a medium level problem and sounds easy but may leave you scratching your head in terms of an optimal solution.

991. Broken Calculator

Problem Statement

There is a broken calculator that has the integer startValue on its display initially. In one operation, you can:
multiply the number on display by 2, or
subtract 1 from the number on display.
Given two integers startValue and target, return the minimum number of operations needed to display target on the calculator

Input: startValue = 2, target = 3
Output: 2
Explanation: Use double operation and then decrement operation {2 -> 4 -> 3}.

Thought Process:

The immediate thought striking your mind would be to increase the startValue using * operator (in case of a smaller startValue) or decrease it by subtracting to make it equal to target and count the steps we took in our journey.

It can lead to errors so the desired method is to do the otherwise backward approach. To reduce the target using the exact opposite operators of division and subtraction to count the occurrences of operations.

In case, target becomes lesser than startValue, we will increment until the startValue and return the difference along with the actual counter. Confused about this step, proceed further and understand.

Logic

The approach is simple, we declare a counter and run a loop which is terminated once our target value is no more greater than the startValue.
In case our target is odd, we increment the value of target by 1 else we will divide the target value into half.
Eventually, once the loop is terminated, we will return the summation count of times the loop ran and the difference between the startValue and target.
Difference between startValue and target will be decremented on other side of startValue to make it equal to the target along with the counter that ran along the loop.

Code

In case, you are looking to learn practice Python from scratch or want to practice DSA then do checkout my YouTube Channel for free lectures and code-along sessions!
Code Broski: Click here to redirect to Python Fundamentals playlist!