Judging & Submission Guide

This page summarizes AACPOJ verdicts, submission limits, custom-test limits, and the registered language compile information.

Verdicts

Code	Meaning	Notes
`AC`	Accepted	Your program passed all scoring tests for this submission.
`PAC`	Partial score	A testcase output met the condition for partial credit, but did not reach the best answer or highest score. This kind of problem is rare.
`WA`	Wrong Answer	Your program did not crash while running, but its output was wrong. The submission page may include feedback explaining what went wrong.
`PE`	Presentation Error	The output is close but whitespace or formatting is wrong.
`IR`	Invalid Return	The program ended in an unusual way. For example, returning a non-zero value from `main` produces this result.
`TLE`	Time Limit Exceeded	The program ran for too long.
`MLE`	Memory Limit Exceeded	The program used too much memory.
`OLE`	Output Limit Exceeded	The program printed too much output, often because of an infinite loop or leftover debug output.
`RTE`	Runtime Error	The program crashed while running, often because of an out-of-bounds array access, division by zero, or memory problem.
`CE`	Compile Error	Compilation failed; compiler output is shown on the submission page.
`IE`	Internal Error	The judge system or problem settings had an issue, so an administrator usually needs to check it.
`QU` / `P` / `G`	Queued / Processing / Grading	The submission is not finished yet.
`AB`	Aborted	The submission was aborted.

Detailed RTE feedback depends on how the program failed. Common messages include:

Feedback	Common cause
`segmentation fault` / `bus error`	The program touched memory it should not use. Common causes include an out-of-bounds array index, a bad pointer, recursion that is too deep, or using too much memory.
`floating point exception`	An invalid arithmetic operation, such as integer division or modulo by zero.
`killed`	The system stopped the program. It may have used too many resources or behaved unexpectedly, but this message alone does not tell the exact reason.
`{} syscall disallowed`	The program tried to perform an operating-system action that the OJ does not allow. Normal solutions rarely hit this; report it to an administrator if ordinary code does.
`std::bad_alloc`	C++ failed to allocate memory, usually because a `vector`, array, or similar data structure is too large.
`failed initializing`	The program used too much global or static data before `main` started.

Some memory problems may appear as MLE, while others appear as RTE with segmentation fault or std::bad_alloc.
If RTE only appears on larger tests, check array bounds, recursion depth, pointer/index validity, and division by zero.

Source length

65,536 characters

Queued submissions per user

Maximum problem time limit

60 s

Maximum problem memory limit

1 GiB

Source visibility mode

all-solved

Official judging uses the time and memory limits shown on each problem page.
Contest problems can add per-problem submission limits; check the contest/problem page.
The queued-submission limit controls how many submissions can wait for judging at once.

Custom input limit

1 MiB

Custom-test rate

1 / 3 s

Sample-test rate

1 / 1 s

Custom-test compile cap

10 s CPU

Custom-test execution cap

15 s wall-clock

Custom and sample tests are debugging aids; they do not affect official score.
Official submissions are still judged by the hidden tests and each problem's answer rules.
Interactive problems usually do not provide custom tests because stdin/stdout alone cannot simulate the protocol.

The table below is read from the OJ language settings. Missing compile options mean no public compile-option note is configured for that language.

ID	Language	Runtime	Compile Options
`C`	C	`gcc 11`	`gcc -std=c99 -Wall -DONLINE_JUDGE -O2 -lm -fmax-errors=5 -march=native -s`
`C11`	C11	`gcc11 11`	`gcc -std=c11 -Wall -DONLINE_JUDGE -O2 -lm -fmax-errors=5 -march=native -s`
`CPP03`	C++03	`g++ 11`	`g++ -Wall -DONLINE_JUDGE -O2 -lm -fmax-errors=5 -march=native -s`
`CPP11`	C++11	`g++11 11`	`g++ -std=c++11 -Wall -DONLINE_JUDGE -O2 -lm -fmax-errors=5 -march=native -s`
`CPP14`	C++14	`g++14 11`	`g++ -std=c++14 -Wall -DONLINE_JUDGE -O2 -lm -fmax-errors=5 -march=native -s`
`CPP17`	C++17	`g++17 11`	`g++ -std=c++17 -Wall -DONLINE_JUDGE -O2 -lm -fmax-errors=5 -march=native -s`
`CPP20`	C++20	`g++20 11`	`g++ -std=c++20 -Wall -DONLINE_JUDGE -O2 -lm -fmax-errors=5 -march=native -s`