Running and submitting

How running with the samples, running with your own input and submitting differ, how judging works, and which limits apply.

In the editor you can run your program – to check that it works – or submit it for grading. Practice runs are not graded and don’t use attempts; every submission is graded and kept.

Where your code runs

Your code doesn’t run in your browser or in the app’s server. It runs on the judge – a separate, isolated environment with no internet access.

Language	How it runs
C++	Compiled with g++ 14, the GNU C++20 standard, with optimisation (`-O2`). The macro `ONLINE_JUDGE` is defined. The compiler warns about common mistakes (`-Wall`), but not about comparing an `int` with a `size_t`, such as `i < v.size()`
Python	Python 3.13, standard library only
C#	C# 14 on .NET 10, with optimisation. Write the program with a `Main` method or without one (statements straight in the file). The usual `using`s of a new console project (`System`, `System.Collections.Generic`, `System.IO`, `System.Linq` and others) are already there. The symbol `ONLINE_JUDGE` is defined. Standard library only; see the tips

Three actions

	Run samples	Run with custom input	Submit
Where	Top bar, `Ctrl` `Enter`	The Custom input tab	Top bar, `Ctrl` `Shift` `Enter`
Data	The statement’s examples	The input you type	Every test, including hidden ones
What you get	Whether each sample passes	Your program’s output	A verdict and points
Uses an attempt	No	No	Yes
Kept in history	No	No	Yes, under Submissions
During an assessment	Allowed	Not allowed	Allowed
After the topic closes	Allowed	Allowed	Not allowed
Limits	The problem’s time limit, at most 2 s; at most 512 MB of memory	As for samples	The problem’s time and memory limits

On a Mac press ⌘ instead of Ctrl. These keys also work while focus is elsewhere in the editor window.

Running with the samples

Write your code.
Choose Run samples or press Ctrl Enter.
The Tests tab opens at the bottom: you see the progress while your program runs, then each sample’s result.

If every sample passes, you see “All samples pass”. Otherwise you see the first failing sample’s result, e.g. “Wrong answer”, and “1 of 2 samples pass”. Select a sample’s row to see its input, expected output, your output and error output.

If the code doesn’t compile, you see “Compilation error” and the link Show compiler messages.

Samples are only a start: hidden tests also decide the grade. You see them once your submission is judged.

Running with your own input

Open the Custom input tab.
Type the input in the left box (up to 64 KB). If the program reads a file, the box is labelled with its name, e.g. duom.txt.
Choose Run with custom input, or press Ctrl Enter in the box.

On the right you see what the program printed or, if it writes a file, the output file’s contents. If the file wasn’t created, it says, e.g., “rez.txt was not created.” Below the output you see the error output (if any), the run time, the memory used, the exit code (if not 0) and the signal that stopped the program.

There is no expected output here, so you won’t get “Accepted”. If the program finished without errors, you see “Program finished”; if it hit a limit or crashed, you see that result, e.g. “Time limit exceeded”.

Your custom input is remembered in this browser together with your draft.

One run at a time

Only one of your practice runs runs at a time. If you start a new one before the previous one finishes, the previous one is cancelled: “This run was cancelled because a newer one started.”

Run results stay in the editor until you close it. They don’t go into your submissions history.

Submitting

Make sure your program passes the samples.
Choose Submit or press Ctrl Shift Enter.
The Last result tab opens and shows judging progress.
When judging finishes, you see the verdict and the tests. How to read them: Results.

Screenshot to comeThe Last result tab: the verdict, tests passed and the list of testsStudent account, a submission just judged “Wrong answer” (7 of 10 tests)students/learning/editor-last-result

You can close the editor right after submitting – the submission is judged anyway. You’ll find the result under Submissions, and a notification arrives in your inbox (you can turn it off under Settings → Notifications, “Submission results”).

When you can’t submit, the Submit button is disabled; hover over it to see why, e.g. “No attempts left today. They reset at midnight.”

Judging progress

While a submission or run is being judged, the panel shows its state and the time since you sent it:

State	What it means
Sending…	Your code is being sent to the server
Waiting in the queue	Waiting for a free place on the judge
Compiling	C++ and C# code is compiled; Python code is checked for syntax errors
Testing	Tests are running. Progress shows next to it, e.g. “3 of 10”
Checked	Judging is done; the result is shown
System error	Judging failed on our side. Such an attempt doesn’t count
Cancelled	The run was cancelled because a newer one started

The state updates by itself; there’s no need to reload the page.

If a submission waits in the queue for more than a minute, you see “The judge is busy or offline. Your submission is saved and will be judged as soon as it’s available.” You don’t need to do anything.
For a practice run, you are offered to try again: “… Run your program again in a moment.” and a Retry button.
If the connection drops, you see “No connection to the server – the status updates as soon as it is back.”
If the status can’t be fetched: “Couldn’t get the status. Reload the page.”

Attempt limits

A course can limit how many submissions a day you can make for each problem. You see the attempts left on the problem page (“3 of 5 left”) and in the editor’s bottom panel (“3 of 5 attempts left today”). Without a limit: “No daily attempt limit”.

Every submission counts as an attempt, except those that got “Compilation error”, “System error” or “Check failed”.
Submissions still being judged count.
Practice runs with the samples or your own input don’t use attempts.
Attempts reset at midnight, Lithuanian time.

Once the attempts are used up, you can’t submit until the next day: “No attempts left today. Next attempt: …”. You can still run your program.

When a submission is refused

Message	Reason
“Wait for your previous submissions to be checked.”	You already have three submissions that haven’t been checked
“Too many requests in a short time. Wait 20 s and try again.”	More than 6 submissions or more than 12 runs in a minute
“The code is empty.”	The editor has no code
“The code is too long: at most 256 KB.”	The code is larger than 256 KB
“The input is too long: at most 64 KB.”	Your custom input is larger than 64 KB
“This programming language isn’t allowed for this problem.”	The language isn’t allowed in this problem
“This problem isn’t open yet.”	The topic hasn’t started
“Submissions closed …”	The topic has closed (you can still run)
“During a test, programs can only be run with the samples.”	An assessment is running
“This problem has no sample tests. Run your program with custom input.”	The problem has no samples
“This problem was updated. Reload it to see the new statement – your code is kept.”	Your teacher published a new version of the problem. Choose Reload
“You’ve been signed out. Sign in again – your code is saved on this device.”	Your session ended
“Couldn’t send. Your code is saved on this device – try again.”	A connection or server error

Tips

Your program must end without an error. If a C++ program’s main returns something other than 0, a C# program ends with an unhandled exception or Environment.Exit with a non-zero code, or a Python program ends with an error (e.g. sys.exit(1) or an unhandled exception), the test gets “Runtime error” even if the output is right.
In file problems nothing comes from the keyboard: the program must read the input file and write the output file. Output written to the screen is not checked.
Python has only the standard library; other packages (e.g. numpy) are not installed.
C# has only the .NET standard library; there are no NuGet packages.
- Close a StreamWriter (e.g. using var output = new StreamWriter("rez.txt");), or the output file stays empty.
- Threads and Tasks work, but the time limit counts the CPU time of all threads together. Starting other programs isn’t possible.
- The .NET runtime itself takes part of the memory limit (about 16–25 MB).
- Numbers use a dot whatever your computer’s settings: double.Parse("3.5") is 3.5, while double.Parse("3,5") is 35.
- Strings are compared and sorted by character codes, as in C++ and Python: "B" comes before "a", and Lithuanian letters come after z. Your computer may sort them differently.
ONLINE_JUDGE. If you read input from a file on your own computer while the problem uses standard input, wrap opening the file in #ifndef ONLINE_JUDGE (in C#, #if !ONLINE_JUDGE) – it won’t run on the judge.