Problem:
輪ゴム

n 本の釘を平板上の座標 P1 (x1, y1), P2 (x2, y2), P3 (x3, y3),..., Pn (xn, yn) に１本ずつ打ち、輪ゴムの輪の中に全ての釘が入るように 1 本の輪ゴムで囲みます。このとき、輪ゴムが交差してはいけません。

釘の座標を読み込んで、上記のように釘を輪ゴムで囲んだときに輪ゴムに接していない釘の本数を出力するプログラムを作成してください。輪ゴムは充分に伸び縮みするものとします。同じ座標に 2 本以上の釘を打つことはないものとします。また、輪ゴムがかかった釘と釘の間は直線で結ばれるものとし、その直線上に 3 本以上の釘が並ぶことはないものとします。例えば、図 1 に示すような入力はありえません。図 2 に示すように輪ゴムがかかっていない釘が 1 直線上に並ぶことはありえます。

図１

図２

ただし、それぞれの座標値は -1000.0 以上1000.0 以下の実数です。また、n は 3 以上 100 以下の整数です。

Input

複数のデータセットが与えられます。各データセットは以下のような形式です与えられます。

n
x1, y1
x2, y2
... 　　　　
...
xn, yn

n が 0 の時、入力の最後を示します。データセットの数は 50 を超えません。

Output

データセットごとに、ゴムと接していない釘の本数を出力してください。

例えば、図 3 に示す４つの釘を表す入力があった場合、図 4 のように囲まれるので、輪ゴムに接していない釘の本数は 1 本です。

図３

図４

Sample Input

4
1.0,0.0
0.0,1.0
2.0,1.0
1.0,2.0
9
-509.94,892.63
567.62,639.99
-859.32,-64.84
-445.99,383.69
667.54,430.49
551.12,828.21
-940.2,-877.2
-361.62,-970
-125.42,-178.48
0

Output for the Sample Input

0
3

Hint

以下は２つめのサンプル入力に対する図です。

Solution in JAVA (judge verdict: Wrong Answer)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.util.Arrays;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.ListIterator;

class Main {

    public static void main(String[] args) throws IOException {
        doit(args, System.in, System.out);
    }

    static void doit(String[] args, InputStream in, PrintStream out)
            throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(in));
        String line = null;
        while ((line = reader.readLine()) != null) {
            if (line.isEmpty()) {
                continue;
            }
            int n = Integer.parseInt(line);
            if (n == 0) {
                break;
            }
            double[][] points = new double[n][2];
            for (int i = 0; i < n; i++) {
                String[] values = reader.readLine().split(",");
                points[i][0] = Double.parseDouble(values[0]);
                points[i][1] = Double.parseDouble(values[1]);
            }
            Arrays.sort(points, new Comparator<double[]>() {
                @Override
                public int compare(double[] o1, double[] o2) {
                    return (int) (o1[0] - o2[0]);
                }
            });
            if (opz(points, 0, 1, 2) < 0.0) {
                swap(points, 1, 2);
            }
            LinkedList<Integer> vertexes = new LinkedList<Integer>();
            vertexes.add(0);
            vertexes.add(1);
            vertexes.add(2);
            int result = 0;
            for (int i = 3; i < n; i++) {
                int a = vertexes.getLast();
                boolean outer = false;
                ListIterator<Integer> it = vertexes.listIterator();
                while (it.hasNext()) {
                    int b = it.next();
                    if (opz(points, a, b, i) < 0) {
                        it.previous();
                        it.add(i);
                        outer = true;
                        break;
                    }
                    a = b;
                }
                if (!outer) {
                    result++;
                }
            }
            ListIterator<Integer> it = vertexes.listIterator();
            int a = it.next();
            int b = it.next();
            while (it.hasNext()) {
                int c = it.next();
                if (opz(points, a, b, c) < 0) {
                    it.previous();
                    it.previous();
                    it.remove();
                    result++;
                    b = it.next();
                    continue;
                }
                a = b;
                b = c;
            }
            if (opz(points, vertexes.get(vertexes.size() - 2), vertexes
                    .getLast(), vertexes.getFirst()) < 0) {
                result++;
            }
            out.println(result);
        }
    }

    private static void swap(double[][] points, int a, int b) {
        if (a == b) {
            return;
        }
        double[] tmp = points[a];
        points[a] = points[b];
        points[b] = tmp;
    }

    private static double opz(double[][] points, int a, int b, int c) {
        double x1 = points[b][0] - points[a][0];
        double y1 = points[b][1] - points[a][1];
        double x2 = points[c][0] - points[b][0];
        double y2 = points[c][1] - points[b][1];
        return x1 * y2 - x2 * y1;
    }
}