Atrium Performance Call Sheet

Sorting Easy 3 views

Like30

The atrium's performance director keeps a fast-moving call sheet where each ensemble signs in with stage@act@priority. The sheet preserves exactly what they wrote—stage nicknames, stylized act titles, and a numeric priority that determines who rehearses first. By the time the sound check starts, the list is a scramble, making it hard to brief lighting or schedule the rotating platforms. The director needs a helper routine that transforms the raw entries into a neatly ordered list ready for broadcast to the crew.

Each returned string must read "priority - stage: act", preserving the original stage and act text. Sorting should use the integer priority segment first, then the stage name alphabetically, and finally the act title using case-insensitive comparison when both earlier keys match. The function may not alter the original list; it should build a fresh sequence while leaving every character in the recorded strings untouched.

Before doors open, coordination compares the helper's output with a master schedule. Anything out of position forces an on-the-fly reshuffle that delays rehearsals and confuses the crew radios. Provide a list that aligns perfectly, including the quiet case where no entries were captured and an empty list tells the director the atrium floor stays dark.

Algorithm Flow

Recommendation Algorithm Flow for Atrium Performance Call Sheet - Budibadu

Best Answers

java

import java.util.*;

class Solution {
    public String[] atrium_performance_call_sheet(String[] entries) {
        List<String[]> parsed = new ArrayList<>();
        for (String entry : entries) {
            String[] parts = entry.split("@");
            parsed.add(new String[]{parts[2], parts[0], parts[1], parts[1].toLowerCase()});
        }
        parsed.sort((a, b) -> {
            int p = Integer.compare(Integer.parseInt(a[0]), Integer.parseInt(b[0]));
            if (p != 0) return p;
            int s = a[1].compareTo(b[1]);
            if (s != 0) return s;
            return a[3].compareTo(b[3]);
        });
        String[] result = new String[parsed.size()];
        for (int i = 0; i < parsed.size(); i++) {
            String[] p = parsed.get(i);
            result[i] = p[0] + " - " + p[1] + ": " + p[2];
        }
        return result;
    }
}

javascript

function atrium_performance_call_sheet(entries) {
    const parsed = entries.map(entry => {
        const [stage, act, priority] = entry.split("@");
        return { priority: parseInt(priority), stage, act, actLower: act.toLowerCase() };
    });
    parsed.sort((a, b) => {
        if (a.priority !== b.priority) return a.priority - b.priority;
        if (a.stage !== b.stage) return a.stage.localeCompare(b.stage);
        return a.actLower.localeCompare(b.actLower);
    });
    return parsed.map(p => `${p.priority} - ${p.stage}: ${p.act}`);
}

php

<?php
function atrium_performance_call_sheet($entries) {
    $parsed = [];
    foreach ($entries as $entry) {
        $parts = explode("@", $entry);
        $parsed[] = [(int)$parts[2], $parts[0], $parts[1], strtolower($parts[1])];
    }
    usort($parsed, function($a, $b) {
        if ($a[0] !== $b[0]) return $a[0] - $b[0];
        $s = strcmp($a[1], $b[1]);
        if ($s !== 0) return $s;
        return strcmp($a[3], $b[3]);
    });
    $result = [];
    foreach ($parsed as $p) {
        $result[] = $p[0] . " - " . $p[1] . ": " . $p[2];
    }
    return $result;
}
?>

python

from typing import List

def atrium_performance_call_sheet(entries: List[str]) -> List[str]:
    parsed = []
    for entry in entries:
        parts = entry.split("@")
        stage, act, priority = parts[0], parts[1], int(parts[2])
        parsed.append((priority, stage, act.lower(), stage, act))
    parsed.sort(key=lambda x: (x[0], x[1], x[2]))
    return [f"{p[0]} - {p[3]}: {p[4]}" for p in parsed]

rust

pub fn atrium_performance_call_sheet(entries: Vec<String>) -> Vec<String> {
    let mut parsed: Vec<(i32, String, String, String)> = entries.iter().map(|entry| {
        let parts: Vec<&str> = entry.split("@").collect();
        let priority = parts[2].parse::<i32>().unwrap();
        (priority, parts[0].to_string(), parts[1].to_string(), parts[1].to_lowercase())
    }).collect();
    parsed.sort_by(|a, b| {
        a.0.cmp(&b.0)
            .then_with(|| a.1.cmp(&b.1))
            .then_with(|| a.3.cmp(&b.3))
    });
    parsed.iter().map(|p| format!("{} - {}: {}", p.0, p.1, p.2)).collect()
}

typescript

function atrium_performance_call_sheet(entries: string[]): string[] {
    const parsed = entries.map(entry => {
        const [stage, act, priority] = entry.split("@");
        return { priority: parseInt(priority), stage, act, actLower: act.toLowerCase() };
    });
    parsed.sort((a, b) => {
        if (a.priority !== b.priority) return a.priority - b.priority;
        if (a.stage !== b.stage) return a.stage.localeCompare(b.stage);
        return a.actLower.localeCompare(b.actLower);
    });
    return parsed.map(p => `${p.priority} - ${p.stage}: ${p.act}`);
}

Comments (0)

Join the Discussion

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

Atrium Performance Call Sheet

Algorithm Flow

Best Answers

Solutions Coming Soon

Related Sorting Problems

Atrium Roster Sorted Signal

Festival Cabins Sorted Flag

Midnight Vendor Queue Order

Harbor Manifest Planner Log

Market Slate Phrase

Artisan Label String

Comments (0)

Join the Discussion