Problem:
Score : 300 points

Problem Statement

A company has N members, who are assigned ID numbers 1, ..., N.

Every member, except the member numbered 1, has exactly one immediate boss with a smaller ID number.

When a person X is the immediate boss of a person Y, the person Y is said to be an immediate subordinate of the person X.

You are given the information that the immediate boss of the member numbered i is the member numbered A_i. For each member, find how many immediate subordinates it has.

Constraints

2 \leq N \leq 2 \times 10^5

1 \leq A_i < i

Input

Input is given from Standard Input in the following format:

N
A_2 ... A_N

Output

For each of the members numbered 1, 2, ..., N, print the number of immediate subordinates it has, in its own line.

Sample Input 1

5
1 1 2 2

Sample Output 1

2
2
0
0
0

The member numbered 1 has two immediate subordinates: the members numbered 2 and 3.

The member numbered 2 has two immediate subordinates: the members numbered 4 and 5.

The members numbered 3, 4, and 5 do not have immediate subordinates.

Sample Input 2

10
1 1 1 1 1 1 1 1 1

Sample Output 2

9
0
0
0
0
0
0
0
0
0

Sample Input 3

7
1 2 3 4 5 6

Sample Output 3

1
1
1
1
1
1
0

Solution in C# (.NET Core 3.1.201) (judge verdict: Accepted)

/*******************************************c#
* 20.04.16 AtCoder Beginner Contest 159. C - Maximum Volume
*
*
*********************************************/
/*********************************************

::test input::

*********************************************/
using System; //Console, IComparable
using System.IO; //StreamWriter 
using System.Linq; //Select(), Where(), OrderBy(), Count()
using System.Collections.Generic; //List<T>
using System.Reflection; //PropertyInfo[], GetProperties[]
using static System.Console; using static IOmacro.CInput;

namespace tempName {
    public class CRun{
        private static class gv{
            public static int N;
            public static int[] A;
            
            public static int[] pin;
            public static int[] pout;
            public static List<int>[] gph;
            
            public static int[] cnt;
        }
    
        public void build(){            
            gv.N = _int;
            gv.A = _inta;
        }
        
        int order = 0;
        public void dfs(int p) {
            gv.pin[p] = ++order;
            foreach (var x in gv.gph[p]) dfs(x);
            gv.pout[p] = order;
            WriteLine($"{p}, {gv.pin[p]}, {gv.pout[p]}");
        }
        
        public void solve(){
            
            /*
            gv.pin = new int[gv.N +2]; Array.Clear(gv.pin, 0, gv.pin.Length);
            gv.pout = new int[gv.N +2]; Array.Clear(gv.pout, 0, gv.pout.Length);
            gv.gph = new List<int>[gv.N +5];
            for (int i=0; i<gv.gph.Length; i++) gv.gph[i] = new List<int>();
            
            for (int i=0; i<gv.A.Length; i++) {
                gv.gph[gv.A[i]].Add(i+2);
            }
            
            dfs(1);
            */
            
            gv.cnt = new int[gv.N+2];
            
            foreach (var x in gv.A) {
                gv.cnt[x]++;
            }
            
            for (int i=1; i<=gv.N; i++) {
                WriteLine(gv.cnt[i]);
            }
        }
    }

    class Program { 
        static void Main() { 
            var run = new CRun();
            run.build();
            run.solve();
        } 
    }
}

namespace IOmacro {
    public static class CInput {
        public static StreamWriter _writer = new StreamWriter(Console.OpenStandardOutput());
        public static string _string{get{return Console.ReadLine();}}
        public static string[] _stringa{get{return (Console.ReadLine().Split());}}
        public static int _int{get{return int.Parse(Console.ReadLine());}}
        public static int[] _inta{get{return Console.ReadLine().Split().Select(x=>int.Parse(x)).ToArray();}}
        public static long _long{get{return long.Parse(Console.ReadLine());}}
        public static long[] _longa{get{return Console.ReadLine().Split().Select(x=>long.Parse(x)).ToArray();}}    
    }
}