Minimum index to split array into subarrays with co-prime products

// C# program for the 
// above approach
using System;
class GFG{
    
// Function to find the 
// GCD of 2 numbers
static int GCD(int a, int b)
{
  // Base Case
  if (b == 0)
    return a;

  // Find the GCD 
  // recursively
  return GCD(b, a % b);
}

// Function to find the minimum 
// partition index K s.t. product
// of both subarrays around that 
// partition are co-prime
static int findPartition(int[] nums, 
                         int N)
{
  // Stores the prefix and 
  // suffix array product
  int[] prefix = new int[N];
  int[] suffix = new int[N];
  int i, k;

  prefix[0] = nums[0];

  // Update the prefix array
  for (i = 1; i < N; i++) 
  {
    prefix[i] = prefix[i - 1] * 
                nums[i];
  }

  suffix[N - 1] = nums[N - 1];

  // Update the suffix array
  for (i = N - 2; i >= 0; i--) 
  {
    suffix[i] = suffix[i + 1] * 
                nums[i];
  }

  // Iterate the given array
  for (k = 0; k < N - 1; k++) 
  {
    // Check if prefix[k] and
    // suffix[k+1] are co-prime
    if (GCD(prefix[k],
            suffix[k + 1]) == 1) 
    {
      return k;
    }
  }

  // If no index for partition
  // exists, then return -1
  return -1;
}

// Driver code
static void Main() 
{
  int[] arr = {2, 3, 4, 5};
  int N = arr.Length;

  // Function call
  Console.WriteLine(findPartition(arr, N));
}
}

// This code is contributed by divyeshrabadiya07

using System;
using System.Collections.Generic;

class MainClass {
    // Function to calculate the prime factorization of a number and update a frequency dictionary
    public static void PrimeFreq(int x, Dictionary<int, int> freq) {
        int temp = x;
        for (int i = 2; i * i <= x; i++) {
            while (temp % i == 0) {
                // If the factor is already in the frequency dictionary, increment its count
                if (freq.ContainsKey(i)) {
                    freq[i]++;
                }
                else {
                    // If the factor is not in the dictionary, add it with a count of 1
                    freq[i] = 1;
                }
                temp /= i;
            }
        }
        // If there's a remaining prime factor greater than 1, update the frequency dictionary
        if (temp > 1) {
            if (freq.ContainsKey(temp)) {
                freq[temp]++;
            }
            else {
                freq[temp] = 1;
            }
        }
    }

    // Function to find the index where a valid split can occur
    public static int FindValidSplit(List<int> nums) {
        // Create a dictionary to store the prime factorization frequency of the entire list
        Dictionary<int, int> freq = new Dictionary<int, int>();

        // Calculate the prime factorization of each number in the list and update the frequency dictionary
        foreach (int num in nums) {
            PrimeFreq(num, freq);
        }

        // Initialize a temporary frequency dictionary
        Dictionary<int, int> currFreq = new Dictionary<int, int>();

        // Iterate through the list
        for (int i = 0; i < nums.Count; i++) {
            // Calculate the prime factorization of the current number and store it in the temporary dictionary
            PrimeFreq(nums[i], currFreq);

            bool isValidSplit = true;

            // Compare the prime factorization of the current number with the frequency dictionary
            foreach (KeyValuePair<int, int> entry in currFreq) {
                int key = entry.Key;
                int value = entry.Value;

                // Check if there are enough prime factors of this type in the original frequency dictionary
                if (freq.ContainsKey(key) && freq[key] - value > 0) {
                    isValidSplit = false;
                    break;
                }
            }

            // If it's a valid split and not the last element, return the current index
            if (isValidSplit && i != nums.Count - 1) {
                return i;
            }
        }

        // If no valid split is found, return -1
        return -1;
    }

    public static void Main(string[] args) {
        // Create a list of integers
        List<int> arr = new List<int>();
        arr.Add(2);
        arr.Add(3);
        arr.Add(4);
        arr.Add(5);

        // Call the FindValidSplit function and print the result
        Console.WriteLine(FindValidSplit(arr));
    }
}