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 <algorithm>
#include <iostream>
#include <unordered_map>
#include <vector>

struct Context {
	std::vector<int>& blocks;
	std::unordered_map<uint64_t, int> cache;
};

struct State {
	uint64_t data;

	State() : data(0) {}
	State(uint64_t data) : data(data) {}

	State mark(int index) {
		return data | (((uint64_t)1) << index);
	}

	bool is_marked(int index) {
		return (data & (((uint64_t)1) << index)) != 0;
	}
};

int search(Context& ctx, State state, int count) {
	if (ctx.blocks.size() == 0) return count;
	auto& cache_iter = ctx.cache.find(state.data);
	if (cache_iter != ctx.cache.end()) return (*cache_iter).second;

	int max = count;

	for (int i = 0; i < ctx.blocks.size() - 1; i++) {
		if (state.is_marked(i)) continue;

		// ?¬????????????????????????¢???
		for (int j = i + 1; j < ctx.blocks.size(); j++) {
			if (state.is_marked(j)) continue;
			if (std::abs(ctx.blocks[i] - ctx.blocks[j]) > 1) break;

			int result = search(ctx, state.mark(i).mark(j), count + 2);
			if (result > max) max = result;
		}
	}

	ctx.cache[state.data] = max;
	return max;
}

int main()
{
	std::vector<int> blocks;
	blocks.reserve(300);

	while (true) {
		int num_blocks;
		std::cin >> num_blocks;

		if (num_blocks == 0) return 0;

		blocks.clear();
		for (int i = 0; i < num_blocks; i++)
		{
			int w;
			std::cin >> w;
			blocks.push_back(w);
		}

		Context ctx{ blocks, {} };
		std::cout << search(ctx, {}, 0) << std::endl;
	}
}

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

#define rep(i, a, b) for (int i = a; i < (b); i++)
#define int long long
#define DBG 1
using VI = vector<int>;
using VVI = vector<VI>;
void solve(int N) {
  VI w(N);
  rep(i, 0, N) { cin >> w[i]; }

  VVI dp(N + 1, VI(N + 1, 0));

  rep(d, 2, N + 1) {
    rep(i, 0, N) {
      int k = i + d;
      if (k > N)
        break;
      rep(p, i, k) { dp[i][k] = max(dp[i][k], dp[i][p] + dp[p][k]); }
      if (abs(w[i] - w[k - 1]) <= 1 and dp[i + 1][k - 1] == k - i - 2) {
        dp[i][k] = max(dp[i][k], dp[i + 1][k - 1] + 2);
      }
    }
  }
  cout << dp[0][N] << endl;
}

signed main(void) {
  while (1) {
    int n;
    cin >> n;
    if (n == 0)
      break;
    solve(n);
  }
}

C++: #include<iostream>
#include<vector>
#include<tuple>
#include<algorithm>
#include<cmath>
using namespace std;
vector<tuple<int, int, int>>vec; int n, a[1000], dp[1000][1000];
int main() {
	while (true) {
		cin >> n; if (n == 0)break; vec.clear(); for (int i = 0; i < 1000; i++) { for (int j = 0; j < 1000; j++)dp[i][j] = 0; } for (int i = 0; i < n; i++)cin >> a[i];
		for (int i = 0; i < n; i++) { for (int j = i + 1; j < n; j++) { vec.push_back(make_tuple(j - i, i, j)); } }
		sort(vec.begin(), vec.end());
		for (int i = 0; i < n - 1; i++) { if (abs(a[i] - a[i + 1]) <= 1) { dp[i][i + 1] = 1; } }
		for (int i = 0; i < vec.size(); i++) {
			int a1 = get<1>(vec[i]), a2 = get<2>(vec[i]);
			if (dp[a1][a2] == 0)continue;
			if (a2 < n - 2 && abs(a[a2 + 1] - a[a2 + 2]) <= 1)dp[a1][a2 + 2] = 1;
			if (a1 > 0 && a2 < n - 1 && abs(a[a1 - 1] - a[a2 + 1]) <= 1)dp[a1 - 1][a2 + 1] = 1;
		}
		for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { if (dp[i][j] == 1)dp[i][j] = j - i + 1; } }
		for (int i = 0; i < n; i++) { for (int j = i; j < n; j++) { for (int k = j; k < n; k++) { dp[i][k] = max(dp[i][k], dp[i][j - 1] + dp[j][k]); } } }
		cout << dp[0][n - 1] << endl;
	}
	return 0;
}

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];
bool 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] = 0;
		}
		rep(i, n)cin >> x[i];
		for (int i = 1; i < n; i += 2) {
			rep(j, n) {
				int lb = j, ub = j + i;
				if (abs(x[lb] - x[ub]) <= 1) {
					if (i == 1)dp[lb][ub] = 1;
					else dp[lb][ub] |= dp[lb + 1][ub - 1];
				}
				FOR(mid, lb + 1, ub - 1) {
					dp[lb][ub] |= dp[lb][mid] && dp[mid + 1][ub];
				}
			}
		}
		//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;
	}
}