DEV Community: Somnath Das

Real-Life Algorithms: The Checkout Queue Problem 🛒💻

Somnath Das — Fri, 10 Jul 2026 12:08:53 +0000

Sometimes the best algorithmic challenges aren't found on LeetCode or HackerRank—they're hiding in plain sight during your weekend errands.

While waiting outside a packed mall during a massive promotional event, I watched the security team manage the crowd by pulsing people inside group by group. Naturally, my developer brain couldn't just stand there; it immediately turned this crowd-control tactic into a queuing theory puzzle.

If you love a good math or system optimization problem, here is the scenario I came up with:

The Setup

Imagine a massive line of n shoppers waiting outside. The store allows exactly k people inside at a time, and there are m open parallel cash registers.

The Constraints

n (total shoppers) can reach up to 1,000,000,000.
k (batch capacity) maxes out at 5,000.
m (registers) maxes out at 100.

The Mechanics

Here is how the system operates to keep things from descending into chaos:

The Batch System: Shoppers enter in strict groups of k. (The very last group will just be the remainder of n modulo k).
The Coin Flip: Every customer who walks in has exactly a 50% chance of actually making a purchase.
Perfect Efficiency: The buyers are incredibly smart—they instantly divide themselves evenly across the m registers to keep the lines as short as possible.
The Bottleneck: Every transaction takes exactly 1 second. Therefore, the total time for a whole group to finish is determined by the length of the longest register line.
The Gate: The next group of k shoppers cannot step foot inside until every single buyer from the current group has finished checking out. (Non-buyers just wait at the exit, taking 0 extra seconds).

The Challenge

Given n, k, and m, what is the expected total time (in seconds) it will take to process the entire crowd?

Example to visualize:
If a group enters and exactly 5 people decide to buy, and we have 2 registers (m = 2)...
The optimal split is 3 people in one line and 2 in the other. The longest line has 3 people, so that entire batch takes exactly 3 seconds to clear! (But remember, the actual number of buyers in each batch is a probability distribution).

This problem perfectly blends probability, queuing theory, and algorithmic optimization. It is a fantastic exercise in calculating expected values, working with combinations, and handling edge cases with that tricky final batch.

Happy coding, and may your algorithms be as perfectly distributed as these hypothetical shoppers!

My First App Got Rejected. Here's What It Taught Me.

Somnath Das — Tue, 07 Jul 2026 11:59:57 +0000

A few weeks ago, I submitted my Android app Resist & Rise for publication.

I was excited.

A few days later, I received this email:

Your app doesn't meet the minimum quality standards to be published.

At first, I was disappointed. But after reviewing my app, I realized something important:

Building a working app isn't the same as building a polished product.

The rejection made me rethink everything—from onboarding and first impressions to branding, UX, and overall user experience.

Now I'm improving:

Better onboarding
Stronger UI polish
Privacy policy
More meaningful recovery insights
A smoother first-time user experience

This rejection wasn't the end—it was feedback.

Every rejected build is an opportunity to create something better.

Back to building. Back to improving. 🚀

Yes, I just built a fully functional Android APK using React Native.

Somnath Das — Mon, 06 Jul 2026 06:36:30 +0000

And the craziest part? AI handled the entire design.

I wanted an app that relies entirely on local-device storage. Instead of wrestling with UI mockups and boilerplate code, I let Antigravity AI act as my technical co-founder.

It didn't just autocomplete lines of code. It:

Orchestrated the React Native setup

Structured the local storage seamlessly

Designed the complete user interface from scratch

We are moving past AI that just writes snippets. With agentic execution, the barrier to entry for native mobile development just hit zero. The developers who learn to direct these AI agents won't just code faster—they will ship entire products single-handedly.

What do you think of this shift?
Let me know in the comments.

ReactNative #AntigravityAI #AndroidDev #AgenticAI #TechTrends

99% of newbie developers are terrified of the Linux kernel.

Somnath Das — Mon, 06 Jul 2026 06:26:12 +0000

They think it’s a chaotic maze reserved only for senior engineers with decades of experience.
So they buy a 700-page textbook to learn how Operating Systems work instead.

But textbooks only give you theory.
The Linux source code gives you reality.

If you want to learn memory management, process scheduling, or file systems from scratch...
There is no better masterclass in the world than exploring the codebase that runs the modern internet.

You don’t have to read the massive 30-million-line modern tree on day one.
Start with Linux 0.01. Or focus on a single, well-documented subsystem.

Writing code teaches you syntax.
Reading world-class, battle-tested code teaches you architecture, trade-offs, and survival.

It forces you to understand how software physically interacts with the silicon.
No bloated abstractions. No hand-holding. Just pure, foundational engineering.

The developers who learn to navigate the kernel don't just become better programmers.
They become engineers who stop guessing why a system is failing, and start knowing exactly where to look.

Have you ever tried diving into the Linux source code?
Let me know in the comments.

Seeing Code in the Real World: The Bus Seating Problem 🚌

Somnath Das — Sat, 27 Jun 2026 10:19:10 +0000

Working in software development, it is hard to turn off the logic center of the brain. Have you ever looked at a completely normal, everyday situation and thought, "Wait, there's an algorithm for this"?

That happened to me recently on a simple bus ride.

I observed a family getting on the bus and trying to figure out their seating arrangement. Because of the way they sat, one child was left sitting alone. My brain immediately started crunching the numbers—mathematically, there was absolutely a way to seat them all safely!

I decided to turn this real-world observation into a custom coding problem. I call it The Bus Seating Problem.

📝 The Scenario & Rules

Imagine an empty bus with paired seats. A group boards consisting of n adults (parents) and m children.

To make this a solid algorithmic challenge, let's establish some strict baseline constraints:

Both n and m are greater than 1 (at least 2 adults and 2 children).
The children always outnumber the adults (m > n).

Here are the survival rules for seating:

Two children can sit together safely.
No two adults can sit together.
A child CANNOT sit alone. They must sit with another child or an adult.
Adults can sit with children.

The Objective: Given n and m, is it possible to seat everyone safely?

Solutions : https://github.com/buildwithsomnath/everyday-algorithms

🚀 How to Solve Arrays and Hashing Problems in Data Structure?

Somnath Das — Sun, 10 May 2026 03:09:58 +0000

Arrays and Hashing are among the most important topics in Data Structures & Algorithms (DSA) and are frequently asked in coding interviews at companies like FAANG, startups, and product-based companies. Here’s a simple roadmap to master them 👇

📌 1. Understand the Problem Type

Before coding, identify the pattern:
✅ Searching elements
✅ Frequency counting
✅ Duplicate detection
✅ Pair/target sum problems
✅ Prefix sum or subarray problems
✅ Grouping & mapping

📌 2. Master Array Basics

Arrays are all about indexing and traversal. Focus on:
🔹 Traversing efficiently
🔹 Sorting techniques
🔹 Two-pointer approach
🔹 Sliding Window technique
🔹 Prefix Sum optimization

Example Problems:
✔ Two Sum
✔ Best Time to Buy & Sell Stock
✔ Maximum Subarray
✔ Product of Array Except Self

📌 3. Learn Hashing (HashMap / Dictionary / Set)

Hashing helps reduce time complexity from O(n²) → O(n) by storing values smartly.

Use:
🔹 unordered_map → key-value storage
🔹 unordered_set → unique elements checking

When to use hashing?
👉 Fast lookup required
👉 Counting frequencies
👉 Finding duplicates
👉 Tracking visited elements

📌 Example Code (Two Sum using Hashing in C++)

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

vector<int> twoSum(vector<int>& nums, int target) {
    unordered_map<int, int> mp;

    for (int i = 0; i < nums.size(); i++) {
        int complement = target - nums[i];

        if (mp.find(complement) != mp.end()) {
            return {mp[complement], i};
        }

        mp[nums[i]] = i;
    }

    return {};
}

int main() {
    vector<int> nums = {2, 7, 11, 15};
    int target = 9;

    vector<int> ans = twoSum(nums, target);

    cout << "Indices: ";
    for (int x : ans) {
        cout << x << " ";
    }

    return 0;
}

✅ Time Complexity: O(n)
✅ Space Complexity: O(n)

📌 4. Follow This Problem-Solving Strategy

1️⃣ Read the problem carefully
2️⃣ Spend at least 30 minutes trying to solve it yourself
3️⃣ Do dry runs with sample test cases on paper
4️⃣ If stuck, try solving the brute force approach first
5️⃣ Then optimize using Arrays / Hashing techniques
6️⃣ Analyze Time Complexity & Space Complexity
7️⃣ Practice similar variations

📌 5. Golden Questions to Practice

🔥 Two Sum
🔥 Contains Duplicate
🔥 Valid Anagram
🔥 Group Anagrams
🔥 Top K Frequent Elements
🔥 Longest Consecutive Sequence

💡 Pro Tip:

Whenever you see words like “frequency”, “duplicate”, “fast lookup”, or “pair finding”, think about HashMap/HashSet instantly!

Remember: Don’t jump to solutions too quickly. Spending time thinking builds problem-solving skills. Even if you can’t solve the optimal solution, getting the brute force approach right is progress 🚀

💻 Consistency beats talent in DSA. Practice 1–2 problems daily and focus on patterns instead of memorizing solutions.

🌿 AI-Powered Plant Disease Detection System

Somnath Das — Mon, 30 Mar 2026 15:03:25 +0000

Agriculture and Artificial Intelligence are coming together to solve real-world problems! In this project, I built a Plant Disease Detection System using Deep Learning (CNN) that can identify plant diseases from leaf images and provide actionable insights like treatment and fertilizer recommendations.

🔍 What This Project Does

The workflow is simple and effective:

Upload a plant leaf image → Get disease prediction → Receive treatment guidance

This makes it highly useful for farmers, agricultural professionals, and even researchers looking for quick and reliable plant health analysis.

🎯 Key Features

🔍 Real-time Disease Detection using Convolutional Neural Networks
🎯 81–84% Accuracy across 38 plant disease classes
💊 Treatment & Prevention Recommendations tailored to predictions
📊 Prediction History Tracking with timestamps
📱 Responsive Design (Desktop, Tablet, Mobile)
🚀 REST API Support for integration with mobile apps
🔐 Security Focused (CSRF protection, file validation, input sanitization)

🌾 Supported Plants & Diseases

The model currently supports 38 disease classes across multiple crops:

🍅 Tomato – 10 disease classes
🥔 Potato – 3 disease classes
🌽 Corn – 4 disease classes
🌶️ Pepper – 2 disease classes
🍎 Other crops also included

🛠️ Tech Stack

Backend: Django
Machine Learning: TensorFlow, CNN
Languages: Python
Frontend: HTML, CSS
API: RESTful services

🎯 Goal of This Project

The main goal is to empower farmers with AI-driven tools that can:

Improve crop health
Reduce agricultural losses
Provide quick decision support
Promote smart farming practices

🔗 GitHub Repository

Check out the full project here:
👉 https://github.com/buildwithsomnath/Plant-Disease-Detection/tree/main

📸 Screenshot

💬 Final Thoughts

This project reflects my passion for Data Science, Machine Learning, and Full Stack Development, and how these skills can be used to build impactful real-world solutions.

If you found this interesting or have suggestions, feel free to share your thoughts. I’d love to collaborate and improve this further!

🏷️ Tags

#AI #MachineLearning #DeepLearning #ComputerVision #Django #TensorFlow #DataScience #AgricultureTech