Suma de los primeros M elementos de Array formados por la concatenación infinita de un array dado

Dada una array arr[] que consiste en N enteros y un entero positivo M , la tarea es encontrar la suma de los primeros M elementos de la array formada por la concatenación infinita de la array dada arr[] .

Ejemplos:

Entrada: arr[] = {1, 2, 3}, M = 5
Salida: 9
Explicación:
El arreglo formado por la concatenación infinita del arreglo dado arr[] es de la forma {1, 2, 3, 1, 2 , 3, 1, 2, 3, 1, 2, 3, … }.
La suma de los primeros M(= 5) elementos de la array es 1 + 2 + 3 + 1 + 2 = 9.

Entrada: arr[] = {1}, M = 7
Salida: 7

Enfoque: el problema dado se puede resolver utilizando el operador de módulo (%) y considere la array dada como la array circular y encuentre la suma de los primeros M elementos en consecuencia. Siga los pasos a continuación para resolver este problema:

• Inicialice una variable, diga suma como 0 para almacenar la suma resultante de los primeros M elementos de la nueva array.
• Iterar sobre el rango [0, M – 1] usando la variable i e incrementar el valor de sum por arr[i%N] .
• Después de completar los pasos anteriores, imprima el valor de la suma como resultado.

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

// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the sum of first
// M numbers formed by the infinite
// concatenation of the array A[]
int sumOfFirstM(int A[], int N, int M)
{
    // Stores the resultant sum
    int sum = 0;
 
    // Iterate over the range [0, M - 1]
    for (int i = 0; i < M; i++) {
 
        // Add the value A[i%N] to sum
        sum = sum + A[i % N];
    }
 
    // Return the resultant sum
    return sum;
}
 
// Driver Code
int main()
{
    int arr[] = { 1, 2, 3 };
    int M = 5;
    int N = sizeof(arr) / sizeof(arr[0]);
    cout << sumOfFirstM(arr, N, M);
 
    return 0;
}

// Java program for the above approach
 
import java.io.*;
import java.lang.*;
 
class GFG {
 
  // Function to find the sum of first
  // M numbers formed by the infinite
  // concatenation of the array A[]
  public static int sumOfFirstM(int A[], int N, int M)
  {
     
    // Stores the resultant sum
    int sum = 0;
 
    // Iterate over the range [0, M - 1]
    for (int i = 0; i < M; i++) {
 
      // Add the value A[i%N] to sum
      sum = sum + A[i % N];
    }
 
    // Return the resultant sum
    return sum;
  }
 
  // Driver Code
  public static void main(String[] args) {
    int arr[] = { 1, 2, 3 };
    int M = 5;
    int N = arr.length;
    System.out.println(sumOfFirstM(arr, N, M));
 
  }
}
 
// This code is contributed by gfgking.

# Python3 program for the above approach
 
# Function to find the sum of first
# M numbers formed by the infinite
# concatenation of the array A[]
def sumOfFirstM(A, N, M):
     
    # Stores the resultant sum
    sum = 0
 
    # Iterate over the range [0, M - 1]
    for i in range(M):
         
        # Add the value A[i%N] to sum
        sum = sum + A[i % N]
 
    # Return the resultant sum
    return sum
 
# Driver Code
if __name__ == '__main__':
     
    arr = [ 1, 2, 3 ]
    M = 5
    N = len(arr)
     
    print(sumOfFirstM(arr, N, M))
     
# This code is contributed by ipg2016107

// C# program for the above approach
using System;
class GFG {
 
    // Function to find the sum of first
    // M numbers formed by the infinite
    // concatenation of the array A[]
    static int sumOfFirstM(int[] A, int N, int M)
    {
 
        // Stores the resultant sum
        int sum = 0;
 
        // Iterate over the range [0, M - 1]
        for (int i = 0; i < M; i++) {
 
            // Add the value A[i%N] to sum
            sum = sum + A[i % N];
        }
 
        // Return the resultant sum
        return sum;
    }
 
    // Driver Code
    public static void Main()
    {
        int[] arr = { 1, 2, 3 };
        int M = 5;
        int N = arr.Length;
        Console.WriteLine(sumOfFirstM(arr, N, M));
    }
}
 
// This code is contributed by subhammahato348.

<script>
  
        // JavaScript program for the above approach
 
 
        // Function to find the sum of first
        // M numbers formed by the infinite
        // concatenation of the array A[]
        function sumOfFirstM(A, N, M) {
            // Stores the resultant sum
            let sum = 0;
            // Iterate over the range [0, M - 1]
            for (let i = 0; i < M; i++) {
 
                // Add the value A[i%N] to sum
                sum = sum + A[i % N];
            }
 
            // Return the resultant sum
            return sum;
        }
 
        // Driver Code
 
        let arr = [1, 2, 3];
        let M = 5;
        let N = arr.length;
        document.write(sumOfFirstM(arr, N, M));
 
 
 
  // This code is contributed by Potta Lokesh
   
</script>

9

Tiempo Complejidad: O(M)
Espacio Auxiliar: O(1)