// PRE:  x is roundable to a number in
//        the value range of type int
// POST: return value is the integer 
//        nearest to x, or the one 
//        further away from 0 if x lies
//        right in between two integers.
int round (double x) {
    if(x > 0){
      return x + .5;
    }
    else{
      return x - .5;
    }
}

#include <iostream>
#include <vector>

int main(){

    std::vector<int> test(5);
    test[1] = test.size();
    test.pop_back();
    test[2] = test.size();
    test.push_back(2);
    test[3] = test.empty();

    for(unsigned int i = 0; i < test.size(); i++){
        std::cout << test.at(i) << " ";
    }
    std::cout << std::endl;
	
    return 0;
}

std::vector<int> test(5);

// POST: Converts the letter to upper case.
void char_to_upper(char& letter) {
  if ('a' <= letter && letter <= 'z') {
    letter -= 'a' - 'A';  // 'a' > 'A'
  }
}

// POST: Converts all letters to upper-case.
void to_upper(std::vector<char>& letters) {
  for (unsigned int i = 0; i < letters.size(); ++i) {
    char_to_upper(letters[i]);
  }
}

int main () {
  // Say to std::cin not to ignore whitespace.
  std::cin >> std::noskipws;
  
  std::vector<char> letters;
  char ch;
  
  // Step 1: Read input.
  do {
    std::cin >> ch;
    letters.push_back(ch);
  } while (ch != '\n');
  
  // Step 2: Convert to upper-case.
  to_upper(letters);
  
  // Step 3: Output.
  for (unsigned int i = 0; i < letters.size(); ++i) {
    std::cout << letters[i];
  }
  return 0;
}

#include <iostream>

void foo(int a, int b){
    int temp = a;
    a = b;
    b = temp;
}

int main(){
    int a = 5;
    int b = 7;
    foo(a, b);
    std::cout << a << " " << b;
    return 0;
}

char c1 = 'i';
std::cout << c1;

char c2 = 110;
std::cout << c2;

char c3 = c1 - 3;
std::cout << c3;

char c4 = c1 - 'a' + 'A';
std::cout << c4;

// POST: the targets of i and j got their values swapped
void swap (int& i, int& j) {
    const int tmp = i;
    i = j;
    j = tmp;
}

// PRE: length is the real length of the vector sequence.
// POST: Reverses the sequence stored in the vector sequence.
void reverse(std::vector<int>& sequence, unsigned int length) {
  if (length > 1) {
    int front = 0;
    int back = length-1;
    while (front < back) {
      swap(sequence.at(front), sequence.at(back));
      ++front;
      --back;
    }
  }
}

int main () {
  unsigned int length;
  std::vector<int> sequence (10);
  
  // Step 1: Read input.
  std::cin >> length;
  if (length > 10) {
    std::cout << "Bad input" << std::endl;
    return 0;
  }
  for (unsigned int i = 0; i < length; ++i) {
    std::cin >> sequence.at(i);
  }
  
  // Step 2: Reverse sequence;
  reverse(sequence, length);
  
  // Step 3: Output
  for (unsigned int i = 0; i < length; ++i) {
    std::cout << sequence.at(i) << " ";
  }
  std::cout << std::endl;
  
  return 0;
}

#include <iostream>

int foo (int a, int b) {
    a += b;
    return a;
}

int main() {
    int a = 0;
    int b = 1;
    for (int i=0; i<5; ++i) {
        b = foo (a, b);
        std::cout << b << " ";
    }
    return 0;
}

#include <iostream>

int foo (int& a, int b) {
    a += b;
    return a;
}

int main() {
    int a = 0;
    int b = 1;
    for (int i=0; i<5; ++i) {
        b = foo (a, b);
        std::cout << b << " ";
    }
    return 0;
}

#include <iostream>

int foo (int a, int& b) {
    a += b;
    return a;
}

int main() {
    int a = 0;
    int b = 1;
    for (int i=0; i<5; ++i) {
        b = foo (a, b);
        std::cout << b << " ";
    }
    return 0;
}

#include <iostream>

int foo(const int x){
	x = 5;
	return x;
}

int main(){

    std::cout << foo(3) << std::endl;
    
    return 0;
}

#include <iostream>

int& foo(int x){
	x = 5;
	return x;
}

int main(){

    std::cout << foo(3) << std::endl;
    
    return 0;
}

T foo (S i)
{
    return ++i;
}

1. T = int,        S = int
2. T = int,        S = const int
3. T = int,        S = int&
4. T = int&,       S = int
5. T = const int&, S = int&