📜  对排序数组的替代XOR操作

📅  最后修改于: 2021-04-30 03:20:38             🧑  作者: Mango

给定一个数组arr []和两个整数XK。该任务是对数组K执行以下操作:

  1. 对数组进行排序。
  2. 将排序数组的每个备用元素与X异或,即arr [0],arr [2],arr [4],…

将上述步骤重复K次后,打印修改后的数组中的最大和最小元素。

例子:

方法:可以维护频率数组,而不是在每次迭代中对数组进行排序,该频率数组将存储数组中每个元素的频率。从1遍历到数组中的最大元素,可以按排序的顺序处理元素,并且在每次操作后,当备用元素与给定的整数进行异或时,可以调整相同元素的频率。检查编程实现以获取更多详细信息。

下面是上述方法的实现:

C++
// C++ implementation of the approach
#include 
using namespace std;
  
#define MAX 100000
  
// Function to find the maximum and the
// minimum elements from the array after
// performing the given operation k times
void xorOnSortedArray(int arr[], int n, int k, int x)
{
  
    // To store the current sequence of elements
    int arr1[MAX + 1] = { 0 };
  
    // To store the next sequence of elements
    // after xoring with current elements
    int arr2[MAX + 1] = { 0 };
    int xor_val[MAX + 1];
  
    // Store the frequency of elements of arr[] in arr1[]
    for (int i = 0; i < n; i++)
        arr1[arr[i]]++;
  
    // Storing all precomputed XOR values so that
    // we don't have to do it again and again
    // as XOR is a costly operation
    for (int i = 0; i <= MAX; i++)
        xor_val[i] = i ^ x;
  
    // Perform the operations k times
    while (k--) {
  
        // The value of count decide on how many elements
        // we have to apply XOR operation
        int count = 0;
        for (int i = 0; i <= MAX; i++) {
            int store = arr1[i];
  
            // If current element is present in
            // the array to be modified
            if (arr1[i] > 0) {
  
                // Suppose i = m and arr1[i] = num, it means
                // 'm' appears 'num' times
                // If the count is even we have to perform
                // XOR operation on alternate 'm' starting
                // from the 0th index because count is even
                // and we have to perform XOR operations
                // starting with initial 'm'
                // Hence there will be ceil(num/2) operations on
                // 'm' that will change 'm' to xor_val[m] i.e. m^x
                if (count % 2 == 0) {
                    int div = ceil((float)arr1[i] / 2);
  
                    // Decrease the frequency of 'm' from arr1[]
                    arr1[i] = arr1[i] - div;
  
                    // Increase the frequency of 'm^x' in arr2[]
                    arr2[xor_val[i]] += div;
                }
  
                // If the count is odd we have to perform
                // XOR operation on alternate 'm' starting
                // from the 1st index because count is odd
                // and we have to leave the 0th 'm'
                // Hence there will be (num/2) XOR operations on
                // 'm' that will change 'm' to xor_val[m] i.e. m^x
                else if (count % 2 != 0) {
                    int div = arr1[i] / 2;
                    arr1[i] = arr1[i] - div;
                    arr2[xor_val[i]] += div;
                }
            }
  
            // Updating the count by frequency of
            // the current elements as we have
            // processed that many elements
            count = count + store;
        }
  
        // Updating arr1[] which will now store the
        // next sequence of elements
        // At this time, arr1[] stores the remaining
        // 'm' on which XOR was not performed and
        // arr2[] stores the frequency of 'm^x' i.e.
        // those 'm' on which operation was performed
        // Updating arr1[] with frequency of remaining
        // 'm' & frequency of 'm^x' from arr2[]
        // With help of arr2[], we prevent sorting of
        // the array again and again
        for (int i = 0; i <= MAX; i++) {
            arr1[i] = arr1[i] + arr2[i];
  
            // Resetting arr2[] for next iteration
            arr2[i] = 0;
        }
    }
  
    // Finding the maximum and the minimum element
    // from the modified array after the operations
    int min = INT_MAX;
    int max = INT_MIN;
    for (int i = 0; i <= MAX; i++) {
        if (arr1[i] > 0) {
            if (min > i)
                min = i;
            if (max < i)
                max = i;
        }
    }
  
    // Printing the max and the min element
    cout << min << " " << max << endl;
}
  
// Driver code
int main()
{
    int arr[] = { 605, 986 };
    int n = sizeof(arr) / sizeof(arr[0]);
    int k = 548, x = 569;
  
    xorOnSortedArray(arr, n, k, x);
  
    return 0;
}


Java
// Java implementation of the approach 
class GFG
{
    static int MAX = 100000;
  
    // Function to find the maximum and the
    // minimum elements from the array after
    // performing the given operation k times
    public static void xorOnSortedArray(int[] arr, int n, 
                                        int k, int x) 
    {
  
        // To store the current sequence of elements
        int[] arr1 = new int[MAX + 1];
  
        // To store the next sequence of elements
        // after xoring with current elements
        int[] arr2 = new int[MAX + 1];
        int[] xor_val = new int[MAX + 1];
  
        // Store the frequency of elements
        // of arr[] in arr1[]
        for (int i = 0; i < n; i++)
            arr1[arr[i]]++;
  
        // Storing all precomputed XOR values so that
        // we don't have to do it again and again
        // as XOR is a costly operation
        for (int i = 0; i <= MAX; i++)
            xor_val[i] = i ^ x;
  
        // Perform the operations k times
        while (k-- > 0) 
        {
  
            // The value of count decide on how many elements
            // we have to apply XOR operation
            int count = 0;
            for (int i = 0; i <= MAX; i++)
            {
                int store = arr1[i];
  
                // If current element is present in
                // the array to be modified
                if (arr1[i] > 0) 
                {
  
                    // Suppose i = m and arr1[i] = num, it means
                    // 'm' appears 'num' times
                    // If the count is even we have to perform
                    // XOR operation on alternate 'm' starting
                    // from the 0th index because count is even
                    // and we have to perform XOR operations
                    // starting with initial 'm'
                    // Hence there will be ceil(num/2) operations on
                    // 'm' that will change 'm' to xor_val[m] i.e. m^x
                    if (count % 2 == 0) 
                    {
                        int div = (int) Math.ceil(arr1[i] / 2);
  
                        // Decrease the frequency of 'm' from arr1[]
                        arr1[i] = arr1[i] - div;
  
                        // Increase the frequency of 'm^x' in arr2[]
                        arr2[xor_val[i]] += div;
                    }
  
                    // If the count is odd we have to perform
                    // XOR operation on alternate 'm' starting
                    // from the 1st index because count is odd
                    // and we have to leave the 0th 'm'
                    // Hence there will be (num/2) XOR operations on
                    // 'm' that will change 'm' to xor_val[m] i.e. m^x
                    else if (count % 2 != 0) 
                    {
                        int div = arr1[i] / 2;
                        arr1[i] = arr1[i] - div;
                        arr2[xor_val[i]] += div;
                    }
                }
  
                // Updating the count by frequency of
                // the current elements as we have
                // processed that many elements
                count = count + store;
            }
  
            // Updating arr1[] which will now store the
            // next sequence of elements
            // At this time, arr1[] stores the remaining
            // 'm' on which XOR was not performed and
            // arr2[] stores the frequency of 'm^x' i.e.
            // those 'm' on which operation was performed
            // Updating arr1[] with frequency of remaining
            // 'm' & frequency of 'm^x' from arr2[]
            // With help of arr2[], we prevent sorting of
            // the array again and again
            for (int i = 0; i <= MAX; i++)
            {
                arr1[i] = arr1[i] + arr2[i];
  
                // Resetting arr2[] for next iteration
                arr2[i] = 0;
            }
        }
  
        // Finding the maximum and the minimum element
        // from the modified array after the operations
        int min = Integer.MAX_VALUE;
        int max = Integer.MIN_VALUE;
        for (int i = 0; i <= MAX; i++)
        {
            if (arr1[i] > 0) 
            {
                if (min > i)
                    min = i;
                if (max < i)
                    max = i;
            }
        }
  
        // Printing the max and the min element
        System.out.println(min + " " + max);
    }
  
    // Driver code
    public static void main(String[] args) 
    {
        int[] arr = { 605, 986 };
        int n = arr.length;
        int k = 548, x = 569;
        xorOnSortedArray(arr, n, k, x);
  
    }
}
  
// This code is contributed by
// sanjeev2552


Python 3
# Python 3 implementation of the approach
MAX = 10000
import sys
from math import ceil, floor
  
# Function to find the maximum and the
# minimum elements from the array after
# performing the given operation k times
def xorOnSortedArray(arr, n, k, x):
      
    # To store the current sequence of elements
    arr1 = [0 for i in range(MAX + 1)]
  
    # To store the next sequence of elements
    # after xoring with current elements
    arr2 = [0 for i in range(MAX + 1)]
    xor_val = [0 for i in range(MAX + 1)]
  
    # Store the frequency of elements 
    # of arr[] in arr1[]
    for i in range(n):
        arr1[arr[i]] += 1
  
    # Storing all precomputed XOR values 
    # so that we don't have to do it 
    # again and again as XOR is a costly operation
    for i in range(MAX + 1):
        xor_val[i] = i ^ x
  
    # Perform the operations k times
    while (k > 0):
        k -= 1
          
        # The value of count decide on
        # how many elements we have to 
        # apply XOR operation
        count = 0
        for i in range(MAX + 1):
            store = arr1[i]
  
            # If current element is present in
            # the array to be modified
            if (arr1[i] > 0):
                  
                # Suppose i = m and arr1[i] = num, 
                # it means 'm' appears 'num' times
                # If the count is even we have to 
                # perform XOR operation on alternate 
                # 'm' starting from the 0th index because 
                # count is even and we have to perform
                # XOR operations starting with initial 'm'
                # Hence there will be ceil(num/2) 
                # operations on 'm' that will change 
                # 'm' to xor_val[m] i.e. m^x
                if (count % 2 == 0):
                    div = arr1[i] // 2 + 1
  
                    # Decrease the frequency of 
                    # 'm' from arr1[]
                    arr1[i] = arr1[i] - div
  
                    # Increase the frequency of
                    # 'm^x' in arr2[]
                    arr2[xor_val[i]] += div
  
                # If the count is odd we have to perform
                # XOR operation on alternate 'm' starting
                # from the 1st index because count is odd
                # and we have to leave the 0th 'm'
                # Hence there will be (num/2) XOR operations on
                # 'm' that will change 'm' to xor_val[m] i.e. m^x
                elif (count % 2 != 0):
                    div = arr1[i] // 2
                    arr1[i] = arr1[i] - div
                    arr2[xor_val[i]] += div
  
            # Updating the count by frequency of
            # the current elements as we have
            # processed that many elements
            count = count + store
  
        # Updating arr1[] which will now store the
        # next sequence of elements
        # At this time, arr1[] stores the remaining
        # 'm' on which XOR was not performed and
        # arr2[] stores the frequency of 'm^x' i.e.
        # those 'm' on which operation was performed
        # Updating arr1[] with frequency of remaining
        # 'm' & frequency of 'm^x' from arr2[]
        # With help of arr2[], we prevent sorting of
        # the array again and again
        for i in range(MAX+1):
            arr1[i] = arr1[i] + arr2[i]
  
            # Resetting arr2[] for next iteration
            arr2[i] = 0
  
    # Finding the maximum and the minimum element
    # from the modified array after the operations
    mn = sys.maxsize
    mx = -sys.maxsize-1
    for i in range(MAX + 1):
        if (arr1[i] > 0):
            if (mn > i):
                mn = i
            if (mx < i):
                mx = i
  
    # Printing the max and the min element
    print(mn,mx)
  
# Driver code
if __name__ == '__main__':
    arr = [605, 986]
    n = len(arr)
    k = 548
    x = 569
  
    xorOnSortedArray(arr, n, k, x)
      
# This code is contributed by Surendra_Gangwar


C#
// C# implementation of the approach 
using System;
      
class GFG
{
    static int MAX = 100000;
  
    // Function to find the maximum and the
    // minimum elements from the array after
    // performing the given operation k times
    public static void xorOnSortedArray(int[] arr, int n, 
                                        int k, int x) 
    {
  
        // To store the current sequence of elements
        int[] arr1 = new int[MAX + 1];
  
        // To store the next sequence of elements
        // after xoring with current elements
        int[] arr2 = new int[MAX + 1];
        int[] xor_val = new int[MAX + 1];
  
        // Store the frequency of elements
        // of arr[] in arr1[]
        for (int i = 0; i < n; i++)
            arr1[arr[i]]++;
  
        // Storing all precomputed XOR values so that
        // we don't have to do it again and again
        // as XOR is a costly operation
        for (int i = 0; i <= MAX; i++)
            xor_val[i] = i ^ x;
  
        // Perform the operations k times
        while (k-- > 0) 
        {
  
            // The value of count decides on 
            // how many elements we have to
            // apply XOR operation
            int count = 0;
            for (int i = 0; i <= MAX; i++)
            {
                int store = arr1[i];
  
                // If current element is present in
                // the array to be modified
                if (arr1[i] > 0) 
                {
  
                    // Suppose i = m and arr1[i] = num, 
                    // it means 'm' appears 'num' times
                    // If the count is even we have to perform
                    // XOR operation on alternate 'm' starting
                    // from the 0th index because count is even
                    // and we have to perform XOR operations
                    // starting with initial 'm'
                    // Hence there will be ceil(num/2) operations on
                    // 'm' that will change 'm' to xor_val[m] i.e. m^x
                    if (count % 2 == 0) 
                    {
                        int div = (int) Math.Ceiling((double)(arr1[i] / 2));
  
                        // Decrease the frequency of 'm' from arr1[]
                        arr1[i] = arr1[i] - div;
  
                        // Increase the frequency of 'm^x' in arr2[]
                        arr2[xor_val[i]] += div;
                    }
  
                    // If the count is odd we have to perform
                    // XOR operation on alternate 'm' starting
                    // from the 1st index because count is odd
                    // and we have to leave the 0th 'm'
                    // Hence there will be (num/2) XOR operations on
                    // 'm' that will change 'm' to xor_val[m] i.e. m^x
                    else if (count % 2 != 0) 
                    {
                        int div = arr1[i] / 2;
                        arr1[i] = arr1[i] - div;
                        arr2[xor_val[i]] += div;
                    }
                }
  
                // Updating the count by frequency of
                // the current elements as we have
                // processed that many elements
                count = count + store;
            }
  
            // Updating arr1[] which will now store the
            // next sequence of elements
            // At this time, arr1[] stores the remaining
            // 'm' on which XOR was not performed and
            // arr2[] stores the frequency of 'm^x' i.e.
            // those 'm' on which operation was performed
            // Updating arr1[] with frequency of remaining
            // 'm' & frequency of 'm^x' from arr2[]
            // With help of arr2[], we prevent sorting of
            // the array again and again
            for (int i = 0; i <= MAX; i++)
            {
                arr1[i] = arr1[i] + arr2[i];
  
                // Resetting arr2[] for next iteration
                arr2[i] = 0;
            }
        }
  
        // Finding the maximum and the minimum element
        // from the modified array after the operations
        int min = int.MaxValue;
        int max = int.MinValue;
        for (int i = 0; i <= MAX; i++)
        {
            if (arr1[i] > 0) 
            {
                if (min > i)
                    min = i;
                if (max < i)
                    max = i;
            }
        }
  
        // Printing the max and the min element
        Console.WriteLine(min + " " + max);
    }
  
    // Driver code
    public static void Main(String[] args) 
    {
        int[] arr = { 605, 986 };
        int n = arr.Length;
        int k = 548, x = 569;
        xorOnSortedArray(arr, n, k, x);
    }
}
  
// This code is contributed by Rajput-Ji


输出:
605 986