{"id":1817,"date":"2024-10-15T10:41:19","date_gmt":"2024-10-15T10:41:19","guid":{"rendered":"https:\/\/algocademy.com\/blog\/algorithmic-thinking-developing-problem-solving-skills-for-programming-success\/"},"modified":"2026-10-15T10:34:48","modified_gmt":"2026-10-15T10:34:48","slug":"algorithmic-thinking-developing-problem-solving-skills-for-programming-success","status":"publish","type":"post","link":"https:\/\/algocademy.com\/blog\/algorithmic-thinking-developing-problem-solving-skills-for-programming-success\/","title":{"rendered":"Algorithmic Thinking: How to Build Problem-Solving Skills"},"content":{"rendered":"

Algorithmic thinking is the ability to turn a vague problem into a precise sequence of steps that always works and is fast enough for the input size. It has less to do with knowing named algorithms than with a habit: define the problem exactly, solve a small case by hand, notice what you did, generalise it, and check its cost. You build it with practice on that habit, and the rest of this post shows the habit applied to a real problem.<\/p>\n

The five steps<\/h2>\n
    \n
  1. Restate the problem precisely.<\/strong> What are the inputs, their types and size limits? What exactly is the output? What counts as valid? Ask about empty input, duplicates, negative numbers and ties.<\/li>\n
  2. Solve small examples by hand.<\/strong> Pick two or three inputs, including a tricky one, and work out the answers without thinking about code. Pay attention to what you actually do.<\/li>\n
  3. Write down the simplest correct method.<\/strong> Usually brute force. It gives you a correctness baseline and a complexity to beat.<\/li>\n
  4. Find the waste and remove it.<\/strong> Where does the simple method repeat work, or look at data it could have ruled out? That question leads to a better data structure or technique.<\/li>\n
  5. Verify.<\/strong> Trace your steps on the examples and edge cases, state the time and space complexity, and compare against the brute force on random inputs if you can.<\/li>\n<\/ol>\n

    Decomposition (breaking the problem into smaller ones) and abstraction (ignoring details that do not matter, such as treating a map as a graph) run through all five steps. Our post on breaking down complex problems<\/a> covers decomposition in more detail.<\/p>\n

    Worked example: longest substring without repeating characters<\/h2>\n

    1. Restate.<\/strong> Input: a string s<\/code>. Output: the length of the longest contiguous substring in which no character appears twice. For \"abcabcbb\"<\/code> the answer is 3 (\"abc\"<\/code>). For \"\"<\/code> it is 0.<\/p>\n

    2. By hand.<\/strong> In \"pwwkew\"<\/code> I scan left to right. \"pw\"<\/code> is fine; the next w<\/code> repeats, so I must drop everything up to and including the first w<\/code>. Continue from the second w<\/code>: \"wke\"<\/code> is length 3, then the next w<\/code> repeats again. The answer is 3. Note what I did: I kept a stretch of characters, and when a repeat appeared I moved the start of the stretch forward past the earlier copy.<\/p>\n

    3. Brute force.<\/strong> Try every start index and extend until a repeat appears:<\/p>\n

    def brute(s):\n    best = 0\n    for i in range(len(s)):\n        seen = set()\n        for j in range(i, len(s)):\n            if s[j] in seen:\n                break\n            seen.add(s[j])\n            best = max(best, j - i + 1)\n    return best<\/code><\/pre>\n
    This is correct. Its time is O(n\u00b2) in the worst case, and it also re-reads the same characters from many different start positions.<\/p>\n
    4. Remove the waste.<\/strong> When the inner loop restarts at i + 1<\/code>, it re-scans characters it already knew were distinct. My hand method never went backwards. It kept a start index and, for each character, the last position where it appeared. On a repeat inside the current stretch, jump the start to just after that earlier position.<\/p>\n
    def window(s):\n    last = {}              # char -> most recent index\n    start = best = 0\n    for i, ch in enumerate(s):\n        if ch in last and last[ch] >= start:\n            start = last[ch] + 1\n        last[ch] = i\n        best = max(best, i - start + 1)\n    return best<\/code><\/pre>\n
    Each character is visited once, so this is O(n) time, with extra space bounded by the number of distinct characters.<\/p>\n
    5. Verify.<\/strong> Run both functions on examples, including \"abba\"<\/code>, which exposes the need for the check last[ch] >= start<\/code>. Without it, when the last a<\/code> is read, the code would jump the start backwards to index 1. Output from the code above:<\/p>\n
    'abcabcbb' 3 3\n'bbbbb' 1 1\n'pwwkew' 3 3\n'' 0 0\n'a' 1 1\n'abba'     2 2<\/code><\/pre>\n
    Each row is the input followed by the results of brute<\/code> and window<\/code>. The two also agreed on 2,000 random strings over a three-letter alphabet. Comparing a fast solution against a slow, obviously correct one is the cheapest strong test you have. This is the sliding window pattern; the Longest Subarray Without Repeating<\/a> lessons on AlgoCademy take the same problem from brute force to the optimised version in steps.<\/p>\n
    The mental moves behind the steps<\/h2>\n