Starfall Signal Map

Published at05 Jan 2026

Graph Easy 15 views

Like29

You are given an origin point and a list of vectors. The output is a recursively built list of coordinates that expands outward from the origin.

Each vector creates two branches: one at origin + vector and one at origin - vector. Between those two branch points, you place the full result built from the remaining vectors.

That is why origin = [0,0] and vectors = [[2,1]] gives [[2,1],[0,0],[-2,-1],[0,0]]: first the positive branch, then the base case at the origin, then the negative branch, then the base case again. With origin = [1,-1] and vectors = [[3,0],[0,2]], the same pattern repeats one level deeper.

If there are no vectors left, the result is just [origin]. So the task is to generate the full recursive signal map in that exact order.

Example Input & Output

Example 1

Input

origin = [0,0], vectors = []

Output

[[0,0]]

Explanation

Example with input: origin = [0,0], vectors = []

Example 2

Input

origin = [0,0], vectors = [[2,1]]

Output

[[2,1], [0,0], [-2,-1], [0,0]]

Explanation

Example with input: origin = [0,0], vectors = [[2,1]]

Example 3

Input

origin = [1,-1], vectors = [[3,0], [0,2]]

Output

[[4,-1], [1,1], [1,-1], [1,-3], [1,-1], [-2,-1], [1,1], [1,-1], [1,-3], [1,-1]]

Explanation

Example with input: origin = [1,-1], vectors = [[3,0], [0,2]]

Algorithm Flow

Recommendation Algorithm Flow for Starfall Signal Map

Solution Approach

This pattern is easiest to build with recursion.

Suppose we are processing vector index i. If i is already past the end of the list, return a list containing only the origin.

Otherwise let the current vector be [dx, dy]. Build the answer as:

[origin + [dx, dy]] + solve(i + 1) + [origin - [dx, dy]] + solve(i + 1)

The key detail is that the recursive result for the remaining vectors is inserted after both the positive point and the negative point, so the same smaller pattern appears on both sides.

If there are m vectors, the output size grows exponentially because each level duplicates the rest of the structure.

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 find_shortest_signal_path(int[][] grid) {
        int rows = grid.length;
        if (rows == 0) return -1;
        int cols = grid[0].length;
        if (grid[0][0] == 1 || grid[rows-1][cols-1] == 1) return -1;
        Queue<int[]> q = new LinkedList<>();
        q.add(new int[]{0, 0, 1});
        boolean[][] visited = new boolean[rows][cols];
        visited[0][0] = true;
        int[][] dirs = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
        while (!q.isEmpty()) {
            int[] curr = q.poll();
            int r = curr[0], c = curr[1], d = curr[2];
            if (r == rows - 1 && c == cols - 1) return d;
            for (int[] dir : dirs) {
                int nr = r + dir[0], nc = c + dir[1];
                if (nr >= 0 && nr < rows && nc >= 0 && nc < cols && grid[nr][nc] == 0 && !visited[nr][nc]) {
                    visited[nr][nc] = true;
                    q.add(new int[]{nr, nc, d + 1});
                }
            }
        }
        return -1;
    }
}

javascript

function find_shortest_signal_path(grid) {
    const rows = grid.length;
    if (rows === 0) return -1;
    const cols = grid[0].length;
    if (grid[0][0] === 1 || grid[rows-1][cols-1] === 1) return -1;
    const q = [[0, 0, 1]];
    const visited = new Set(['0,0']);
    while (q.length > 0) {
        const [r, c, d] = q.shift();
        if (r === rows - 1 && c === cols - 1) return d;
        for (let [dr, dc] of [[0, 1], [0, -1], [1, 0], [-1, 0]]) {
            let nr = r + dr, nc = c + dc;
            if (nr >= 0 && nr < rows && nc >= 0 && nc < cols && grid[nr][nc] === 0 && !visited.has(`${nr},${nc}`)) {
                visited.add(`${nr},${nc}`);
                q.push([nr, nc, d + 1]);
            }
        }
    }
    return -1;
}

php

function find_shortest_signal_path($grid) {
    $rows = count($grid);
    if ($rows == 0) return -1;
    $cols = count($grid[0]);
    if ($grid[0][0] == 1 || $grid[$rows-1][$cols-1] == 1) return -1;
    $q = [[0, 0, 1]];
    $visited = ['0,0' => true];
    while (!empty($q)) {
        $curr = array_shift($q);
        $r = $curr[0]; $c = $curr[1]; $d = $curr[2];
        if ($r == $rows - 1 && $c == $cols - 1) return $d;
        foreach ([[0, 1], [0, -1], [1, 0], [-1, 0]] as $dir) {
            $nr = $r + $dir[0]; $nc = $c + $dir[1];
            if ($nr >= 0 && $nr < $rows && $nc >= 0 && $nc < $cols && $grid[$nr][$nc] == 0 && !isset($visited["$nr,$nc"])) {
                $visited["$nr,$nc"] = true;
                $q[] = [$nr, $nc, $d + 1];
            }
        }
    }
    return -1;
}

python

from collections import deque
def find_shortest_signal_path(grid: list) -> int:
    rows = len(grid)
    if rows == 0: return -1
    cols = len(grid[0])
    if grid[0][0] == 1 or grid[rows-1][cols-1] == 1: return -1
    q = deque([(0, 0, 1)])
    visited = {(0, 0)}
    while q:
        r, c, d = q.popleft()
        if r == rows - 1 and c == cols - 1: return d
        for dr, dc in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
            nr, nc = r + dr, c + dc
            if 0 <= nr < rows and 0 <= nc < cols and grid[nr][nc] == 0 and (nr, nc) not in visited:
                visited.add((nr, nc))
                q.append((nr, nc, d + 1))
    return -1

rust

use std::collections::{VecDeque, HashSet};
pub fn find_shortest_signal_path(grid: Vec<Vec<i32>>) -> i32 {
    let rows = grid.len();
    if rows == 0 { return -1; }
    let cols = grid[0].len();
    if grid[0][0] == 1 || grid[rows-1][cols-1] == 1 { return -1; }
    let mut q = VecDeque::new();
    q.push_back((0, 0, 1));
    let mut visited = HashSet::new();
    visited.insert((0, 0));
    let dirs = [(0, 1), (0, -1), (1, 0), (-1, 0)];
    while let Some((r, c, d)) = q.pop_front() {
        if r == rows - 1 && c == cols - 1 { return d; }
        for (dr, dc) in &dirs {
            let nr = (r as i32 + dr) as usize;
            let nc = (c as i32 + dc) as usize;
            if nr < rows && nc < cols && grid[nr][nc] == 0 && !visited.contains(&(nr, nc)) {
                visited.insert((nr, nc));
                q.push_back((nr, nc, d + 1));
            }
        }
    }
    -1
}

typescript

function find_shortest_signal_path(grid: number[][]): number {
    const rows = grid.length;
    if (rows === 0) return -1;
    const cols = grid[0].length;
    if (grid[0][0] === 1 || grid[rows-1][cols-1] === 1) return -1;
    const q: [number, number, number][] = [[0, 0, 1]];
    const visited = new Set(['0,0']);
    while (q.length > 0) {
        const [r, c, d] = q.shift()!;
        if (r === rows - 1 && c === cols - 1) return d;
        for (let [dr, dc] of [[0, 1], [0, -1], [1, 0], [-1, 0]]) {
            let nr = r + dr, nc = c + dc;
            if (nr >= 0 && nr < rows && nc >= 0 && nc < cols && grid[nr][nc] === 0 && !visited.has(`${nr},${nc}`)) {
                visited.add(`${nr},${nc}`);
                q.push([nr, nc, d + 1]);
            }
        }
    }
    return -1;
}

Related Graph Challenges

Comments (0)

Join the Discussion

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

Starfall Signal Map

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

Shortest Path in Weighted Graph

Catalog Shelf Lineup

Ascending Manifest

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.