Problem:
Score : 300 points

Problem Statement

You are given an array A of length N.
Your task is to divide it into several contiguous subarrays.
Here, all subarrays obtained must be sorted in either non-decreasing or non-increasing order.
At least how many subarrays do you need to divide A into?

Constraints

1 \leq N \leq 10^5

1 \leq A_i \leq 10^9

Each A_i is an integer.

Input

Input is given from Standard Input in the following format:

N
A_1 A_2 ... A_N

Output

Print the minimum possible number of subarrays after division of A.

Sample Input 1

6
1 2 3 2 2 1

Sample Output 1

2

One optimal solution is to divide the array into [1,2,3] and [2,2,1].

Sample Input 2

9
1 2 1 2 1 2 1 2 1

Sample Output 2

5

Sample Input 3

7
1 2 3 2 1 999999999 1000000000

Sample Output 3

3

Solution in C# (Mono 4.6.2.0) (judge verdict: Wrong Answer)

using System;
using System.Text;
using System.Linq;
using System.Collections;
using System.Collections.Generic;
using static System.Console;
using static System.Math;

namespace AtCoder
{
    public class Program
    {
        public static void Main(string[] args)
        {
            new Program().Solve(new ConsoleInput(Console.In, ' '));
        }

        public void Solve(ConsoleInput cin)
        {
            // 解答はココに書く
            var N = cin.ReadInt;
            var A = cin.ReadIntArray(N);
            var tempA = A;
            
            var firstFlg = true;
            var upFlg = false;
            var downFlg = false;
            var evenFlg = false;
            var ans = 0;
            
            for(int i=0; i<N;){
                WriteLine($"A[{i}]{A[i]}");
                for(int j=i+1; j<N; j++){
                    WriteLine($"upFlg:{upFlg} downFlg:{downFlg} evenFlg:{evenFlg}");
                    WriteLine($"J[{j}]{A[j]}");
                    if(!upFlg && !downFlg && !evenFlg){
                        if(A[j]-A[i] > 0){
                            upFlg = true;
                            WriteLine("up");
                        }
                        if(A[j]-A[i]==0){
                            evenFlg = true;
                            WriteLine("even");
                        }
                        if(A[j]-A[i] < 0){
                            downFlg = true;
                            WriteLine("down");
                        }
                    }else{
                        if(upFlg && A[i]+j == A[j])continue;
                        if(evenFlg && A[i] == A[j])continue;
                        if(downFlg && A[i]-j == A[j])continue;
                        ans++;
                        i = i+j;
                        upFlg = false;
                        evenFlg = false;
                        downFlg = false;
                        WriteLine($"カウント：{ans}");
                        break;
                    }
                }
            }
            WriteLine(ans);
        }
    }

    public class ConsoleInput
    {
        private readonly System.IO.TextReader _stream;
        private char _separator = ' ';
        private Queue<string> inputStream;
        public ConsoleInput(System.IO.TextReader stream, char separator = ' ')
        {
            this._separator = separator;
            this._stream = stream;
            inputStream = new Queue<string>();
        }
        public string Read
        {
            get
            {
                if (inputStream.Count != 0) return inputStream.Dequeue();
                string[] tmp = _stream.ReadLine().Split(_separator);
                for (int i = 0; i < tmp.Length; ++i)
                    inputStream.Enqueue(tmp[i]);
                return inputStream.Dequeue();
            }
        }
        public string ReadLine { get { return _stream.ReadLine(); }}
        public int ReadInt { get { return int.Parse(Read); }}
        public long ReadLong { get { return long.Parse(Read); }}
        public double ReadDouble { get { return double.Parse(Read); }}
        public string[] ReadStrArray(long N) { var ret = new string[N]; for (long i = 0; i < N; ++i) ret[i] = Read; return ret;}
        public int[] ReadIntArray(long N) { var ret = new int[N]; for (long i = 0; i < N; ++i) ret[i] = ReadInt; return ret;}
        public long[] ReadLongArray(long N) { var ret = new long[N]; for (long i = 0; i < N; ++i) ret[i] = ReadLong; return ret;}
    }
    
}