Tiempo total durante el cual el héroe estará en estado de shock.

Dado un ataque de array que contiene N enteros en orden no decreciente y un entero D . Cada elemento en el ataque de array indica el momento en que el héroe es atacado dentro de un juego y D indica la duración durante la cual el héroe estará en estado de shock y no podrá contraatacar. La tarea es encontrar el tiempo total durante el cual el héroe estará en estado de shock.

Ejemplo:

Entrada: ataque = [1, 4], d= 2
Salida: 4
Explicación:
En el segundo 1, Hero es atacado y permanece en estado de shock durante los segundos 1 y 2.
En el segundo 4, Hero es atacado y permanece en estado de shock durante segundos 4 y 5,
que son 4 segundos en total.

Entrada: ataque = [1, 2], d= 2
Salida: 3
Explicación:
En el segundo 1, Hero es atacado y permanece en shock durante los segundos 1 y 2.
En el segundo 2, Hero es atacado y permanece en shock durante segundos 2 y 3.
que son 3 segundos en total.

Enfoque: Calcule el tiempo durante el cual el héroe estará en estado de shock utilizando la fórmula:

Tiempo de choque para el ataque[i] = (ataque[i]+D) – max(Tiempo en el que finaliza el ataque anterior, ataque[i])

Ahora, para resolver este problema, siga los pasos a continuación:

1. Cree una variable totalTime para almacenar la respuesta a este problema.
2. Crea una variable, prev e inicialízala en el ataque[0]. Esta variable almacenará la hora en que finaliza el ataque anterior para cada ataque individual.
3. Ejecute un ciclo de i=0 a i<N , y en cada iteración:
   • Agregue el tiempo de choque del ataque[i] i, e. (ataque[i] + D) – max(anterior, ataque[i]) a totalTime .
   • Cambie prev al momento en que finaliza el ataque anterior, por lo que prev=attack[i]+D .
4. Devuelve totalTime como la respuesta después de que finaliza el ciclo.

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 total time for
// which hero will be under shock
int heroInShock(vector<int>& attack, int D)
{
 
    int N = attack.size();
    int totalTime = 0;
 
    int prev = attack[0];
 
    for (int i = 0; i < N; i++) {
 
        // Adding time of attack in total time
        totalTime += (attack[i] + D)
                     - max(prev, attack[i]);
 
        // Changing prev to the time where
        // the previous attack ends
        prev = attack[i] + D;
    }
 
    return totalTime;
}
 
// Driver Code
int main()
{
    vector<int> attack = { 1, 2, 6 };
    int D = 2;
    cout << heroInShock(attack, D);
    return 0;
}

// Java program for the above approach
import java.util.ArrayList;
 
class GFG{
 
// Function to find the total time for
// which hero will be under shock
static int heroInShock(ArrayList<Integer> attack, int D)
{
    int N = attack.size();
    int totalTime = 0;
    int prev = (int)attack.get(0);
 
    for(int i = 0; i < N; i++)
    {
         
        // Adding time of attack in total time
        totalTime += ((int)attack.get(i) + D) -
                      Math.max(prev, (int)attack.get(i));
 
        // Changing prev to the time where
        // the previous attack ends
        prev = (int)attack.get(i) + D;
    }
    return totalTime;
}
 
// Driver code
public static void main(String args[])
{
    ArrayList<Integer> attack = new ArrayList<Integer>();
    attack.add(1);
    attack.add(2);
    attack.add(6);
 
    int D = 2;
    System.out.println(heroInShock(attack, D));
}
}
 
// This code is contributed by gfking

# Python code for the above approach
 
# Function to find the total time for
# which hero will be under shock
def heroInShock(attack, D):
    N = len(attack)
    totalTime = 0
    prev = attack[0]
    for i in range(N):
 
        # Adding time of attack in total time
        totalTime += (attack[i] + D) - max(prev, attack[i])
 
        # Changing prev to the time where
        # the previous attack ends
        prev = attack[i] + D
 
    return totalTime
 
# Driver Code
attack = [1, 2, 6]
D = 2
print(heroInShock(attack, D))
 
# This code is contributed by Saurabh Jaiswal

// C# code to implement above approach
using System;
using System.Collections;
class GFG {
 
  // Function to find the total time for
  // which hero will be under shock
  static int heroInShock(ArrayList attack, int D)
  {
 
    int N = attack.Count;
    int totalTime = 0;
 
    int prev = (int)attack[0];
 
    for (int i = 0; i < N; i++) {
 
      // Adding time of attack in total time
      totalTime += ((int)attack[i] + D)
        - Math.Max(prev, (int)attack[i]);
 
      // Changing prev to the time where
      // the previous attack ends
      prev = (int)attack[i] + D;
    }
 
    return totalTime;
  }
 
  // Driver code
  public static void Main()
  {
    ArrayList attack = new ArrayList();
    attack.Add(1);
    attack.Add(2);
    attack.Add(6);
 
    int D = 2;
    Console.Write(heroInShock(attack, D));
  }
}
 
// This code is contributed by Samim Hossain Mondal.

<script>
      // JavaScript code for the above approach
 
      // Function to find the total time for
      // which hero will be under shock
      function heroInShock(attack, D)
      {
          let N = attack.length;
          let totalTime = 0;
 
          let prev = attack[0];
 
          for (let i = 0; i < N; i++) {
 
              // Adding time of attack in total time
              totalTime += (attack[i] + D)
                  - Math.max(prev, attack[i]);
 
              // Changing prev to the time where
              // the previous attack ends
              prev = attack[i] + D;
          }
 
          return totalTime;
      }
 
      // Driver Code
      let attack = [1, 2, 6];
      let D = 2;
      document.write(heroInShock(attack, D));
 
// This code is contributed by Potta Lokesh
  </script>

5

Complejidad temporal: O(N)
Espacio auxiliar: O(1)