Mirage Oasis Rings

Published at05 Jan 2026

Array Array Manipulation Easy 7 views

Like11

You can think of this as a small game with a very specific goal. In Mirage Oasis Rings, you are trying to work toward the right number by following one clear idea.

Calculate mirage oasis ring pattern A good way to think about it is to first understand what goes in, then what rule you must follow, and finally what shape the answer should have.

For example, if the input is rings = 3, the answer is 40. Three rings repeat the pattern, generating forty mirrored arcs. Another example is rings = 0, which gives 1. Only the first water mirror is visible.

This is a friendly practice problem, but it still rewards careful reading. The key is understanding the rule clearly and then applying it carefully.

One helpful habit is to say the rule out loud in your own words before you start solving. If you can explain what counts, what changes, and what the final answer should look like, you are already much closer to the right solution.

Example Input & Output

Example 1

Input

rings = 3

Output

Explanation

Three rings repeat the pattern, generating forty mirrored arcs.

Example 2

Input

rings = 0

Output

Explanation

Only the first water mirror is visible.

Example 3

Input

rings = 5

Output

364

Explanation

Five rings follow the ritual, producing three hundred sixty-four shimmering reflections.

Algorithm Flow

Recommendation Algorithm Flow for Mirage Oasis Rings

Solution Approach

This problem asks us to count the number of distinct rings formed by the connections in a graph. A ring here is a connected group of nodes, so the answer is the number of connected components in the graph, counting isolated nodes as their own components.

The cleanest way to solve this is a graph traversal. We build an undirected adjacency list, then run BFS or DFS from each unvisited node, counting one component each time we start a new traversal.

Here is the implementation:

function count_distinct_rings(n, edges) {
    const adj = Array.from({ length: n }, () => []);
    for (const [u, v] of edges) {
        adj[u].push(v);
        adj[v].push(u);
    }
    const visited = new Array(n).fill(false);
    let count = 0;
    for (let i = 0; i < n; i++) {
        if (!visited[i]) {
            count++;
            const stack = [i];
            visited[i] = true;
            while (stack.length > 0) {
                const u = stack.pop();
                for (const v of adj[u]) {
                    if (!visited[v]) {
                        visited[v] = true;
                        stack.push(v);
                    }
                }
            }
        }
    }
    return count;
}

We build an undirected adjacency list so each edge connects both directions. Then we iterate over every node; whenever we find one not yet visited, we have discovered a new component, so we increment the count and flood-fill that component. Because edges are undirected, a component is fully reachable from any of its nodes.

Let us trace n = 3, edges = [[0, 1], [1, 2]]. Nodes 0, 1, 2 all connect into one component, so the answer is 1. For n = 3, edges = [[0, 1]], nodes 0 and 1 form one component and node 2 is isolated, giving 2. With no edges and n = 1, the single node is one component, giving 1.

The time complexity is O(n + e) and the space complexity is O(n).

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 int count_distinct_rings(int n, int[][] conn) {
        java.util.List<Integer>[] g = new java.util.ArrayList[n];
        for (int i = 0; i < n; i++) g[i] = new java.util.ArrayList<>();
        for (int[] e : conn) { g[e[0]].add(e[1]); g[e[1]].add(e[0]); }
        boolean[] seen = new boolean[n];
        int count = 0;
        for (int i = 0; i < n; i++) {
            if (!seen[i]) {
                count++;
                java.util.Stack<Integer> st = new java.util.Stack<>();
                seen[i] = true; st.push(i);
                while (!st.isEmpty()) {
                    int u = st.pop();
                    for (int w : g[u]) if (!seen[w]) { seen[w] = true; st.push(w); }
                }
            }
        }
        return count;
    }
}

javascript

function count_distinct_rings(n, conn) {
    var g = [];
    for (var i = 0; i < n; i++) g[i] = [];
    for (var k = 0; k < conn.length; k++) {
        var u = conn[k][0], v = conn[k][1];
        g[u].push(v); g[v].push(u);
    }
    var seen = {}; var count = 0;
    for (var i = 0; i < n; i++) {
        if (!seen[i]) {
            count++;
            var stack = [i]; seen[i] = true;
            while (stack.length) {
                var u = stack.pop();
                for (var j = 0; j < g[u].length; j++) {
                    var w = g[u][j];
                    if (!seen[w]) { seen[w] = true; stack.push(w); }
                }
            }
        }
    }
    return count;
}

php

<?php
function count_distinct_rings($n, $conn) {
    $g = array_fill(0, $n, []);
    foreach ($conn as $e) { $g[$e[0]][] = $e[1]; $g[$e[1]][] = $e[0]; }
    $seen = []; $count = 0;
    for ($i = 0; $i < $n; $i++) {
        if (!isset($seen[$i])) {
            $count++;
            $stack = [$i]; $seen[$i] = true;
            while (count($stack)) {
                $u = array_pop($stack);
                foreach ($g[$u] as $w) if (!isset($seen[$w])) { $seen[$w] = true; $stack[] = $w; }
            }
        }
    }
    return $count;
}

python

def count_distinct_rings(n: int, conn: list) -> int:
    g = {i: [] for i in range(n)}
    for u, v in conn:
        g[u].append(v); g[v].append(u)
    seen = set(); count = 0
    for i in range(n):
        if i not in seen:
            count += 1
            stack = [i]; seen.add(i)
            while stack:
                u = stack.pop()
                for w in g[u]:
                    if w not in seen:
                        seen.add(w); stack.append(w)
    return count

rust

pub fn count_distinct_rings(n: i32, conn: Vec<Vec<i32>>) -> i32 {
    let n = n as usize;
    let mut g = vec![Vec::new(); n];
    for e in conn {
        g[e[0] as usize].push(e[1]);
        g[e[1] as usize].push(e[0]);
    }
    let mut seen = vec![false; n];
    let mut count = 0;
    for i in 0..n {
        if !seen[i] {
            count += 1;
            let mut st = vec![i]; seen[i] = true;
            while let Some(u) = st.pop() {
                for &w in &g[u] { if !seen[w as usize] { seen[w as usize] = true; st.push(w as usize); } }
            }
        }
    }
    count
}

typescript

function count_distinct_rings(n: number, conn: number[][]): number {
    var g: number[][] = [];
    for (var i = 0; i < n; i++) g[i] = [];
    for (var k = 0; k < conn.length; k++) {
        var u = conn[k][0], v = conn[k][1];
        g[u].push(v); g[v].push(u);
    }
    var seen: { [key: number]: boolean } = {}; var count = 0;
    for (var i = 0; i < n; i++) {
        if (!seen[i]) {
            count++;
            var stack: number[] = [i]; seen[i] = true;
            while (stack.length) {
                var u = stack.pop();
                for (var j = 0; j < g[u].length; j++) {
                    var w = g[u][j];
                    if (!seen[w]) { seen[w] = true; stack.push(w); }
                }
            }
        }
    }
    return count;
}

Related Array Challenges

Comments (0)

Join the Discussion

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

Mirage Oasis Rings

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

Emberstone Step Glow

Aurora Feather Lights

Crystal Bell Resonance

Moonlit Orchid Bloom

Harbor Tide Chants

Starlight Lantern Chain

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.