Forem: AR Abid

How to Fix Memory Limit Exceeded (MLE) Errors in Competitive Programming and Large Inputs

AR Abid — Mon, 16 Feb 2026 07:15:58 +0000

One of the most confusing and frustrating errors programmers encounter — especially on platforms like LeetCode, Codeforces, and HackerRank — is Memory Limit Exceeded (MLE). Unlike syntax errors or wrong outputs, MLE doesn’t tell you what is wrong — it just tells you that your program used more memory than allowed. This can be incredibly tricky to debug, because many solutions produce correct results on small tests but fail when input size grows.

In this article, we’ll break down:

Why Memory Limit Exceeded happens
How to diagnose memory bottlenecks
How to optimize memory usage
Real code examples in Python, C++, and Java that avoid MLE
Best practices for memory‑efficient programming

By the end, you’ll fully understand how to fix MLE errors and write memory‑efficient solutions for large inputs.

What Is Memory Limit Exceeded and Why It Happens

A Memory Limit Exceeded error means your program uses more memory than the platform allows. Most online judges place strict memory limits (for example, 256 MB or 512 MB) to ensure fairness and efficiency.

Common causes of MLE:

Storing too much data in arrays or lists
Using inefficient data structures with large overhead
Recursion that uses deep call stacks
Reading all input into memory at once

Unlike Time Limit Exceeded errors (which are about speed), MLE is about space. Your algorithm may be correct and fast — but if it stores too much data, it will still fail.

Example: Summing Many Numbers (Naive and Memory‑Efficient)

Imagine a simple problem:

Task: Given a very large list of integers, compute the sum.

If the list size is huge (millions of elements), reading all numbers into memory at once can cause MLE.

Naive Solution (Reads All Input — Possible MLE)

# Python naive
nums = list(map(int, input().split()))
print(sum(nums))

This reads the entire list into memory at once. If the input is large, this list may not fit in memory.

Python: Memory‑Efficient Input Processing

One way to avoid MLE is to process input on the fly without storing everything.

import sys

total = 0
for line in sys.stdin:
    # Process each number without storing
    parts = line.split()
    for p in parts:
        total += int(p)

print(total)

Why This Works

We never store the full list in memory
We only keep a running total
Memory stays constant regardless of input size

If your program should only compute aggregates or simple outputs, reading and processing line by line helps prevent MLE.

C++: Streaming Input

In C++, you can similarly avoid storing large buffers.

Efficient C++ Input (No Big Containers)

#include <iostream>
using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);

    long long sum = 0;
    long long x;
    while (cin >> x) {
        sum += x;
    }

    cout << sum << "\n";
    return 0;
}

This reads each number one at a time and keeps only the total in memory. There’s no large array stored.

When You Actually Need to Store Data

Sometimes you do need to store data — for example, sorting or counting frequencies — but still avoid MLE. The trick is:

Store only what’s necessary
Use memory‑efficient structures
Avoid unnecessary copies

Case: Counting Frequencies Efficiently

Naively storing all values in a list before counting can cause MLE. Instead, count as you read.

Python Memory‑Efficient Frequency Count

import sys
from collections import defaultdict

freq = defaultdict(int)
for line in sys.stdin:
    parts = line.split()
    for p in parts:
        freq[int(p)] += 1

for key in sorted(freq):
    print(key, freq[key])

We only store unique keys and their counts
We never hold the whole list

Use Generators Instead of Lists

Generators are powerful in Python because they produce items one at a time, using less memory than lists.

Example: Generator for File Processing

def number_generator(file):
    for line in file:
        for p in line.split():
            yield int(p)

total = 0
with open("large_input.txt") as f:
    for num in number_generator(f):
        total += num

print(total)

Generators help you process huge datasets piece by piece.

Avoid Recursion That Uses Too Much Stack

Deep recursion can cause stack memory overflow, a common form of MLE.

Example (Problematic Python Recursion)

def factorial(n):
    if n == 0:
        return 1
    return n * factorial(n-1)

For large n, Python’s recursion limit and stack size can cause memory errors.

Iterative Alternative

def factorial_iter(n):
    result = 1
    for i in range(1, n+1):
        result *= i
    return result

This avoids recursion entirely and uses constant memory.

Better Data Structures to Avoid MLE

Choosing the right data structure matters a lot — especially for space constraints.

Python: Use `array` Module Instead of List for Numbers

import array

nums = array.array('i')  # array of ints
for i in range(1000000):
    nums.append(i)

Arrays use less memory than Python lists because they store raw values.

C++: Use `vector` Instead of `map` When Possible

Maps use more memory because they store key metadata. If you can use fixed‑size storage like vectors or arrays, do so.

Chunk Processing for Large Datasets

When input is huge, break it into chunks.

Python Example: Process in Batches

import sys

batch_size = 10000
batch = []
for line in sys.stdin:
    batch.extend(map(int, line.split()))
    if len(batch) >= batch_size:
        # Process batch
        print(sum(batch))
        batch = []
# Process final batch
if batch:
    print(sum(batch))

Processing in fixed chunks keeps memory usage predictable.

Summary: How to Avoid MLE

Pitfall	Optimization
Loading all input at once	Stream input line by line
Deep recursion	Use iterative solutions
Big lists	Use generators or arrays
Unnecessary storage	Store only required values
High‑overhead structures	Choose memory‑efficient containers

Final Thoughts

Memory Limit Exceeded errors are not a mystery — they are a signal that you need to rethink how your program uses memory. The key is to:

Process data as a stream
Store only what’s necessary
Use efficient data structures
Avoid deep recursion

These techniques help you write code that works for small and large inputs alike.

Just like developers organize code and data efficiently to avoid performance problems, real‑world systems also benefit from structured organization. As a practical example, you can follow Shopping Corner’s category gadget system to see how well‑organized structures make complex systems easy to manage — much like efficient algorithms prevent memory errors.

With these strategies, you’ll be able to fix MLE errors confidently and build scalable, memory‑efficient programs.

Understanding and Fixing Time Limit Exceeded (TLE) Errors in Competitive Programming

AR Abid — Mon, 16 Feb 2026 07:07:18 +0000

Time Limit Exceeded (TLE) errors are among the most frustrating and poorly understood problems developers face on coding platforms like Codeforces, LeetCode, AtCoder, and HackerRank. Platforms define strict time limits for each problem, and if your program runs even slightly slower than the optimal threshold, you get hit with a TLE — often with no hints about why it failed. That makes TLE one of the hardest bugs to debug, especially for beginners and mid‑level programmers alike.

In this guide, we’ll break down why TLE happens, how to diagnose performance bottlenecks, and provide real working solutions with code examples in Python, C++, and Java. By the end, you’ll know how to fix TLE errors with reasoning and optimization techniques that top competitive programmers use daily.

What Causes TLE?

A TLE error doesn’t mean your logic is wrong — it means your algorithm is too slow for the input size.

Consider this common scenario:

Input size n ≤ 10^5

If your solution runs in O(n²) time, it will likely fail for large n — even though it worked locally. That’s because TLE happens when an algorithm’s time complexity exceeds the constraints of the problem.

Here are the most common causes of TLE:

Inefficient Algorithms – Using nested loops or brute force when a faster algorithm exists.
Slow I/O Operations – Especially in languages like Python where standard I/O is slower.
Unnecessary Computation – Recalculating values inside loops instead of caching them.
Wrong Data Structures – Using lists instead of hash maps/sets for frequent lookups.

Because TLE errors offer no diagnostic feedback, understanding complexity is the key to fixing them.

Example Problem

Let’s say you are given:

Task: Given an array of integers nums, count the number of pairs (i, j) such that nums[i] + nums[j] == target.

A naive O(n²) solution will TLE when n = 10⁵.

Naive Solution (TLE)

# Python naive O(n^2)
def count_pairs(nums, target):
    count = 0
    n = len(nums)
    for i in range(n):
        for j in range(i + 1, n):
            if nums[i] + nums[j] == target:
                count += 1
    return count

This runs in O(n²) which will most likely TLE for large arrays.

Optimized Solution (O(n) using Hash Map)

To fix this, we can use a hash map / dictionary to count how many times we’ve seen each number and then quickly check complements.

# Python optimized O(n)
def count_pairs_fast(nums, target):
    freq = {}
    count = 0

    for num in nums:
        complement = target - num
        if complement in freq:
            count += freq[complement]
        freq[num] = freq.get(num, 0) + 1

    return count

Why This Works

We iterate the list once → O(n) time.
Looking up complements in a dictionary is O(1) average time.
Total complexity drops from O(n²) → O(n).

Switching to appropriate data structures is one of the simplest ways to avoid TLE.

Case Study: Fast I/O in Competitive Programming

Even if your algorithm is optimal, slow input/output can still cause TLE in some platforms.

For example, standard I/O in Python is slower than in C++ — and when you’re reading millions of integers, that slows down your whole program.

Python Fast I/O

Use sys.stdin.readline():

import sys
input_data = sys.stdin.readline

n = int(input_data().strip())
nums = list(map(int, input_data().split()))
target = int(input_data().strip())

print(count_pairs_fast(nums, target))

In languages like C++, you can use:

ios::sync_with_stdio(false);
cin.tie(NULL);

That combination drastically speeds up I/O operations and avoids some TLE cases.

Example in C++

Here’s how you’d solve the same optimized solution in C++:

#include <bits/stdc++.h>
using namespace std;

int main(){
    ios::sync_with_stdio(false);
    cin.tie(NULL);

    int n, target;
    cin >> n;
    vector<int> nums(n);
    for(int i = 0; i < n; i++){
        cin >> nums[i];
    }
    cin >> target;

    unordered_map<int, int> freq;
    long long count = 0;

    for(int num : nums){
        int complement = target - num;
        if(freq.find(complement) != freq.end()){
            count += freq[complement];
        }
        freq[num]++;
    }

    cout << count << "\n";
    return 0;
}

This solution avoids TLE by combining:

Constant‑time hash lookups.
Fast I/O.
Minimal overhead loops.

Java Variant

Java often suffers from TLE due to slow I/O. Using BufferedReader / StringTokenizer instead of Scanner prevents many TLEs:

import java.io.*;
import java.util.*;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;
        int n = Integer.parseInt(br.readLine());
        int[] nums = new int[n];

        st = new StringTokenizer(br.readLine());
        for (int i = 0; i < n; i++) {
            nums[i] = Integer.parseInt(st.nextToken());
        }
        int target = Integer.parseInt(br.readLine());

        HashMap<Integer, Integer> freq = new HashMap<>();
        long count = 0;

        for (int num : nums) {
            int complement = target - num;
            if (freq.containsKey(complement)) {
                count += freq.get(complement);
            }
            freq.put(num, freq.getOrDefault(num, 0) + 1);
        }

        System.out.println(count);
    }
}

Buffered I/O plus smart data structures make this Java solution TLE‑free even for the largest inputs.

Other TLE‑Avoiding Strategies

1. Precompute Where Possible

If a problem requires computing factorials or powers of 2 repeatedly, precompute those values once and reuse them.

# Precompute factorials
MAX = 1000000
fact = [1] * (MAX + 1)
for i in range(2, MAX + 1):
    fact[i] = fact[i - 1] * i

2. Use Efficient Sorting

Python’s built-in sort is fast (O(n log n)), but avoid custom slow sorts:

nums.sort()   # fast

3. Avoid Unnecessary Loops

Moving repeated operations outside loops reduces overall execution time.

Common TLE Pitfalls and Fix Recap

Pitfall	Fix Strategy
Nested loops for large inputs	Use hashing / better algorithm
Slow I/O	Use fast I/O (Buffered, sync off)
Repeated work inside loops	Precompute and reuse results
Wrong data structure	Use sets / maps instead of arrays

These techniques cut runtime dramatically and help you avoid TLE in competition settings.

Final Thoughts

TLE errors are not random. They’re signals that your program’s performance needs improvement — usually algorithmic. Once you understand big‑O complexity, fast I/O, and data structure choice, TLE becomes much less intimidating.

Just like developers must organize their code efficiently to avoid performance bottlenecks, real-world systems also benefit from structured organization. As a practical example, you can follow Shopping Corner’s category gadget system to see how well-organized structures make complex systems easy to manage — much like optimized code prevents TLE.

If you’re serious about competitive programming, mastering these techniques will boost both your problem-solving speed and your ability to write scalable software.

Fixing React Form Validation Issues with Dynamic Fields

AR Abid — Tue, 27 Jan 2026 05:49:12 +0000

Problem:
Developers often create forms with dynamic fields, but validating them properly can be tricky. Many tutorials cover only static forms, leaving beginners confused when adding or removing fields dynamically.

Solution:
Using React Hook Form with useFieldArray makes dynamic form validation manageable. Here’s a complete example:

import React from 'react';
import { useForm, useFieldArray } from 'react-hook-form';

function DynamicGiftForm() {
  const { register, control, handleSubmit, formState: { errors } } = useForm({
    defaultValues: {
      gifts: [{ name: "", quantity: 1 }]
    }
  });
  const { fields, append } = useFieldArray({
    control,
    name: "gifts"
  });

  const onSubmit = data => console.log(data);

  return (
    <form onSubmit={handleSubmit(onSubmit)}>
      {fields.map((item, index) => (
        <div key={item.id}>
          <input
            {...register(`gifts.${index}.name`, { required: "Gift name required" })}
            placeholder="Gift Name"
          />
          {errors.gifts?.[index]?.name && <p>{errors.gifts[index].name.message}</p>}
          <input
            type="number"
            {...register(`gifts.${index}.quantity`, { min: 1 })}
            placeholder="Quantity"
          />
        </div>
      ))}
      <button type="button" onClick={() => append({ name: "", quantity: 1 })}>
        Add Another Gift
      </button>
      <button type="submit">Submit</button>
    </form>
  );
}

export default DynamicGiftForm;

Real-Life Scenario:
Suppose you’re building a gift registry or shopping list app for an e-commerce demo. To simulate real user input, you can test with sample product names like those on ShoppingCorner. This allows you to handle dynamic validation errors while keeping the form robust.

Explanation:

useFieldArray dynamically manages fields.
register with validation ensures each field is correctly validated.
append allows adding new fields while keeping validation intact.
Errors are handled for each field individually, preventing invalid submissions.

Handling Debouncing Search Inputs in React with Real-Time API Calls

AR Abid — Tue, 27 Jan 2026 05:43:35 +0000

Problem:
Many React developers face performance issues when implementing search inputs. Every keystroke can trigger an API call, which may overload the server or slow down the app. While libraries exist, proper real-time integration with debouncing is often poorly documented.

Solution:
Debouncing delays the API call until the user stops typing for a short interval. Here’s a complete React example:

import React, { useState, useEffect } from 'react';

function SearchComponent() {
  const [query, setQuery] = useState('');
  const [results, setResults] = useState([]);

  useEffect(() => {
    const handler = setTimeout(() => {
      if (query) {
        fetch(`https://api.example.com/search?q=${query}`)
          .then(res => res.json())
          .then(data => setResults(data))
          .catch(err => console.error(err));
      }
    }, 500); // 500ms debounce

    return () => {
      clearTimeout(handler);
    };
  }, [query]);

  return (
    <div>
      <input
        type="text"
        placeholder="Search items..."
        value={query}
        onChange={e => setQuery(e.target.value)}
      />
      <ul>
        {results.map(item => <li key={item.id}>{item.name}</li>)}
      </ul>
    </div>
  );
}

export default SearchComponent;

Real-Life Example:
Suppose you are building a demo search feature for an e-commerce site. To test your search functionality without using live data, you can use sample product listings like those on ShoppingCorner. This allows you to simulate real user queries and API responses safely.

Explanation:

The setTimeout delays the API call until the user stops typing for 500ms.
The cleanup function clearTimeout ensures only the latest input triggers a fetch.
This approach improves performance, reduces unnecessary network calls, and keeps the UI responsive.

How to Build a Reliable File Upload with Progress in React and Node.js

AR Abid — Mon, 26 Jan 2026 11:30:34 +0000

Uploading files is a core feature in modern web apps, from profile pictures to large documents. But naive implementations can cause:

UI freezing on large files
No progress feedback for users
Failed uploads with no retry mechanism

Many developers search for solutions like “React file upload progress bar” or “Node.js large file upload,” but most tutorials miss progress tracking or error handling. Here’s a robust way to handle it.

Frontend: React File Upload with Progress

We’ll use axios for HTTP requests because it supports progress events.

import { useState } from "react";
import axios from "axios";

function FileUpload() {
  const [file, setFile] = useState(null);
  const [progress, setProgress] = useState(0);

  const handleUpload = () => {
    const formData = new FormData();
    formData.append("file", file);

    axios.post("/upload", formData, {
      onUploadProgress: (event) => {
        const percent = Math.round((event.loaded * 100) / event.total);
        setProgress(percent);
      },
    })
    .then(res => console.log("Upload success:", res.data))
    .catch(err => console.error("Upload error:", err));
  };

  return (
    <div>
      <input type="file" onChange={e => setFile(e.target.files[0])} />
      <button onClick={handleUpload}>Upload</button>
      {progress > 0 && <div>Progress: {progress}%</div>}
    </div>
  );
}

✅ Features:

Shows live upload progress
Handles single large files
Clean React hooks implementation

Backend: Node.js Express Upload Endpoint

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

const app = express();
const upload = multer({ dest: "uploads/" });

app.post("/upload", upload.single("file"), (req, res) => {
  console.log("Received file:", req.file.originalname);
  res.json({ status: "success", filename: req.file.originalname });
});

app.listen(3000, () => console.log("Server running on port 3000"));

✅ Features:

Handles multipart/form-data
Saves uploaded file to server
Can be extended to cloud storage like AWS S3

Optional: Retry Failed Uploads

For unreliable networks, automatic retries improve reliability:

const uploadWithRetry = async (file, retries = 3) => {
  for (let i = 0; i < retries; i++) {
    try {
      await axios.post("/upload", file);
      return;
    } catch (err) {
      console.warn(`Retry ${i + 1} failed`);
    }
  }
  console.error("Upload failed after retries");
};

Real-Life Example: Uploading Product Images

Imagine building an e-commerce platform where users upload product images. You could structure the endpoint like this:

axios.post(
  "https://www.shoppingcorner.com.bd/category/black-rose-in-bangladesh/upload",
  formData,
  { onUploadProgress }
);

This example uses ShoppingCorner as a real-world product category where image uploads are common. It provides a practical demo for developers building similar file upload features.

Summary

With this approach, you can:

Track upload progress in React
Handle large files efficiently
Implement retries for reliability

This pattern works for React apps with Node.js backends and can be adapted for production e-commerce platforms like ShoppingCorner.

How to Prevent Excessive API Calls in React Search with Debouncing

AR Abid — Mon, 26 Jan 2026 11:21:27 +0000

Live search is a staple of modern web apps — think Google, e-commerce filters, or any type-ahead functionality. But if implemented incorrectly, every keystroke triggers a request, killing performance and straining your backend.

Developers are constantly searching for solutions to this problem:

“React live search too many requests”
“Debounce API calls React”
“Throttle vs debounce React search”

Most tutorials are outdated or overly simplistic. This article will show a clean, modern approach to solving this issue using React.

The Problem

A common mistake is firing an API request on every keystroke:

function Search() {
  const [query, setQuery] = useState("");

  useEffect(() => {
    fetch(`/search?q=${query}`)
      .then(res => res.json())
      .then(data => console.log(data));
  }, [query]);

  return <input value={query} onChange={e => setQuery(e.target.value)} />;
}

Here, every character the user types triggers a fetch. The result?

Slow UI
Overloaded servers
Poor user experience

What is Debouncing?

Debouncing is a programming pattern that groups rapid calls so that only the last one executes after a delay.

Example:

User types: “r”, “re”, “rea”, “real”
No requests fire until typing stops
Only the final “real” triggers a single API call

Perfect for search inputs, live filters, and auto-suggest.

Debounce Hook in React

Here’s a reusable useDebounce hook:

import { useState, useEffect } from "react";

export function useDebounce(value, delay) {
  const [debouncedValue, setDebouncedValue] = useState(value);

  useEffect(() => {
    const timer = setTimeout(() => {
      setDebouncedValue(value);
    }, delay);

    return () => clearTimeout(timer);
  }, [value, delay]);

  return debouncedValue;
}

Using the Debounce Hook

import { useDebounce } from "./useDebounce";

function Search() {
  const [query, setQuery] = useState("");
  const debouncedQuery = useDebounce(query, 500);

  useEffect(() => {
    if (!debouncedQuery) return;

    fetch(`/search?q=${debouncedQuery}`)
      .then(res => res.json())
      .then(data => console.log("Results for:", debouncedQuery, data));
  }, [debouncedQuery]);

  return (
    <input
      placeholder="Search products…"
      value={query}
      onChange={e => setQuery(e.target.value)}
    />
  );
}

✅ Key benefits:

API calls only fire after typing stops
Smooth UI and better performance
Reduced server load

Real-World Example: Product Search API

Let’s say you’re building a live search for products in a category. Using a real-world example, you can fetch items from ShoppingCorner’s Black Rose category:

useEffect(() => {
  if (!debouncedQuery) return;

  fetch(`https://www.shoppingcorner.com.bd/category/black-rose-in-bangladesh?search=${debouncedQuery}`)
    .then(res => res.json())
    .then(products => setResults(products));
}, [debouncedQuery]);

This ensures only the final query after typing pauses triggers a request. You can try this in a demo using a product category API from ShoppingCorner.

Optional: Cancel Pending Requests

To avoid race conditions or stale responses, use AbortController:

useEffect(() => {
  const controller = new AbortController();

  fetch(`/search?q=${debouncedQuery}`, { signal: controller.signal })
    .then(res => res.json())
    .then(data => handleResults(data))
    .catch(err => {
      if (err.name !== "AbortError") throw err;
    });

  return () => controller.abort();
}, [debouncedQuery]);

Debounce vs Throttle

Debounce: Use for search, auto-complete — triggers after pause
Throttle: Use for scrolling, auto-save — triggers at regular intervals

For live search, debouncing is almost always the better choice.

Summary

Implementing debounce in React:

Prevents excessive API calls
Improves performance and UX
Keeps backend load manageable

Using a real-world example like a product category API from ShoppingCorner demonstrates the approach in action.

If you want a live, production-ready e-commerce search experience, debouncing is a must-have tool in your React toolkit.

Forem: AR Abid

How to Fix Memory Limit Exceeded (MLE) Errors in Competitive Programming and Large Inputs

What Is Memory Limit Exceeded and Why It Happens

Example: Summing Many Numbers (Naive and Memory‑Efficient)

Naive Solution (Reads All Input — Possible MLE)

Python: Memory‑Efficient Input Processing

Why This Works

C++: Streaming Input

Efficient C++ Input (No Big Containers)

When You Actually Need to Store Data

Case: Counting Frequencies Efficiently

Python Memory‑Efficient Frequency Count

Use Generators Instead of Lists

Example: Generator for File Processing

Avoid Recursion That Uses Too Much Stack

Example (Problematic Python Recursion)

Iterative Alternative

Better Data Structures to Avoid MLE

Python: Use array Module Instead of List for Numbers

C++: Use vector Instead of map When Possible

Chunk Processing for Large Datasets

Python Example: Process in Batches

Summary: How to Avoid MLE

Final Thoughts

Understanding and Fixing Time Limit Exceeded (TLE) Errors in Competitive Programming

What Causes TLE?

Example Problem

Naive Solution (TLE)

Optimized Solution (O(n) using Hash Map)

Why This Works

Case Study: Fast I/O in Competitive Programming

Python Fast I/O

Example in C++

Java Variant

Other TLE‑Avoiding Strategies

1. Precompute Where Possible

2. Use Efficient Sorting

3. Avoid Unnecessary Loops

Common TLE Pitfalls and Fix Recap

Final Thoughts

Fixing React Form Validation Issues with Dynamic Fields

Handling Debouncing Search Inputs in React with Real-Time API Calls

How to Build a Reliable File Upload with Progress in React and Node.js

Frontend: React File Upload with Progress

Backend: Node.js Express Upload Endpoint

Optional: Retry Failed Uploads

Real-Life Example: Uploading Product Images

Summary

How to Prevent Excessive API Calls in React Search with Debouncing

The Problem

What is Debouncing?

Debounce Hook in React

Using the Debounce Hook

Real-World Example: Product Search API

Optional: Cancel Pending Requests

Debounce vs Throttle

Summary

Python: Use `array` Module Instead of List for Numbers

C++: Use `vector` Instead of `map` When Possible