# AND xor OR

### Problem Statement :

```Given an array  of  distinct elements. Let  and  be the smallest and the next smallest element in the interval  where .

.

where , are the bitwise operators ,  and  respectively.

Input Format

First line contains integer N.
Second line contains N integers, representing elements of the array A[] .

Output Format

Print the value of maximum possible value of Si.```

### Solution :

```                            ```Solution in C :

In C ++ :

#include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
#include <stack>
using namespace std;

int main() {

int n;
cin>>n;

int * arr;

arr =  new int[n];

for(int i=0;i<n;i++)cin>>arr[i];

stack<int> S;

int m = 0;

for(int i=0;i<n;i++)
{
while(true)
{
if(S.empty())
{
S.push(arr[i]);
break;
}

else if(S.top() < arr[i] )
{
m = max(m, S.top()^arr[i]);
S.push(arr[i]);
break;
}
else
{
S.pop();
}
}
}

stack<int> S2;

for(int i=n-1;i>=0;i--)
{
while(true)
{
if(S.empty())
{
S.push(arr[i]);
break;
}

else if(S.top() < arr[i] )
{
m = max(m, S.top()^arr[i]);
S.push(arr[i]);
break;
}
else
{
S.pop();
}
}
}

cout<<m<<endl;
return 0;
}

In Java :

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Solution {

public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int[] arr = new int[n];
for(int i = 0; i < n; i++){
arr[i] = in.nextInt();
}

Stack<Integer> stack = new Stack<Integer>();
int result = 0;
for(int i = 0; i < n; i++){
while(true){
if(stack.isEmpty()){
break;
} else if(stack.peek() < arr[i]){
result = Math.max(result, stack.peek() ^ arr[i]);
break;
} else{
stack.pop();
}
}
}
stack = new Stack<Integer>();

for(int i = n - 1; i >= 0; i--){
while(true){
if(stack.isEmpty()){
break;
} else if(stack.peek() < arr[i]){
result = Math.max(result, stack.peek() ^ arr[i]);
break;
} else{
stack.pop();
}
}
}

System.out.println(result);
}
}

In C :

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>

long long int sol(int A, int B)
{
return (((A & B) ^ (A | B)) & (A ^ B));
}

long long int inter(long long int arr[], int n)
{
int i,j;
long long int min1 = 9999999999, min2 = 9999999999, max = -1;
for(i=0;i<n-1;i++)
{
if(sol(arr[i], arr[i+1]) > max)
max = sol(arr[i], arr[i+1]);
if(i+2 <= n-1)
if(arr[i+1] > arr[i] && arr[i+1] > arr[i+2] && sol(arr[i], arr[i+2]) > max)
max = sol(arr[i], arr[i+2]);

}
return max;

}

int main()
{
int n,i;
scanf("%d", &n);
long long int arr[n];
for(i=0;i<n;i++)
{
scanf("%lli", &arr[i]);
}
printf("%lli", inter(arr, n));
return 0;
}

In  Python3 :

n_elements = int(input())
data = list(map(int, input().split()))
assert len(data) == n_elements

res = 0
minima = [data]
for i in range(1, n_elements):
d = data[i]
while len(minima):
x = minima.pop()
res = max(d ^ x, res)
if x < d:
minima.append(x)
break
minima.append(d)
print(res)```
```

## View More Similar Problems

Given a pointer to the head of a linked list, insert a new node before the head. The next value in the new node should point to head and the data value should be replaced with a given value. Return a reference to the new head of the list. The head pointer given may be null meaning that the initial list is empty. Function Description: Complete the function insertNodeAtHead in the editor below

## Insert a node at a specific position in a linked list

Given the pointer to the head node of a linked list and an integer to insert at a certain position, create a new node with the given integer as its data attribute, insert this node at the desired position and return the head node. A position of 0 indicates head, a position of 1 indicates one node away from the head and so on. The head pointer given may be null meaning that the initial list is e

## Delete a Node

Delete the node at a given position in a linked list and return a reference to the head node. The head is at position 0. The list may be empty after you delete the node. In that case, return a null value. Example: list=0->1->2->3 position=2 After removing the node at position 2, list'= 0->1->-3. Function Description: Complete the deleteNode function in the editor below. deleteNo

## Print in Reverse

Given a pointer to the head of a singly-linked list, print each data value from the reversed list. If the given list is empty, do not print anything. Example head* refers to the linked list with data values 1->2->3->Null Print the following: 3 2 1 Function Description: Complete the reversePrint function in the editor below. reversePrint has the following parameters: Sing