int ilog(int n)
{
  if (n == 1)
    return 0;
  else
    return 1 + ilog(n/2);
}

int maximum(int A[], int first, int last)
{
  if (first == last)
    return A[first];
  else {
    int middle = (first + last)/2;
    int leftmax = maximum(A, first, middle);
    int rightmax = maximum(A, middle+1, last);
    if (leftmax > rightmax)
      return leftmax;
    else
      return rightmax;
  }
}

The function requires n-1 comparisons.

class StopWatch {
public:
  StopWatch();
  void start();
  void stop();
  void reset();
  void advanceOneSecond();
  unsigned int minutes();
  unsigned int seconds();

private:
  unsigned int secondsElapsed;
  bool running;
};

StopWatch::StopWatch()
{
  secondsElapsed = 0;
  running = false;
}

void StopWatch::start()
{
  running = true;
}

void StopWatch::stop()
{
  running = false;
}

void StopWatch::reset()
{
  running = false;
  secondsElapsed = 0;
}

void StopWatch::advanceOneSecond()
{
  if (running)
    secondsElapsed++;
}

unsigned int StopWatch::minutes()
{
  return secondsElapsed / 60;
}

unsigned int StopWatch::seconds()
{
  return secondsElapsed % 60;
}

void reverseString(string& s)
{
  stack cs;

  for (int i = 0; i < s.length(); i++) {
    cs.push(s[i]);

  for (int i = 0; i < s.length(); i++) {
    s[i] = cs.pop();

}

bool is_balanced(const string& expression)
{
  const char LEFT_PARENTHESIS = '(';
  const char RIGHT_PARENTHESIS = ')';
  const char LEFT_BRACKET = '[';
  const char RIGHT_BRACKET = ']';
  
  stack store;
  string::size_type i;
  char next;
  bool failed = false;

  for (i = 0; !failed && (i < expression.length()); i++) {
    next = expression[i];
    if (next == LEFT_PARENTHESIS || next == LEFT_BRACKET) 
      store.push(next);
    else if (next == RIGHT_PARENTHESIS) {
      if (!store.empty() && store.top() == LEFT_PARENTHESIS)
        store.pop();
      else
        failed = true;
    }
    else if (next == RIGHT_BRACKET) {
      if (!store.empty() && store.top() == LEFT_BRACKET)
        store.pop();
      else
        failed = true;
    }
  }

  return (store.empty() && !failed);
}

int evaluateExpression(const string& s)
{
  stack<int> digitStack;

  for (int i = 0; i < s.length(); i++) {
    if (isdigit(s[i])) {
      digitStack.push(s[i] - '0');
    }
    else if (isoperator(s[i])) {
      assert(!digitStack.empty());
      int rightOperand = digitStack.top();
      digitStack.pop();
      assert(!digitStack.empty());
      int leftOperand = digitStack.top();
      digitStack.pop();
      switch (s[i]) {
        case '+': digitStack.push(leftOperand + rightOperand); break;
        case '-': digitStack.push(leftOperand - rightOperand); break;
        case '*': digitStack.push(leftOperand * rightOperand); break;
        case '/': digitStack.push(leftOperand / rightOperand); break;
      }
    }
  }
  assert(!digitStack.empty());
  return digitStack.top();
}

#include <stdlib.h>

class Die {
public:
  Die();
  void roll();
  unsigned int readTop();
private:
  unsigned int topValue;
};

Die::Die()
{
  topValue = 1;
}

void Die::roll()
{
  topValue = 1 + rand() % 6;
}

unsigned int Die::readTop()
{
  return topValue;
}