Ranking Algorithm | Axon Arena

Algorithm Details

How your performance is calculated

Scoring Mechanism

Our ranking algorithm evaluates your performance across four challenge types: Logic Master, Math Integral Sprint, Memory Marathon, and Arithmetic Sprint. It considers your accuracy, speed, and participation, with weights applied to reflect challenge difficulty.

Correctness Ratio

Calculated as (correct_attempts / total_attempts) × 100, measuring the percentage of correct attempts for each challenge.

Weighted Score

Combines correctness ratio with a challenge-specific weight: correctness_ratio × weight. Higher weights are assigned to more difficult challenges.

Average Time

The average time taken per round, used as a tiebreaker in rankings.

Ranking

Users are ranked within each challenge type based on their weighted score, with average time per round as a secondary sorting criterion.

Challenge Weights

Different challenge types are weighted based on their difficulty:

•
Logic Master: 1.7 - Highest weight due to complex problem-solving
•
Math Sprint: 1.2 - Moderate complexity for quick calculations
•
Memory Marathon: 1.0 - Standard difficulty for memory tasks
•
Arithmetic Sprint: 0.8 - Easiest challenge type

Attempt Handling

Each challenge attempt is processed as follows:

•
Attempts are grouped by user and challenge, with summary records identified by specific metadata.
•
Only correct attempts contribute to the correctness ratio.
•
Summary records provide total time per round for averaging.

Algorithm Pseudocode

Below is the pseudocode for our ranking algorithm, outlining how performance data is processed:

// Step 1: Collect and process attempt data
function processAttempts(participantRecords):
    attemptsList = []
    for each record in participantRecords:
        if record contains summaryData:
            roundDuration = extractSummaryTime(record)
            append {participantId, taskId, taskType, taskName, roundId, attemptCount, roundDuration} to attemptsList
        else:
            append {participantId, taskId, taskType, taskName, roundId, attemptCount, isValid, duration} to attemptsList
    return attemptsList

// Step 2: Aggregate summary data for rounds
function aggregateRounds(attemptsList):
    roundData = []
    for each summaryRecord in attemptsList where isSummaryRecord:
        append {participantId, taskId, taskType, taskName, roundId, roundDuration} to roundData
    return roundData

// Step 3: Define task weights
function getTaskWeights(taskTypes):
    weightsMap = {}
    for each taskType in taskTypes:
        if taskType is 'Logic Master':
            weightsMap[taskType] = 1.7
        else if taskType is 'Maths Sprint Integral':
            weightsMap[taskType] = 1.2
        else if taskType is 'Memory Marathon':
            weightsMap[taskType] = 1.0
        else if taskType is 'Arithmetic Sprint':
            weightsMap[taskType] = 0.8
        else:
            weightsMap[taskType] = 1.0
    return weightsMap

// Step 4: Calculate participant performance
function calculatePerformance(roundData, attemptsList, weightsMap):
    performanceStats = []
    for each participant, task in roundData:
        roundsCount = countDistinct(roundData[participant, task].roundId)
        totalAttempts = count(attemptsList where participantId = participant and taskId = task and not isSummaryRecord)
        validAttempts = count(attemptsList where participantId = participant and taskId = task and not isSummaryRecord and isValid)
        avgRoundTime = average(roundData[participant, task].roundDuration)
        accuracyRate = (validAttempts / totalAttempts) * 100 if totalAttempts > 0 else 0
        weightedPerformance = accuracyRate * weightsMap[taskType]
        append {participantId, taskId, taskType, taskName, weight, roundsCount, totalAttempts, validAttempts, avgRoundTime, accuracyRate, weightedPerformance} to performanceStats
    return performanceStats

// Step 5: Rank participants
function rankParticipants(performanceStats):
    rankings = []
    for each taskType in performanceStats:
        sortedStats = sort(performanceStats[taskType] by weightedPerformance descending, avgRoundTime ascending)
        for rank, stat in sortedStats:
            append {participantId, participantEmail, taskId, taskType, taskName, weight, roundsCount, totalAttempts, validAttempts, accuracyRate, avgRoundTime, weightedPerformance, rank} to rankings
    return rankings

How It Works

1.
Attempt Processing: Collects all attempt data, identifying summary records that contain total time per round.
2.
Round Aggregation: Groups summary records by user and challenge to calculate round-specific metrics.
3.
Weight Assignment: Assigns weights to each challenge type based on difficulty.
4.
Performance Calculation: Computes correctness ratio, average round time, and weighted score for each user and challenge.
5.
Ranking: Ranks users within each challenge type based on weighted score, using average round time as a tiebreaker.

Ready to test your skills and climb the leaderboard?

PGP Verification

Verify our algorithm's integrity

PGP Key for Algorithm Verification

To ensure the transparency and integrity of our ranking algorithm, we provide a PGP key for verification. You can use this key to verify the authenticity of our algorithm code and any related communications.

Use this PGP key to verify signed messages or files related to our ranking algorithm.

Public PGP Key ID: CBF38DA255F0AD867F5B170047ACDC16F8BF96DD

Email: info@axonarena.com