Starfall Signal Map

Graph Easy 13 views

Like29

In the Seafarer’s Cove, lookout directors chart aurora sweeps by projecting flares onto the valley floor. Each chart begins with an Origin [x, y]. A series of sky vectors then define how far mirrored flares swing from that core. Your task in Starfall Signal Map is to translate these vectors into a final list of projected coordinates for the airship captains.

The "secret sauce" here is a Recursive Wrapping Rule. For every vector [dx, dy], you update the current list: first add a new coordinate [x + dx, y + dy], then append the entire existing list, next add the mirrored point [x - dx, y - dy], and finally append the existing list again. If no vectors remain, the result is just the origin. This symmetrical expansion captures the balanced rhythm of the flares as they trace across the mountain sky! You must return the complete ordered list of integer pairs, ensuring the captains can replay the exact ceremony path with precision.

Examples

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 - Budibadu

Best Answers

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

Comments (0)

Join the Discussion

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

Starfall Signal Map

Examples

Algorithm Flow

Best Answers

Solutions Coming Soon

Related Graph Problems

Catalog Shelf Lineup

Ascending Manifest

Memory Rune Sequencer

Shortest Path in Weighted Graph

Comments (0)

Join the Discussion