Relación de todos los subarreglos de tamaño K

Dada una array arr[] y un entero K , la tarea es calcular la proporción de todos los subarreglos de tamaño K .

Ejemplos:

Entrada: arr[] = {24, 3, 2, 1}, K = 3 
Salida: 4 1.5 
Explicación: 
Todos los subarreglos de tamaño K y su relación: 
Subarreglo 1: {24, 3, 2} = 24 / 3 / 2 = 4 
Subarreglo 2: {3, 2, 1} = 3/2/1= 1,5

Entrada: arr[] = {1, -2, 3, -4, 5, 6}, K = 2 
Salida: -0,5 -0,666667 -0,75 -0,8 0,833333 

Enfoque: la idea es iterar sobre cada subarreglo de tamaño K presente en el arreglo dado y seguir los pasos a continuación para resolver el problema: 

1. Inicialice una variable, por ejemplo, una relación con el primer elemento del subarreglo.
2. Iterar sobre el subarreglo restante y seguir dividiendo la relación entre los elementos encontrados uno por uno.
3. Finalmente, imprima el valor final de la relación para ese subarreglo.
4. Repita los pasos anteriores para todos los subarreglos.

A continuación se muestra la implementación del enfoque anterior: 

// C++ implementation of the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the ratio of
// all subarrays of size K
int calcRatio(double arr[], int n, int k)
{
 
    // Traverse every subarray of size K
    for (int i = 0; i <= n - k; i++) {
 
        // Initialize ratio
        double ratio = arr[i];
 
        // Calculate ratio of the
        // current subarray
        for (int j = i + 1; j < k + i; j++)
            ratio /= arr[j];
 
        // Print ratio of the subarray
        cout << ratio << " ";
    }
}
 
// Driver Code
int main()
{
    // Given array
    double arr[] = { 24, 3, 2, 1 };
    int n = sizeof(arr) / sizeof(arr[0]);
    int k = 3;
 
    // Function Call
    calcRatio(arr, n, k);
 
    return 0;
}

// Java implementation of the above approach
import java.util.*;
 
class GFG{
   
// Function to find the ratio of
// all subarrays of size K
static void calcRatio(double arr[], int n,
                                    int k)
{
     
    // Traverse every subarray of size K
    for(int i = 0; i <= n - k; i++)
    {
   
        // Initialize ratio
        double ratio = arr[i];
   
        // Calculate ratio of the
        // current subarray
        for(int j = i + 1; j < k + i; j++)
            ratio /= arr[j];
   
        // Print ratio of the subarray
        System.out.print(ratio + " ");
    }
}
  
// Driver code
public static void main (String[] args)
{
     
    // Given array
    double arr[] = { 24, 3, 2, 1 };
    int n = arr.length;
    int k = 3;
     
    // Function call
    calcRatio(arr, n, k);
}
}
 
// This code is contributed by offbeat

# Python3 implementation
# of the above approach
 
# Function to find the ratio of
# all subarrays of size K
def calcRatio(arr, n, k):
 
    # Traverse every subarray
    # of size K
    for i in range(n - k + 1):
 
        # Initialize ratio
        ratio = arr[i]
 
        # Calculate ratio of the
        # current subarray
        for j in range(i + 1, k + i):
            ratio = ratio / arr[j]
 
        # Print ratio of the subarray
        print(ratio, end = " ")
 
# Given array
arr = [24, 3, 2, 1]
n = len(arr)
k = 3
 
# Function Call
calcRatio(arr, n, k)
 
# This code is contributed by divyeshrabadiya07

// C# implementation of the above approach
using System;
  
class GFG{
    
// Function to find the ratio of
// all subarrays of size K
static void calcRatio(double []arr, int n,
                                    int k)
{
   
    // Traverse every subarray of size K
    for(int i = 0; i <= n - k; i++)
    {
    
        // Initialize ratio
        double ratio = arr[i];
    
        // Calculate ratio of the
        // current subarray
        for(int j = i + 1; j < k + i; j++)
            ratio /= arr[j];
    
        // Print ratio of the subarray
        Console.Write(ratio + " ");
    }
}
   
// Driver code
public static void Main(string[] args)
{
      
    // Given array
    double []arr = { 24, 3, 2, 1 };
    int n = arr.Length;
    int k = 3;
      
    // Function call
    calcRatio(arr, n, k);
}
}
 
// This code is contributed by rutvik_56

<script>
 
// Javascript implementation of the above approach
 
// Function to find the ratio of
// all subarrays of size K
function calcRatio(arr, n, k)
{
 
    // Traverse every subarray of size K
    for (var i = 0; i <= n - k; i++) {
 
        // Initialize ratio
        var ratio = arr[i];
 
        // Calculate ratio of the
        // current subarray
        for (var j = i + 1; j < k + i; j++)
            ratio /= arr[j];
 
        // Print ratio of the subarray
        document.write(ratio + " ");
    }
}
 
// Driver Code
// Given array
var arr = [ 24, 3, 2, 1 ];
var n = arr.length;
var k = 3;
// Function Call
calcRatio(arr, n, k);
 
</script>

4 1.5 

Complejidad de Tiempo: O(N ² ) 
Espacio Auxiliar: O(1)