Imagine searching for a solution on stackoverflow you came across two solution one is of 2 lines another is 10 lines there is a great chance that you will pick the one with 2 lines. But wait that’s now always right.

Understanding Time Complexity

Time Complexity describes how much time the code will take to execute with increasing input size.

Say your code executes fine for 10 inputs but is slow for 1000 inputs; the time complexity will help you understand why.

Time Complexity can be categorised based on 3 scenarios:

1. Best Case Scenario

2. Average Case Scenario

3. Worst Case Scenario

The best case, average case and worst case are denoted by Ω(Omega), θ(Theta) and O(Big O), respectively.

Time complexity can be Constant, Logarithmic, Linear, Linear Logarithmic, Quadratic, Exponential and Factorial, where constant means the least time and factorial is the maximum time.

A Simple Analogy

Imagine, while you are using Google Maps to navigate, sometimes maps suggest you take a longer route instead of a shortcut, and by doing so, you can save time since the shortcut has potholes, traffic lights, and traffic jams, which can increase travel time.

Similarly, in coding, your 2 lines of code may be forcing the machine to iterate multiple times, whereas the 10 lines of code can do it easily.

Code Example

Let’s consider a very common problem, “The Two Sum Problem”

Problem: Given an array of integers and a target value, find if there are two numbers that add up to the target.

The Brute Force Approach

#include <iostream>
using namespace std;

int main() {
    int arr[] = {2, 7, 11, 15};
    int target = 9, n = 4;

    for (int i = 0; i < n; i++)
        for (int j = i + 1; j < n; j++)
            if (arr[i] + arr[j] == target)
                cout << i << " " << j << endl;

    return 0;
}

This code looks short and easy to implement, but it’s slow during execution because here we are checking every possible pair of numbers in the array. It has two nested loops, making it inefficient for larger arrays.

Optimised Code

#include <iostream>
#include <unordered_map>
using namespace std;

int main() {
    int arr[] = {2, 7, 11, 15};
    int target = 9, n = 4;

    unordered_map<int, int> map; // stores number and its index

    for (int i = 0; i < n; i++) {
        int complement = target - arr[i];

        if (map.find(complement) != map.end()) {
            cout << map[complement] << " " << i << endl;
            break;
        }

        map[arr[i]] = i;
    }

    return 0;
}

This solution uses a hash map to remember the numbers we've already seen. For each new number, it checks if the complement (target - current number) is already in the map. This means we only need to loop through the array once, which makes it way faster than the brute-force approach.

Conclusion

In conclusion, when evaluating code, it's crucial to look beyond the number of lines and consider the time complexity. A shorter code snippet might seem appealing, but it can be less efficient, especially with larger inputs. Understanding and applying the principles of time complexity can lead to more efficient and scalable solutions.

Check out my full portfolio on https://softwareguy.xyz

In this guide, we'll quickly build a simple REST API using Express.js and MongoDB. Whether you're new to backend development or need a refresher, this tutorial will help you start with a basic CRUD (Create, Read, Update, Delete) API.

What You'll Learn:

• Setting up an Express.js server

• Connecting to MongoDB

• Creating API routes

• Performing CRUD operations

• Testing the API using Postman

Prerequisites:

• Node.js installed

• Basic understanding of JavaScript

• MongoDB Atlas account (or local MongoDB setup)

Step 1: Setting Up the Project

Open your terminal and create a new project:

mkdir express-mongo-api && cd express-mongo-api
npm init -y

Install required dependencies:

npm install express mongoose dotenv cors body-parser

• express – Web framework for Node.js

• mongoose – ODM for MongoDB

• dotenv – Manage environment variables

• cors – Handle cross-origin requests

• body-parser – Parse incoming JSON data

Step 2: Connecting to MongoDB

Create a .env file in the root directory and add your MongoDB connection string:

MONGO_URI=your_mongodb_connection_string
PORT=5000

Now, create a file db.js to establish the database connection:

const mongoose = require('mongoose');
require('dotenv').config();

mongoose.connect(process.env.MONGO_URI, { useNewUrlParser: true, useUnifiedTopology: true })
  .then(() => console.log('MongoDB Connected'))
  .catch(err => console.error(err));

module.exports = mongoose;

Step 3: Defining the User Model

Inside a models folder, create User.js:

const mongoose = require('mongoose');

const userSchema = new mongoose.Schema({
  name: String,
  email: String,
  age: Number
});

module.exports = mongoose.model('User', userSchema);

Step 4: Building API Routes

Create a routes folder and add userRoutes.js:

const express = require('express');
const router = express.Router();
const User = require('../models/User');

// Create a user
router.post('/', async (req, res) => {
  try {
    const user = new User(req.body);
    await user.save();
    res.status(201).json(user);
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

// Get all users
router.get('/', async (req, res) => {
  const users = await User.find();
  res.json(users);
});

// Get a user by ID
router.get('/:id', async (req, res) => {
  const user = await User.findById(req.params.id);
  res.json(user);
});

// Update a user
router.put('/:id', async (req, res) => {
  const user = await User.findByIdAndUpdate(req.params.id, req.body, { new: true });
  res.json(user);
});

// Delete a user
router.delete('/:id', async (req, res) => {
  await User.findByIdAndDelete(req.params.id);
  res.json({ message: 'User deleted' });
});

module.exports = router;

Step 5: Setting Up the Express Server

Create server.js in the root directory:

const express = require('express');
require('dotenv').config();
require('./db'); // Connect to MongoDB

const app = express();
app.use(express.json()); // Middleware to parse JSON
app.use('/users', require('./routes/userRoutes')); // Use user routes

const PORT = process.env.PORT || 5000;
app.listen(PORT, () => console.log(`Server running on port ${PORT}`));

Run the server:

node server.js

You should see "MongoDB Connected" and "Server running on port 5000" in your terminal.

Step 6: Testing the API with Postman

Use Postman or cURL to test the API:

Create a user (POST /users)

{
  "name": "John Doe",
  "email": "johndoe@example.com",
  "age": 25
}

Get all users (GET /users)

Returns an array of users.

Get a user by ID (GET /users/:id)

Fetches a specific user by their ID.

Update a user (PUT /users/:id)

Send an updated JSON object.

Delete a user (DELETE /users/:id)

Removes a user from the database.

Optional: Deploying the API

• Deploy to Render, Vercel, or Railway for free hosting.

• Use MongoDB Atlas instead of local MongoDB.

• Add authentication using JWT (JSON Web Tokens).

Check out my full portfolio on softwareguy.xyz