Buscar valor después de realizar consultas de Incremento Decremento

Dada una variable X que tiene un valor inicial 0 y una array de consultas Q[] de tamaño N que contiene el tipo de operaciones, la tarea es devolver el valor de N después de realizar todas las operaciones siguientes:

• Tipo-1: Incrementa el valor de X en 1.
• Tipo-2: Disminuye el valor de X en 1. 

Ejemplos: 

Entrada: Q = {2, 1, 1}
Salida: 1
Explicación: Las operaciones se realizan de la siguiente manera:
Inicialmente, X = 0, 
Consulta 1 (Tipo 2): X se decrementa en 1, X = 0 – 1 = -1 
Consulta 2 (Tipo 1): X se incrementa en 1, X = -1 + 1 = 0
Consulta 3 (Tipo 1): X se incrementa en 1, X = 0 + 1 = 1
Por lo tanto, la salida será 1

Entrada: Q = {1, 1, 1}
Salida: 3

Enfoque: Para resolver el problema, siga la siguiente idea: 

• Atraviesa la array dada de Consultas. 
• Siempre que el elemento de la array sea 1, incremente N en 1 y 
• Siempre que el elemento de la array sea 2, disminuya N en 1.
• Devuelva el valor final de N como la respuesta requerida.

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

// C++ code for the above approach.
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to findvalue after queries
int findvalue(vector<int>& queries)
{
    // Storing array size in n
    int n = queries.size();
    int x = 0;
    for (int i = 0; i < n; i++) {
 
        // If query is of type 1, increment
        if (queries[i] == 1) {
            x = x + 1;
        }
 
        // Else query is of type 2, decrement
        else {
            x = x - 1;
        }
    }
    return x;
}
 
// Drivers code
int main()
{
    // Declaring array of integers
    // which contains queries
    vector<int> queries = { 2, 1, 1 };
    int ans = findvalue(queries);
 
    // Function Call
    cout << ans;
    return 0;
}

// Java code for the above approach.
public class GFG {
     
    // Function to findvalue after queries
    static int findvalue(int []queries)
    {
        // Storing array size in n
        int n = queries.length;
        int x = 0;
        for (int i = 0; i < n; i++) {
 
            // If query is of type 1, increment
            if (queries[i] == 1) {
                x = x + 1;
            }
 
            // Else query is of type 2, decrement
            else {
                x = x - 1;
            }
        }
        return x;
    }
 
    // Drivers code
    public static void main(String[] args)
    {
        // Declaring array of integers
        // which contains queries
        int []queries = { 2, 1, 1 };
        int ans = findvalue(queries);
 
        // Function Call
        System.out.println(ans);
    }
}
 
// This code is contributed by AnkThon

# Python3 code for the above approach.
 
# Function to findvalue after queries
def findvalue(queries)  :
 
    # Storing array size in n
    n = len(queries);
    x = 0;
    for i in range(n) :
 
        # If query is of type 1, increment
        if (queries[i] == 1) :
            x = x + 1;
 
        # Else query is of type 2, decrement
        else :
            x = x - 1;
    return x;
 
# Drivers code
if __name__ == "__main__" :
 
    # Declaring array of integers
    # which contains queries
    queries = [ 2, 1, 1 ];
    ans = findvalue(queries);
 
    # Function Call
    print(ans);
     
    # This code is contributed by AnkThon

// C# code for the above approach.
 
using System;
using System.Collections.Generic;
 
class GFG {
    // Function to findvalue after queries
    static int findvalue(List<int> queries)
    {
        // Storing array size in n
        int n = queries.Count;
        int x = 0;
        for (int i = 0; i < n; i++) {
 
            // If query is of type 1, increment
            if (queries[i] == 1) {
                x = x + 1;
            }
 
            // Else query is of type 2, decrement
            else {
                x = x - 1;
            }
        }
        return x;
    }
 
    // Drivers code
    public static void Main(string[] args)
    {
        // Declaring array of integers
        // which contains queries
        List<int> queries = new List<int>{ 2, 1, 1 };
        int ans = findvalue(queries);
 
        // Function Call
        Console.Write(ans);
    }
}
 
// This code is contributed by phasing17

<script>
// Javascript code for the above approach.
 
// Function to findvalue after queries
function findvalue( queries)
{
    // Storing array size in n
    let n = queries.length;
    let x = 0;
    for (let i = 0; i < n; i++) {
 
        // If query is of type 1, increment
        if (queries[i] == 1) {
            x = x + 1;
        }
 
        // Else query is of type 2, decrement
        else {
            x = x - 1;
        }
    }
    return x;
}
 
// Drivers code
 
    // Declaring array of integers
    // which contains queries
    let queries = [ 2, 1, 1 ];
    let ans = findvalue(queries);
 
    // Function Call
   document.write(ans);
    
   // This code is contributed by satwik4409.
   </script>

1

Complejidad temporal : O(N). 
Espacio Auxiliar : O(1).