Problem p00434 (C++)

Buggy submission (status: Runtime Error):
#include <limits.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
// #include <windows.h>
#include <algorithm>
#include <functional>
#include <iostream>
#include <queue>
#include <set>

using namespace std;

typedef unsigned int uint;
typedef long long int llint;
typedef pair<llint, llint> pii;

#define mpq(T) priority_queue<T, vector<T>, greater<T>>
#define FOR(i, a, b) for (int i = (a), i < (b); i++)
#define REP(i, a) for (int i = 0; i < (a); i++)

class BIT {
private:
  int s;
  llint *d;

public:
  BIT(int size) {
    s = size;
    d = (llint *)malloc(sizeof(llint) * s);
    for (int i = 0; i < s; i++) {
      d[i] = 0;
    }
  }

  void add(int b, int x) {
    for (int i = b + 1; i <= s; i += (i & -i)) {
      d[i - 1] += x;
    }
  }

  llint sum(int b) {
    llint all = 0;
    for (int i = b + 1; i > 0; i -= (i & -i)) {
      all += d[i - 1];
    }
    return all;
  }

  ~BIT() { free(d); }
};

class unionfind {
private:
  int s;
  int *o;
  int *r;

public:
  unionfind(int dsize) {
    s = dsize;
    o = (int *)malloc(sizeof(int) * s);
    r = (int *)malloc(sizeof(int) * s);
    for (int i = 0; i < s; i++) {
      o[i] = i;
      r[i] = 0;
    }
  }

  int mfind(int b) {
    if (o[b] != b) {
      o[b] = mfind(o[b]);
    }
    return o[b];
  }

  void munion(int a, int b) {
    int aw = mfind(a);
    int bw = mfind(b);
    if (aw == bw) {
      return;
    }
    if (r[aw] > r[bw]) {
      o[bw] = a;
    } else if (r[aw] < r[bw]) {
      o[aw] = bw;
    } else {
      o[bw] = aw;
      r[aw]++;
    }
    s--;
  }

  int size() { return s; }

  ~unionfind() {
    free(o);
    free(r);
  }
};

template <class T> int lbound(T *d, T key, int s, int e) {
  s--;
  while (e - s > 1) {
    int m = (s + e) / 2;
    if (d[m] < key) {
      s = m;
    } else {
      e = m;
    }
  }
  return e;
}

template <class T> int ubound(T *d, T key, int s, int e) {
  s--;
  while (e - s > 1) {
    int m = (s + e) / 2;
    if (key < d[m]) {
      e = m;
    } else {
      s = m;
    }
  }
  return e;
}

class zpress {
private:
  int ms;
  pii *md;
  int n;
  int s;
  llint *d;
  int *t;

public:
  zpress(int dsize = 1000000) {
    int ms = dsize;
    md = (pii *)malloc(sizeof(pii) * ms);
    d = (llint *)malloc(sizeof(llint) * ms);
    t = (int *)malloc(sizeof(int) * ms);
    n = 0;
  }

  void in(llint x) {
    in2(x, n);
    n++;
  }

  void in2(llint x, int b) { md[b] = make_pair(x, b); }

  void syori() { syori2(n); }

  void syori2(int k) {
    sort(md, md + k);
    llint mae = LLONG_MIN;
    s = 0;
    REP(i, k) {
      if (md[i].first != mae) {
        d[s] = md[i].first;
        s++;
        mae = md[i].first;
      }
      t[md[i].second] = s - 1;
    }
  }

  llint iti(int b) { return t[b]; }

  int size() { return s; }

  int first(llint x) { return lbound(d, x, 0, s); }

  int end(llint x) {
    return ubound(d, x, 0, s);
    ;
  }

  ~zpress() {
    free(md);
    free(d);
    free(t);
  }
};

class xorshift {
private:
  unsigned int a, b, c, d;

public:
  xorshift(unsigned int aw = 123456789, unsigned int bw = 362436069,
           unsigned int cw = 521288629, unsigned int dw = 88675123,
           unsigned int e = 97) {
    a = aw;
    b = bw;
    c = cw;
    d = dw;
    for (unsigned int i = 0; i < e; i++) {
      operator()();
    }
  }

  unsigned int operator()() {
    unsigned int w = a ^ (a << 11);
    a = b;
    b = c;
    c = d;
    d = (d ^ (d >> 19)) ^ (w ^ (w >> 8));
    return d;
  }
};

llint gcd(llint a, llint b) {
  while (1) {
    llint w = a % b;
    if (w == 0) {
      return b;
    }
    a = b;
    b = w;
  }
}

llint sei(llint d, llint p) {
  if (d < 0) {
    d -= ((d + 1) / p - 1) * p;
  } else {
    d %= p;
  }
  return d;
}

llint inv(llint a, llint p) {
  llint r0 = sei(a, p);
  llint r1 = p;
  llint a0 = 1;
  llint b0 = 0;
  llint a1 = 0;
  llint b1 = 1;
  while (1) {
    llint q = r0 / r1;
    llint w = r0 - q * r1;
    if (w == 0) {
      break;
    }
    r0 = r1;
    r1 = w;
    w = a0 - q * a1;
    a0 = a1;
    a1 = w;
  }
  return sei(a1, p);
}

template <llint P> class mod {
private:
  llint d;

public:
  mod(llint a = 0) {
    d = a;
    d = sei(d, P);
  }

  mod operator-() const { return mod(P - d); }

  mod operator+=(const mod &a) {
    d = d + a.d;
    d = sei(d, P);
    return *this;
  }

  mod operator-=(const mod &a) { return operator+=(-a); }

  mod operator*=(const mod &a) {
    d = d * a.d;
    d = sei(d, P);
    return *this;
  }

  mod operator/=(const mod &a) { return a * mod(inv(d, P)); }

  mod operator+(const mod &a) const {
    mod w = *this;
    return (w += a);
  }

  mod operator-(const mod &a) const {
    mod w = *this;
    return (w -= a);
  }

  mod operator*(const mod &a) const {
    mod w = *this;
    return (w *= a);
  }

  mod operator/(const mod &a) const {
    mod w = *this;
    return (w /= a);
  }

  bool operator==(const mod &a) const { return (d == a.d); }

  bool operator!=(const mod &a) const { return (d != a.d); }

  operator llint() const { return d; }
};

/////////////////////////////////////////////////////

FILE *fi;
FILE *fo;

void err(char *a) {
  printf("%s\n", a);
  getchar();
}

llint in() {
  llint w;
  fscanf(fi, "%lld", &w);
  return w;
}

void ins(char *a) { fscanf(fi, "%s", a); }

void out(llint a) { fprintf(fo, "%lld\n", a); }

void outs(char *a) { fprintf(fo, "%s\n", a); }

void func();

int main() {
  fi = stdin;
  fo = stdout;
  func();
  return 0;
}

bool t[30];

void func() {
  fill(t, t + 39, true);
  REP(i, 28) { t[in() - 1] = false; }
  REP(i, 30) {
    if (t[i]) {
      out(i + 1);
    }
  }
}

Fixed submission:
#include <limits.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
// #include <windows.h>
#include <algorithm>
#include <functional>
#include <iostream>
#include <queue>
#include <set>

using namespace std;

typedef unsigned int uint;
typedef long long int llint;
typedef pair<llint, llint> pii;

#define mpq(T) priority_queue<T, vector<T>, greater<T>>
#define FOR(i, a, b) for (int i = (a), i < (b); i++)
#define REP(i, a) for (int i = 0; i < (a); i++)

class BIT {
private:
  int s;
  llint *d;

public:
  BIT(int size) {
    s = size;
    d = (llint *)malloc(sizeof(llint) * s);
    for (int i = 0; i < s; i++) {
      d[i] = 0;
    }
  }

  void add(int b, int x) {
    for (int i = b + 1; i <= s; i += (i & -i)) {
      d[i - 1] += x;
    }
  }

  llint sum(int b) {
    llint all = 0;
    for (int i = b + 1; i > 0; i -= (i & -i)) {
      all += d[i - 1];
    }
    return all;
  }

  ~BIT() { free(d); }
};

class unionfind {
private:
  int s;
  int *o;
  int *r;

public:
  unionfind(int dsize) {
    s = dsize;
    o = (int *)malloc(sizeof(int) * s);
    r = (int *)malloc(sizeof(int) * s);
    for (int i = 0; i < s; i++) {
      o[i] = i;
      r[i] = 0;
    }
  }

  int mfind(int b) {
    if (o[b] != b) {
      o[b] = mfind(o[b]);
    }
    return o[b];
  }

  void munion(int a, int b) {
    int aw = mfind(a);
    int bw = mfind(b);
    if (aw == bw) {
      return;
    }
    if (r[aw] > r[bw]) {
      o[bw] = a;
    } else if (r[aw] < r[bw]) {
      o[aw] = bw;
    } else {
      o[bw] = aw;
      r[aw]++;
    }
    s--;
  }

  int size() { return s; }

  ~unionfind() {
    free(o);
    free(r);
  }
};

template <class T> int lbound(T *d, T key, int s, int e) {
  s--;
  while (e - s > 1) {
    int m = (s + e) / 2;
    if (d[m] < key) {
      s = m;
    } else {
      e = m;
    }
  }
  return e;
}

template <class T> int ubound(T *d, T key, int s, int e) {
  s--;
  while (e - s > 1) {
    int m = (s + e) / 2;
    if (key < d[m]) {
      e = m;
    } else {
      s = m;
    }
  }
  return e;
}

class zpress {
private:
  int ms;
  pii *md;
  int n;
  int s;
  llint *d;
  int *t;

public:
  zpress(int dsize = 1000000) {
    int ms = dsize;
    md = (pii *)malloc(sizeof(pii) * ms);
    d = (llint *)malloc(sizeof(llint) * ms);
    t = (int *)malloc(sizeof(int) * ms);
    n = 0;
  }

  void in(llint x) {
    in2(x, n);
    n++;
  }

  void in2(llint x, int b) { md[b] = make_pair(x, b); }

  void syori() { syori2(n); }

  void syori2(int k) {
    sort(md, md + k);
    llint mae = LLONG_MIN;
    s = 0;
    REP(i, k) {
      if (md[i].first != mae) {
        d[s] = md[i].first;
        s++;
        mae = md[i].first;
      }
      t[md[i].second] = s - 1;
    }
  }

  llint iti(int b) { return t[b]; }

  int size() { return s; }

  int first(llint x) { return lbound(d, x, 0, s); }

  int end(llint x) {
    return ubound(d, x, 0, s);
    ;
  }

  ~zpress() {
    free(md);
    free(d);
    free(t);
  }
};

class xorshift {
private:
  unsigned int a, b, c, d;

public:
  xorshift(unsigned int aw = 123456789, unsigned int bw = 362436069,
           unsigned int cw = 521288629, unsigned int dw = 88675123,
           unsigned int e = 97) {
    a = aw;
    b = bw;
    c = cw;
    d = dw;
    for (unsigned int i = 0; i < e; i++) {
      operator()();
    }
  }

  unsigned int operator()() {
    unsigned int w = a ^ (a << 11);
    a = b;
    b = c;
    c = d;
    d = (d ^ (d >> 19)) ^ (w ^ (w >> 8));
    return d;
  }
};

llint gcd(llint a, llint b) {
  while (1) {
    llint w = a % b;
    if (w == 0) {
      return b;
    }
    a = b;
    b = w;
  }
}

llint sei(llint d, llint p) {
  if (d < 0) {
    d -= ((d + 1) / p - 1) * p;
  } else {
    d %= p;
  }
  return d;
}

llint inv(llint a, llint p) {
  llint r0 = sei(a, p);
  llint r1 = p;
  llint a0 = 1;
  llint b0 = 0;
  llint a1 = 0;
  llint b1 = 1;
  while (1) {
    llint q = r0 / r1;
    llint w = r0 - q * r1;
    if (w == 0) {
      break;
    }
    r0 = r1;
    r1 = w;
    w = a0 - q * a1;
    a0 = a1;
    a1 = w;
  }
  return sei(a1, p);
}

template <llint P> class mod {
private:
  llint d;

public:
  mod(llint a = 0) {
    d = a;
    d = sei(d, P);
  }

  mod operator-() const { return mod(P - d); }

  mod operator+=(const mod &a) {
    d = d + a.d;
    d = sei(d, P);
    return *this;
  }

  mod operator-=(const mod &a) { return operator+=(-a); }

  mod operator*=(const mod &a) {
    d = d * a.d;
    d = sei(d, P);
    return *this;
  }

  mod operator/=(const mod &a) { return a * mod(inv(d, P)); }

  mod operator+(const mod &a) const {
    mod w = *this;
    return (w += a);
  }

  mod operator-(const mod &a) const {
    mod w = *this;
    return (w -= a);
  }

  mod operator*(const mod &a) const {
    mod w = *this;
    return (w *= a);
  }

  mod operator/(const mod &a) const {
    mod w = *this;
    return (w /= a);
  }

  bool operator==(const mod &a) const { return (d == a.d); }

  bool operator!=(const mod &a) const { return (d != a.d); }

  operator llint() const { return d; }
};

/////////////////////////////////////////////////////

FILE *fi;
FILE *fo;

void err(char *a) {
  printf("%s\n", a);
  getchar();
}

llint in() {
  llint w;
  fscanf(fi, "%lld", &w);
  return w;
}

void ins(char *a) { fscanf(fi, "%s", a); }

void out(llint a) { fprintf(fo, "%lld\n", a); }

void outs(char *a) { fprintf(fo, "%s\n", a); }

void func();

int main() {
  fi = stdin;
  fo = stdout;
  func();
  return 0;
}

bool t[30];

void func() {
  fill(t, t + 30, true);
  REP(i, 28) { t[in() - 1] = false; }
  REP(i, 30) {
    if (t[i]) {
      out(i + 1);
    }
  }
}