Array range queries for elements with frequency same as value

// C# Program to answer Q queries to 
// find number of times an element x 
// appears x times in a Query subarray
using System;
using System.Collections.Generic;

class GFG
{
    /* Returns the count of number x with 
    frequency x in the subarray from 
    start to end */
    public static int solveQuery(int start, 
                                 int end, 
                                 int[] arr)
    {

        // map for frequency of elements 
        Dictionary<int, 
                   int> mp = new Dictionary<int, 
                                            int>();

        // store frequency of each element 
        // in arr[start; end] 
        for (int i = start; i <= end; i++)
        {
            if (mp.ContainsKey(arr[i]))
                mp[arr[i]]++;
            else
                mp.Add(arr[i], 1);
        }

        // Count elements with same frequency 
        // as value 
        int count = 0;
        foreach (KeyValuePair<int, 
                              int> entry in mp)
        {
            if (entry.Key == entry.Value)
                count++;
        }
        return count;
    }

    // Driver code 
    public static void Main(String[] args)
    {
        int[] A = { 1, 2, 2, 3, 3, 3 };
        int n = A.Length;

        // 2D array of queries with 2 columns 
        int[,] queries = {{ 0, 1 }, { 1, 1 },
                          { 0, 2 }, { 1, 3 },
                          { 3, 5 }, { 0, 5 }};

        // calculating number of queries 
        int q = queries.Length;

        for (int i = 0; i < q; i++)
        {
            int start = queries[i, 0];
            int end = queries[i, 1];
            Console.WriteLine("Answer for Query " + (i + 1) +
                              " = " + solveQuery(start, end, A));
        }
    }
}

// This code is contributed by
// sanjeev2552

/* C# Program to answer Q queries to
   find number of times an element x 
   appears x times in a Query subarray */

using System;
using System.Collections.Generic;

public class GFG {
// Variable to represent block size. 
// This is made global so compare() 
// of sort can use it.
    static int block;


/* Inserts element (x) into current range
   and updates current answer *//* Removes element (x) from current 
   range btw L and R and updates 
   current Answer */
    static void add(int x, int[] currentAns,
                    Dictionary<int, int> freq)
    {
        freq.TryGetValue(x, out int value);
        freq[x] = value + 1;
        if (freq[x] == x + 1) {
            currentAns[0]--;
        }
        else if (freq[x] == x) {
            currentAns[0]++;
        }
    }
/* Removes element (x) from current 
   range btw L and R and updates 
   current Answer */
    static void remove(int x, int[] currentAns,
                       Dictionary<int, int> freq)
    {
        freq[x]--;
        if (freq[x] == x) {
            currentAns[0]++;
        }
        else if (freq[x] == x - 1) {
            currentAns[0]--;
        }
    }
// Structure to represent a query range
    class Query {
        public int L;
        public int R;
        public int index;

        public Query(int L, int R, int index)
        {
            this.L = L;
            this.R = R;
            this.index = index;
        }
    }
    /* Utility Function to answer all queries
   and build the ans array in the original 
   order of queries */
static void queryResultsUtil(int[] a, Query[] q,
                                 int[] ans, int m)
    {
         // map to store freq of each element
        var freq = new Dictionary<int, int>();
        // Initialize current L, current R
    // and current sum
        int currL = 0, currR = 0;
        int[] currentAns = { 0 };
 // Traverse through all queries
        for (int i = 0; i < m; i++) {
            int L = q[i].L, R = q[i].R;
            int index = q[i].index;
 // Remove extra elements of previous
        // range. For example if previous 
        // range is [0, 3] and current range 
        // is [2, 5], then a[0] and a[1] are 
        // removed
            while (currL < L) {
                remove(a[currL], currentAns, freq);
                currL++;
            }
     // Add Elements of current Range
            while (currL > L) {
                currL--;
                add(a[currL], currentAns, freq);
            }

            while (currR <= R) {
                add(a[currR], currentAns, freq);
                currR++;
            }
    // Remove elements of previous range.  For example
        // when previous range is [0, 10] and current range
        // is [3, 8], then a[9] and a[10] are Removed
            while (currR > R + 1) {
                currR--;
                remove(a[currR], currentAns, freq);
            }

            ans[index] = currentAns[0];
        }
    }
    
    /* Wrapper for queryResultsUtil() and outputs the
   ans array constructed by answering all queries */

    static void queryResults(int[] a, int n, Query[] q,
                             int m)
    {
        block = (int)Math.Sqrt(n);

        Array.Sort(q, (x, y) => {
            /* Function used to sort all queries 
   so that all queries of same block
   are arranged together and within 
   a block, queries are sorted in 
   increasing order of R values. */
            if (x.L / block != y.L / block) {
                return x.L / block - y.L / block;
            }
            return x.R - y.R;
        });

        int[] ans = new int[m];
        queryResultsUtil(a, q, ans, m);

        for (int i = 0; i < m; i++) {
            Console.WriteLine("Answer for Query " + (i + 1)
                              + " = " + ans[i]);
        }
    }

    
    public static void Main(string[] args)
    {
        int[] A = { 1, 2, 2, 3, 3, 3 };
        int n = A.Length;

        Query[] q
            = { new Query(0, 1, 0), new Query(1, 1, 1),
                new Query(0, 2, 2), new Query(1, 3, 3),
                new Query(3, 5, 4), new Query(0, 5, 5) };
        int m = q.Length;

        queryResults(A, n, q, m);
    }
}