Mountain Cabin Signal Range

Published at05 Jan 2026

String Easy 4 views

Like30

In Mountain Cabin Signal Range, you are given an array of numbers and need to return the overall range of the data. Here, range means the largest value minus the smallest value.

This is not about counting how many values there are between them, and it is not about the difference between neighboring entries. You should look across the whole array, find the maximum number, find the minimum number, and subtract.

For example, if the input is altitudes = [1000,2000,500], the answer is 1500 because the highest value is 2000 and the lowest value is 500. If the input is altitudes = [10,20,30], the answer is 20. If all values are the same, like [5,5,5], the range is 0 because the maximum and minimum are equal.

An empty array should return 0 in this export. So the task is to find the largest and smallest values in the array and return their difference, or 0 when the list is empty.

Example Input & Output

Example 1

Input

altitudes = [1000,2000,500]

Output

1500

Explanation

The maximum is 2000 and the minimum is 500, so the range is 1500.

Example 2

Input

altitudes = [10,20,30]

Output

Explanation

The highest value is 30 and the lowest is 10, so the difference is 20.

Example 3

Input

altitudes = [5,5,5]

Output

Explanation

When every value is the same, the minimum and maximum match, so the range is 0.

Algorithm Flow

Recommendation Algorithm Flow for Mountain Cabin Signal Range

Solution Approach

A clean way to solve this problem is to scan the array once while keeping track of two values: the smallest number seen so far and the largest number seen so far. Once the scan is finished, subtract the minimum from the maximum. That directly gives the range.

The main reason this works well is that the problem only cares about the extreme ends of the array. You do not need to sort the full list, compare every pair, or build extra structures. Sorting would work, but it would do more work than necessary because the middle values do not affect the final answer at all.

In JavaScript, the logic can look like this:

if (altitudes.length === 0) return 0;

let minVal = altitudes[0];
let maxVal = altitudes[0];

for (let i = 1; i < altitudes.length; i++) {
  if (altitudes[i] < minVal) minVal = altitudes[i];
  if (altitudes[i] > maxVal) maxVal = altitudes[i];
}

return maxVal - minVal;

This starts by handling the empty-array case, because there is no minimum or maximum when the list has no values. The tests for this problem expect 0 there, so returning early is the simplest choice.

For a non-empty array, the first element is used to initialize both minVal and maxVal. Then the loop checks each remaining value. If the current number is smaller than the current minimum, update minVal. If it is larger than the current maximum, update maxVal. At the end, the difference maxVal - minVal is the range.

This handles all the key cases naturally. If all values are equal, the minimum and maximum stay the same, so the answer becomes 0. If the array contains negative values, the same logic still works because numeric comparison already handles them correctly. In an array like [100, -100], the minimum becomes -100, the maximum becomes 100, and the range is 200.

The time complexity is O(n) because you inspect each element once. The space complexity is O(1) because only a few variables are used. So the full strategy is: return 0 for an empty array, otherwise track the minimum and maximum in one pass and subtract them at the end.

Best Answers
These are the verified best solutions for this Challenge. You can use them as a reference to improve your solution.

java

class Solution {
    public double calculate_min_range(int[][] cabins) {
        int n = cabins.length;
        if (n <= 1) return 0.0;
        double[] minD = new double[n];
        Arrays.fill(minD, Double.MAX_VALUE);
        minD[0] = 0.0;
        boolean[] visited = new boolean[n];
        double res = 0.0;
        for (int i = 0; i < n; i++) {
            int u = -1;
            for (int j = 0; j < n; j++) {
                if (!visited[j] && (u == -1 || minD[j] < minD[u])) u = j;
            }
            visited[u] = true;
            res = Math.max(res, minD[u]);
            for (int v = 0; v < n; v++) {
                if (!visited[v]) {
                    double d = Math.sqrt(Math.pow(cabins[u][0] - cabins[v][0], 2) + Math.pow(cabins[u][1] - cabins[v][1], 2));
                    minD[v] = Math.min(minD[v], d);
                }
            }
        }
        return res;
    }
}

javascript

function calculate_min_range(cabins) {
    const n = cabins.length;
    if (n <= 1) return 0;
    const dist = (p1, p2) => Math.sqrt((p1[0]-p2[0])**2 + (p1[1]-p2[1])**2);
    const minD = new Array(n).fill(Infinity);
    minD[0] = 0;
    const visited = new Array(n).fill(false);
    let res = 0;
    for (let i = 0; i < n; i++) {
        let u = -1;
        for (let j = 0; j < n; j++) {
            if (!visited[j] && (u === -1 || minD[j] < minD[u])) u = j;
        }
        visited[u] = true;
        res = Math.max(res, minD[u]);
        for (let v = 0; v < n; v++) {
            if (!visited[v]) minD[v] = Math.min(minD[v], dist(cabins[u], cabins[v]));
        }
    }
    return res;
}

php

function calculate_min_range($cabins) {
    $n = count($cabins);
    if ($n <= 1) return 0;
    $dist = function($p1, $p2) {
        return sqrt(pow($p1[0]-$p2[0], 2) + pow($p1[1]-$p2[1], 2));
    };
    $minD = array_fill(0, $n, INF);
    $minD[0] = 0;
    $visited = array_fill(0, $n, false);
    $res = 0;
    for ($i = 0; $i < $n; $i++) {
        $u = -1;
        for ($j = 0; $j < $n; $j++) {
            if (!$visited[$j] && ($u == -1 || $minD[$j] < $minD[$u])) $u = $j;
        }
        $visited[$u] = true;
        $res = max($res, $minD[$u]);
        for ($v = 0; $v < $n; $v++) {
            if (!$visited[$v]) $minD[$v] = min($minD[$v], $dist($cabins[$u], $cabins[$v]));
        }
    }
    return $res;
}

python

import math
def calculate_min_range(cabins: list) -> float:
    n = len(cabins)
    if n <= 1: return 0.0
    def dist(p1, p2):
        return math.sqrt((p1[0]-p2[0])**2 + (p1[1]-p2[1])**2)
    min_d = [float('inf')] * n
    min_d[0] = 0.0
    visited = [False] * n
    res = 0.0
    for _ in range(n):
        u = -1
        for i in range(n):
            if not visited[i] and (u == -1 or min_d[i] < min_d[u]):
                u = i
        visited[u] = True
        res = max(res, min_d[u])
        for v in range(n):
            if not visited[v]:
                min_d[v] = min(min_d[v], dist(cabins[u], cabins[v]))
    return res

rust

pub fn calculate_min_range(cabins: Vec<Vec<i32>>) -> f64 {
    let n = cabins.len();
    if n <= 1 { return 0.0; }
    let mut min_d = vec![f64::MAX; n];
    min_d[0] = 0.0;
    let mut visited = vec![false; n];
    let mut res = 0.0;
    for _ in 0..n {
        let mut u = None;
        for i in 0..n {
            if !visited[i] && (u.is_none() || min_d[i] < min_d[u.unwrap()]) { u = Some(i); }
        }
        let u = u.unwrap();
        visited[u] = true;
        res = res.max(min_d[u]);
        for v in 0..n {
            if !visited[v] {
                let d = (((cabins[u][0] - cabins[v][0]).pow(2) + (cabins[u][1] - cabins[v][1]).pow(2)) as f64).sqrt();
                min_d[v] = min_d[v].min(d);
            }
        }
    }
    res
}

typescript

function calculate_min_range(cabins: number[][]): number {
    const n = cabins.length;
    if (n <= 1) return 0;
    const dist = (p1: number[], p2: number[]) => Math.sqrt((p1[0]-p2[0])**2 + (p1[1]-p2[1])**2);
    const minD = new Array(n).fill(Infinity);
    minD[0] = 0;
    const visited = new Array(n).fill(false);
    let res = 0;
    for (let i = 0; i < n; i++) {
        let u = -1;
        for (let j = 0; j < n; j++) {
            if (!visited[j] && (u === -1 || minD[j] < minD[u])) u = j;
        }
        visited[u] = true;
        res = Math.max(res, minD[u]);
        for (let v = 0; v < n; v++) {
            if (!visited[v]) minD[v] = Math.min(minD[v], dist(cabins[u], cabins[v]));
        }
    }
    return res;
}

Related String Challenges

Comments (0)

Join the Discussion

Share your thoughts, ask questions, or help others with this Challenge.

Mountain Cabin Signal Range

Example Input & Output

Algorithm Flow

Solution Approach

Best AnswersThese are the verified best solutions for this Challenge. You can use them as a reference to improve your solution.

Solutions Coming Soon

Related String Challenges

Wildlife Bridge Network Scan

Equinox Gate Verdict

Reverse String

Check Palindrome

Vowel Counter

String Length

Comments (0)

Join the Discussion

Best Answers
These are the verified best solutions for this Challenge. You can use them as a reference to improve your solution.