Isosceles triangles with nearest perimeter using JavaScript

Almost Isosceles Triangle

An Almost Isosceles Integer Triangle is a triangle where all side lengths are integers and two sides are almost equal, with their absolute difference being exactly 1 unit of length.

Problem Statement

We need to write a JavaScript function that takes a number representing the desired perimeter of a triangle. The function should find an almost isosceles triangle whose perimeter is nearest to the input perimeter.

For example, if the desired perimeter is 500, the almost isosceles triangle with the nearest perimeter will be [167, 166, 167] with perimeter 500.

Understanding Almost Isosceles Triangles

For a valid almost isosceles triangle with sides a, b, c where |a - b| = 1:

• Triangle inequality must hold: a + b > c, a + c > b, b + c > a
• Two sides differ by exactly 1
• All sides are positive integers

Solution Approach

We'll iterate through possible perimeters near the target and check if we can form a valid almost isosceles triangle:

const findAlmostIsosceles = (targetPerimeter) => {
    // Check perimeters from target downwards and upwards
    for (let diff = 0; diff <= targetPerimeter; diff++) {
        // Check target - diff first
        let result = checkPerimeter(targetPerimeter - diff);
        if (result.length > 0) return result;
        
        // Then check target + diff
        if (diff > 0) {
            result = checkPerimeter(targetPerimeter + diff);
            if (result.length > 0) return result;
        }
    }
    return [];
};

const checkPerimeter = (perimeter) => {
    // For almost isosceles: two sides a, a±1, and third side c
    // Try a and a-1 as the two similar sides
    for (let a = Math.floor(perimeter / 3); a >= 1; a--) {
        let b = a - 1;
        let c = perimeter - a - b;
        
        if (c > 0 && isValidTriangle(a, b, c)) {
            return [a, b, c].sort((x, y) => y - x);
        }
    }
    
    // Try a and a+1 as the two similar sides
    for (let a = Math.floor(perimeter / 3); a >= 1; a--) {
        let b = a + 1;
        let c = perimeter - a - b;
        
        if (c > 0 && isValidTriangle(a, b, c)) {
            return [a, b, c].sort((x, y) => y - x);
        }
    }
    
    return [];
};

const isValidTriangle = (a, b, c) => {
    return (a + b > c) && (a + c > b) && (b + c > a);
};

// Test with perimeter 500
const targetPerimeter = 500;
const result = findAlmostIsosceles(targetPerimeter);
console.log(`Almost isosceles triangle for perimeter ${targetPerimeter}:`, result);
console.log(`Actual perimeter: ${result.reduce((sum, side) => sum + side, 0)}`);

Almost isosceles triangle for perimeter 500: [ 167, 166, 167 ]
Actual perimeter: 500

Example with Different Target

// Test with perimeter 100
const result100 = findAlmostIsosceles(100);
console.log(`Almost isosceles triangle for perimeter 100:`, result100);
console.log(`Actual perimeter: ${result100.reduce((sum, side) => sum + side, 0)}`);

// Test with perimeter 50
const result50 = findAlmostIsosceles(50);
console.log(`Almost isosceles triangle for perimeter 50:`, result50);
console.log(`Actual perimeter: ${result50.reduce((sum, side) => sum + side, 0)}`);

Almost isosceles triangle for perimeter 100: [ 34, 33, 33 ]
Actual perimeter: 100
Almost isosceles triangle for perimeter 50: [ 17, 16, 17 ]
Actual perimeter: 50

Key Points

• The algorithm checks perimeters closest to the target first
• For each perimeter, it tries different combinations where two sides differ by 1
• Triangle inequality validation ensures the result forms a valid triangle
• The solution returns sides in descending order for consistency

Conclusion

This approach efficiently finds almost isosceles triangles by systematically checking perimeters near the target and validating triangle constraints. The algorithm prioritizes exact matches before exploring nearby perimeters.