Color the Triangle Red - Practice Coding Problems

Color the Triangle Red - Problem

Array Math Hard

Imagine you're a digital artist working with a beautiful equilateral triangle canvas made up of smaller triangular tiles. Your goal is to create a "viral coloring effect" where red color spreads automatically across the entire triangle!

The Setup: You have an equilateral triangle of side length n, divided into n² unit triangular tiles. The triangle has n rows, where row i contains 2i - 1 triangles, indexed as (i, 1) to (i, 2i - 1).

The Magic Rule: Once you initially color k triangles red, an automatic spreading algorithm runs:

🔍 Find any white triangle that has at least 2 red neighbors
🎨 Color it red
🔄 Repeat until no more triangles can be colored

Your Mission: Find the minimum number of triangles to color initially so that the spreading algorithm eventually colors the entire triangle red. Return the coordinates of these initial triangles.

Note: Two triangles are neighbors if they share a side. For example, (1,1) and (2,2) are neighbors, but (2,2) and (3,3) are not.

Input & Output

Constraints

Asked in

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(2^(n²) × n²)	O(n²)	Try every possible combination of initial triangles until finding the minimum set that works
Optimized Strategy (Mathematical Analysis)	O(3^(n²/3))	O(n²)	Use geometric insights to identify critical positions that must be colored initially

Brute Force (Try All Combinations) — Algorithm Steps

Start with k=1, try all single triangle combinations
For each combination, simulate the spreading algorithm
Check if all triangles become red after spreading
If not, increment k and try all k-triangle combinations
Return the first valid combination found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All Positions

Create list of all triangle coordinates in the n×n triangle

Try k=1

Test each single triangle as the initial red triangle

Simulate Spread

Run the spreading algorithm to see if entire triangle becomes red

Increment k

If no single triangle works, try all pairs, then triplets, etc.

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

typedef struct {
    int row, col;
} Coordinate;

typedef struct {
    char key[20];
    bool value;
} HashEntry;

int** colorTheTriangle(int n, int* returnSize, int** returnColumnSizes) {
    // Generate all triangle coordinates
    Coordinate* triangles = malloc(n * n * sizeof(Coordinate));
    int triangleCount = 0;
    
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= 2 * i - 1; j++) {
            triangles[triangleCount++] = (Coordinate){i, j};
        }
    }
    
    // Try combinations starting from k=1
    for (int k = 1; k <= triangleCount; k++) {
        int* indices = malloc(k * sizeof(int));
        if (tryKCombination(triangles, triangleCount, k, 0, indices, 0, n)) {
            int** result = malloc(k * sizeof(int*));
            *returnColumnSizes = malloc(k * sizeof(int));
            *returnSize = k;
            
            for (int i = 0; i < k; i++) {
                result[i] = malloc(2 * sizeof(int));
                result[i][0] = triangles[indices[i]].row;
                result[i][1] = triangles[indices[i]].col;
                (*returnColumnSizes)[i] = 2;
            }
            
            free(indices);
            free(triangles);
            return result;
        }
        free(indices);
    }
    
    free(triangles);
    *returnSize = 0;
    return NULL;
}

bool tryKCombination(Coordinate* triangles, int triangleCount, int k, int start, int* indices, int depth, int n) {
    if (depth == k) {
        // Test this combination
        Coordinate* combo = malloc(k * sizeof(Coordinate));
        for (int i = 0; i < k; i++) {
            combo[i] = triangles[indices[i]];
        }
        
        bool result = simulate(combo, k, triangles, triangleCount, n);
        free(combo);
        return result;
    }
    
    for (int i = start; i <= triangleCount - (k - depth); i++) {
        indices[depth] = i;
        if (tryKCombination(triangles, triangleCount, k, i + 1, indices, depth + 1, n)) {
            return true;
        }
    }
    
    return false;
}

bool simulate(Coordinate* initialRed, int initialCount, Coordinate* triangles, int triangleCount, int n) {
    HashEntry* red = malloc(triangleCount * sizeof(HashEntry));
    int redCount = 0;
    
    // Initialize with initial red triangles
    for (int i = 0; i < initialCount; i++) {
        sprintf(red[redCount].key, "%d,%d", initialRed[i].row, initialRed[i].col);
        red[redCount].value = true;
        redCount++;
    }
    
    bool changed = true;
    while (changed) {
        changed = false;
        for (int i = 0; i < triangleCount; i++) {
            char key[20];
            sprintf(key, "%d,%d", triangles[i].row, triangles[i].col);
            
            bool isRed = false;
            for (int j = 0; j < redCount; j++) {
                if (strcmp(red[j].key, key) == 0) {
                    isRed = true;
                    break;
                }
            }
            
            if (!isRed) {
                int redNeighbors = countRedNeighbors(triangles[i], red, redCount, n);
                if (redNeighbors >= 2) {
                    strcpy(red[redCount].key, key);
                    red[redCount].value = true;
                    redCount++;
                    changed = true;
                }
            }
        }
    }
    
    bool result = (redCount == triangleCount);
    free(red);
    return result;
}

int countRedNeighbors(Coordinate triangle, HashEntry* red, int redCount, int n) {
    Coordinate neighbors[5];
    int neighborCount = 0;
    
    int row = triangle.row;
    int col = triangle.col;
    
    // Same row neighbors
    if (col > 1) neighbors[neighborCount++] = (Coordinate){row, col - 1};
    if (col < 2 * row - 1) neighbors[neighborCount++] = (Coordinate){row, col + 1};
    
    // Adjacent row neighbors
    if (row > 1) neighbors[neighborCount++] = (Coordinate){row - 1, (col + 1) / 2};
    if (row < n) {
        neighbors[neighborCount++] = (Coordinate){row + 1, 2 * col - 1};
        neighbors[neighborCount++] = (Coordinate){row + 1, 2 * col};
    }
    
    int redNeighborCount = 0;
    for (int i = 0; i < neighborCount; i++) {
        if (neighbors[i].row >= 1 && neighbors[i].row <= n && 
            neighbors[i].col >= 1 && neighbors[i].col <= 2 * neighbors[i].row - 1) {
            char nbKey[20];
            sprintf(nbKey, "%d,%d", neighbors[i].row, neighbors[i].col);
            
            for (int j = 0; j < redCount; j++) {
                if (strcmp(red[j].key, nbKey) == 0) {
                    redNeighborCount++;
                    break;
                }
            }
        }
    }
    
    return redNeighborCount;
}

int main() {
    int returnSize;
    int* returnColumnSizes;
    int** result = colorTheTriangle(3, &returnSize, &returnColumnSizes);
    
    printf("[\n");
    for (int i = 0; i < returnSize; i++) {
        printf("  [%d, %d]%s\n", result[i][0], result[i][1], (i == returnSize - 1) ? "" : ",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^(n²) × n²)

We try all 2^(n²) possible combinations, and for each combination, we simulate the spreading algorithm which takes O(n²) time

⚠ Quadratic Growth

Space Complexity

O(n²)

Space to store the triangle state and current combination being tested

⚠ Quadratic Space

25.0K Views

Medium Frequency

~15 min Avg. Time

850 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen