City Bus Loop Access

Published at05 Jan 2026

Tree Medium 6 views

Like27

In City Bus Loop Access, the tested task is a yes-or-no check on a plain list of numbers. You are given an array and need to return true if at least one value in the array is not zero. If every value is zero, or the array is empty, return false.

This means the problem is not about adding the numbers, sorting them, or comparing them to a target. The only question is whether the list contains any non-zero entry at all. A positive number counts, and a negative number also counts, because both are different from zero.

For example, nums = [1,2,3] returns true because the list clearly contains non-zero values. The array [0,0,0] returns false because every entry is zero. The array [5,-5,5] returns true because all of its values are non-zero. An empty array returns false because there is nothing inside it that could satisfy the rule.

So the task is simply to scan the list and decide whether any element is different from zero.

Example Input & Output

Example 1

Input

nums = [1,2,3]

Output

true

Explanation

The list contains non-zero values, so the check passes.

Example 2

Input

nums = [0,0,0]

Output

false

Explanation

Every value is zero, so there is no qualifying element.

Example 3

Input

nums = [5,-5,5]

Output

true

Explanation

Negative values still count because they are different from zero.

Algorithm Flow

Recommendation Algorithm Flow for City Bus Loop Access

Solution Approach

A simple one-pass scan is enough to solve this problem. Since the only thing you need to know is whether the array contains at least one non-zero value, you can stop as soon as you find one. There is no need to inspect the rest of the list after that point.

The key condition is num !== 0. That is all the problem is asking about. A value like 5 should make the answer true, and a value like -5 should also make the answer true because it is still not zero. Only exact zero values fail the condition.

In JavaScript, the core logic can look like this:

for (const num of nums) {
  if (num !== 0) {
    return true;
  }
}
return false;

This works because the first non-zero value is enough to prove the answer. In [1, 2, 3], the very first element already gives you true. In [0, 0, 0], the loop finishes without finding any non-zero number, so the answer stays false. In [5, -5, 5], even the negative value would still count as success because the comparison only cares whether the number equals zero.

You could also solve this with a built-in helper such as some(), but the explicit loop is often clearer when explaining the reasoning. It shows directly that the algorithm is making one pass, checking one condition, and returning early when possible.

This approach handles the edge cases naturally. An empty array returns false because the loop never runs and no qualifying element is found. A one-element array like [10] returns true if that single value is non-zero. If the single value were 0, the answer would be false.

The time complexity is O(n) in the worst case because you may need to inspect every element. The space complexity is O(1) because the solution only uses a loop variable and a direct comparison.

So the full strategy is: scan the array from left to right, return true on the first value that is not zero, and return false only if no such value exists.

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

java

import java.util.*;

class Solution {
    public int city_bus_loop_access(int n, int[][] roads, int start, int[] closed_stations) {
        Set<Integer> closed = new HashSet<>();
        for (int s : closed_stations) closed.add(s);
        if (closed.contains(start)) return 0;
        List<Integer>[] adj = new ArrayList[n];
        for (int i = 0; i < n; i++) adj[i] = new ArrayList<>();
        for (int[] road : roads) {
            adj[road[0]].add(road[1]);
            adj[road[1]].add(road[0]);
        }
        Set<Integer> visited = new HashSet<>();
        Queue<Integer> queue = new LinkedList<>();
        visited.add(start);
        queue.add(start);
        while (!queue.isEmpty()) {
            int u = queue.poll();
            for (int v : adj[u]) {
                if (!visited.contains(v) && !closed.contains(v)) {
                    visited.add(v);
                    queue.add(v);
                }
            }
        }
        return visited.size();
    }
}

javascript

function city_bus_loop_access(n, roads, start, closed_stations) {
    const closed = new Set(closed_stations);
    if (closed.has(start)) return 0;
    const adj = Array.from({length: n}, () => []);
    for (const [u, v] of roads) {
        adj[u].push(v);
        adj[v].push(u);
    }
    const visited = new Set([start]);
    const queue = [start];
    while (queue.length > 0) {
        const u = queue.shift();
        for (const v of adj[u]) {
            if (!visited.has(v) && !closed.has(v)) {
                visited.add(v);
                queue.push(v);
            }
        }
    }
    return visited.size;
}

php

<?php
function city_bus_loop_access($n, $roads, $start, $closed_stations) {
    $closed = array_flip($closed_stations);
    if (isset($closed[$start])) return 0;
    $adj = array_fill(0, $n, []);
    foreach ($roads as $road) {
        $u = $road[0];
        $v = $road[1];
        $adj[$u][] = $v;
        $adj[$v][] = $u;
    }
    $visited = [$start => true];
    $queue = [$start];
    while (!empty($queue)) {
        $u = array_shift($queue);
        foreach ($adj[$u] as $v) {
            if (!isset($visited[$v]) && !isset($closed[$v])) {
                $visited[$v] = true;
                $queue[] = $v;
            }
        }
    }
    return count($visited);
}
?>

python

from typing import List
from collections import deque

def city_bus_loop_access(n: int, roads: List[List[int]], start: int, closed_stations: List[int]) -> int:
    closed = set(closed_stations)
    if start in closed: return 0
    adj = [[] for _ in range(n)]
    for u, v in roads:
        adj[u].append(v)
        adj[v].append(u)
    visited = {start}
    queue = deque([start])
    while queue:
        u = queue.popleft()
        for v in adj[u]:
            if v not in visited and v not in closed:
                visited.add(v)
                queue.append(v)
    return len(visited)

rust

use std::collections::{HashSet, VecDeque};

pub fn city_bus_loop_access(n: i32, roads: Vec<Vec<i32>>, start: i32, closed_stations: Vec<i32>) -> i32 {
    let closed: HashSet<i32> = closed_stations.into_iter().collect();
    if closed.contains(&start) { return 0; }
    let mut adj = vec![vec![]; n as usize];
    for road in roads {
        let u = road[0] as usize;
        let v = road[1] as usize;
        adj[u].push(v as i32);
        adj[v].push(u as i32);
    }
    let mut visited = HashSet::new();
    let mut queue = VecDeque::new();
    visited.insert(start);
    queue.push_back(start);
    while let Some(u) = queue.pop_front() {
        for &v in &adj[u as usize] {
            if !visited.contains(&v) && !closed.contains(&v) {
                visited.insert(v);
                queue.push_back(v);
            }
        }
    }
    visited.len() as i32
}

typescript

function city_bus_loop_access(n: number, roads: number[][], start: number, closed_stations: number[]): number {
    const closed = new Set(closed_stations);
    if (closed.has(start)) return 0;
    const adj: number[][] = Array.from({length: n}, () => []);
    for (const [u, v] of roads) {
        adj[u].push(v);
        adj[v].push(u);
    }
    const visited = new Set<number>([start]);
    const queue: number[] = [start];
    while (queue.length > 0) {
        const u = queue.shift()!;
        for (const v of adj[u]) {
            if (!visited.has(v) && !closed.has(v)) {
                visited.add(v);
                queue.push(v);
            }
        }
    }
    return visited.size;
}

City Bus Loop Access

Example Input & Output

Algorithm Flow

Solution Approach

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

Solutions Coming Soon

Related Tree Challenges

Chronicle Walkway Binding

Comments (0)

Join the Discussion

City Bus Loop Access

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 Tree Challenges

Chronicle Walkway Binding

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.