Dado un número entero, instancias y una array , arr[] de tamaño N que representa el porcentaje de utilización promedio del sistema informático en cada segundo, la tarea es encontrar el número de instancias al final del período de tiempo tal que el sistema informático escala automáticamente el número de instancias de acuerdo con las siguientes reglas:
- Utilización promedio < 25 %: reduzca la cantidad de instancias a la mitad si la cantidad de instancias es mayor que 1.
- 25 % ≤ Utilización media ≤ 60 %: No realice ninguna acción.
- Uso promedio > 60 %: duplique el número de instancias si el valor duplicado no supera 2* 10 8 .
Una vez que se realiza una acción de agregar o reducir el número de instancias, el sistema dejará de monitorear durante 10 segundos. Durante ese tiempo, el número de instancias no cambia.
Ejemplos:
Entrada: instancias = 2, arr[] = {25, 23, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 76, 80} Salida: 2 Explicación: en el segundo
1 ,
arr
[ 0] = 25 ≤ 25, así que no haga nada.
En el segundo 2, arr[1] = 23 < 25, por lo que se instancia una acción para reducir a la mitad el número de instancias a ceil(2/2) = 1. El sistema dejará de verificar durante 10 segundos, por lo que desde arr[2] hasta arr[11] no se tomarán medidas.
En el segundo 13, arr[12] = 76 > 60, por lo que el número de instancias se duplica de 1 a 2.No hay más lecturas a considerar y 2 es el valor final.
Entrada: instancias = 5, arr = {30, 5, 4, 8, 19, 89}
Salida: 3
Explicación:
en el segundo 1, 25 ≤ arr[0] = 30 ≤ 60, así que no realice ninguna acción.
En el segundo 2, arr[1] = 5 < 25, por lo que se instancia una acción para reducir a la mitad el número de instancias a ceil(5/2) = 3. El sistema dejará de
verificar durante 10 segundos, por lo que desde arr[2] hasta arr[5] no se tomarán medidas.No hay más lecturas a considerar y 3 es la respuesta final.
Enfoque: el problema dado se puede resolver recorriendo la array dada arr[] y si el elemento actual es menor que 25, divida el número de instancias entre 2 si el número de instancias es mayor que 1. De lo contrario, si el valor actual es mayor a 60 multiplica el numero de instancias por 2 si el numero de instancias no es mayor a 10 8 , luego de realizar cualquiera de las dos operaciones incrementa el indice actual por 10. Sigue los pasos para resolver el problema:
- Recorra el arreglo , arr[] usando la variable i y realice los siguientes pasos:
- Si arr[i] es menor que 25 y las instancias son mayores que 1, divida las instancias por 2 e incremente i por 10 .
- Si arr[i] es mayor que 60 y las instancias son menores o iguales a 10 8 , multiplique las instancias por 2 e incremente i por 10 .
- Incremente el índice i en 1 .
- Después de completar los pasos anteriores, imprima el número de instancias como resultado.
A continuación se muestra la implementación del enfoque anterior:
C++
// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
// Function to find the number of
// instances after compintion
void finalInstances(int instances,
int arr[], int N)
{
int i = 0;
// Traverse the array, arr[]
while (i < N)
{
// If current element is less
// than 25
if (arr[i] < 25 && instances > 1)
{
// Divide instances by 2 and take ceil value
double temp = (instances / 2.0);
instances = (int)(ceil(temp));
i = i + 10;
}
// If the current element is
// greater than 60
else if (arr[i] > 60 &&
instances <= (2*pow(10, 8)))
{
// Double the instances
instances = instances * 2;
i = i + 10;
}
i = i + 1;
}
// Print the instances at the end
// of the traversal
cout << instances;
}
// Driver Code
int main()
{
int instances = 2;
int arr[] = { 25, 23, 1, 2, 3, 4, 5,
6, 7, 8, 9, 10, 76, 80 };
int N = sizeof(arr) / sizeof(arr[0]);
// Function Call
finalInstances(instances, arr, N);
}
// This code is contributed by splevel62
Java
// Java program for above approach
class GFG{
// Function to find the number of
// instances after compintion
public static void finalInstances(int instances,
int[] arr)
{
int i = 0;
// Traverse the array, arr[]
while (i < arr.length)
{
// If current element is less
// than 25
if (arr[i] < 25 && instances > 1)
{
// Divide instances by 2
instances = (instances / 2);
i = i + 10;
}
// If the current element is
// greater than 60
else if (arr[i] > 60 &&
instances <= Math.pow(10, 8))
{
// Double the instances
instances = instances * 2;
i = i + 10;
}
i = i + 1;
}
// Print the instances at the end
// of the traversal
System.out.println(instances);
}
// Driver Code
public static void main(String args[])
{
int instances = 2;
int[] arr = { 25, 23, 1, 2, 3, 4, 5,
6, 7, 8, 9, 10, 76, 80 };
// Function Call
finalInstances(instances, arr);
}
}
// This code is contributed by _saurabh_jaiswal
Python3
# Python program for the above approach from math import ceil # Function to find the number of # instances after completion def finalInstances(instances, arr): i = 0 # Traverse the array, arr[] while i < len(arr): # If current element is less # than 25 if arr[i] < 25 and instances > 1: # Divide instances by 2 instances = ceil(instances / 2) i += 10 # If the current element is # greater than 60 elif arr[i] > 60 and instances <= 10**8: # Double the instances instances *= 2 i += 10 i += 1 # Print the instances at the end # of the traversal print(instances) # Driver Code instances = 2 arr = [25, 23, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 76, 80] # Function Call finalInstances(instances, arr)
C#
// C# program for above approach
using System;
class GFG{
// Function to find the number of
// instances after compintion
static void finalInstances(int instances, int[] arr)
{
int i = 0;
// Traverse the array, arr[]
while (i < arr.Length) {
// If current element is less
// than 25
if (arr[i] < 25 && instances > 1) {
// Divide instances by 2
instances = (instances / 2);
i = i + 10;
}
// If the current element is
// greater than 60
else if (arr[i] > 60 && instances <= Math.Pow(10, 8))
{
// Double the instances
instances = instances * 2;
i = i + 10;
}
i = i + 1;
}
// Print the instances at the end
// of the traversal
Console.Write(instances);
}
// Driver Code
static void Main()
{
int instances = 2;
int[] arr = {25, 23, 1, 2, 3, 4, 5,
6, 7, 8, 9, 10, 76, 80};
// Function Call
finalInstances(instances, arr);
}
}
// This code is contributed by sanjoy_62.
Javascript
<script>
// JavaScript Program for the above approach
// Function to find the number of
// instances after completion
function finalInstances(instances, arr) {
let i = 0;
// Traverse the array, arr[]
while (i < arr.length) {
// If current element is less
// than 25
if (arr[i] < 25 && instances > 1) {
// Divide instances by 2
instances = Math.ceil(instances / 2);
i = i + 10;
}
// If the current element is
// greater than 60
else if (arr[i] > 60 && instances <= Math.pow(10, 8))
{
// Double the instances
instances = instances * 2;
i = i + 10;
}
i = i + 1;
}
// Print the instances at the end
// of the traversal
document.write(instances);
}
// Driver Code
let instances = 2;
let arr = [25, 23, 1, 2, 3, 4, 5,
6, 7, 8, 9, 10, 76, 80];
// Function Call
finalInstances(instances, arr);
// This code is contributed by Potta Lokesh
</script>
2
Complejidad temporal: O(N)
Espacio auxiliar: O(1)
Publicación traducida automáticamente
Artículo escrito por srichakradhar y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA