Coding without the SOI-header

Including the STL

With the SOI header, you’re already including the c++ standard template library, so you can use things like std::vector or std::sort. If you don’t have access to the SOI header, you can instead do the following.

// include everything from stl
#include <bits/stdc++.h>
// avoid typing std:: for stl stuff
using namespace std;

signed main(){
    // speed up input / output
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    // code here
}

The first two lines in main() speed up input and output. This can make a big different in runtime if you’re reading $10^{4}$ or more integers.

If you’re on a mac, then you’re probably using clang, so including <bits/stdc++.h> won’t work. In that case, you need to look in the c++ reference to see which headers you need to include. Including the following ones should be sufficient for most use cases.

// include individual headers
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstddef>
#include <cstdint>
#include <cstdlib>
#include <deque>
#include <forward_list>
#include <fstream>
#include <functional>
#include <initializer_list>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <memory>
#include <ostream>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <string>
#include <tuple>
#include <type_traits>
#include <unordered_set>
#include <unordered_map>
#include <utility>
#include <valarray>
#include <vector>

Input-Output

With the SOI header, you read numbers with read_int, strings with read_string, etc. In vanilla c++, you use cin to read input. The syntax is cin >> variable_1 >> variable_2 >> variable_3;. You can read an arbitrary number of variables this way, but you need to declare the variables beforehand.

signed main(){
    int n; // declare int
    cin >> n; // read int x
    string s, t;
    cin >> s >> t; // read two strings
}

The above program is equivalent to

signed main(){
    int n = read_int();
    string s = read_string();
    string t = read_string();
}

To read a vector, use a for loop.

signed main(){
    int n;
    cin >> n;
    vector<int> v(n), w(n);
    // with normal for loop
    for(int i = 0; i < n; ++i){
        cin >> v[i];
    }
    // with range-based for loop
    for(int &e : w){
        cin >> e;
    }
    // with auto and range-based for loop
    for(auto &e : w){
        cin >> e;
    }
}

To print output in vanilla c++, use cout << variable_1 << " " << variable_2 << "\n";. Note that you need to print spaces " " and newlines "\n" yourself.

signed main(){
    int n = 5, m = 7;
    cout << n << " " << m << "\n";
    cout << "Hello SOI!\n";
}

The above program is equivalent to

signed main(){
    int n = 5, m = 7;
    print(n, m);
    print("Hello SOI");
}

For vectors, use a for loop once again.

signed main(){
    int n = 5;
    vector<int> a(n);
    // with normal for loop
    for(int i = 0; i < n; ++i){
        cout << a[i] << " ";
    }
    cout << "\n";
    // with range-based for loop
    for(int const&e : a){
        cout << e << " ";
    }
    cout << "\n";
    // with auto and range-based for loop
    for(auto const&e : a){
        cout << e << " ";
    }
    cout << "\n";

Note that all the above loops print a space after the last element of the vector. This usually does not matter, as the grader ignores trailing whitespace.

Overflows

In vanilla c++, int can only hold $32$-bit integers, so it can only store values up to $2^{31}- 1$ which is slightly above $2 \cdot 10^{9}$. If try to store larger numbers, you cause an overflow, which is undefined behaviour. Usually the number will wrap around to negative numbers. (But you could also get an infinite loop for instance.) The SOI header increases this limit to $2^{63}- 1$ which is around $9 \cdot 10^{18}$. This has a performance cost however.

If you want to use numbers up to $2^{63}- 1$, use long long or int64_t instead of int. The most common case for this is when you want to multiply to ints.

signed main(){
    int a = 1000000000;
    int b = 1000000000;
    int c = 2 * a; // ok, c is 2 * 10^9
    int d = a * b // overflow, d usually is -1486618624
    long long e = a * b; // overflow again
    // to avoid the overflow, convert to long long first
    long long f = a * (long long) b;
    int64_t g = a * (int64_t) b; // same as f
}

You can replace int by $64$-bit integers for your whole program with the following line at the start of your program. But remember that there is a performance cost, so you might get TLE due to this.

// include stl first
#include <bits/stdc++.h>

// replace int by int64_t
#define int int64_t

// use signed to avoid a compiler error
signed main(){
    // code here
}

Debugging

With the soi header, you can debug with the fancy dbg() macro. While there is no perfect replacement for it in vanilla c++, you can use cerr to print debugging information that will be ignored by the grader. Be warned though: Printing into cerr slows down your program, so you might get TLE if you print too much. The syntax is similar to the one of cout.

signed main(){
    cerr << "Start of main function\n";
    int n = 5;
    for(int i=0;i<n;++i){
        cerr << "Iteration " << i << " of " << n << "\n";
    }
    if(n == -1){
        cerr << "This code should not be reached\n";
    }
    // use a loop to print vectors
    vector<int> v(5);
    cerr << "v: ";
    for(auto const&e:v){
        cerr << e << " ";
    }
    cerr << "\n";
}

Output written to cerr is flushed immediately, so you’ll see your output even if your program crashes right afterwards.