Problem p02641 (C++)

Buggy submission (status: Time Limit Exceeded):
// AUTHOR wiley_codechef
// TASK : Atcoder
//--------------------------------HEADERS-------------------------------------------------------------//
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

//-------------------------------------------------------Typedefs----------------------------------------------//

typedef long long int ll;

typedef pair<int, int> pii;

typedef pair<ll, ll> pll;

typedef pair<string, string> pss;

typedef vector<int> vi;

typedef vector<vi> vvi;

typedef vector<pii> vii;

typedef vector<ll> vl;

typedef vector<vl> vvl;

double EPS = 1e-9;

int INF = 1000000005;

long long INFF = 1000000000000000005LL;

double PI = acos(-1);

int dirx[8] = {-1, 0, 0, 1, -1, -1, 1, 1};

int diry[8] = {0, 1, -1, 0, -1, 1, -1, 1};

//---------------------------------------------------------Hash
//defines--------------------------------------------------//

#define PII 3.14159265358979323846
#ifdef TESTING
#define DEBUG fprintf(stderr, "====TESTING====\n")
#define VALUE(x) cerr << "The value of " << #x << " is " << x << endl
#define debug(...) fprintf(stderr, __VA_ARGS__)
#else
#define DEBUG
#define VALUE(x)
#define debug(...)
#endif

#define FOR(a, b, c) for (int(a) = (b); (a) < (c); ++(a))
#define FORN(a, b, c) for (int(a) = (b); (a) <= (c); ++(a))
#define FORD(a, b, c) for (int(a) = (b); (a) >= (c); --(a))
#define FORSQ(a, b, c) for (int(a) = (b); (a) * (a) <= (c); ++(a))
#define FORC(a, b, c) for (char(a) = (b); (a) <= (c); ++(a))
#define FOREACH(a, b) for (auto &(a) : (b))
#define REP(i, n) FOR(i, 0, n)
#define REPN(i, n) FORN(i, 1, n)
#define MAX(a, b) a = max(a, b)
#define MIN(a, b) a = min(a, b)
#define SQR(x) ((ll)(x) * (x))
#define RESET(a, b) memset(a, b, sizeof(a))
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define ALL(v) v.begin(), v.end()
#define ALLA(arr, sz) arr, arr + sz
#define SIZE(v) (int)v.size()
#define SORT(v) sort(ALL(v))
#define REVERSE(v) reverse(ALL(v))
#define SORTA(arr, sz) sort(ALLA(arr, sz))
#define REVERSEA(arr, sz) reverse(ALLA(arr, sz))
#define PERMUTE next_permutation
#define T(a)                                                                   \
  ll a;                                                                        \
  cin >> a;
#define TT(t)                                                                  \
  T(t);                                                                        \
  while (t--)
#define IOS                                                                    \
  ios_base::sync_with_stdio(0);                                                \
  cin.tie(0);                                                                  \
  cout.tie(0);
#define f(i, x, y) for (int i = x; i < y; i++)
#define array(a) ll a[n];
#define line "\n";
//-------------------------------------------------TEMPLATES----------------------------------------------------------//

template <class T> T max(T a, T b, T c) { return max(a, max(b, c)); }
template <class T> T min(T a, T b, T c) { return min(a, min(b, c)); }
void SieveOfEratosthenes(ll n) // O(nloglogn)
{
  ll prime[n];
  memset(prime, true, sizeof(prime));

  for (ll p = 2; p * p <= n; p++) {
    if (prime[p] == true) {
      for (ll i = p * p; i <= n; i += p)
        prime[i] = false;
    }
  }
}
bool isPrime(ll n) // O(sqrt(n))
{
  if (n < 2)
    return false;
  for (ll i = 2; i * i <= n; i++)
    if (n % i == 0)
      return false;
  return true;
}
std::vector<ll> generatePrimeFactors(ll n) {
  std::vector<ll> prime;
  for (ll i = 2; i * i <= n; i++) {
    if (n % i == 0) {
      prime.pb(i);
      while (n % i == 0)
        n = n / i;
    }
  }
  if (n != 1)
    prime.pb(n);
  return prime;
}
std::vector<ll> generateFactors(ll n) {
  std::vector<ll> fact;
  for (ll i = 2; i * i <= n; i++) {
    if (n % i == 0) {
      fact.pb(i);
      if (n / i != i)
        fact.pb(n / i);
      // 24 - 1,2,3,4,6,8,12
    }
  }
  fact.pb(1);
  if (n != 1)
    fact.pb(n);
  sort(fact.begin(), fact.end());
  return fact;
}

ll extendedGCD(ll a, ll b, ll &x, ll &y) {
  // produces correct results for negative integers as well
  if (a == 0) {
    x = 0;
    y = 1;
    return b;
  }
  ll x1, y1, d;
  d = extendedGCD(b % a, a, x1, y1);
  x = y1 - (b / a) * x1;
  y = x1;
  return d;
}
ll gcd(ll a, ll b) // O(log min(a,b))
{
  /*
  recursive implementation below
  if(!b) return a;
  return gcd(b,a%b);
  */

  // non-recursive implementation below
  while (b) {
    a %= b;
    swap(a, b);
  }
  return a;
}

ll multiply(ll a, ll b, ll m);
ll singlemod(ll a, ll m);
ll modpow(ll x, ll n, ll m) // O(logn)// used for calculating (x^n)%m
{
  if (n == 0)
    return 1;
  ll res = 1;
  while (n) {
    if (n % 2)
      res = multiply(res, x, m);
    x = multiply(x, x, m);
    n = n >> 1;
  }
  return singlemod(res, m);
}
ll fastpow(ll x, ll n) {
  if (n == 0)
    return 1;
  ll res = 1;
  while (n) {
    if (n % 2)
      res = res * x;
    x = x * x;
    n = n >> 1;
  }
  return res;
}
ll modinverse(ll x, ll m) // O(logn)
{
  return modpow(x, m - 2, m);
}
ll add(ll a, ll b, ll m) { return (((a % m) + (b % m)) % m); }
ll substract(ll a, ll b, ll m) {
  //    if (a < b)
  //        swap(a, b);
  return (((a % m) - (b % m) + m) % m);
}
ll multiply(ll a, ll b, ll m) { return (((a % m) * (b % m)) % m); }
ll divide(ll a, ll b, ll m) {
  ll temp = modinverse(b, m);
  return multiply(a, temp, m);
}
ll singlemod(ll a, ll m) { return (a % m); }
ll eulerstotientfunction(ll n) // O(sqrt(n))
{
  ll ans = n;
  for (ll i = 2; i * i <= n; i++) {
    if (n % i == 0) {
      while (n % i == 0)
        n = n / i;
      ans -= ans / i;
    }
  }
  if (n > 1)
    ans -= ans / n;
  return ans;
}

ll ncr(ll n, ll k, ll m) {
  if (k > n)
    return 0;
  if (m == 0) {
    ll res = 1;
    k = min(k, n - k);
    for (ll i = 1; i <= k; i++) {
      res *= (n - i + 1);
      res /= i;
    }
    return res;
  } else {
    ll res = 1;
    k = min(k, n - k);
    for (ll i = 1; i <= k; i++) {
      res = multiply(res, n - i + 1, m);
      res = divide(res, i, m);
    }
    return singlemod(res, m);
  }
}
ll kadaneAlgo(const std::vector<ll> &arr) {
  ll size = arr.size();
  ll currmax = arr[0], maxsofar = arr[0];
  for (ll i = 1; i < size; i++) {
    // debug2(currmax,maxsofar);
    currmax = max(arr[i], currmax + arr[i]);
    maxsofar = max(maxsofar, currmax);
  }
  return maxsofar;
}
ll getDigitSum(ll n) {
  ll co = 0;
  while (n > 0) {
    co += n % 10;
    n = n / 10;
  }
  return co;
}

template <class T> void printVector(const std::vector<T> arr) {
  for (auto i : arr)
    cout << i << " ";
  cout << endl;
}
template <class T> void printArray(T arr[], ll n) {
  for (ll i = 0; i < n; i++)
    cout << arr[i] << " ";
  cout << endl;
}
// const int p1 = 13331,m1 = 1e9+9,p2 = 7919, m2 = 1e9+9;
// const int p1 = 97266353,m1 = 972663749,p2 = 97336357, m2 = 1000000007;
// const int p1 = 31 ,m1 = 1e9+7;

// grid cells
// D U R L
// ll dx[] = {1, -1, 0, 0};
// ll dy[] = {0, 0, 1, -1};

bool is_perfect(int x) {
  long double y = sqrt(x);
  return ((y - floor(y)) == 0);
}

bool check(int p, int n) {
  int temp = p, count = 0, f = 5;
  while (f <= temp) {
    count += temp / f;
    f = f * 5;
  }
  return (count >= n);
}

int wiley() {

  T(x)
  T(n)
  array(a) REP(i, n) cin >> a[i];
  sort(a, a + n);
  ll ans = 0;
  REPN(i, 100000) {
    if (!binary_search(a, a + n, x - i)) {
      ans = x - i;
      break;
    } else if (!binary_search(a, a + n, x + i)) {
      ans = x + i;
      break;
    }
  }
  if (n == 0)
    cout << x;
  else
    cout << ans;
}

int main() {
  // Fast I/O --- Vroom Vroom
  //	IOS
  //	TT(t){

  //	read();

  wiley();
  // By Order of Peaky Blinders.
  //	}
  return 0;
}


Fixed submission:
// AUTHOR wiley_codechef
// TASK : Atcoder
//--------------------------------HEADERS-------------------------------------------------------------//
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

//-------------------------------------------------------Typedefs----------------------------------------------//

typedef long long int ll;

typedef pair<int, int> pii;

typedef pair<ll, ll> pll;

typedef pair<string, string> pss;

typedef vector<int> vi;

typedef vector<vi> vvi;

typedef vector<pii> vii;

typedef vector<ll> vl;

typedef vector<vl> vvl;

double EPS = 1e-9;

int INF = 1000000005;

long long INFF = 1000000000000000005LL;

double PI = acos(-1);

int dirx[8] = {-1, 0, 0, 1, -1, -1, 1, 1};

int diry[8] = {0, 1, -1, 0, -1, 1, -1, 1};

//---------------------------------------------------------Hash
//defines--------------------------------------------------//

#define PII 3.14159265358979323846
#ifdef TESTING
#define DEBUG fprintf(stderr, "====TESTING====\n")
#define VALUE(x) cerr << "The value of " << #x << " is " << x << endl
#define debug(...) fprintf(stderr, __VA_ARGS__)
#else
#define DEBUG
#define VALUE(x)
#define debug(...)
#endif

#define FOR(a, b, c) for (int(a) = (b); (a) < (c); ++(a))
#define FORN(a, b, c) for (int(a) = (b); (a) <= (c); ++(a))
#define FORD(a, b, c) for (int(a) = (b); (a) >= (c); --(a))
#define FORSQ(a, b, c) for (int(a) = (b); (a) * (a) <= (c); ++(a))
#define FORC(a, b, c) for (char(a) = (b); (a) <= (c); ++(a))
#define FOREACH(a, b) for (auto &(a) : (b))
#define REP(i, n) FOR(i, 0, n)
#define REPN(i, n) FORN(i, 1, n)
#define MAX(a, b) a = max(a, b)
#define MIN(a, b) a = min(a, b)
#define SQR(x) ((ll)(x) * (x))
#define RESET(a, b) memset(a, b, sizeof(a))
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define ALL(v) v.begin(), v.end()
#define ALLA(arr, sz) arr, arr + sz
#define SIZE(v) (int)v.size()
#define SORT(v) sort(ALL(v))
#define REVERSE(v) reverse(ALL(v))
#define SORTA(arr, sz) sort(ALLA(arr, sz))
#define REVERSEA(arr, sz) reverse(ALLA(arr, sz))
#define PERMUTE next_permutation
#define T(a)                                                                   \
  ll a;                                                                        \
  cin >> a;
#define TT(t)                                                                  \
  T(t);                                                                        \
  while (t--)
#define IOS                                                                    \
  ios_base::sync_with_stdio(0);                                                \
  cin.tie(0);                                                                  \
  cout.tie(0);
#define f(i, x, y) for (int i = x; i < y; i++)
#define array(a) ll a[n];
#define line "\n";
//-------------------------------------------------TEMPLATES----------------------------------------------------------//

template <class T> T max(T a, T b, T c) { return max(a, max(b, c)); }
template <class T> T min(T a, T b, T c) { return min(a, min(b, c)); }
void SieveOfEratosthenes(ll n) // O(nloglogn)
{
  ll prime[n];
  memset(prime, true, sizeof(prime));

  for (ll p = 2; p * p <= n; p++) {
    if (prime[p] == true) {
      for (ll i = p * p; i <= n; i += p)
        prime[i] = false;
    }
  }
}
bool isPrime(ll n) // O(sqrt(n))
{
  if (n < 2)
    return false;
  for (ll i = 2; i * i <= n; i++)
    if (n % i == 0)
      return false;
  return true;
}
std::vector<ll> generatePrimeFactors(ll n) {
  std::vector<ll> prime;
  for (ll i = 2; i * i <= n; i++) {
    if (n % i == 0) {
      prime.pb(i);
      while (n % i == 0)
        n = n / i;
    }
  }
  if (n != 1)
    prime.pb(n);
  return prime;
}
std::vector<ll> generateFactors(ll n) {
  std::vector<ll> fact;
  for (ll i = 2; i * i <= n; i++) {
    if (n % i == 0) {
      fact.pb(i);
      if (n / i != i)
        fact.pb(n / i);
      // 24 - 1,2,3,4,6,8,12
    }
  }
  fact.pb(1);
  if (n != 1)
    fact.pb(n);
  sort(fact.begin(), fact.end());
  return fact;
}

ll extendedGCD(ll a, ll b, ll &x, ll &y) {
  // produces correct results for negative integers as well
  if (a == 0) {
    x = 0;
    y = 1;
    return b;
  }
  ll x1, y1, d;
  d = extendedGCD(b % a, a, x1, y1);
  x = y1 - (b / a) * x1;
  y = x1;
  return d;
}
ll gcd(ll a, ll b) // O(log min(a,b))
{
  /*
  recursive implementation below
  if(!b) return a;
  return gcd(b,a%b);
  */

  // non-recursive implementation below
  while (b) {
    a %= b;
    swap(a, b);
  }
  return a;
}

ll multiply(ll a, ll b, ll m);
ll singlemod(ll a, ll m);
ll modpow(ll x, ll n, ll m) // O(logn)// used for calculating (x^n)%m
{
  if (n == 0)
    return 1;
  ll res = 1;
  while (n) {
    if (n % 2)
      res = multiply(res, x, m);
    x = multiply(x, x, m);
    n = n >> 1;
  }
  return singlemod(res, m);
}
ll fastpow(ll x, ll n) {
  if (n == 0)
    return 1;
  ll res = 1;
  while (n) {
    if (n % 2)
      res = res * x;
    x = x * x;
    n = n >> 1;
  }
  return res;
}
ll modinverse(ll x, ll m) // O(logn)
{
  return modpow(x, m - 2, m);
}
ll add(ll a, ll b, ll m) { return (((a % m) + (b % m)) % m); }
ll substract(ll a, ll b, ll m) {
  //    if (a < b)
  //        swap(a, b);
  return (((a % m) - (b % m) + m) % m);
}
ll multiply(ll a, ll b, ll m) { return (((a % m) * (b % m)) % m); }
ll divide(ll a, ll b, ll m) {
  ll temp = modinverse(b, m);
  return multiply(a, temp, m);
}
ll singlemod(ll a, ll m) { return (a % m); }
ll eulerstotientfunction(ll n) // O(sqrt(n))
{
  ll ans = n;
  for (ll i = 2; i * i <= n; i++) {
    if (n % i == 0) {
      while (n % i == 0)
        n = n / i;
      ans -= ans / i;
    }
  }
  if (n > 1)
    ans -= ans / n;
  return ans;
}

ll ncr(ll n, ll k, ll m) {
  if (k > n)
    return 0;
  if (m == 0) {
    ll res = 1;
    k = min(k, n - k);
    for (ll i = 1; i <= k; i++) {
      res *= (n - i + 1);
      res /= i;
    }
    return res;
  } else {
    ll res = 1;
    k = min(k, n - k);
    for (ll i = 1; i <= k; i++) {
      res = multiply(res, n - i + 1, m);
      res = divide(res, i, m);
    }
    return singlemod(res, m);
  }
}
ll kadaneAlgo(const std::vector<ll> &arr) {
  ll size = arr.size();
  ll currmax = arr[0], maxsofar = arr[0];
  for (ll i = 1; i < size; i++) {
    // debug2(currmax,maxsofar);
    currmax = max(arr[i], currmax + arr[i]);
    maxsofar = max(maxsofar, currmax);
  }
  return maxsofar;
}
ll getDigitSum(ll n) {
  ll co = 0;
  while (n > 0) {
    co += n % 10;
    n = n / 10;
  }
  return co;
}

template <class T> void printVector(const std::vector<T> arr) {
  for (auto i : arr)
    cout << i << " ";
  cout << endl;
}
template <class T> void printArray(T arr[], ll n) {
  for (ll i = 0; i < n; i++)
    cout << arr[i] << " ";
  cout << endl;
}
// const int p1 = 13331,m1 = 1e9+9,p2 = 7919, m2 = 1e9+9;
// const int p1 = 97266353,m1 = 972663749,p2 = 97336357, m2 = 1000000007;
// const int p1 = 31 ,m1 = 1e9+7;

// grid cells
// D U R L
// ll dx[] = {1, -1, 0, 0};
// ll dy[] = {0, 0, 1, -1};

bool is_perfect(int x) {
  long double y = sqrt(x);
  return ((y - floor(y)) == 0);
}

bool check(int p, int n) {
  int temp = p, count = 0, f = 5;
  while (f <= temp) {
    count += temp / f;
    f = f * 5;
  }
  return (count >= n);
}

int wiley() {

  int x, n, a;
  if (n == 0) {
    cout << x << endl;
    return 0;
  }
  cin >> x >> n;
  set<int> s;
  for (int i = 0; i < n; ++i) {
    cin >> a;
    s.insert(a);
  }
  int ans1 = x, ans2 = x;
  while (true) {
    if (!s.count(ans1)) {
      cout << ans1 << endl;
      return 0;
    }
    if (!s.count(ans2)) {
      cout << ans2 << endl;
      return 0;
    }
    --ans1;
    ++ans2;
  }
}

int main() {
  // Fast I/O --- Vroom Vroom
  //	IOS
  //	TT(t){

  //	read();

  wiley();
  // By Order of Peaky Blinders.
  //	}
  return 0;
}