Choosing a Language

What Languages Does The USACO Support?

The most popular languages that USACO supports are C++17, Java, and Python 3. C is also supported, but it's essentially a strictly inferior version of C++ and doesn't have the built-in data structures that are often used.

What Are The Differences Between C++11 and C++17?

If you're just starting out, you probably won't be using any C++17-specific features, so submitting in either C++11 or C++17 should suffice. For information about the features introduced in C++11, C++14, and C++17, check the links below.

• C++11 for Programming Contests
• C++ Tricks (C++11 onwards)
• C++14
• C++17

What Are The Differences Between Python 2 and Python 3?

As the link below mentions, there are many differences between Python 2 and 3. Python 3 is newer and an overwhelming majority of USACO contestants use it over Python 2.

• Python 2 vs Python 3

What Language Should I Start Out With?

In general, we recommend the following:

• If you already know one or more of these languages, just use the one you are most comfortable with.
• If you don't know any of these languages, you might as well start with C++, as C++ users generally don't need to worry as much about their solutions being a constant factor too slow. Furthermore, most modules currently lack Java and Python support.

Don't overthink choosing a language -- you can always change languages later!

Can I Pass Every Problem in Every Language?

C++ is typically faster than Java, which in turn is typically faster than Python. Although both Python and Java receive two times the C++ time limit in USACO, this is not the case for most other websites (ex. CodeForces, CSES). Even with the extended time limits, Python and Java sometimes have trouble passing.

• It is guaranteed to be able to receive full credit on all Bronze contests with Python, C++, and Java.
• Python lacks a data structure that keeps its keys in sorted order (the equivalent of std::set in C++), which is required for some problems in Gold and Platinum.
• We don't have any examples of USACO problems that are impossible to pass with Java, though there are instances where the official C++ code is not fast enough to receive full credit if translated into equivalent Java code.

Example - Wormhole Sort

The Java solution presented in the analysis requires over 3s to run (out of a time limit of 4s).

Copy
import java.io.*;
import java.util.*;
public class wormsort {
	public static void main(String[] args) throws IOException{
		BufferedReader br = new BufferedReader(new FileReader("wormsort.in"));
		StringTokenizer st = new StringTokenizer(br.readLine());
		int n = Integer.parseInt(st.nextToken());
		int m = Integer.parseInt(st.nextToken());
		loc = new int[n];
		component = new int[n];

A comparable C++ solution runs in less than 800ms:

Copy
#include<bits/stdc++.h>
using namespace std;

int n,m;
vector<int> loc, lhs, rhs, weight;
vector<vector<int>> edges;
vector<int> component;

void dfs(int curr, int label) {
	if(component[curr] == label) return;

A comparable Python solution only passes the first five test cases:

Copy
import sys
sys.setrecursionlimit(1000000)

sys.stdin = open("wormsort.in","r")
sys.stdout = open("wormsort.out","w")

n,m = map(int,input().split())
loc = [0]*n
component = [0]*n
edges = [[] for i in range(n)]

It is possible to optimise this approach to pass all testcases. This takes around 3.8s to run.

Copy
def main():
	f = open("wormsort.in","rb")
	n, m = map(int, f.readline().split())
	loc = [*map(int, f.readline().split())]
	edges = [[] for _ in range(n)]
	weights = []

	def valid(loc, minW):
		component = [-1] * n
		numcomps = 0

Finally, the approach below uses DSU (a Gold topic), which takes around 1s to run:

Copy
# Author: Nicolas Hsu

file = open('wormsort.in')
N, M = map(int, file.readline().split())
P = tuple(map(int, ('0 '+file.readline()).split()))
W = [ tuple(map(int, file.readline().split())) for i in range(M) ]
W.sort(key=lambda w:-w[2])

par = list(range(N+1))
def find(u):

What Am I Expected to Know?

You should know how to code in at least one of the languages listed above before continuing onto the Bronze section of this guide. For a more detailed list on what you should know, read the "Expected Knowledge" module.