City Bus Loop Access

Published at05 Jan 2026

Graph BFS Medium 20 views

Like27

Given an array of integers, determine whether the array contains at least one non-zero value. Return true if any element is not zero, and false if all elements are zero or the array is empty.

For example, [1, 2, 3] returns true because it contains non-zero values. [0, 0, 0] returns false because every element is zero. An empty array also returns false because there is nothing to satisfy the condition. Negative numbers like -5 count as non-zero, so [-5, 0, 5] returns true.

This is a simple existence check: you only need to find one element that meets the condition. As soon as you encounter a non-zero value, you can immediately return true. If you scan the entire array without finding any non-zero element, return false. This early-exit pattern is common in search problems and can significantly improve performance when the matching element appears early.

The problem is intentionally straightforward to test your understanding of basic array iteration and conditional logic. Despite its simplicity, the early-return pattern it demonstrates is a building block for more complex search algorithms like linear search, find-first, and any-match operations used throughout software development.

Edge cases include an empty array (return false), an array of all zeros (return false), and an array with a single non-zero element (return true immediately on the first element). The solution must handle all these cases correctly without throwing exceptions.

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

The simplest solution scans the array and returns true as soon as it finds a non-zero value. If the loop completes without finding any non-zero, return false.

function solution(nums) {
  for (var i = 0; i < nums.length; i++) {
    if (nums[i] !== 0) return true;
  }
  return false;
}

Initialize a loop from index 0 to the last element. For each element, check if it is not equal to zero. If a non-zero value is found, return true immediately — there is no need to check the remaining elements. If the loop finishes without returning, all elements were zero (or the array was empty), so return false.

The early-return optimization means the best case is O(1) when a non-zero value is at the first position. The worst case is O(n) when all values are zero or the non-zero value is at the very end. Space complexity is O(1) since only a loop variable is used.

Some languages provide built-in helpers like JavaScript's Array.prototype.some() or Python's any(), which express the same logic more concisely: return nums.some(function(n){return n !== 0;}) or return any(n != 0 for n in nums). However, the explicit loop better illustrates the underlying algorithm.

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;
}

Related Graph Challenges

Comments (0)

Join the Discussion

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

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

Railway Network Delay Optimizer

Interstate Rescue Network Audit

Wildlife Bridge Network Scan

Metro Transfer Capacity Map

City Signal Span

Memory Rune Sequencer

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.