Welcome to Algotester!

I got a Wrong Answer on the problem A plus B.

This means that your solution is incorrect, it means there is a valid test case on which your solution result is different from the judge’s solution result. The list of all possible judge verdicts:

Wrong Answer	There is a valid test case on which your solution result is different from the judge’s solution result.
Runtime Error	The program ended unexpectedly (for example, there was an attempt to divide by 0, or to index outside the array).
Time Limit	There is a valid test case in which the program execution time exceeds the limit specified in the statement.
Memory Limit	There is a valid test case in which the program memory consumption exceeds the limit specified in the statement.
Compilation Error	The compiler is unable to compile your code. To see compiler output, go to compiler tab in the solution view.
Internal error	There is a judge error. Algotester team is trying to fix it.
Idle Time Limit Exceeded	Interactor waited too long for user output. This error is occurred when interaction protocol is violated.
Accepted	This is the only verdict that is good for you - the program passed all test cases and is accepted by the judge!

How to find problems?

In section Problems, you can:
1. Sort problems by the number of people who solved it. Easy problems are solved more frequently than hard ones.
2. Choose theme or complexity using tags. Click on a tag or write down the theme in the search field.
3. Find a specific problem by its ID, name, or source (contest name in which this problem was used).
Where can I find hints if I struggle with a problem?

In section Analysis you can find written editorial to some problems. Also, you can find video editorials in our YouTube.
Can I compare my progress with other members?

Yes, a full list of users, sorted by the number of solved problems, is available on the left menu in section Rank. Also, you can find online queue with yours and other users solutions in section Solution queue.
Archive is good, but how to participate in real contest?

In Ivan Franko National University of Lviv (and others Lviv universities), you can participate in regular onsite contests using Algotester. Subscribe to us on Facebook, Twitter and Telegram to not to miss any event.

What languages can be used to solve problems?

Language	Version	Compiler Arguments
C++ 14	g++ 6.4.0	`-O2`
C++ 17	g++ 10.3.0	`-O2 -std=c++17`
C++ 20	g++ 11.2.0	`-O2 -std=c++20`
C++ 23	g++ 14.1.0	`-O2 -std=c++23`
C	gcc 14.1.0	`-O2 -std=gnu23`
C#	Mono C# compiler version 6.4.0.198	`/o+ /r:System.Numerics.dll`
Java 8	openjdk 1.8.0
Java 19	openjdk 19
Java 23	openjdk 23
Pascal	Free Pascal Compiler 3.2.2	`-O2 -Sh`
Python	Python 3.8.1	`-O`
PyPy	PyPy 7.3.0 with GCC 7.4.0	`-O`
F#	F# Compiler version 4.1	`-r:System.Numerics.dll --optimize+ --crossoptimize+`
Go	go version go1.20.5
Node.js	Node.js v20.0.0
Ruby	ruby 3.2.2
Rust	rustc 1.70.0	`--edition 2021 -C opt-level=3`

Examples of problem "A plus B" solutions written on available programming languages:

C++

#include <iostream>
using namespace std;
        
int main()
{
    int a, b;
    cin >> a >> b;
    
    cout << a + b << endl;
    
    return 0;
}

#include <stdio.h>

int main()
{
    int a, b;
    scanf("%d%d", &a, &b);
    printf("%d\n", a+b);
    return 0;
}

using System;

class Algotester
{
    public static void Main(string[] args)
    {
        string[] line = Console.ReadLine().Split(' ');
        int a = Int32.Parse(line[0]);
        int b = Int32.Parse(line[1]);

        Console.WriteLine(a + b);
    }
}

Java

import java.util.Scanner;

public class Algotester
{
    public static void main(String[] args) 
    {
        Scanner in = new Scanner(System.in);
        int a = in.nextInt();
        int b = in.nextInt();
        
        System.out.println(a + b);
   }
}

Pascal

var a, b : integer;
begin
    read(a, b);

    writeln(a + b);
end.

Python / PyPy

a, b = input().split()
a, b = int(a), int(b)
print(a+b)

let main() =
    let line = System.Console.ReadLine()
    let numbers = line.Split(' ')
    let a = System.Int32.Parse(numbers.[0])
    let b = System.Int32.Parse(numbers.[1])
    System.Console.WriteLine(a + b)

main()

package main
 
import (
    "fmt"
)
 
func main() {
    var a, b int
    fmt.Scanf("%d %d", &a, &b)
    fmt.Printf("%d\n", a+b)
}

Node.js

function Main(input) {
    s = input.split(" ");
    var a = parseInt(s[0]);
    var b = parseInt(s[1]);
    console.log('%d', a+b);
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));

Ruby

# Read input from stdin
input = gets.chomp

# Split the input string into two numbers
a, b = input.split.map(&:to_i)

# Calculate the sum
sum = a + b

# Print the result
puts sum

Rust

use std::io;

fn main() {
    // Read input from stdin
    let mut input = String::new();

    io::stdin()
        .read_line(&mut input)
        .expect("Failed to read input.");

    // Parse input string to numbers
    let mut numbers = input.split_whitespace();
    let a: i32 = numbers.next().unwrap().parse().expect("Invalid number entered for a.");
    let b: i32 = numbers.next().unwrap().parse().expect("Invalid number entered for b.");

    // Calculate the sum
    let sum = a + b;

    // Write the sum to stdout
    println!("{}", sum);
}

The process of creating a problem at Algotester

Stages of problem creation

Lists

Use proper LaTeX commands for lists:

Unordered (bulletpoint) list:
\begin{itemize}
 \item One entry in the list
 \item Another entry in the list
\end{itemize}
Ordered (numerated) list:
\begin{enumerate}
 \item One entry in the list
 \item Another entry in the list
\end{enumerate}

Images
- All images must be uploaded in the Resources section of an Algotester problem.
- Images are referenced by resource name without file extension.
- Images must be centered by default, with the image description below:
```
\begin{center}
 \includegraphics[width=0.5\textwidth]{resource-name}
\end{center}
```
Samples
- A statement must contain at least one sample.
- Avoid too trivial samples (aka Boiko samples).
- The first sample must be the first test case of the problem. The same holds for the following samples, if any.
- There is an opportunity to create samples only for statement.
Notes
- The Notes section must contain sample descriptions when appropriate.
- The Notes section can also contain additional definitions when needed, but they must also be referenced in the main statement.
Miscellaneous
- Parts of the statement that need special emphasis (non-obvious constraints or conditions, corrected parts of the statements, etc.) must be bold (enclosed in \textbf{}).
- Use --- in Ukrainian and -- in English, never use - as a long dash.
- Use spell-checker when writing English and Ukrainian statements.

The algotester.h and algotester_generator.h libraries are created to facilitate writing the source codes for the problems. You should use them when writing all validators, checkers, scorers, and test generators.

The algotester.h library

While using the library, you will work with the AlgotesterReader class. This is a class for reading data. While reading, it can also validate various properties. This reader can work in two modes: strict for validators and non-strict for checkers and scorers. In strict mode, you have to check the data format with all spaces and end-of-line characters. In a non-strict mode it is not necessary to read spaces or end-of-line characters.

List of AlgotesterReader class methods and their brief description:

You can find more information about this methods here.

Another important functions of the library:

initValidator – returns reader in strict mode. You have to use it for validators. It has no parameters.
initChecker – returns an array of three readers in non-strict mode: input stream reader, user output reader and author output reader. You have to use it for checkers. It takes the programs input parameters (int argc, char* argv[]).
initInteractiveChecker – returns a tuple of such elements: input stream reader, user input stream (you have to write answers in this stream) and user output reader. You have to use it for interactive checkers. It takes the programs input parameters (int argc, char* argv[]).
initScorer – returns an array of three readers in non-strict mode: input stream reader, user output reader and author output reader. You have to use it for scorers. It takes the programs input parameters (int argc, char* argv[]).
isClose – checks if 2 double values are close with given absolute and relative tolerance. It takes two double values, absolute and relative tolerance. Default tolerances are $10^{-7}$ .
equalsIgnoreCase – checks if strings are equal ignoring case.
check – takes a condition and a string (error message). If condition is false prints error message.

You can find examples of validators, checkers and other source codes here.

The algotester_generator.h library

This library is designed to facilitate the writing of generators for problems. It contains AlgotesterGenerator class. To work with it, you need to initialize the generator with the initGenerator function. It takes the input parameters of your program. You can initialize it in this way: auto gen = initGenerator(argc, argv). When creating tests with the generator, we recommend you to select «Append hash to arguments» checkbox. After that, you can use methods to generate different values.

List of AlgotesterGenerator class methods and their brief description:

randInt – generate uniform random unsigned 64-bit integer. You can pass bounds to this method. If you pass one integer $n$ , it will generate integer in range $[0, n)$ . If you pass two integers $l$ and $r$ , it will generate integer in range $[l, r]$ .
randUInt – the same as randInt, but generate unsigned integers.
randDouble – generate uniform random real number in range $[0, 1]$ . If you pass one integer $n$ , it will generate integer in range $[0, n]$ . If you pass two integers $l$ and $r$ , it will generate integer in range $[l, r]$ .
shuffle – random shuffles elements. It can take vector, or iterators to the begin and end.
randomElement – returns random element of vector.
randLogUniform – takes integer $n$ , returns random integer in range $[1, n]$ , such that natural logarithm of that number is uniformly distributed. Useful in cases when you want to generate both small and large values.
randBiasedInt – takes boundaries and $t$ as parameters. If you pass one integer $n$ , it will generate integer in range $[0, n]$ . If you pass two integers $l$ and $r$ , it will generate integer in range $[l, r]$ . Generates $|t| + 1$ numbers. If $t = 0$ , returns random number, if $t < 0$ , returns minimum of $t+1$ uniform values, if $t > 0$ , returns maximum of $t+1$ uniform values. Works in O(1).
getArg – takes index $i$ , returns $i$ -th argument of input parameters.

Full description of all methods you can find here.

Help

Welcome to Algotester!

The process of creating a problem at Algotester

Stages of problem creation

The algotester.h library

The algotester_generator.h library