Fading echo of a once-vivid past

There is a distinct, almost sacred kind of silence that settles over a competitive programmer's workspace when a contest finally ends. The frantic adrenaline of the last two hours dissipates, the racing heartbeat begins to slow down, and the glowing monitor casts long, quiet shadows across the room in the dead of the night. For a very long time, my nights in Chittagong were defined entirely by this intense, exhausting, and exhilarating rhythm. The world outside my window would be asleep, but inside my mind, I was traversing graphs, balancing trees, and wrestling with time limits.

Recently, I found myself logging back into my Codeforces account— not to register for an upcoming Div 2 round, but simply to look back at the trail I had left behind. Wanting to look at my journey objectively, I wrote a script to pull my entire competitive programming history directly from the Codeforces API. To keep the focus on the grand scale of the journey rather than obsessing over the precise minutiae, I rounded all my lifetime statistics down to the nearest floor of tens.

The API returned a ledger of my youth: 180 contests, 4,870 submissions, and 2,610 accepted solutions. It showed a peak rating of 1880—achieved in the grueling battles of early 2023—and a current, much quieter rating of 1550.

Those aren’t just raw numbers in a JSON response. They are a deeply personal ledger of frustration, elation, caffeine-fueled epiphanies, and a testament to a mind trying to push its absolute limits. But as I look at my current rating sitting quietly in the Specialist (cyan) tier, and as I remember the staggering heights of what I almost achieved when I touched the edge of Candidate Master, it all feels like the fading echo of a once-vivid past.

This is the story of my journey through the Codeforces ranks. It is an analytical autopsy of why I flew so close to the sun, a look into the true nature of my algorithmic strengths and mathematical weaknesses, why I ultimately fell just short of the coveted purple handle, and how I finally found peace in letting the obsession go.

The Illusion of the Grind and the Mathematics Mirage

I registered on Codeforces back in June 2019, but my true, unyielding descent into the rabbit hole began in early 2020. Like many others, the pandemic era provided the absolute perfect incubator for a competitive programming addiction. There was nowhere to go, nothing else to do, and no distractions—just the infinite scroll of the problemset, the ticking clock of the virtual contests, and the intoxicating, unmatched hit of dopamine that comes with a bold, green Accepted.

If you were to look at a surface-level summary of my 4,870 submissions, you might draw a completely incorrect conclusion about the type of programmer I was. The raw count shows that I solved over a thousand problems tagged with "Math" and "Greedy." To an untrained eye, I looked like a mathematical prodigy, a contestant who thrived on finding clever number theory tricks and ad-hoc patterns.

But the API data, when analyzed with depth, reveals the illusion of the grind.

When I calculated the average rating of those accepted math and greedy problems, they hovered in the low 1300s to 1400s. The high volume of solves was simply a byproduct of the Codeforces format: Div 2 A and Div 2 B problems are almost exclusively math, greedy, and simple implementation. You have to solve them to survive, so I solved them by the hundreds.

In reality, math was my absolute kryptonite. It was the bane of my existence. Whenever a problem required a deep intuitive leap into number theory, a hyper-specific modular arithmetic observation, or a purely ad-hoc mathematical trick, I felt like I was walking through mud. I didn't have that innate, magical ability to look at a sequence of numbers and instantly "see" the O(1) formula hiding beneath it. I had to grind out every single mathematical observation with brute-force mental effort, paper, and immense frustration. Math wasn't my strength; it was the hurdle I spent my entire career tripping over.

The Algorithmic Sanctuary: Finding Beauty in Structure

So, if math was my weakness, how did I ever reach 1880? How did I climb to the upper echelons of the Expert tier?

The answer lies deeper in the data. When I filter my accepted submissions to look only at the highest-rated problems—the problems that truly pushed my rating upwards and defined my peak—a completely different, incredibly clear picture emerges.

My true strengths were heavily, undeniably rooted in classic, hardcore computer science. My highest-rated accepted solutions belonged to the heavyweights of the algorithmic world:

  • Trees: Average AC rating of ~1930
  • Hashing: Average AC rating of ~1930
  • Shortest Paths: Average AC rating of ~1920
  • DFS and Similar: Average AC rating of ~1870
  • Graphs: Average AC rating of ~1820
  • Dynamic Programming (DP): Average AC rating of ~1700

When the problems stopped being about mathematical parlor tricks and started being about engineering, I thrived. I was an algorithmic purist.

There was a profound, almost architectural beauty in writing a perfectly optimized Dynamic Programming solution. While others stumbled over the complexities of state transitions, I found immense satisfaction in defining the state, managing the base cases, and watching a complex, seemingly exponential problem collapse into a highly efficient O(N log N) or O(N) execution.

Graphs were my sanctuary. The moment a problem description mentioned "cities connected by roads" or "a network of computers," my brain immediately shifted into high gear. I didn't need to guess patterns. I could rely on the unbreakable laws of Depth-First Search, Breadth-First Search, Dijkstra's algorithm, and Disjoint Set Unions. I loved the feeling of taking a chaotic, disconnected set of nodes and imposing order upon them through code. I loved the explicit, deterministic nature of tree diameters, Lowest Common Ancestors (LCA), and heavily optimized Segment Trees.

In these domains, I wasn't guessing. I was building. When a problem required robust data structures and flawless implementation, I could out-code almost anyone in my rating bracket. My hands knew the exact keystrokes to implement a robust Fenwick tree or a complex DSU with path compression. This was where I belonged. This was the engine that drove me to the doorstep of Candidate Master.

The Codeforces Meta and The Gatekeepers

If I was capable of solving 1900- and 2000-rated graph and tree problems, the obvious question is: why did I never cross the 1900 rating threshold? Why did I peak at 1880, agonizingly close to the Purple handle, only to fall back down?

The answer lies in the infamous "meta" of Codeforces problem setting, and the brutal reality of how contests are structured.

Codeforces, particularly in the Div 2 and lower Div 1 tiers, heavily favors contestants with strong ad-hoc and mathematical intuition. A standard Div 2 contest features five to six problems. Problems A and B are speed tests. But Problem C and Problem D are the true gatekeepers. More often than not, Div 2 C and Div 2 D are heavily reliant on obscure parity observations, game theory tricks, or constructive math.

You cannot solve Problem E or Problem F—which are usually the beautiful, heavy algorithmic problems involving DP on trees, advanced Graph Theory, or Data Structures—without first getting past C and D.

This created a massive, insurmountable mismatch between my specific skill set and the platform's meta. I would start a contest, breeze through A and B, and then hit a brick wall on a math-heavy Problem C. I would sit there for 80 excruciating minutes, filling pages of a notebook with scribbled numbers, desperately trying to find the mathematical invariant or the greedy trick that the problem setter had hidden in plain sight.

Meanwhile, Problem E—a beautiful, standard graph problem that perfectly aligned with my mastery of Shortest Paths and Trees—sat completely unread. I had the algorithmic firepower to solve the 2000-rated problem, but I was mathematically gatekept by the 1500-rated problem.

This is what ultimately created my invisible ceiling at 1880. To reach Candidate Master, you need to consistently perform well on the first four problems of a Div 2 round. Because my math skills were hard-capped, I was subjected to immense volatility. If a contest happened to have an algorithmic Problem C and D, my rating would skyrocket. But if a contest was math-heavy, I would bleed rating points.

I was an algorithmic heavyweight trying to compete in a mathematics arena. I had brought a brilliant, highly-tuned graph-theory hammer to a contest that exclusively demanded a mathematical scalpel. I was at the mercy of the problem setters, and eventually, that lack of control took its toll.

The Weight of 1880 and the Inevitable Burnout

In February 2023, the momentum reached its absolute, dizzying peak. My rating hit 1880. I was an established Expert.

For anyone outside the competitive programming bubble, 1880 might just look like an arbitrary number. But inside the bubble, 1900 is a legendary threshold. It is the boundary that separates the dedicated hobbyists from the truly elite, highly respected competitors. Purple—Candidate Master—is the dream that keeps you awake at 3:00 AM. And there I was, sitting a mere 20 points away.

Just one good contest. Just one solid, above-average performance. If I could just get a contest that leaned slightly towards DP or Graphs, I would cross the threshold. I wanted it desperately. I spent hours lying in bed, staring at the ceiling, dreaming about seeing my handle change color on the global leaderboard.

But the pressure I put on myself became suffocating. Every contest felt less like a fun mental exercise and more like a high-stakes exam that would define my self-worth. When the contest countdown timer hit zero, my hands would shake. If I couldn't solve Problem B within the first 15 minutes, panic would set in.

When you tie your emotional stability to a number that updates every two hours based on an unpredictable problem set, the volatility will destroy your mental health. A bad drop in rating would ruin my entire week. I found myself actually fearing the "Register" button. I would look at upcoming contests and hesitate, terrified that a bad performance would push me further away from my Purple dream.

Slowly but surely, the peak faded. The burnout was total and absolute. The math problems felt harder. The graph algorithms I once wrote with joy felt like tedious chores. 1880 became 1800, then 1700, and eventually, I dropped all the way back down to Specialist (1550). The deep blue color I had fought so fiercely to maintain faded away, replaced by the cyan I had fought so hard to escape years prior.

I stepped away. I stopped registering. I stopped grinding. The terminal went quiet, and the nights in Chittagong returned to being just normal, peaceful nights.

Fading Echoes and New Beginnings

Today, my Codeforces profile is a quiet graveyard of past ambitions. The green squares on my activity heatmap are incredibly sparse, scattered like distant, fading stars across the calendar. I went over a year without touching a competitive programming problem.

I didn't reach Candidate Master. I never got my Purple handle. For a long time, in the depths of my burnout, that felt like a colossal, unforgivable failure. It felt like a waste of 4,870 submissions, 180 contests, and countless hours of my youth that I could never get back.

But time provides a beautiful clarity.

Recently, on a quiet evening, I opened Codeforces again. I didn't look at my rating graph. I didn't check the upcoming contest schedule. I just picked a random, highly-rated tree problem from the archive. I grabbed a piece of paper, mapped out the nodes, structured the Depth-First Search in my head, and typed out the code. I didn't rush. I didn't look at a clock. I just wrote the code, piece by piece, enjoying the pure, unadulterated logic of it all.

I submitted it.

Accepted.

A small, genuine smile crept onto my face. There was absolutely no rating pressure. There was no agonizing over the leaderboard, no desperate calculations of how many points I needed to reach the next tier, and no fear of failure. It was just me, a complex puzzle, and the quiet, deeply fulfilling satisfaction of solving it.

My competitive programming journey as a frantic, do-or-die grind is a fading echo of a once-vivid past. The all-consuming intensity that defined those late nights at home during covid is gone, and I am perfectly fine with that. After stepping away for more than a year, I've come to realize that the raw, unadulterated point of this all was never the color of my handle—it was simply the joy of the puzzle.

I'm going to start competing a bit more from now on, but entirely on my own terms. No more shaking hands as the clock ticks down. No more suffocating pressure to protect a rating. Instead, I want to calmly tackle the very things that used to terrify me. I want to step out of my algorithmic sanctuary and patiently chip away at those ad-hoc math tricks without the fear of a dropping leaderboard.

I may not have reached Candidate Master during my relentless grind, but who knows? Perhaps approaching the unknown with a quiet, relaxed mind is the exact key required to finally unlock it. Either way, the race is over. I'm just here for the sheer fun of it, and looking back at the thousands of hours I spent fighting the compiler, I realize this quiet peace is exactly what I needed.