Aurora Diary Synthesis

import java.util.*;

class Solution {
    public String synthesize_aurora_diary(String root_line, List<Map<String, String>> observers) {
        return recurse(0, root_line, observers);
    }
    
    private String recurse(int idx, String root, List<Map<String, String>> obs) {
        if (idx == obs.size()) return root;
        Map<String, String> current = obs.get(idx);
        String name = current.get("name");
        String insight = current.get("insight");
        return name + " begins:\n" + recurse(idx + 1, root, obs) + "\n" + name + " notes: " + insight;
    }
}

function synthesize_aurora_diary(root_line, observers) {
    function recurse(idx) {
        if (idx === observers.length) return root_line;
        const { name, insight } = observers[idx];
        return `${name} begins:\n${recurse(idx + 1)}\n${name} notes: ${insight}`;
    }
    return recurse(0);
}

function synthesize_aurora_diary($root_line, $observers) {
    $recurse = function($idx) use ($root_line, $observers, &$recurse) {
        if ($idx === count($observers)) return $root_line;
        $name = $observers[$idx]["name"];
        $insight = $observers[$idx]["insight"];
        return "$name begins:\n" . $recurse($idx + 1) . "\n$name notes: $insight";
    };
    return $recurse(0);
}

from typing import List, Dict

def synthesize_aurora_diary(root_line: str, observers: List[Dict[str, str]]) -> str:
    def recurse(idx: int) -> str:
        if idx == len(observers):
            return root_line
        name = observers[idx]["name"]
        insight = observers[idx]["insight"]
        inner = recurse(idx + 1)
        return f"{name} begins:\n{inner}\n{name} notes: {insight}"
    return recurse(0)

pub fn synthesize_aurora_diary(root_line: &str, observers: &[(String, String)]) -> String {
    fn recurse(idx: usize, root: &str, obs: &[(String, String)]) -> String {
        if idx == obs.len() {
            return root.to_string();
        }
        let (name, insight) = &obs[idx];
        let inner = recurse(idx + 1, root, obs);
        format!("{} begins:\n{}\n{} notes: {}", name, inner, name, insight)
    }
    recurse(0, root_line, observers)
}

function find_maximal_balanced_subarrays(nums: number[]): number[][] {
    let p = [0, 0, 0];
    let diffs: {[key: string]: number[]} = {"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: [number, number][] = [];
    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: [number, number][] = [];
    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));
}