Genere una array con una suma mínima que se pueda eliminar en pasos P

Dados dos números N y P . La tarea es generar una array de todos los elementos positivos, y en una operación puede elegir un número mínimo en la array y restarlo de todos los elementos de la array. Si el elemento de la array se convierte en 0, lo eliminará. 
Debe imprimir la suma mínima posible de la array y una array posible de modo que después de aplicar exactamente P pasos, la array desaparezca.

Ejemplos:  

Entrada: N = 4, P = 2 
Salida: 
La suma mínima posible es: 5 
Los elementos del arreglo son: 1 2 1 1 
Explicación: 
El arreglo puede ser [1, 2, 1, 1] después del primer paso se convierte en [0, 1, 0, 0] y se convierte en [1] y después del paso 2 desaparecerá. Por lo tanto, la suma es 5 y es el valor mínimo posible.
Entrada : N = 3, P = 1 
Salida
La suma mínima posible es: 3 
Los elementos del arreglo son: 1 1 1  

Enfoque: el problema se puede resolver siguiendo un enfoque codicioso. Primero, colocaremos primero P números naturales, y para el resto (N – P) posiciones lo llenaremos con 1 porque tenemos que minimizar la suma.
Entonces la suma será P*(P+1)/2 + (N – P) .

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

C++

// C++ implementation of above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the required array
void findArray(int N, int P)
{
    // calculating minimum possible sum
    int ans = (P * (P + 1)) / 2 + (N - P);
 
    // Array
    int arr[N + 1];
 
    // place first P natural elements
    for (int i = 1; i <= P; i++)
        arr[i] = i;
 
    // Fill rest of the elements with 1
    for (int i = P + 1; i <= N; i++)
        arr[i] = 1;
 
    cout << "The Minimum Possible Sum is: " << ans << "\n";
    cout << "The Array Elements are: \n";
 
    for (int i = 1; i <= N; i++)
        cout << arr[i] << ' ';
}
 
// Driver Code
int main()
{
    int N = 5, P = 3;
 
    findArray(N, P);
 
    return 0;
}

Java

// Java implementation of the approach
class GFG
{
     
    // Function to find the required array
    static void findArray(int N, int P)
    {
        // calculating minimum possible sum
        int ans = (P * (P + 1)) / 2 + (N - P);
 
        // Array
        int arr[] = new int[N + 1];
 
        // place first P natural elements
        for (int i = 1; i <= P; i++)
        {
            arr[i] = i;
        }
 
        // Fill rest of the elements with 1
        for (int i = P + 1; i <= N; i++)
        {
            arr[i] = 1;
        }
 
        System.out.print("The Minimum Possible Sum is: " +
                                                ans + "\n");
        System.out.print("The Array Elements are: \n");
 
        for (int i = 1; i <= N; i++)
        {
            System.out.print(arr[i] + " ");
        }
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int N = 5, P = 3;
 
        findArray(N, P);
    }
}
 
// This code contributed by Rajput-Ji

Python3

# Python3 implementation of above approach
 
# Function to find the required array
def findArray(N, P):
     
    # calculating minimum possible sum
    ans = (P * (P + 1)) // 2 + (N - P);
 
    # Array
    arr = [0] * (N + 1);
 
    # place first P natural elements
    for i in range(1, P + 1):
        arr[i] = i;
 
    # Fill rest of the elements with 1
    for i in range(P + 1, N + 1):
        arr[i] = 1;
 
    print("The Minimum Possible Sum is: ", ans);
    print("The Array Elements are: ");
 
    for i in range(1, N + 1):
        print(arr[i], end = " ");
 
# Driver Code
N = 5;
P = 3;
findArray(N, P);
 
# This code is contributed by mits

C#

// C# implementation of the approach
using System;
 
class GFG
{
     
    // Function to find the required array
    static void findArray(int N, int P)
    {
        // calculating minimum possible sum
        int ans = (P * (P + 1)) / 2 + (N - P);
 
        // Array
        int []arr = new int[N + 1];
 
        // place first P natural elements
        for (int i = 1; i <= P; i++)
        {
            arr[i] = i;
        }
 
        // Fill rest of the elements with 1
        for (int i = P + 1; i <= N; i++)
        {
            arr[i] = 1;
        }
 
        Console.Write("The Minimum Possible Sum is: " +
                                                ans + "\n");
        Console.Write("The Array Elements are: \n");
 
        for (int i = 1; i <= N; i++)
        {
            Console.Write(arr[i] + " ");
        }
    }
 
    // Driver Code
    public static void Main()
    {
        int N = 5, P = 3;
 
        findArray(N, P);
    }
}
 
/* This code contributed by PrinciRaj1992 */

PHP

<?php
// PHP implementation of above approach
 
// Function to find the required array
function findArray($N, $P)
{
    // calculating minimum possible sum
    $ans = ($P * ($P + 1)) / 2 + ($N - $P);
 
    // Array
    $arr[$N + 1] = array();
 
    // place first P natural elements
    for ($i = 1; $i <= $P; $i++)
        $arr[$i] = $i;
 
    // Fill rest of the elements with 1
    for ($i = $P + 1; $i <= $N; $i++)
        $arr[$i] = 1;
 
    echo "The Minimum Possible Sum is: ",
                              $ans, "\n";
    echo "The Array Elements are: \n";
 
    for ($i = 1; $i <= $N; $i++)
    echo $arr[$i], ' ';
}
 
// Driver Code
$N = 5;
$P = 3;
findArray($N, $P);
 
// This code is contributed by ajit.
?>

Javascript

<script>
    // Javascript implementation of the approach
     
    // Function to find the required array
    function findArray(N, P)
    {
        // calculating minimum possible sum
        let ans = parseInt((P * (P + 1)) / 2, 10) + (N - P);
   
        // Array
        let arr = new Array(N + 1);
   
        // place first P natural elements
        for (let i = 1; i <= P; i++)
        {
            arr[i] = i;
        }
   
        // Fill rest of the elements with 1
        for (let i = P + 1; i <= N; i++)
        {
            arr[i] = 1;
        }
   
        document.write("The Minimum Possible Sum is: " +
                                                ans + "</br>");
        document.write("The Array Elements are: " + "</br>");
   
        for (let i = 1; i <= N; i++)
        {
            document.write(arr[i] + " ");
        }
    }
     
    let N = 5, P = 3;
   
      findArray(N, P);
         
</script>
Producción: 

The Minimum Possible Sum is: 8
The Array Elements are: 
1 2 3 1 1

 

Complejidad de tiempo: O(N)

Espacio Auxiliar: O(N)
 

Publicación traducida automáticamente

Artículo escrito por souradeep y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *