Memory Rune Sequencer

Published at05 Jan 2026

Graph Easy 5 views

Like14

You are given a list of rune entries, and each entry looks like [power, order, label]. The job is to sort the whole list using these rules in order.

First compare power: larger power should come earlier. If two entries have the same power, compare order: smaller order should come earlier. If both numbers are still tied, compare the string label alphabetically.

For example, [[10,1,"A"],[5,2,"B"],[10,2,"C"]] becomes [[10,1,"A"],[10,2,"C"],[5,2,"B"]] because the two entries with power 10 come first, and between them the smaller second value wins. If two entries are [5,1,"J"] and [5,1,"K"], then "J" comes before "K".

So this is a multi-key sorting problem with one descending rule and two ascending tie-breakers.

Example Input & Output

Example 1

Input

entries = [[10,1,"A"],[5,2,"B"],[10,2,"C"]]

Output

[[10,1,"A"],[10,2,"C"],[5,2,"B"]]

Explanation

The entries with higher power come first, and the second field breaks the tie between the two entries with power 10.

Example 2

Input

entries = [[1,10,"Z"],[1,5,"X"]]

Output

[[1,5,"X"],[1,10,"Z"]]

Explanation

The power is tied, so the entry with smaller order value 5 comes before order value 10.

Example 3

Input

entries = [[5,1,"K"],[5,1,"J"]]

Output

[[5,1,"J"],[5,1,"K"]]

Explanation

Both numeric fields are tied, so the label is used as the final alphabetical tiebreaker.

Algorithm Flow

Recommendation Algorithm Flow for Memory Rune Sequencer

Solution Approach

The cleanest way to solve this is with a custom comparator or sort key.

Each entry should be ordered by:

(-power, order, label)

That means higher power comes first, while order and label still use normal ascending order.

In comparator form, compare the first field in reverse, then the second field normally, then the label alphabetically if both numbers are tied.

After sorting once with those rules, the array is in the required sequence. This takes O(n log n) time.

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 calculate_lcs_length(String s1, String s2) {
        int m = s1.length(), n = s2.length();
        int[][] dp = new int[m + 1][n + 1];
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (s1.charAt(i-1) == s2.charAt(j-1)) dp[i][j] = dp[i-1][j-1] + 1;
                else dp[i][j] = Math.max(dp[i-1][j], dp[i][j-1]);
            }
        }
        return dp[m][n];
    }
}

javascript

function calculate_lcs_length(s1, s2) {
    const m = s1.length, n = s2.length;
    const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
    for (let i = 1; i <= m; i++) {
        for (let j = 1; j <= n; j++) {
            if (s1[i-1] === s2[j-1]) dp[i][j] = dp[i-1][j-1] + 1;
            else dp[i][j] = Math.max(dp[i-1][j], dp[i][j-1]);
        }
    }
    return dp[m][n];
}

php

function calculate_lcs_length($s1, $s2) {
    $m = strlen($s1); $n = strlen($s2);
    $dp = array_fill(0, $m + 1, array_fill(0, $n + 1, 0));
    for ($i = 1; $i <= $m; $i++) {
        for ($j = 1; $j <= $n; $j++) {
            if ($s1[$i-1] == $s2[$j-1]) $dp[$i][$j] = $dp[$i-1][$j-1] + 1;
            else $dp[$i][$j] = max($dp[$i-1][$j], $dp[$i][$j-1]);
        }
    }
    return $dp[$m][$n];
}

python

def calculate_lcs_length(s1: str, s2: str) -> int:
    m, n = len(s1), len(s2)
    dp = [[0] * (n + 1) for _ in range(m + 1)]
    for i in range(1, m + 1):
        for j in range(1, n + 1):
            if s1[i-1] == s2[j-1]:
                dp[i][j] = dp[i-1][j-1] + 1
            else:
                dp[i][j] = max(dp[i-1][j], dp[i][j-1])
    return dp[m][n]

rust

pub fn calculate_lcs_length(s1: String, s2: String) -> i32 {
    let m = s1.len(); let n = s2.len();
    let mut dp = vec![vec![0; n + 1]; m + 1];
    let s1_chars: Vec<char> = s1.chars().collect();
    let s2_chars: Vec<char> = s2.chars().collect();
    for i in 1..=m {
        for j in 1..=n {
            if s1_chars[i-1] == s2_chars[j-1] { dp[i][j] = dp[i-1][j-1] + 1; }
            else { dp[i][j] = std::cmp::max(dp[i-1][j], dp[i][j-1]); }
        }
    }
    dp[m][n]
}

typescript

function calculate_lcs_length(s1: string, s2: string): number {
    const m = s1.length, n = s2.length;
    const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
    for (let i = 1; i <= m; i++) {
        for (let j = 1; j <= n; j++) {
            if (s1[i-1] === s2[j-1]) dp[i][j] = dp[i-1][j-1] + 1;
            else dp[i][j] = Math.max(dp[i-1][j], dp[i][j-1]);
        }
    }
    return dp[m][n];
}

Related Graph Challenges

Comments (0)

Join the Discussion

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

Memory Rune Sequencer

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

Starfall Signal Map

Shortest Path in Weighted Graph

Catalog Shelf Lineup

Ascending Manifest

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.