Encuentre el valor final de A después de operaciones AND-OR alternativas en A y B

Dados 3 enteros A , B y N , la tarea es realizar operaciones AND-OR alternativas en A y B , y luego asignar el resultado de cada operación a A . Encuentre el valor final de A

Ejemplos :

Entrada : A = 4, B = 5, N = 1
Salida : 4
Explicación : Realice 1 operación, es decir, A = A y B, por lo tanto, A = 4 y 5 = 4
Entrada : A = 4, B = 5, N = 1000
Salida : 5

Enfoque ingenuo : la tarea se puede resolver mediante observaciones. Se puede observar que la respuesta será A Y B Si el Número N es Impar . La respuesta será A O B si el Número N es Par . Es porque la operación AND-OR se ejecuta alternativamente.

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

/*package whatever //do not write package name here */
#include <bits/stdc++.h>
using namespace std;
 
int main()
{
    int A = 4;
    int B = 5;
    int n = 1000;
    int N = 1;
    for (N = 1; N <= n; N++) {
        if ((N % 2) != 0) {
            A = A & B;
        }
        else {
            A = A | B;
        }
    }
 
    cout << "Output is:" << A;
    return 0;
}
 
// This code is contributed by rakeshsahni

/*package whatever //do not write package name here */
 
import java.io.*;
 
class GFG {
    public static void main (String[] args) {
        int A=4;
                int B=5;
                int n =1000;
                int N = 1;
                for(N=1;N<=n;N++)
        {
            if ((N % 2) != 0) {
                A = A & B;
            } else {
                A = A | B;
            }}
 
            System.out.println("Output is:" + A);
    }
}

# Python program for above approach
A = 4
B = 5
n = 1000
N = 1
 
for N in range(1, n+1):
    if ((N % 2) != 0):
        A = A & B
 
    else:
        A = A | B
 
print("Output is:", end="")
print(A)
 
# This code is contributed by ninja_hattori.

// C# program to implement the approach
using System;
class GFG {
 
  public static void Main()
  {
        int A=4;
                int B=5;
                int n =1000;
                int N = 1;
                for(N=1;N<=n;N++)
        {
            if ((N % 2) != 0) {
                A = A & B;
            } else {
                A = A | B;
            }}
 
        Console.Write("Output is:" + A);
  }
}
 
// This code is contributed by sanjoy_62.

<script>
     // JavaScript program for above approach
        var A = 4;
        var B = 5;
        var n = 1000;
        var N = 1;
        for (N = 1; N <= n; N++) {
            if ((N % 2) != 0) {
                A = A & B;
            } else {
                A = A | B;
            }
        }
 
        document.write("Output is:" + A);
 
// This code is contributed by Rajput-Ji
</script>

Output is:5

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

Enfoque : La tarea se puede resolver usando observaciones. Se puede observar que la respuesta será A , solo cuando N es 1 , para el resto de los N valores la respuesta será B . Es porque, después de la primera operación, ambos números serán iguales a B
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 resultant value of A
int find(int A, int B, int N)
{
    if (N == 1)
        return A & B;
    else
        return B;
}
 
// Driver Code
int main()
{
    cout << find(4, 5, 1000);
    return 0;
}

// JAVA program for the above approach
import java.util.*;
class GFG
{
   
  // Function to find the resultant value of A
  public static int find(int A, int B, int N)
  {
    if (N == 1)
      return A & B;
    else
      return B;
  }
 
  // Driver Code
  public static void main(String[] args)
  {
    System.out.print(find(4, 5, 1000));
  }
}
 
// This code is contributed by Taranpreet

# Python code for the above approach
 
# Function to find the resultant value of A
def find(A, B, N):
    if (N == 1):
        return A & B;
    else:
        return B;
 
# Driver Code
print(find(4, 5, 1000));
 
# This code is contributed by Saurabh Jaiswal

// C# program for the above approach
using System;
class GFG
{
   
  // Function to find the resultant value of A
  static int find(int A, int B, int N)
  {
    if (N == 1)
      return A & B;
    else
      return B;
  }
 
  // Driver Code
  public static void Main()
  {
    Console.Write(find(4, 5, 1000));
  }
}
 
// This code is contributed by Samim Hossain Mondal.

<script>
        // JavaScript code for the above approach
 
        // Function to find the resultant value of A
        function find(A, B, N) {
            if (N == 1)
                return A & B;
            else
                return B;
        }
 
        // Driver Code
        document.write(find(4, 5, 1000));
 
       // This code is contributed by Potta Lokesh
    </script>

5

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