#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef long double ld;
typedef tuple<int, int> duo;
const int dx[] = {0, 0, 1, -1, 1, 1, -1, -1};
const int dy[] = {1, -1, 0, 0, 1, -1, 1, -1};
const int Mod = 1000000000 + 0;
//{{{ templates
#define TT_ template<typename T>inline
#define TTF_ template<typename T,typename F>inline
TT_ T sq(T x){return x*x;}
TT_ T In(){T x;cin>>x;return x;}
TT_ void Out(T&x){cout<<x;}
TT_ void sort(T&v){sort(begin(v),end(v));}
TT_ void revs(T&v){reverse(begin(v),end(v));}
TT_ void uniq(T&v){sort(v);v.erase(unique(begin(v),end(v)),end(v));}
TT_ int ubnd(T&v,typename T::value_type x){return upper_bound(begin(v),end(v),x)-begin(v);}
TT_ int lbnd(T&v,typename T::value_type x){return lower_bound(begin(v),end(v),x)-begin(v);}
TTF_ void inpt(T&v,int n,F f){for(v.reserve(n);n--;v.emplace_back(f()));}
TTF_ void show(T&v,F f,string d=" ",string e="\n"){int i=0;for(auto&x:v)i++&&(cout<<d),f(x);cout<<e;}
TT_ typename T::iterator minel(T&v){return min_element(begin(v),end(v));}
TT_ typename T::iterator maxel(T&v){return max_element(begin(v),end(v));}

inline void fast_io(){ios_base::sync_with_stdio(0);cin.tie(0);}
inline int in(){int x;scanf("%d",&x);return x;}
inline ll pow_mod(ll a,ll k,ll m){ll r=1;for(;k>0;a=a*a%m,k>>=1)if(k&1)r=r*a%m;return r;}
inline ll mod_inv(ll a,ll p){return pow_mod(a,p-2,p);}
//}}} priority_queue queue deque front stringstream max_element min_element insert count make_tuple

template<typename T>
struct Cont {
  T v;
  int count;
  Cont(T v, int count) : v(v), count(count) {}
};

template<typename T>
vector<Cont<T>> RLE(const vector<T>& x){
  vector<Cont<T>> rle;
  for (auto s = begin(x); s != end(x);){
    auto sc = s;
    while (s != end(x) && *sc == *s) ++s;
    rle.emplace_back(*sc, s - sc);
  }
  return rle;
}

template<typename T>
int solve(const vector<T>& rle, int s, int k){
  stack<T> S;
  queue<T> Q;
  for (int i = 0; i <= s; i++) S.push(rle[i]);
  switch (k){
    case 0:
      Q.push(T(rle[s].v, rle[s + 1].count));
      Q.push(rle[s + 2]);
      break;
    case 1:
      Q.push(T(rle[s + 2].v, rle[s + 1].count + rle[s + 2].count));
      break;
    case 2:
      Q.push(T(rle[s].v, 1));
      Q.push(T(rle[s + 1].v, rle[s + 1].count - 1));
      Q.push(rle[s + 2]);
      break;
    case 3:
      S.top().count--;
      S.push(T(rle[s + 1].v, 1));
      Q.push(rle[s + 1]);
      Q.push(rle[s + 2]);
      break;
  }
  const int N = rle.size();
  for (int i = s + 3; i < N; i++) Q.push(rle[i]);
  int ans = 0;
  while (!S.empty() && !Q.empty()){
    Cont<int> st = S.top();
    Cont<int> qf = Q.front();
    if (st.v != qf.v) break;
    if (st.count + qf.count < 4) break;
    ans += st.count + qf.count;
    S.pop();
    Q.pop();
  }
  return ans;
}

int main()
{
  // 1-3 3-1 -> 0
  // n-1-m   -> 1
  // 3-2 3-3 -> 2
  // 2-3     -> 3
  while (int N = in()){
    vector<int> v;
    inpt(v, N, in);
    auto rle = RLE(v);
    rle.emplace_back(-0xDEAD, -0xBEEF);
    rle.emplace_back(-0xDEAD, -0xBEEF);
    int maxi = 0;
    for (int i = 0; i < rle.size() - 2; i++){
      if (rle[i].count + rle[i + 1].count == 4 && rle[i].count != 2) maxi = max(maxi, solve(rle, i, 0));
      if (rle[i + 1].count == 1 && rle[i].v == rle[i + 2].v) maxi = max(maxi, solve(rle, i, 1));
      if (rle[i].count == 3 && rle[i + 1].count > 1) maxi = max(maxi, solve(rle, i, 2));
      if (rle[i].count == 2 && rle[i + 1].count == 3) maxi = max(maxi, solve(rle, i, 3));
    }
    printf("%d\n", N - maxi);
  }
  return 0;
}

Measured memory_bytes: 1336