Practice Code Typing – SkillsTyping

Choose your language:

ℹ️ Select 'Choose Exercise', or randomize 'Next Random Exercise' in selected language.

Choose Exercise:

Ready

Exercise Algorithm Area

Correct typos to continue.

1package main
2
3import (
4	"fmt"
5	"time"
6)
7
8// calculateDynamicRate computes the rate of change for a metric over a dynamically
9// determined time window. The window size is adjusted based on the density of
10// data points to ensure a meaningful rate calculation.
11func calculateDynamicRate(metricData []float64, timestamps []time.Time, maxWindow time.Duration, minDataPoints int) (float64, error) {
12	if len(metricData) == 0 || len(timestamps) == 0 || len(metricData) != len(timestamps) {
13		return 0, fmt.Errorf("invalid input: metricData or timestamps are empty or mismatched lengths")
14	}
15
16	// Determine the optimal window size based on data point density.
17	// We aim for at least minDataPoints within the window, capped by maxWindow.
18	var optimalWindow time.Duration
19	if len(metricData) < minDataPoints {
20		// Not enough data points even for the smallest possible window.
21		return 0, fmt.Errorf("insufficient data points (%d) for minimum required (%d)", len(metricData), minDataPoints)
22	}
23
24	// Calculate the time span of the available data.
25	dataSpan := timestamps[len(timestamps)-1].Sub(timestamps[0])
26
27	// Estimate the average time between data points.
28	avgInterval := dataSpan / time.Duration(len(timestamps)-1)
29
30	// Calculate the required window to contain at least minDataPoints.
31	requiredWindow := avgInterval * time.Duration(minDataPoints-1)
32
33	// The optimal window is the minimum of maxWindow and the required window,
34	// ensuring we don't exceed maxWindow and have enough data.
35	if requiredWindow > maxWindow {
36		optimalWindow = maxWindow
37	} else {
38		optimalWindow = requiredWindow
39	}
40
41	// Ensure the optimal window is at least the interval between the last two points
42	// to avoid division by zero or meaningless rates if data is very sparse.
43	lastInterval := timestamps[len(timestamps)-1].Sub(timestamps[len(timestamps)-2])
44	if optimalWindow < lastInterval {
45		optimalWindow = lastInterval
46	}
47
48	// Filter data points within the determined optimal window, ending at the last timestamp.
49	var windowData []float64
50	var windowTimestamps []time.Time
51	windowStartTime := timestamps[len(timestamps)-1].Add(-optimalWindow)
52
53	for i := len(timestamps) - 1; i >= 0; i-- {
54		if timestamps[i].After(windowStartTime) || timestamps[i].Equal(windowStartTime) {
55			windowData = append(windowData, metricData[i])
56			windowTimestamps = append(windowTimestamps, timestamps[i])
57		} else {
58			break // Data is sorted by time, so we can stop early.
59		}
60	}
61
62	// Reverse to maintain chronological order for rate calculation.
63	for i, j := 0, len(windowData)-1; i < j; i, j = i+1, j-1 {
64		windowData[i], windowData[j] = windowData[j], windowData[i]
65		windowTimestamps[i], windowTimestamps[j] = windowTimestamps[j], windowTimestamps[i]
66	}
67
68	// Check if we have enough data points within the filtered window.
69	if len(windowData) < 2 {
70		return 0, fmt.Errorf("insufficient data points (%d) within the calculated window (%s) for rate calculation", len(windowData), optimalWindow)
71	}
72
73	// Calculate the rate of change: (last_value - first_value) / time_span_of_window
74	firstValue := windowData[0]
75	lastValue := windowData[len(windowData)-1]
76	timeSpan := windowTimestamps[len(windowTimestamps)-1].Sub(windowTimestamps[0])
77
78	if timeSpan <= 0 {
79		// This should ideally not happen if optimalWindow is handled correctly,
80		// but as a safeguard against identical timestamps.
81		return 0, fmt.Errorf("time span within window is zero or negative (%s)", timeSpan)
82	}
83
84	rate := (lastValue - firstValue) / timeSpan.Seconds()
85
86	return rate, nil
87}
88
89func main() {
90	// Example Usage:
91	metricValues := []float64{10, 12, 15, 18, 20, 22, 25, 28, 30, 33}
92	timestamps := []time.Time{
93		time.Now().Add(-9 * time.Minute),
94		time.Now().Add(-8 * time.Minute),
95		time.Now().Add(-7 * time.Minute),
96		time.Now().Add(-6 * time.Minute),
97		time.Now().Add(-5 * time.Minute),
98		time.Now().Add(-4 * time.Minute),
99		time.Now().Add(-3 * time.Minute),
100		time.Now().Add(-2 * time.Minute),
101		time.Now().Add(-1 * time.Minute),
102		time.Now(),
103	}
104
105	maxWindow := 5 * time.Minute
106	minDataPoints := 3
107
108	rate, err := calculateDynamicRate(metricValues, timestamps, maxWindow, minDataPoints)
109	if err != nil {
110		fmt.Printf("Error calculating rate: %v\n", err)
111	} else {
112		fmt.Printf("Calculated rate: %.2f per second\n", rate)
113	}
114
115	// Edge case: Insufficient data points
116	shortMetric := []float64{10, 12}
117	shortTimestamps := []time.Time{time.Now().Add(-2 * time.Minute), time.Now()}
118	rateShort, errShort := calculateDynamicRate(shortMetric, shortTimestamps, maxWindow, minDataPoints)
119	if errShort != nil {
120		fmt.Printf("Error calculating rate for short data: %v\n", errShort)
121	} else {
122		fmt.Printf("Calculated rate for short data: %.2f per second\n", rateShort)
123	}
124
125	// Edge case: Data too sparse for minDataPoints within maxWindow
126	sparseMetric := []float64{10, 11, 12, 13}
127	sparseTimestamps := []time.Time{
128		time.Now().Add(-10 * time.Minute),
129		time.Now().Add(-8 * time.Minute),
130		time.Now().Add(-6 * time.Minute),
131		time.Now().Add(-4 * time.Minute),
132	}
133	rateSparse, errSparse := calculateDynamicRate(sparseMetric, sparseTimestamps, maxWindow, minDataPoints)
134	if errSparse != nil {
135		fmt.Printf("Error calculating rate for sparse data: %v\n", errSparse)
136	} else {
137		fmt.Printf("Calculated rate for sparse data: %.2f per second\n", rateSparse)
138	}
139}

Algorithm description viewbox

PromQL Rate Calculation with Dynamic Window

Algorithm description:

This Go program calculates the rate of change for a time-series metric using a dynamically adjusted time window. It aims to provide a meaningful rate by ensuring a minimum number of data points are considered, while also respecting a maximum window size. This is useful in monitoring systems where metrics can have varying reporting frequencies, and a fixed window might lead to inaccurate or unstable rate calculations.

Algorithm explanation:

The `calculateDynamicRate` function takes metric values, their corresponding timestamps, a maximum allowed window duration, and a minimum required number of data points. It first checks for valid input. Then, it estimates the average time interval between data points and calculates a `requiredWindow` to encompass at least `minDataPoints`. The `optimalWindow` is determined by taking the minimum of `maxWindow` and `requiredWindow`, ensuring both constraints are met. It also ensures the `optimalWindow` is at least as large as the interval between the last two data points to prevent issues with very sparse data. Data points falling within this `optimalWindow`, ending at the latest timestamp, are filtered. If fewer than two data points are available in the filtered window, an error is returned. Otherwise, the rate is calculated as the difference between the last and first values in the window, divided by the time span of the window in seconds. The time complexity is O(N) due to iterating through the data points to filter the window, where N is the total number of data points. The space complexity is O(W), where W is the number of data points within the determined window, for storing `windowData` and `windowTimestamps`.

Pseudocode:

FUNCTION calculateDynamicRate(metricData, timestamps, maxWindow, minDataPoints):
  IF metricData is empty OR timestamps is empty OR lengths mismatch THEN
    RETURN error "Invalid input"
  END IF

  IF number of data points < minDataPoints THEN
    RETURN error "Insufficient data points"
  END IF

  Calculate dataSpan from first to last timestamp.
  Calculate avgInterval between data points.
  Calculate requiredWindow = avgInterval * (minDataPoints - 1).

  optimalWindow = MIN(maxWindow, requiredWindow).
  lastInterval = time difference between last two timestamps.
  IF optimalWindow < lastInterval THEN
    optimalWindow = lastInterval.
  END IF

  Define windowStartTime = last timestamp - optimalWindow.
  Initialize windowData and windowTimestamps.

  Iterate backwards from the last timestamp:
    IF current timestamp >= windowStartTime THEN
      Add current metric value to windowData.
      Add current timestamp to windowTimestamps.
    ELSE
      BREAK loop.
    END IF
  END ITERATE.

  Reverse windowData and windowTimestamps to maintain chronological order.

  IF number of data points in window < 2 THEN
    RETURN error "Insufficient data points in window"
  END IF

  firstValue = first element of windowData.
  lastValue = last element of windowData.
  timeSpan = last timestamp in window - first timestamp in window.

  IF timeSpan <= 0 THEN
    RETURN error "Time span is zero or negative"
  END IF

  rate = (lastValue - firstValue) / timeSpan.seconds().
  RETURN rate, nil
END FUNCTION

Library

Playable exercises

Choose Exercise

Filter, sort, and preview algorithm before you choose one to play.

Total 9 published items

Pages 2 pages available

Language

Sort by Direction

Browse published coding scenarios with filters, sorting, and pagination.

Published

PromQL Query (promql)

PromQL Exponential Moving Average (EMA)

Difficulty: writing: 5; length: 10
Popularity: 0
Created: 2026-01-26 14:09 UTC
Published: 2026-01-26 16:42 UTC
Author: Damian

#EMA #moving average #smoothing #time series #algorithm #data smoothing

goal: Calculate the Exponential Moving Average (EMA) of a series of data points. input: values (slice of float64) or metricData (map[time.Time]float64), period (int) output: Slice of float64 EMA values or a map of time.Time to float64 EMA values, and an error.

Canonical Algorithm Text

package main import ( "fmt" "math" "time" ) // calculateEMA computes the Exponential Moving Average (EMA) for a given series of values. // EMA is calculated using the formula: EMA_today = (Value_today * alpha) + (EMA_yesterday * (1 - alpha)) // where alpha is the smoothing factor...

Description Algorithm

This Go program calculates the Exponential Moving Average (EMA) for a series of numerical data points, optionally associated with timestamps. EMA is a type of moving average that places a greater weight and significance...

Explanation

The `calculateEMA` function computes the EMA for a slice of float64 values given a `period`. It first validates that the `period` is positive. If the input `values` slice is empty, it returns an empty slice. The smoothing factor `alpha` is calculated as `2 / (period + 1)`. The first EMA value is initialized with the first data point. Subsequent EMA values are calculated iteratively using the formula: `EMA_today = (Value_today * alpha) + (EMA_yesterday * (1 - alpha))`. The `calculateEMAWithTimestamps` function is a helper that sorts data points by timestamp before applying the core EMA calculation, returning the results mapped back to their original timestamps. The time complexity for `calculateEMA` is O(N), where N is the number of data points, due to a single pass. The `calculateEMAWithTimestamps` function adds O(N log N) for sorting timestamps. Space complexity for `calculateEMA` is O(N) for the result slice, and for `calculateEMAWithTimestamps` it's O(N) for storing sorted timestamps, values, and the result map.

Pseudocode

FUNCTION calculateEMA(values, period): IF period <= 0 THEN RETURN error "Period must be positive" END IF IF values is empty THEN RETURN empty list END IF alpha = 2.0 / (period + 1). emaResults = list of same size as valu...

Published

PromQL Query (promql)

PromQL Rate Calculation with Dynamic Window

Difficulty: writing: 1; length: 10
Popularity: 0
Created: 2026-01-26 14:09 UTC
Published: 2026-01-26 16:42 UTC
Author: Damian

#rate calculation #time series #dynamic window #algorithm #data analysis #promql

goal: Calculate the rate of change of a metric over a dynamic time window. input: metricData (slice of float64), timestamps (slice of time.Time), maxWindow (time.Duration), minDataPoints (int) output: Calculated rate (float64) and an error.

Canonical Algorithm Text

package main import ( "fmt" "time" ) // calculateDynamicRate computes the rate of change for a metric over a dynamically // determined time window. The window size is adjusted based on the density of // data points to ensure a meaningful rate calculation. func calculateDynamicRat...

Description Algorithm

This Go program calculates the rate of change for a time-series metric using a dynamically adjusted time window. It aims to provide a meaningful rate by ensuring a minimum number of data points are considered, while also...

Explanation

The `calculateDynamicRate` function takes metric values, their corresponding timestamps, a maximum allowed window duration, and a minimum required number of data points. It first checks for valid input. Then, it estimates the average time interval between data points and calculates a `requiredWindow` to encompass at least `minDataPoints`. The `optimalWindow` is determined by taking the minimum of `maxWindow` and `requiredWindow`, ensuring both constraints are met. It also ensures the `optimalWindow` is at least as large as the interval between the last two data points to prevent issues with very sparse data. Data points falling within this `optimalWindow`, ending at the latest timestamp, are filtered. If fewer than two data points are available in the filtered window, an error is returned. Otherwise, the rate is calculated as the difference between the last and first values in the window, divided by the time span of the window in seconds. The time complexity is O(N) due to iterating through the data points to filter the window, where N is the total number of data points. The space complexity is O(W), where W is the number of data points within the determined window, for storing `windowData` and `windowTimestamps`.

Pseudocode

FUNCTION calculateDynamicRate(metricData, timestamps, maxWindow, minDataPoints): IF metricData is empty OR timestamps is empty OR lengths mismatch THEN RETURN error "Invalid input" END IF IF number of data points < minDa...

Published

PromQL Query (promql)

Calculate Histogram Quantile

Difficulty: writing: 9; length: 6
Popularity: 0
Created: 2026-01-26 13:25 UTC
Published: 2026-01-26 13:41 UTC
Author: Admin

#histogram #quantile #promql #latency #distribution

goal: Calculate a specific quantile from a histogram metric. input: metricName (string), quantile (float64), duration (time.Duration), labelsToSum ([]string) output: PromQL query string

Canonical Algorithm Text

package main import ( "fmt" "strings" "time" ) // calculateHistogramQuantile computes the specified quantile for a histogram metric. // It uses the histogram_quantile function and handles potential label aggregation. func calculateHistogramQuantile(metricName string, quantile flo...

Description Algorithm

This scenario involves calculating a specific quantile (e.g., p95) from a histogram metric in PromQL. Histograms record observations into buckets, and this query aggregates these buckets over a time window to estimate th...

Explanation

The `histogram_quantile(quantile, bucket_rate)` function in PromQL is used to calculate quantiles from histogram metrics. It requires a `quantile` value (between 0 and 1) and a `bucket_rate` series. The `bucket_rate` is typically derived by applying `rate()` to the `_bucket` metric of the histogram, aggregated by the `le` (less than or equal to) label. This calculates the per-second rate of observations falling into each bucket over the specified `duration`. The `histogram_quantile` function then interpolates between buckets to estimate the value at the desired quantile. The `sum by (le)` clause is essential to aggregate buckets correctly. Time complexity is O(N*M) where N is the number of time series and M is the number of buckets, as it iterates through buckets for each series. Space complexity is O(N) to store intermediate results. Edge cases include invalid quantile values, non-positive durations, and missing `_bucket` metrics.

Pseudocode

function calculateHistogramQuantile(metricName, quantile, duration, labelsToSum): if metricName is empty or quantile is invalid or duration is not positive: return error message bucketQuery = "sum by (" + labelsToSum + "...

Published

PromQL Query (promql)

Calculate SLO Budget Remaining

Difficulty: writing: 3; length: 10
Popularity: 0
Created: 2026-01-26 13:25 UTC
Published: 2026-01-26 13:41 UTC
Author: Admin

#SLO budget #promql #remaining budget #consumption #metrics

goal: Calculate the remaining SLO budget in units and percentage. input: metricName (string), totalBudgetUnits (int64), sloPeriod (time.Duration) output: PromQL query string

Canonical Algorithm Text

package main import ( "fmt" "time" ) // calculateSLOBudgetRemaining calculates the remaining budget for an SLO. // It subtracts the consumed budget (e.g., errors, downtime) from the total allowed budget. // This function assumes the metric represents 'bad' events and the goal is...

Description Algorithm

This scenario focuses on calculating the remaining budget for a Service Level Objective (SLO). It involves determining the total allowed 'bad' events (e.g., errors, downtime) over a defined period and subtracting the num...

Explanation

Calculating remaining SLO budget involves understanding the total allowance and the actual consumption. For a counter metric representing violations (e.g., `slo_violations_total`), the total consumed budget over the SLO period can be found using `increase(metric[sloPeriod])`. The remaining budget is then `totalBudgetUnits - increase(metric[sloPeriod])`. This provides the absolute number of 'bad' events still permissible. To express this as a percentage, the remaining units are divided by the total budget units and multiplied by 100. Time complexity is dominated by `increase()`, which is O(N*W) where N is series and W is the window duration. Space complexity is O(N*W). Edge cases include negative or zero budget units, non-positive durations, and metrics that are not counters.

Pseudocode

function calculateSLOBudgetRemaining(metricName, totalBudgetUnits, sloPeriod): if metricName or budget or period are invalid: return error message consumedUnits = "increase(" + metricName + "[" + sloPeriod + "])" remaini...

Published

PromQL Query (promql)

Calculate Request Rate

Difficulty: writing: 4; length: 4
Popularity: 0
Created: 2026-01-26 13:25 UTC
Published: 2026-01-26 13:41 UTC
Author: Admin

#rate #counter #promql #rate calculation #resets

goal: Calculate per-second rate of increase for a counter metric. input: metricName (string), duration (time.Duration) output: PromQL query string

Canonical Algorithm Text

package main import ( "fmt" "time" ) // calculateRequestRate calculates the per-second rate of increase for a counter metric. // It handles counter resets by looking for a decrease in value and resetting the rate. func calculateRequestRate(metricName string, duration time.Duratio...

Description Algorithm

This scenario focuses on calculating the per-second rate of increase for a counter metric in PromQL. It utilizes the `rate()` function, which is designed to handle counter resets automatically. The goal is to provide a r...

Explanation

The `rate()` function in PromQL is fundamental for calculating the average per-second rate of increase of a counter over a specified time interval. It intelligently handles counter resets by detecting a decrease in value and adjusting the calculation accordingly. The function samples the counter at the given `duration` and calculates the increase, then divides by the duration to get the per-second rate. This approach ensures accurate rate measurements even when counters are reset (e.g., during service restarts). The time complexity is O(1) for each evaluation, as it operates on a fixed window. Space complexity is also O(1) as it doesn't store historical data beyond the window. Edge cases like empty metric names or non-positive durations are handled by returning an error or an empty query.

Pseudocode

function calculateRequestRate(metricName, duration): if metricName is empty or duration is not positive: return error message or empty string query = "rate(" + metricName + "[" + duration + "])" return query function cal...

Published

PromQL Query (promql)

Calculate Burn Rate Alert

Difficulty: writing: 8; length: 10
Popularity: 0
Created: 2026-01-26 13:25 UTC
Published: 2026-01-26 13:41 UTC
Author: Admin

#burn rate #SLO #promql #alerting #budget

goal: Calculate the burn rate of an SLO budget for alerting. input: metricName (string), budgetDuration (time.Duration), alertWindow (time.Duration) output: PromQL query string

Canonical Algorithm Text

package main import ( "fmt" "time" ) // calculateBurnRate calculates the burn rate of an SLO budget over a specified period. // Burn rate is typically defined as the ratio of actual consumption to the allowed consumption rate. // For an SLO, this often means how quickly 'bad' eve...

Description Algorithm

This scenario focuses on calculating the 'burn rate' of an Service Level Objective (SLO) budget. The burn rate measures how quickly the 'bad' events (violations) are occurring relative to the allowed rate defined by the...

Explanation

Burn rate is a key metric for SLO management. It's typically calculated as the ratio of the current rate of violations to the average rate of violations allowed by the SLO. For instance, if an SLO allows 100 errors over 30 days, the allowed rate is `100 / (30 days)`. If the current rate of errors over a short window (e.g., 5 minutes) is higher than this allowed rate, the burn rate will be greater than 1. PromQL implementations often involve `rate()` for the current violation rate and `avg_over_time(rate(...))` for the longer-term average or allowed rate. Time complexity depends on the functions used; `rate()` and `avg_over_time()` are typically O(N*W) where N is series and W is window. Space complexity is similar. Edge cases include zero or negative durations, and metrics that are not counters.

Pseudocode

function calculateBurnRate(metricName, budgetDuration, alertWindow): if metricName or durations are invalid: return error message currentRate = "rate(" + metricName + "[" + alertWindow + "])" averageRate = "avg_over_time...

Published

PromQL Query (promql)

Join Metrics by Label

Difficulty: writing: 6; length: 5
Popularity: 0
Created: 2026-01-26 13:25 UTC
Published: 2026-01-26 13:41 UTC
Author: Admin

#label join #promql #vector matching #correlation #metrics

goal: Join two metrics based on a common label and perform an operation. input: metricA (string), metricB (string), commonLabel (string) output: PromQL query string

Canonical Algorithm Text

package main import ( "fmt" ) // joinMetricsByLabel performs a simple join operation between two metrics using a common label. // It assumes both metrics have a label named 'instance' that can be used for joining. // The operation performed is subtraction: metricA - metricB. func...

Description Algorithm

This scenario focuses on joining two different metrics in PromQL based on a shared label. It demonstrates how to align time series from distinct sources using matching labels and then perform an arithmetic operation (lik...

Explanation

PromQL's label matching and vector matching capabilities are used to join metrics. When performing binary operations between two vectors (e.g., `metricA - metricB`), PromQL requires explicit instructions on how to match the elements of these vectors. The `on(<label_list>)` clause specifies which labels must match for a pair of time series to be considered a match. The `group_left(<label_list>)` or `group_right(<label_list>)` modifiers dictate which labels from the 'unmatched' side of the operation should be preserved in the resulting time series. For instance, `metricA - metricB on(instance) group_left()` will subtract `metricB` from `metricA` for all series where the `instance` label matches, and the resulting series will retain all labels from `metricA`. Time complexity is O(N*M) where N and M are the number of series in each vector, due to pairwise comparisons. Space complexity is O(N+M) for storing intermediate results. Edge cases include missing common labels, mismatched label values, and differing numbers of series.

Pseudocode

function joinMetricsByLabel(metricA, metricB, commonLabel): if metricA or metricB or commonLabel is empty: return error message query = metricA + " - " + metricB + " on(" + commonLabel + ") group_left()" return query fun...

Published

PromQL Query (promql)

Calculate Window Aggregation

Difficulty: writing: 8; length: 6
Popularity: 0
Created: 2026-01-26 13:25 UTC
Published: 2026-01-26 13:41 UTC
Author: Admin

#window aggregation #promql #sliding window #sum #metrics

goal: Calculate the sum of a metric over a sliding window. input: metricName (string), windowDuration (time.Duration) output: PromQL query string

Canonical Algorithm Text

package main import ( "fmt" "time" ) // calculateWindowSum calculates the sum of a metric over a sliding window. // It uses the `sum_over_time` function, which aggregates values within the specified duration. func calculateWindowSum(metricName string, windowDuration time.Duration...

Description Algorithm

This scenario focuses on performing window aggregation in PromQL, specifically calculating the sum of a metric over a sliding time window. This is useful for smoothing out noisy data, identifying trends, or calculating c...

Explanation

Window aggregation functions in PromQL, like `sum_over_time`, `avg_over_time`, `max_over_time`, and `min_over_time`, operate on a sliding window of data. `sum_over_time(metric[duration])` calculates the sum of all recorded values for `metric` within the last `duration` for each point in time. This means that as time progresses, the window slides forward, and the sum is recalculated based on the new data points entering and leaving the window. This is distinct from a `sum()` aggregation which aggregates across all series at a single point in time. Time complexity is O(N*W) where N is the number of series and W is the window duration, as it needs to process data points within the window. Space complexity is O(N*W) to store data for the window. Edge cases include empty metric names, non-positive durations, and metrics with very low scrape intervals.

Pseudocode

function calculateWindowSum(metricName, windowDuration): if metricName is empty or windowDuration is not positive: return error message query = "sum_over_time(" + metricName + "[" + windowDuration + "])" return query fun...

Language (required)

Paste your code (required)

Max 20,000 characters. (Dangerous HTML/script fragments will be blocked)

Normalized preview:

I agree to Publish this, after admin approval (queued for review). (Not required) I confirm this submission is anonymous and does not contain personal data. I grant SkillsTyping a free, non-exclusive, worldwide, and irrevocable license to store, modify, adapt, and publish this content after review. I understand that publication is not guaranteed, that I retain no ownership or usage claims over published versions, and that no compensation will be provided. See Privacy Policy

Publish details

Shown only if you opt to submit for review. Required when consent is checked.

Title (required with consent)

Short description / summary (required with consent)

Algorithm explanation (required with consent)

Pseudocode (required with consent)