Find Triangular Sum of an Array - Practice Coding Problems

Find Triangular Sum of an Array - Problem

Imagine you have a digital array reduction machine that transforms arrays using a special triangular process! 🔺

Given a 0-indexed integer array nums where each element is a digit between 0 and 9, you need to find the triangular sum by repeatedly applying this transformation:

Check termination: If the array has only 1 element, that's your answer!
Create new array: Build a new array of length n-1
Sum adjacent pairs: For each position i, set newArray[i] = (nums[i] + nums[i+1]) % 10
Replace and repeat: Use the new array and go back to step 1

This creates a triangular pattern where each level has one fewer element, similar to Pascal's triangle but with modulo arithmetic! The process continues until you're left with a single digit.

Example: [1,2,3,4,5] → [3,5,7,9] → [8,2,6] → [0,8] → [8]

Input & Output

example_1.py — Small Array

$ Input: [1,2,3,4,5]

› Output: 8

💡 Note: Step by step: [1,2,3,4,5] → [3,5,7,9] → [8,2,6] → [0,8] → [8]. Each level sums adjacent elements mod 10.

example_2.py — Single Element

$ Input: [5]

› Output: 5

💡 Note: When array has only one element, that element is already the triangular sum.

example_3.py — Two Elements

$ Input: [7,3]

› Output: 0

💡 Note: Simple case: (7 + 3) % 10 = 10 % 10 = 0.

Visualization

Tap to expand

Understanding the Visualization

Build Initial Pyramid

Place all array elements as the base level of the pyramid

Combine Adjacent Blocks

Each pair of adjacent blocks creates one block above them with their sum mod 10

Repeat Until One Block

Continue the process level by level until only one block remains at the top

Mathematical Insight

Each original block contributes to the final result with a Pascal's triangle coefficient weight

Key Takeaway

🎯 Key Insight: The triangular sum process follows Pascal's triangle - each element's contribution can be calculated directly using binomial coefficients, eliminating the need for step-by-step simulation.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We process n + (n-1) + (n-2) + ... + 1 = n(n+1)/2 elements total

⚠ Quadratic Growth

Space Complexity

O(n)

Need space for the current array being processed

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 1000
0 ≤ nums[i] ≤ 9
Each element is a single digit
Array is 0-indexed

Asked in

G Google 15 ⊞ Microsoft 12 a Amazon 8 f Meta 6

The optimal approach uses combinatorics to recognize that each element contributes to the final sum with weight equal to a binomial coefficient from Pascal's triangle. This reduces the O(n²) simulation to an elegant O(n) mathematical solution.

Common Approaches

Approach	Time	Space	Notes
✓ Simulation Approach	O(n²)	O(n)	Simulate the triangular reduction process step by step
Mathematical Approach (Optimal)	O(n)	O(1)	Use Pascal's triangle coefficients to calculate result directly

Simulation Approach — Algorithm Steps

Start with the original array
While array length > 1, create new array of length n-1
For each position i, set newArray[i] = (array[i] + array[i+1]) % 10
Replace current array with new array
Return the single remaining element

Visualization

Tap to expand

Step-by-Step Walkthrough

Original Array

Start with [1,2,3,4,5]

Level 1 Reduction

Sum adjacent: [(1+2)%10, (2+3)%10, (3+4)%10, (4+5)%10] = [3,5,7,9]

Level 2 Reduction

Continue: [(3+5)%10, (5+7)%10, (7+9)%10] = [8,2,6]

Level 3 Reduction

Further: [(8+2)%10, (2+6)%10] = [0,8]

Final Result

Last step: [(0+8)%10] = [8]

Code -

solution.c — C

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

int triangularSum(int* nums, int numsSize) {
    while (numsSize > 1) {
        for (int i = 0; i < numsSize - 1; i++) {
            nums[i] = (nums[i] + nums[i + 1]) % 10;
        }
        numsSize--;
    }
    return nums[0];
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int nums[100];
    int size = 0;
    char* token = strtok(line, "[],\n");
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    printf("%d\n", triangularSum(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We process n + (n-1) + (n-2) + ... + 1 = n(n+1)/2 elements total

⚠ Quadratic Growth

Space Complexity

O(n)

Need space for the current array being processed

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 1000
0 ≤ nums[i] ≤ 9
Each element is a single digit
Array is 0-indexed

28.4K Views

Medium Frequency

~15 min Avg. Time

856 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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Simulation Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler