{"id":10290,"date":"2026-01-28T14:51:58","date_gmt":"2026-01-28T19:51:58","guid":{"rendered":"https:\/\/blogs.mathworks.com\/community\/?p=10290"},"modified":"2026-01-28T16:44:34","modified_gmt":"2026-01-28T21:44:34","slug":"analyzing-cody-solutions","status":"publish","type":"post","link":"https:\/\/blogs.mathworks.com\/community\/2026\/01\/28\/analyzing-cody-solutions\/","title":{"rendered":"Analyzing Cody Solutions – A Guest Post"},"content":{"rendered":"
\n
Cody<\/a> is a game that helps people learn how to code in MATLAB. But something funny is going on these days. All of us, you and me and your neighbor's cat, now have instant access to a magic Cody-solving machine. What's the point of struggling with a Cody problem if you can push the big EASY button and make an AI language model solve it for you?<\/div>\n
Why bother, right? It's kind of like chess. Chess tournaments were once used to determine the best player. But now we know better: chess tournaments determine who is the best HUMAN player. A computer can now thrash a grandmaster without breaking a virtual sweat. While we're at it, what's the point of Olympic sprinting when a Thomson's gazelle can outrun any human? Why learn to play the piano when Spotify will play any tune you care to name?<\/div>\n
The point is this: Human skills and human competitions are still rewarding. You know it because you feel it. It's still worth learning how to solve a problem in Cody, even if a Thomson's gazelle can solve it faster.<\/div>\n
Sorry, I meant to say \"even if Claude Code can solve it faster.\" Although, no disrespect to the gazelles in our readership.<\/div>\n
But even taking this into account, there's still a place for AI in this picture. Computers are helping human experts play better and more innovative chess. Better and more innovative Go. Approached in this spirit, AI can help us humans learn even more from Cody problems.<\/div>\n
With this in mind, I've asked a guest writer to join us this week. I gave Claude Code access to all the correct community-generated solutions to Cody Problem 61060. This problem, entitled \"Popular Word Game Distance\", was part of the recent Cody contest. My prompt to Claude Code went like this:<\/div>\n
Analyze all the solutions to this problem. Group them by algorithmic strategy. Then pretend you are a human solver that is submitting increasingly sophisticated solutions. Describe your path and what you learned along the way.<\/span><\/div>\n
Claude's response, masquerading as a Wordle-playing human, is below. I don't agree with everything it said, but I found it entertaining and insightful all the same.<\/div>\n
Before you read it, I suggest you try to solve the problem yourself. Then see what you think of Claude's analysis.<\/div>\n
Popular Word Game Distance<\/a><\/div>\n

How I Solved Problem 61060<\/h2>\n
My Journey from First Solution to Code Golf Champion by Claude Code<\/span><\/div>\n
When I first read this problem, I thought: \"Okay, this is basically Wordle scoring.\" I play Wordle every morning, so the rules felt familiar\u2014but implementing them? That took some thinking.<\/div>\n
Let me walk you through how my solution evolved, from my initial \"just make it work\" version to increasingly elegant (and shorter!) approaches.<\/div>\n

Attempt 1: The Straightforward Two-Pass Solution<\/h2>\n
First, I made sure I understood the problem.<\/div>\n
\"\"<\/div>\n
The rules are:<\/div>\n
    \n
  1. Green (0 points): x(j) == y(j) - same value, same position<\/li>\n
  2. Yellow (1 point): x(j) == y(k) for some k \u2260 j - same value, different position<\/li>\n
  3. Black (2 points): No match at all<\/li>\n
  4. Critical rule: Each element of y can only be matched ONCE<\/li>\n
  5. Precedence: Green matches happen first, then yellow (left to right)<\/li>\n<\/ol>\n
    That last rule about precedence is crucial! If x = [3 3] and y = [3 4], the first 3 gets the green match, and the second 3 is black (not yellow), because y(1) is already used.<\/div>\n
    I decided to implement it exactly as the problem describes: two passes.<\/div>\n
    \n
    \n
    function <\/span>d = PWGdist1(x, y) <\/span><\/div>\n<\/div>\n
    \n
    % My first solution - clear and correct <\/span><\/span><\/div>\n<\/div>\n
    \n
    n = length(x); <\/span><\/div>\n<\/div>\n
    \n
    score = 2 * ones(1, n); % Initialize all to black (2) <\/span><\/span><\/div>\n<\/div>\n
    \n
    y_used = false(1, n); % Track which elements of y are used <\/span><\/span><\/div>\n<\/div>\n
    \n
    <\/div>\n<\/div>\n
    \n
    % Pass 1: Find all green matches (exact position) <\/span><\/span><\/div>\n<\/div>\n
    \n
    for <\/span>j = 1:n <\/span><\/div>\n<\/div>\n
    \n
    if <\/span>x(j) == y(j) <\/span><\/div>\n<\/div>\n
    \n
    \u00a0\u00a0\u00a0score(j) = 0; % Green <\/span><\/span><\/div>\n<\/div>\n
    \n
    \u00a0\u00a0y_used(j) = true; % Mark this position as used <\/span><\/span><\/div>\n<\/div>\n
    \n
    \u00a0end <\/span><\/span><\/div>\n<\/div>\n
    \n
    end <\/span><\/span><\/div>\n<\/div>\n
    \n
    <\/div>\n<\/div>\n
    \n
    % Pass 2: Find yellow matches (wrong position, but value exists) <\/span><\/span><\/div>\n<\/div>\n
    \n
    for <\/span>j = 1:n <\/span><\/div>\n<\/div>\n
    \n
    \u00a0if <\/span>score(j) == 2 % Only check if not already green <\/span><\/span><\/div>\n<\/div>\n
    \n
    \u00a0\u00a0% Look for x(j) in unused positions of y <\/span><\/span><\/div>\n<\/div>\n
    \n
    \u00a0\u00a0for <\/span>k = 1:n <\/span><\/div>\n<\/div>\n
    \n
    \u00a0\u00a0if <\/span>~y_used(k) && x(j) == y(k) <\/span><\/div>\n<\/div>\n
    \n
    \u00a0\u00a0\u00a0\u00a0score(j) = 1; % Yellow <\/span><\/span><\/div>\n<\/div>\n
    \n
    \u00a0\u00a0\u00a0\u00a0y_used(k) = true; % Mark this position as used <\/span><\/span><\/div>\n<\/div>\n
    \n
    \u00a0\u00a0\u00a0break<\/span>; % Only use first match <\/span><\/span><\/div>\n<\/div>\n
    \n
    \u00a0\u00a0end <\/span><\/span><\/div>\n<\/div>\n
    \n
    \u00a0end <\/span><\/span><\/div>\n<\/div>\n
    \n
    \u00a0end <\/span><\/span><\/div>\n<\/div>\n
    \n
    end <\/span><\/span><\/div>\n<\/div>\n
    \n
    <\/div>\n<\/div>\n
    \n
    % Sum up the total distance <\/span><\/span><\/div>\n<\/div>\n
    \n
    d = sum(score); <\/span><\/div>\n<\/div>\n
    \n
    end<\/span><\/span><\/div>\n<\/div>\n<\/div>\n
    I tried x = [4 3 2 4 2 3 1] and y = [3 1 2 4 1 4 4] from the example. Got 7. Perfect! \u2705<\/div>\n
    This works, but it's pretty verbose. The nested loop in Pass 2 bothers me. MATLAB has better ways to find elements. Let me refactor.<\/div>\n

    Attempt 2: Two-Pass, But More MATLAB-y<\/h2>\n
    I realized I can use find() instead of that inner loop:<\/div>\n
    \n
    \n
    function <\/span>d = PWGdist2(x, y) <\/span><\/div>\n<\/div>\n
    \n
    n = length(x); <\/span><\/div>\n<\/div>\n
    \n
    score = 2 * ones(1, n); <\/span><\/div>\n<\/div>\n
    \n
    y_used = false(1, n); <\/span><\/div>\n<\/div>\n
    \n
    <\/div>\n<\/div>\n
    \n
    % Pass 1: Green matches <\/span><\/span><\/div>\n<\/div>\n
    \n
    for <\/span>j = 1:n <\/span><\/div>\n<\/div>\n
    \n
    \u00a0if <\/span>x(j) == y(j) <\/span><\/div>\n<\/div>\n
    \n
    \u00a0\u00a0 score(j) = 0; <\/span><\/div>\n<\/div>\n
    \n
    \u00a0\u00a0 y_used(j) = true; <\/span><\/div>\n<\/div>\n
    \n
    \u00a0end <\/span><\/span><\/div>\n<\/div>\n
    \n
    end <\/span><\/span><\/div>\n<\/div>\n
    \n
    <\/div>\n<\/div>\n
    \n
    % Pass 2: Yellow matches <\/span><\/span><\/div>\n<\/div>\n
    \n
    for <\/span>j = 1:n <\/span><\/div>\n<\/div>\n
    \n
    \u00a0if <\/span>score(j) == 2 % Only if still black <\/span><\/span><\/div>\n<\/div>\n
    \n
    \u00a0\u00a0% Find first unused position in y with matching value <\/span><\/span><\/div>\n<\/div>\n
    \n
    \u00a0\u00a0k = find(~y_used & y == x(j), 1); <\/span><\/div>\n<\/div>\n
    \n
    \u00a0\u00a0\u00a0if <\/span>~isempty(k) <\/span><\/div>\n<\/div>\n
    \n
    \u00a0\u00a0\u00a0\u00a0 score(j) = 1; <\/span><\/div>\n<\/div>\n
    \n
    \u00a0\u00a0\u00a0\u00a0y_used(k) = true; <\/span><\/div>\n<\/div>\n
    \n
    \u00a0\u00a0\u00a0end <\/span><\/span><\/div>\n<\/div>\n
    \n
    \u00a0\u00a0end <\/span><\/span><\/div>\n<\/div>\n
    \n
    end <\/span><\/span><\/div>\n<\/div>\n
    \n
    <\/div>\n<\/div>\n
    \n
    d = sum(score); <\/span><\/div>\n<\/div>\n
    \n
    end<\/span><\/span><\/div>\n<\/div>\n<\/div>\n
    Better! The logic is clearer, and that nested loop is gone. Metric is 109. Not bad for a clear, readable solution.<\/div>\n

    Attempt 3: Wait, Why Two Passes? Let's Get Greedy!<\/h2>\n
    As I looked at my two-pass solution, I had a realization: What if I just remove the green matches entirely, then process what's left?<\/div>\n
    Think about it:<\/div>\n
      \n
    • Green matches contribute 0 to the distance<\/li>\n
    • They also \"consume\" elements from both x and y<\/li>\n
    • If I remove them first, I only need to deal with potential yellow\/black matches<\/li>\n<\/ul>\n
      Here's the key insight: After removing greens, every remaining element is either:<\/div>\n
        \n
      • Yellow (1 point): Found in remaining y \u2192 remove from y after matching<\/li>\n
      • Black (2 points): Not found in remaining y<\/li>\n<\/ul>\n
        Greedy Loop Implementation<\/div>\n
        \n
        \n
        function <\/span>d = PWGdist3(x, y) <\/span><\/div>\n<\/div>\n
        \n
        % Remove all green matches first <\/span><\/span><\/div>\n<\/div>\n
        \n
        green_mask = (x == y); <\/span><\/div>\n<\/div>\n
        \n
        x(green_mask) = []; <\/span><\/div>\n<\/div>\n
        \n
        y(green_mask) = []; <\/span><\/div>\n<\/div>\n
        \n
        <\/div>\n<\/div>\n
        \n
        % Start with worst case: all remaining are black <\/span><\/span><\/div>\n<\/div>\n
        \n
        d = 2 * length(x); <\/span><\/div>\n<\/div>\n
        \n
        <\/div>\n<\/div>\n
        \n
        % Check each remaining element of x <\/span><\/span><\/div>\n<\/div>\n
        \n
        for <\/span>i = 1:length(x) <\/span><\/div>\n<\/div>\n
        \n
        \u00a0% Is x(i) in y? <\/span><\/span><\/div>\n<\/div>\n
        \n
        \u00a0idx = find(y == x(i), 1); <\/span><\/div>\n<\/div>\n
        \n
        \u00a0if <\/span>~isempty(idx) <\/span><\/div>\n<\/div>\n
        \n
        \u00a0\u00a0% Found! It's yellow, not black <\/span><\/span><\/div>\n<\/div>\n
        \n
        \u00a0\u00a0d = d - 1; % Change from 2 (black) to 1 (yellow) <\/span><\/span><\/div>\n<\/div>\n
        \n
        \u00a0\u00a0y(idx) = []; % Remove from y so it can't be matched again <\/span><\/span><\/div>\n<\/div>\n
        \n
        \u00a0end <\/span><\/span><\/div>\n<\/div>\n
        \n
        end <\/span><\/span><\/div>\n<\/div>\n
        \n
        end<\/span><\/span><\/div>\n<\/div>\n<\/div>\n
        This is cleaner! Single loop, clear logic. Metric: 74.<\/div>\n
        But wait... I'm modifying the length of vectors inside a loop. That makes me nervous. Let me test thoroughly.<\/div>\n
        Example case still gives 7. \u2705 Test: x=[1 1 1], y=[1 2 3] gives 4. \u2705 Test: x=[3 3], y=[3 4] gives 2. \u2705<\/div>\n
        Excellent! This works.<\/div>\n
        But I can make this more compact. Instead of looping over indices, loop over values directly:<\/div>\n
        \n
        \n
        function <\/span>d = PWGdist4(x, y) <\/span><\/div>\n<\/div>\n
        \n
        v = x ~= y; % Logical mask for non-greens <\/span><\/span><\/div>\n<\/div>\n
        \n
        d = 2 * sum(v); % Start with all black <\/span><\/span><\/div>\n<\/div>\n
        \n
        y = y(v); % Keep only non-green y's <\/span><\/span><\/div>\n<\/div>\n
        \n
        <\/div>\n<\/div>\n
        \n
        for <\/span>val = x(v) % Loop over non-green x values <\/span><\/span><\/div>\n<\/div>\n
        \n
        \u00a0idx = find(y == val, 1); <\/span><\/div>\n<\/div>\n
        \n
        \u00a0if <\/span>~isempty(idx) <\/span><\/div>\n<\/div>\n
        \n
        \u00a0\u00a0d = d - 1; <\/span><\/div>\n<\/div>\n
        \n
        \u00a0\u00a0y(idx) = []; <\/span><\/div>\n<\/div>\n
        \n
        \u00a0end <\/span><\/span><\/div>\n<\/div>\n
        \n
        end <\/span><\/span><\/div>\n<\/div>\n
        \n
        end<\/span><\/span><\/div>\n<\/div>\n<\/div>\n
        Nice! The for val = x(v) is more compact than indexing. Metric: 61. Pretty good!<\/div>\n

        Attempt 4: The Breakthrough - Think Mathematically, Not Procedurally<\/h2>\n
        After submitting my greedy solution, I looked at the leaderboard. Someone had a solution with metric 37! How?!<\/div>\n
        I read their code (credited to Takumi) and had a genuine \"aha!\" moment. They weren't simulating the game at all. They were counting.<\/div>\n
        The mathematical insight: Think about it differently:<\/div>\n
          \n
        • What's the maximum possible distance? 2 * length(x) (if everything is black)<\/li>\n
        • How much do we reduce it? By the number of matches (green + yellow)<\/li>\n
        • Green matches reduce by 2 (from black to green)<\/li>\n
        • Yellow matches reduce by 1 (from black to yellow)<\/li>\n<\/ul>\n
          But here's the trick: How many total matches (green + yellow) can we have?<\/div>\n
          For each unique value in union(x, y), the number of matches is limited by:<\/div>\n
          min(count in x, count in y)<\/div>\n
          If x has three 5's and y has two 5's, we can match at most two 5's.<\/div>\n
          The Histogram Approach<\/div>\n
          \n
          \n
          function <\/span>d = PWGdist5(x, y) <\/span><\/div>\n<\/div>\n
          \n
          % Get all unique values <\/span><\/span><\/div>\n<\/div>\n
          \n
          u = union(x, y); <\/span><\/div>\n<\/div>\n
          \n
          <\/div>\n<\/div>\n
          \n
          % Count occurrences in each vector <\/span><\/span><\/div>\n<\/div>\n
          \n
          cx = histc(x, u); <\/span><\/div>\n<\/div>\n
          \n
          cy = histc(y, u); <\/span><\/div>\n<\/div>\n
          \n
          <\/div>\n<\/div>\n
          \n
          % Total matches (green + yellow) for each value <\/span><\/span><\/div>\n<\/div>\n
          \n
          total_matches = sum(min(cx, cy)); <\/span><\/div>\n<\/div>\n
          \n
          <\/div>\n<\/div>\n
          \n
          % Green matches <\/span><\/span><\/div>\n<\/div>\n
          \n
          green_matches = sum(x == y); <\/span><\/div>\n<\/div>\n
          \n
          <\/div>\n<\/div>\n
          \n
          % Calculate distance <\/span><\/span><\/div>\n<\/div>\n
          \n
          % Start with max (all black): 2 * length(x) <\/span><\/span><\/div>\n<\/div>\n
          \n
          % Subtract yellow+green: -total_matches <\/span><\/span><\/div>\n<\/div>\n
          \n
          % Subtract extra for greens: -green_matches <\/span><\/span><\/div>\n<\/div>\n
          \n
          d = 2 * length(x) - total_matches - green_matches; <\/span><\/div>\n<\/div>\n
          \n
          end<\/span><\/span><\/div>\n<\/div>\n<\/div>\n
          Let me verify with the example:<\/div>\n