Encrypt the given string with the following operations

Given a string s, the task is to encrypt the string in the following way: 

1. If the frequency of current character is even, then increment current character by x.
2. If the frequency of current character is odd, then decrement current character by x.

Note: All the operations are circular that is adding 1 to ‘z’ will give ‘a’ and subtracting 1 from ‘a’ will give ‘z’

Examples:

Input :s=”abcda”, x=3 
Output :dyzad 
‘a’ appear 2 times in the string, hence incrementing ‘a’ by 3 becomes ‘d’ 
‘b’ appear 1 times in the string, hence decrementing ‘b’ by 3 becomes ‘y’ 
‘c’ appear 1 times in the string, hence decrementing ‘c’ by 3 becomes ‘z’ 
‘d’ appear 1 times in the string, hence decrementing ‘d’ by 3 becomes ‘a’ 
‘a’ appear 2 times in the string, hence incrementing ‘a’ by 3 becomes ‘d’ 
Hence the string becomes “dyzad”

Input :s=”aabbc”, x=5 
Output :ffggx 

Approach:

• Create a frequency array to store the frequency of each character.
• Traverse the given string and for every character, if its frequency is even, then increment it by x else if the frequency is odd decrement it by x.

Below is the implementation of the above approach:

C++

// C++ implementation of the above approach:
#include <bits/stdc++.h>
#define MAX 26
using namespace std;

// Function to return the encrypted string
string encryptStr(string str, int n, int x)
{

    // Reduce x because rotation of
    // length 26 is unnecessary
    x = x % MAX;

    // Calculate the frequency of characters
    int freq[MAX] = {0};

    for(int i = 0; i < n; i++)
    {
        freq[str[i] - 'a']++;
    }

    for(int i = 0; i < n; i++)
    {

        // If the frequency of current character
        // is even then increment it by x
        if (freq[str[i] - 'a'] % 2 == 0)
        {
            int pos = (str[i] - 'a' + x) % MAX;
            str[i] = (char)(pos + 'a');
        }

        // Else decrement it by x
        else
        {
            int pos = (str[i] - 'a' - x);

            if (pos < 0)
            {
                pos += MAX;
            }

            str[i] = (char)(pos + 'a');
        }
    }

    // Return the count
    return str;
}

// Driver code
int main()
{
    string s = "abcda";
    int n = s.size();
    int x = 3;

    cout << encryptStr(s, n, x) << endl;

    return 0;
}

// This code is contributed by avanitrachhadiya2155

Java

// Java implementation of the above approach:
public class GFG {

    static final int MAX = 26;

    // Function to return the encrypted string
    static String encryptStr(String str, int n, int x)
    {

        // Reduce x because rotation of
        // length 26 is unnecessary
        x = x % MAX;
        char arr[] = str.toCharArray();

        // calculate the frequency of characters
        int freq[] = new int[MAX];
        for (int i = 0; i < n; i++)
            freq[arr[i] - 'a']++;

        for (int i = 0; i < n; i++) {

            // If the frequency of current character
            // is even then increment it by x
            if (freq[arr[i] - 'a'] % 2 == 0) {
                int pos = (arr[i] - 'a' + x) % MAX;
                arr[i] = (char)(pos + 'a');
            }

            // Else decrement it by x
            else {
                int pos = (arr[i] - 'a' - x);
                if (pos < 0)
                    pos += MAX;
                arr[i] = (char)(pos + 'a');
            }
        }

        // Return the count
        return String.valueOf(arr);
    }

    // Driver code
    public static void main(String[] args)
    {
        String s = "abcda";
        int n = s.length();
        int x = 3;
        System.out.println(encryptStr(s, n, x));
    }
}

Python3

# Python3 implementation of the above approach:
MAX = 26

# Function to return the encrypted string
def encryptstrr(strr, n, x):

    # Reduce x because rotation of
    # length 26 is unnecessary
    x = x % MAX
    arr = list(strr)

    # calculate the frequency of characters
    freq = [0]*MAX
    for i in range(n):
        freq[ord(arr[i]) - ord('a')] += 1

    for i in range(n):

        # If the frequency of current character
        # is even then increment it by x
        if (freq[ord(arr[i]) - ord('a')] % 2 == 0):
            pos = (ord(arr[i]) - ord('a') + x) % MAX
            arr[i] = chr(pos + ord('a'))

        # Else decrement it by x
        else:
            pos = (ord(arr[i]) - ord('a') - x)
            if (pos < 0):
                pos += MAX
            arr[i] = chr(pos + ord('a'))

    # Return the count
    return "".join(arr)


# Driver code
s = "abcda"
n = len(s)
x = 3
print(encryptstrr(s, n, x))

# This code is contributed by
# shubhamsingh10

C#

// C# implementation of the above approach:
using System;

class GFG
{

    static int MAX = 26;

    // Function to return the encrypted string
    public static char[] encryptStr(String str,
                                    int n, int x)
    {

        // Reduce x because rotation of
        // length 26 is unnecessary
        x = x % MAX;
        char[] arr = str.ToCharArray();

        // calculate the frequency of characters
        int[] freq = new int[MAX];
        for (int i = 0; i < n; i++)
            freq[arr[i] - 'a']++;

        for (int i = 0; i < n; i++)
        {

            // If the frequency of current character
            // is even then increment it by x
            if (freq[arr[i] - 'a'] % 2 == 0)
            {
                int pos = (arr[i] - 'a' + x) % MAX;
                arr[i] = (char)(pos + 'a');
            }

            // Else decrement it by x
            else
            {
                int pos = (arr[i] - 'a' - x);
                if (pos < 0)
                    pos += MAX;
                arr[i] = (char)(pos + 'a');
            }
        }

        // Return the count
        return arr;
    }

    // Driver code
    public static void Main(String[] args)
    {
        String s = "abcda";
        int n = s.Length;
        int x = 3;
        Console.WriteLine(encryptStr(s, n, x));
    }
}

// This code is contributed by
// sanjeev2552

Javascript

<script>
// Javascript implementation of the above approach:
var MAX = 26;

// Function to return the encrypted string
function encryptStr(str, n, x)
{

    // Reduce x because rotation of
    // length 26 is unnecessary
    x = x % MAX;

    // Calculate the frequency of characters
    var freq = Array(MAX).fill(0);

    for(var i = 0; i < n; i++)
    {
        freq[str[i].charCodeAt(0) - 'a'.charCodeAt(0)]++;
    }

    for(var i = 0; i < n; i++)
    {

        // If the frequency of current character
        // is even then increment it by x
        if (freq[str[i].charCodeAt(0) - 'a'.charCodeAt(0)] % 2 == 0)
        {
            var pos = (str[i].charCodeAt(0) - 'a'.charCodeAt(0) + x) % MAX;
            str[i] = String.fromCharCode(pos + 'a'.charCodeAt(0));
        }

        // Else decrement it by x
        else
        {
            var pos = (str[i].charCodeAt(0) - 'a'.charCodeAt(0) - x);

            if (pos < 0)
            {
                pos += MAX;
            }

            str[i] = String.fromCharCode(pos + 'a'.charCodeAt(0));
        }
    }

    // Return the count
    return str.join('');
}

// Driver code
var s = "abcda";
var n = s.length;
var x = 3;

document.write( encryptStr(s.split(''), n, x));

</script>

Output:

dyzad

Time Complexity: O(N)
Auxiliary Space: O(1), no extra space is required, so it is a constant.