Suggest an edit

Improve this article

Refine the answer for “Input data size”. Your changes go to moderation before they’re published.

Approval required

Content

What you’re changing

Title (EN)

Short answer (EN)

Shown above the full answer for quick recall.

Answer (EN)

## 1. The core idea

> The **more input data**, the **longer the code takes to run**, unless the algorithm scales efficiently.

The size of the input directly affects:

- execution time (CPU load);
- memory usage;
- the number of input/output (I/O) operations;
- the number of iterations and recursion depth.

This dependency is usually expressed through **asymptotic complexity (Big O)**, how fast the execution time grows as the input grows.

---

## 2. A simple visualization

| Algorithm | Complexity | What it means | Example |
|---|---|---|---|
| **O(1)** | constant | doesn't depend on data size | index access `arr[0]` |
| **O(log n)** | logarithmic | grows slowly | binary search |
| **O(n)** | linear | time grows proportionally to the number of elements | a `for` loop over an array |
| **O(n log n)** | quasi-linear | moderate growth | `Array.sort()` |
| **O(n²)** | quadratic | explosive growth with large data | nested loops |
| **O(2ⁿ)** | exponential | grows catastrophically | recursive Fibonacci |
| **O(n!)** | factorial | infeasible for large n | permutations |

---

## 3. Examples in JavaScript

### O(1) - independent of size

```javascript
const arr = [1, 2, 3, 4, 5];
console.log(arr[3]); // instant, whether it's 5 or 5 million elements
```

---

### O(n) - linear dependency

```javascript
function sum(arr) {
  return arr.reduce((acc, num) => acc + num, 0);
}

sum([1, 2, 3]);           // ~3 operations
sum(new Array(1000000));  // ~1,000,000 operations
```

The bigger the array, the more time it takes.

---

### O(n²) - quadratic growth

```javascript
function allPairs(arr) {
  for (let i = 0; i < arr.length; i++) {
    for (let j = 0; j < arr.length; j++) {
      // some operation
    }
  }
}
```

If `n = 1000`, that's roughly **1,000,000** operations.
If `n = 10,000`, it's already **100,000,000**.

---

### O(2ⁿ) - exponential growth

```javascript
function fib(n) {
  if (n <= 1) return n;
  return fib(n - 1) + fib(n - 2);
}

fib(30); // fine
fib(45); // already slow!
```

The growth is explosive. At 100 elements, it's simply infeasible to compute.

---

## 4. How growing input affects performance

| Input size | O(1) | O(log n) | O(n) | O(n²) | O(2ⁿ) |
|---|---|---|---|---|---|
| 10 | fast | fast | fast | fast | fast |
| 100 | fast | fast | fast | moderate | slow |
| 1,000 | fast | fast | moderate | slow | critical |
| 100,000 | fast | fast | slow | critical | critical |

Conclusion: with small data everything "flies",
but as the volume grows, "inefficient" code starts to **explode in execution time**.

---

## 5. Performance in different scenarios

| Task type | Example | How data size affects it |
|---|---|---|
| **Iterating an array** | `map`, `filter`, `reduce` | linear |
| **Searching an array** | `arr.includes()` | linear |
| **Looking up an object / Map** | `obj[key]`, `map.get()` | almost O(1) |
| **Sorting** | `arr.sort()` | O(n log n) |
| **Comparing nested structures** | deep object comparison | can be O(n²) |
| **Rendering in React** | large lists, tables | time grows with DOM size |
| **Database queries** | without an index -> O(n) | more rows means slower |

---

## 6. Practical effects

- **CPU load grows** - operations take longer;
- **memory usage increases** - especially when copying or storing large structures;
- **the event loop gets blocked** - the UI "hangs";
- **FPS drops** - animations get choppy;
- **the GC (garbage collector)** runs more often -> lag.

---

## 7. How to improve performance as data grows

| Problem | Solution |
|---|---|
| Loops take too long | Break into chunks (`setTimeout`, `requestIdleCallback`) |
| Complex filters/searches | Use `Set`, `Map`, indexes |
| Frequent repeated computations | Memoization |
| Too many elements in the DOM | Virtualization (`react-window`, `infinite scroll`) |
| Frequent array re-creation | Use mutations carefully |
| Large JSON | Stream reading (`ReadableStream`) |

---

## Summary

> The larger the input data,
> the more the **asymptotic complexity of the algorithm** and the load on memory/CPU show up.

| Data size grows | -> Affects |
|---|---|
| Number of iterations | Execution time |
| Recursion depth | Risk of stack overflow |
| Number of objects | Memory usage |
| List / array length | Number of re-renders (in React) |
| Volume of I/O | Delay from network / disk |

Markdown · drag & drop images · ⌘B / ⌘I shortcuts765 words

For the reviewer

Note to the moderator (optional)

Visible only to the moderator. Helps review go faster.