Go: package main

import (
	"bufio"
	"fmt"
	"io"
	"os"
	"strconv"
)

const (
	initialBufSize = 10000000
	maxBufSize     = 100000000
)

var sc *bufio.Scanner

func initScanner(r io.Reader) *bufio.Scanner {
	buf := make([]byte, initialBufSize)

	sc := bufio.NewScanner(r)
	sc.Buffer(buf, maxBufSize)
	sc.Split(bufio.ScanWords) // bufio.ScanLines
	return sc
}

func main() {
	sc = initScanner(os.Stdin)
	resolve()
}

func nextInt(sc *bufio.Scanner) int {
	sc.Scan()
	a, _ := strconv.Atoi(sc.Text())
	return int(a)
}
func nextString(sc *bufio.Scanner) string {
	sc.Scan()
	return sc.Text()
}

func nextIntSlice(sc *bufio.Scanner, n int) (a []int) {
	a = make([]int, n)
	for i := 0; i < n; i++ {
		a[i] = nextInt(sc)
	}
	return a
}

var dp [][]int

func initDP(n int) {
	dp = make([][]int, n+1)
	for i := 0; i < len(dp); i++ {
		dp[i] = make([]int, n+1)
		for j := 0; j < len(dp[0]); j++ {
			dp[i][j] = -1
		}
	}
}

func resolve() {
	ans := []int{}
	for true {
		n := nextInt(sc)
		if n == 0 {
			break
		}
		as := nextIntSlice(sc, n)
		initDP(n)
		_rec(as, n, 0, n)
		ans = append(ans, dp[0][n])
	}
	for _, v := range ans {
		fmt.Println(v)
	}
	return
}

func _rec(as []int, n, l, r int) int {
	if dp[l][r] > -1 {
		return dp[l][r]
	}
	if r-l == 1 { // prevent to hit daruma
		dp[l][r] = 0
		return dp[l][r]
	}
	if r-l == 2 {
		if abs(as[l]-as[r-1]) <= 1 {
			dp[l][r] = 2
		} else {
			dp[l][r] = 0
		}
		return dp[l][r]
	}
	if abs(as[l]-as[r-1]) <= 1 {
		v := _rec(as, n, l+1, r-1)
		// if we can remove internal blocks
		if (r - 1 - (l + 1)) == v {
			dp[l][r] = v + 2
			return dp[l][r]
		} else {
			dp[l][r] = v
		}
	}
	for i := l + 1; i < r; i++ {
		v := _rec(as, n, l, i) + _rec(as, n, i, r)
		if dp[l][r] < v {
			dp[l][r] = v
		}
	}
	return dp[l][r]
}

func abs(v int) int {
	if v < 0 {
		return -v
	}
	return v
}

C++: #include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <functional>
#include <numeric>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <utility>
#include <sstream>
#include <complex>
#include <fstream>
#include <bitset>
#include <time.h>

using namespace std;

typedef long long ll;
typedef pair<ll, ll> P;
typedef vector<ll> V;
typedef complex<double> Point;

#define PI acos(-1.0)
#define EPS 1e-10
const ll INF = (1LL << 31) - 1;
const ll MOD = 1e9 + 7;

#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define rep(i,N) for(int i=0;i<(N);i++)
#define ALL(s) (s).begin(),(s).end()
#define EQ(a,b) (abs((a)-(b))<EPS)
#define EQV(a,b) ( EQ((a).real(), (b).real()) && EQ((a).imag(), (b).imag()) )
#define fi first
#define se second
#define N_SIZE (1LL << 20)
#define NIL -1
#define MAX_N 100100 * 3

int n;
int x[100];
int dp[300][300];
//int ans[300];

bool C(int lb, int ub) {
	//cout << lb << " " << ub /*<< dp[lb][ub]*/ << endl;
	if (dp[lb][ub] != -1)return dp[lb][ub];
	if (ub - lb <= 0)return dp[ub][lb] = 0;
	else if (ub - lb == 1) {
		if (abs(x[lb] - x[ub]) <= 1)return dp[lb][ub] = 1;
	}
	dp[lb][ub] = 0;
	if (abs(x[lb] - x[ub]) <= 1) {
		dp[lb][ub] |= C(lb + 1, ub - 1);
	}
	FOR(mid, lb, ub) {
		//cout << "!" << lb << " " << mid << endl;
		//cout << "!" << mid << " " << ub << endl;
		bool f = C(lb, mid);
		f &= C(mid + 1, ub);
		dp[lb][ub] |= f;
	}
	return dp[lb][ub];
}

int main() {
	while (cin >> n&&n) {
		rep(i, 300)rep(j, 300) {
			dp[i][j] = -1;
			//ans[i] = 0;
		}
		rep(i, n)cin >> x[i];
		//C(0, n - 1);
		//rep(i, n) {
		//	FOR(j, i, n) {
		//		cout << i << " " << j << "  " << dp[i][j] << endl;
		//	}
		//}
		int ans = 0;
		rep(i, n) {
			//if (i >= 1)ans[i] = ans[i - 1];
			int num = 0;
			int pos = i;
			for (int j = i + 1; j < n; j += 2) {
				if (dp[i][j]) {
					num = max(num, j - i + 1);
					pos = j;
				}
			}
			ans += num;
			i = pos;
		}
		//rep(i, n) {
		//	FOR(j, i, n) {
		//		cout << i << " " << j << "  " << ans[i][j] << endl;
		//	}
		//}
		cout << ans << endl;
	}
}

C++: #include <bits/stdc++.h>
using namespace std;

int n;
vector<int> w(300);
vector<vector<int>> dp(301, vector<int>(301, -1));


int rec(int l,int r){
    //既に計算済み？
    if(dp[l][r] != -1) return dp[l][r];

    //これ以上取り除けない？
    if(abs(l - r) <= 1) return 0;

    int res = 0;
    //パターン1.
    if(abs(w[l] - w[r - 1]) <= 1 && rec(l + 1,r - 1) == r - l - 2)
    {
        //[l , r)がはじき出せるので
        res = r - l;
    }

    //パターン２.区間を分ける
    for(int mid = l + 1;mid <= r - 1;mid++)
    {
        res = max(res , rec(l,mid) + rec(mid,r));
    }
    return dp[l][r] = res;
};

int main()
{
    while (true)
    {
        cin >> n;
        if (n==0) break;
        for (int i=0; i<n; i++) cin >> w[i];
        int answer = rec(0, n);
        cout << answer << endl;
        for (int i=0; i<301; i++)
        {
            for (int j=0; j<301; j++)
            {
                dp[i][j]=-1;
            }
        }
    }
}

C++: #include <bits/stdc++.h>
using namespace std;
#define rep(i,n) repi(i,0,n)
#define repi(i,a,b) for(int i=(int)(a);i<(int)(b);i++)
#define MOD 1000000007
#define ADD(X,Y) ((X) = ((X) + (Y)%MOD) % MOD)
typedef long long i64; typedef vector<int> iv; typedef vector<string> svec; typedef pair<int, int> pi;
int dd[] = { 0, 1, 0, -1, 0 };
#define mp make_pair
#define pb push_back
#define MAX 300
//This is DP.

int W[MAX];
int dp[MAX+10][MAX+10];
int n, M;
int main()
{
  while(true)
    {
      scanf("%d", &n);
      if(n==0)break;

      
      rep(i,n)
	{
	  scanf("%d", &W[i]);
	}
      
      memset(dp, 0, sizeof(dp));
  
      rep(k,n+1)
	{
	  if(k==0)continue;
	  rep(i,n)
	    {
	      if(i + k > n)continue;
	      M=0;
	      if(dp[i+1][i+k-2]==k-2)
		{
		  if(abs(W[i]-W[i+k-1])<=1)
		    {
		      dp[i][i+k-1]=k;
		      continue;
		    }
		}
	      repi(j,i,i+k-1)
		 {
		   M=max(M,dp[i][j]+dp[j+1][i+k-1]);
		 }
	       
	      dp[i][i+k-1]=M;
	    }
	}
      /*rep(i,n)
	{
	  rep(j,n)
	    {
	      printf("%d ",dp[i][j]);
	    }
	  printf("\n");
	  }*/
      printf("%d\n", dp[0][n-1]);
    }
  return 0;
}

C++: #include "bits/stdc++.h"
using namespace std;
typedef long long ll;
#define INF (1<<30)
#define INFLL (1ll<<60)
typedef pair<int, int> P;
typedef pair<ll, P> E;
#define MOD (1000000007ll)
#define l_ength size
#define PI 3.14159265358979

void mul_mod(ll& a, ll b){
	a *= b;
	a %= MOD;
}

void add_mod(ll& a, ll b){
	b += MOD;
	a += b;
	a %= MOD;
}

int w[334],dp[334][334];
bool done[334][334],memo[334][334],fini[334][334];

bool search(int i, int j){
	int k;
	if(done[i][j]){
		return memo[i][j];
	}
	done[i][j] = true;
	if(i == j){
		memo[i][j] = false;
		return memo[i][j];
	}
	if((j-i)==1){
		memo[i][j] = (abs(w[i] - w[j])<=1);
		return memo[i][j];
	}
	if(abs(w[i] - w[j])<=1 && search(i+1,j-1)){
		memo[i][j] = true;
		return memo[i][j];
	}
	memo[i][j] = false;
	for(k=i; k<j; ++k){
		if(search(i,k) && search(k+1,j)){
			memo[i][j] = true;
			break;
		}
	}
	return memo[i][j];
}

int solve(int i, int j){
	int k;
	if(fini[i][j]){
		return dp[i][j];
	}
	fini[i][j] = true;
	if(search(i,j)){
		dp[i][j] = (j-i+1);
		return dp[i][j];
	}else if(i == j){
		dp[i][j] = 0;
		return dp[i][j];
	}
	dp[i][j] = 0;
	for(k=i; k<j; ++k){
		dp[i][j] = max(dp[i][j],solve(i,k)+solve(k+1,j));
	}
	return dp[i][j];
}

int main(void){
	int n,i,j;
	cin >> n;
	while(n){
		fill(done[0],done[334],false);
		fill(fini[0],fini[334],false);
		for(i=0; i<n; ++i){
			cin >> w[i];
		}
		for(i=0; i<n; ++i){
			for(j=i; j<n; ++j){
				search(i,j);
			}
		}
		cout << (solve(0,n-1)) << endl;
		cin >> n;
	}
	return 0;
}