Why 100 Lines of Code Can Be Better Than 2

In programming, it's easy to assume that shorter code is better code. It looks clean, compact, and clever, and we might believe it uses less memory, and runs faster.

But here's the catch:

Shorter doesn’t always mean smarter or more efficient.

Sometimes, a few extra lines of code can outperform a clever one-liner, especially when it comes to reducing costly operations.

Let’s look at a real-world analogy to make this clear.

---

📦 Product Boxes at a Factory

9 identical product boxes are ready to ship. One of them has a manufacturing defect, it's heavier because it contains extra metal parts.
Your task is to detect and remove it before quality inspection fails.

---

Approach 1: Straightforward

You weigh each box one by one.

int boxes[9] = {1, 1, 1, 1, 1, 1, 1, 4, 1}; // 4 is the heavier box

for (int i = 0; i < 9; i++) {
    if (boxes[i] > 1) {
        return boxes[i];
    }
}

Number of weigh-ins: Up to 9
Efficiency: Low — especially if the heavy box is at the end.

---

Approach 2: Smart Approach

Split the 9 boxes into 3 groups of 3 and compare their total weights.

int boxes[9] = {1, 1, 2, 1, 1, 1, 1, 1, 1}; // 2 is the heavier box

int group1 = boxes[0] + boxes[1] + boxes[2];
int group2 = boxes[3] + boxes[4] + boxes[5];
int group3 = boxes[6] + boxes[7] + boxes[8];

if (group1 == group2) {

    // Faulty box is in group3
    if (boxes[6] > boxes[7]) 
          return boxes[6];
    else if (boxes[7] > boxes[6]) 
          return boxes[7];
    else 
          return boxes[8];

} else if (group1 > group2) {

    // Faulty box is in group1
    if (boxes[0] > boxes[1]) 
          return boxes[0];
    else if (boxes[1] > boxes[0]) 
          return boxes[1];
    else 
          return boxes[2];

} else {

    // Faulty box is in group2
    if (boxes[3] > boxes[4]) 
          return boxes[3];
    else if (boxes[4] > boxes[3]) 
          return boxes[4];
    else 
          return boxes[5];
}

Number of weigh-ins: Just 2 or 3
Efficiency: Much better, faster fault detection.

---

Conclusion

While concise code can be elegant, it's not always the most effective solution. As we've seen, a longer approach can significantly improve performance and clarity.

Short code isn’t automatically good code.

What's more important is whether your solution is readable, maintainable, and efficient.

---

Enjoyed this post?
Found it helpful? Feel free to leave a comment, share it with your team, or follow along for more.

🌐 shanedsouza.com