Input & Output

C++

Java

Python

C++

Method 1 - <iostream>

More straightforward to use. Calling the extraction operator operator>> on cin reads whitespace-separated data from standard input. Similarly, calling the insertion operator operator<< on cout writes to standard output. The escape sequence \n represents a new line.

#include <iostream>
using namespace std;

int main() {
	int a, b, c; cin >> a >> b >> c;
	cout << "sum is " << a+b+c << "\n";
	// or cout << "sum is " << a+b+c << endl;
}

Method 2 - <cstdio>

This library includes the scanf and printf functions, which are slightly more complicated to use.

#include <cstdio>
using namespace std;

int main() {
	int a, b, c;
	// %d specifies that a value of type int is being input.
	// Use %lld (a few judging platforms might need %I64d)
	// to input a long long (64-bit) integer.
	// Many other specifiers are also available; see link for more details.
	// Be sure to add a & character (address-of operator) when using

Java

Method 1 - Scanner and System.out.print

In your CS classes, you've probably implemented input and output using standard input and standard output, or using Scanner to read input and System.out.print to print output.

import java.util.Scanner;

public class Main {
	static Scanner sc = new Scanner(System.in);
	public static void main(String[] args) {
		int a = sc.nextInt();
		int b = sc.nextInt();
		int c = sc.nextInt();
		System.out.print("sum is ");
		System.out.println(a + b + c);
	}
}

This works, but Scanner and System.out.print are slow when we have to handle inputting and outputting tens of thousands of lines.

Method 2 - BufferedReader and PrintWriter

These are faster because they buffer the input and output and handle it all at once as opposed to parsing each line individually. However, BufferedReader is harder to use than Scanner. It has quite a few more methods and the io library must be imported for its use as well. A StringTokenizer is used to split the input line by whitespace into tokens, which are then accessed individually by the nextToken() method.

import java.io.*;
import java.util.StringTokenizer;

public class Main {
	static BufferedReader r = new BufferedReader(new InputStreamReader(System.in));
	static PrintWriter pw = new PrintWriter(System.out);
	public static void main(String[] args) throws IOException {
		StringTokenizer st = new StringTokenizer(r.readLine());
		int a = Integer.parseInt(st.nextToken());
		int b = Integer.parseInt(st.nextToken());

I/O Template

The following template (a shortened version of Kattis's Kattio.java) combines BufferedReader and PrintWriter and takes care of the string processing for you.

/** Simple yet moderately fast I/O routines.
 * Some notes:
 *
 * - When done, you should always do io.close() or io.flush() on the
 *   Kattio-instance, otherwise, you may lose output.
 *
 * - The nextInt(), nextDouble(), and nextLong() methods will throw an
 *   exception if there is no more data in the input.
 *
 * @author: Kattis

The input methods in our Kattio class mimic those of Scanner. Given an instance io:

The original Kattio code had super(new BufferedOutputStream(o)); on line 37. But since PrintWriter uses buffered output, I don't think including BufferedOutputStream is necessary.

Similarly, you may see PrintWriters for file output initialized like the following (ex. here).

PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter("problemname.out")));

but

PrintWriter pw = new PrintWriter(new FileWriter("problemname.out"));

should suffice.

Python

Python

The most intuitive way to do input/output is using the built in input() and print() methods. The input() method will return the next line, and can be processed using different python methods. The print() method takes in a string and an optional string end (defaults to '\n'). Below is an annotated demonstration on different input/output scenarios.

# read in a string
myStr = input()
# prints the string on its own line
print(myStr)

# take in an integer n on a single line
n = int(input())
# prints integer n with " test" after it
print(n, end=" test")

We can also split along with map or a list comprehension to read in multiple integers on the same line (separated by whitespace).

# read in a series of numbers on one line into a list
nums = [int(x) for x in input().split()]
# does the same thing
nums = list(map(int, input().split()))

We can use something similar to the above if we are unpacking a fixed number of integers.

# read in integers n and m, both on the same line
n, m = [int(x) for x in input().split()]
# does the same thing
n, m = map(int, input().split())

So taking three integers as input and printing their sum is quite simple:

a,b,c = map(int, input().split())
print("sum is",a+b+c)

C++

As noted in the resource above, this problem requires 64-bit integers.

Java

As noted in the resource above, this problem requires 64-bit integers.

Method 1 - Scanner and System.out.print

Method 2 - BufferedReader and PrintWriter

With Kattio

Python

C++

Method 1 - freopen

You will need the <cstdio> library. The freopen statements reuse standard I/O for file I/O. Afterwards, you can simply use cin and cout (or scanf and printf) to read and write data.

#include <iostream>
#include <cstdio>
using namespace std;

int main() {
	freopen("problemname.in", "r", stdin);
	// the following line creates/overwrites the output file
	freopen("problemname.out", "w", stdout);
	// cin reads from the file instead of standard input
	int a, b, c; cin >> a >> b >> c;
	// cout prints to the file instead of standard output
	cout << "sum is " << a+b+c << "\n";
}

To test your solution locally without file I/O, just comment out the lines with freopen.

For convenience, we can define a function that will redirect stdin and stdout based on the problem name:

#include <iostream>
#include <cstdio>
using namespace std;

void setIO(string s) { // the argument is the filename without the extension
	freopen((s+".in").c_str(),"r",stdin);
	freopen((s+".out").c_str(),"w",stdout);
}

int main() {
	setIO("problemname");
	int a, b, c; cin >> a >> b >> c;
	cout << "sum is " << a+b+c << "\n";
}

Method 2 - <fstream>

You cannot use C-style I/O (scanf, printf) with this method.

#include <fstream>
using namespace std;

int main() {
	ifstream fin("problemname.in");
	ofstream fout("problemname.out");
	int a, b, c; fin >> a >> b >> c;
	fout << "sum is " << a+b+c << "\n";
}

Java

Java

Again, BufferedReader and PrintWriter should be used. Note how static initialization of r and pw is slightly different.

import java.io.*;
import java.util.StringTokenizer;

public class Main {
	static BufferedReader r;
	static PrintWriter pw;
	static {
		try {
			r = new BufferedReader(new FileReader("problemname.in"));
			pw = new PrintWriter(new FileWriter("problemname.out"));

With Kattio

// Kattio template code above

public class Main {
	static Kattio io;
	static {
		try {
			io = new Kattio("problemname");
		} catch(IOException e) {}
	}
	public static void main(String[] args) {

Python

Python

See here for documentation about file I/O.

The most intuitive way to do file I/O in Python is by redirecting the system input and output to files. After doing this, you can then use the above input() and print() methods as usual.

import sys

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

C++

Method 1 - freopen

Method 2 - <fstream>

Java

Method 1 - Scanner and PrintWriter

Method 2 - BufferedReader and PrintWriter

With Kattio

Python

Method 1

Method 2

Redirecting file input using sys, as mentioned above.

C++

C++

cout << ans; // OK, no newline
cout << ans << endl; // OK, newline
cout << ans << "\n"; // OK, newline
cout << ans << " "; // NOT OK, extra space
cout << ans << "\n\n"; // NOT OK, extra newline

Java

Java

pw.print(ans); // OK, no newline
pw.println(ans); // OK, newline
pw.print(ans+"\n"); // OK, newline
pw.print(ans+" "); // NOT OK, extra space
pw.print(ans+"\n\n") // NOT OK, extra newline

Python

Python

print(ans) # OK, newline
print(ans,end='') # OK, no newline
print(str(ans)+'\n') # NOT OK, extra newline