Aurora Feather Lights

Published atDate not available

Array Easy 0 views

Like0

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

Calculate feather lantern sequence growth 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 sweeps = 4, the answer is 341. Four sweeps follow the rule, producing three hundred forty-one shimmering feathers. Another example is sweeps = 0, which gives 1. Only the opening feather lantern glows.

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

sweeps = 4

Output

341

Explanation

Four sweeps follow the rule, producing three hundred forty-one shimmering feathers.

Example 2

Input

sweeps = 0

Output

Explanation

Only the opening feather lantern glows.

Example 3

Input

sweeps = 2

Output

Explanation

The second sweep adds one feather and echoes the earlier light four times.

Algorithm Flow

Recommendation Algorithm Flow for Aurora Feather Lights

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_maximal_balanced_subarrays(int[] nums) {
        int p0 = 0, p1 = 0, p2 = 0;
        Map<String, List<Integer>> diffs = new HashMap<>();
        diffs.computeIfAbsent("0,0", k -> new ArrayList<>()).add(-1);
        
        for (int i = 0; i < nums.length; i++) {
            int r = (nums[i] % 3 + 3) % 3;
            if (r == 0) p0++;
            else if (r == 1) p1++;
            else p2++;
            String key = (p0 - p1) + "," + (p1 - p2);
            diffs.computeIfAbsent(key, k -> new ArrayList<>()).add(i);
        }
        
        List<int[]> balanced = new ArrayList<>();
        for (List<Integer> indices : diffs.values()) {
            for (int a = 0; a < indices.size(); a++) {
                for (int b = a + 1; b < indices.size(); b++) {
                    balanced.add(new int[]{indices.get(a) + 1, indices.get(b)});
                }
            }
        }
        
        List<int[]> maximal = new ArrayList<>();
        for (int[] b1 : balanced) {
            boolean isSub = false;
            for (int[] b2 : balanced) {
                if (b2[0] <= b1[0] && b2[1] >= b1[1] && (b2[0] != b1[0] || b2[1] != b1[1])) {
                    isSub = true;
                    break;
                }
            }
            if (!isSub) maximal.add(b1);
        }
        
        maximal.sort(Comparator.comparingInt(a -> a[0]));
        int[][] result = new int[maximal.size()][];
        for (int i = 0; i < maximal.size(); i++) {
            int start = maximal.get(i)[0];
            int end = maximal.get(i)[1];
            result[i] = Arrays.copyOfRange(nums, start, end + 1);
        }
        return result;
    }
}

javascript

function find_maximal_balanced_subarrays(nums) {
    let p = [0, 0, 0];
    let diffs = {"0,0": [-1]};
    for (let i = 0; i < nums.length; i++) {
        let r = (nums[i] % 3 + 3) % 3;
        p[r]++;
        let key = (p[0] - p[1]) + "," + (p[1] - p[2]);
        if (!diffs[key]) diffs[key] = [];
        diffs[key].push(i);
    }
    
    let balanced = [];
    for (let key in diffs) {
        let indices = diffs[key];
        for (let a = 0; a < indices.length; a++) {
            for (let b = a + 1; b < indices.length; b++) {
                balanced.push([indices[a] + 1, indices[b]]);
            }
        }
    }
    
    let maximal = [];
    for (let b1 of balanced) {
        let isSub = false;
        for (let b2 of balanced) {
            if (b2[0] <= b1[0] && b2[1] >= b1[1] && (b2[0] !== b1[0] || b2[1] !== b1[1])) {
                isSub = true;
                break;
            }
        }
        if (!isSub) maximal.push(b1);
    }
    
    maximal.sort((a, b) => a[0] - b[0]);
    return maximal.map(b => nums.slice(b[0], b[1] + 1));
}

php

function find_maximal_balanced_subarrays($nums) {
    $p0 = $p1 = $p2 = 0;
    $diffs = ["0,0" => [-1]];
    foreach ($nums as $i => $x) {
        $r = ($x % 3 + 3) % 3;
        if ($r == 0) $p0++;
        else if ($r == 1) $p1++;
        else $p2++;
        $key = ($p0 - $p1) . "," . ($p1 - $p2);
        $diffs[$key][] = $i;
    }
    
    $balanced = [];
    foreach ($diffs as $indices) {
        $count = count($indices);
        for ($a = 0; $a < $count; $a++) {
            for ($b = $a + 1; $b < $count; $b++) {
                $balanced[] = [$indices[$a] + 1, $indices[$b]];
            }
        }
    }
    
    $maximal = [];
    foreach ($balanced as $b1) {
        $isSub = false;
        foreach ($balanced as $b2) {
            if ($b2[0] <= $b1[0] && $b2[1] >= $b1[1] && ($b2[0] != $b1[0] || $b2[1] != $b1[1])) {
                $isSub = true;
                break;
            }
        }
        if (!$isSub) $maximal[] = $b1;
    }
    
    usort($maximal, function($a, $b) { return $a[0] - $b[0]; });
    
    $result = [];
    foreach ($maximal as $b) {
        $result[] = array_slice($nums, $b[0], $b[1] - $b[0] + 1);
    }
    return $result;
}

python

from typing import List

def find_maximal_balanced_subarrays(nums: List[int]) -> List[List[int]]:
    p0, p1, p2 = 0, 0, 0
    diffs = {(0, 0): [-1]}
    for i, x in enumerate(nums):
        r = (x % 3 + 3) % 3
        if r == 0: p0 += 1
        elif r == 1: p1 += 1
        else: p2 += 1
        d = (p0 - p1, p1 - p2)
        if d not in diffs: diffs[d] = []
        diffs[d].append(i)
    
    balanced = []
    for d, indices in diffs.items():
        if len(indices) < 2: continue
        for a in range(len(indices)):
            for b in range(a + 1, len(indices)):
                balanced.append((indices[a] + 1, indices[b]))
    
    if not balanced: return []
    
    maximal = []
    for i, j in balanced:
        is_sub = False
        for i2, j2 in balanced:
            if i2 <= i and j2 >= j and (i2 != i or j2 != j):
                is_sub = True
                break
        if not is_sub:
            maximal.append((i, j))
    
    maximal.sort()
    return [nums[i:j+1] for i, j in maximal]

rust

use std::collections::HashMap;

pub fn find_maximal_balanced_subarrays(nums: Vec<i32>) -> Vec<Vec<i32>> {
    let mut p0 = 0;
    let mut p1 = 0;
    let mut p2 = 0;
    let mut diffs: HashMap<(i32, i32), Vec<i32>> = HashMap::new();
    diffs.insert((0, 0), vec![-1]);
    
    for (i, &x) in nums.iter().enumerate() {
        let r = (x % 3 + 3) % 3;
        if r == 0 { p0 += 1; }
        else if r == 1 { p1 += 1; }
        else { p2 += 1; }
        let d = (p0 - p1, p1 - p2);
        diffs.entry(d).or_insert(vec![]).push(i as i32);
    }
    
    let mut balanced = Vec::new();
    for indices in diffs.values() {
        if indices.len() < 2 { continue; }
        for a in 0..indices.len() {
            for b in a + 1..indices.len() {
                balanced.push((indices[a] + 1, indices[b]));
            }
        }
    }
    
    let mut maximal = Vec::new();
    for &(i, j) in &balanced {
        let mut is_sub = false;
        for &(i2, j2) in &balanced {
            if i2 <= i && j2 >= j && (i2 != i || j2 != j) {
                is_sub = true;
                break;
            }
        }
        if !is_sub {
            maximal.push((i, j));
        }
    }
    
    maximal.sort();
    maximal.into_iter().map(|(i, j)| {
        nums[i as usize ..= j as usize].to_vec()
    }).collect()
}

typescript

function count_aurora_feathers(sweeps: number): number {
    let count = 0;
    for (let i = 0; i <= sweeps; i++) {
        count += Math.pow(4, i);
    }
    return count;
}

Related Array Challenges

Comments (0)

Join the Discussion

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

Aurora Feather Lights

Example Input & Output

Algorithm Flow

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

Crystal Bell Resonance

Moonlit Orchid Bloom

Harbor Tide Chants

Starlight Lantern Chain

Fern Spiral Growth

Coral Pulse Count

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.