Given two strings **X** and **Y** both consisting of **N** uppercase alphabets and an integer **K**, the task is to find the minimum count of cyclic increments of any character in the string **X** by **1** or **K** required to convert the string **X** into string **Y**.

Cyclic Increments:Incrementing character‘Z’by1orKstarts from the character‘A’.

**Examples:**

Input:X = “ABCT”, Y = “PBDI”, K = 13Output:7Explanation:

Convert the character A to P. Increments required are 13 (A to N), 1 (N to O), 1 (O to P). Therefore, the total count is 3.

Character B remains unchanged. Therefore, the total count remains 3.

Convert the character C to D. Increments required are 1 (C to D). Therefore, the total count is 4.

Convert the character T to I. Increments required is of 13 (T to G), 1 (G to H), 1 (H to I). Therefore, the total count is 7.

Input:X = “ABCD”, Y = “ABCD”, K = 6Output:0

**Approach:** Follow the below steps to solve this problem:

- Initialize a variable, say
**count**, to store the minimum increment required to convert string**X**into string**Y**. - Traverse the string
**X**and for every character in string**X**, there are three following cases:- When characters in both the strings
**X**and**Y**are the same then continue. - When characters in the string
**Y**is greater than**X**string then add the value**(Y[i] – X[i])/K**and**(Y[i] – X[i])**modulo**K**to the**count**. - When characters in string
**X**is greater than string**Y**then subtract the character**X[i]**from**90**and subtract**64**from**Y[i]**to calculate the cyclic difference and then add the**difference**modulo**K**and**difference/K**to the**count**.

- When characters in both the strings
- After completing the above steps, print
**count**as the minimum number of increments required.

Below is the implementation of the above approach:

## C++

`// CPP program for the above approach` `#include<bits/stdc++.h>` `using` `namespace` `std;` `// Function to count minimum increments` `// by 1 or K required to convert X to Y` `void` `countOperations(` ` ` `string X, string Y, ` `int` `K)` `{` ` ` `int` `count = 0;` ` ` `// Traverse the string X` ` ` `for` `(` `int` `i = 0; i < X.length(); i++) ` ` ` `{` ` ` `int` `c = 0;` ` ` `// Case 1` ` ` `if` `(X[i] == Y[i])` ` ` `continue` `;` ` ` `// Case 2` ` ` `else` `if` `(X[i] < Y[i])` ` ` `{` ` ` `// Add the difference/K to` ` ` `// the count` ` ` `if` `((Y[i] - X[i]) >= K) {` ` ` `c = (Y[i] - X[i]) / K; ` ` ` `}` ` ` `// Add the difference%K to` ` ` `// the count` ` ` `c += (Y[i] - X[i]) % K;` ` ` `}` ` ` `// Case 3` ` ` `else` `{` ` ` `int` `t = 90 - X[i];` ` ` `t += Y[i] - 65 + 1;` ` ` `// Add the difference/K to` ` ` `// the count` ` ` `if` `(t >= K)` ` ` `c = t / K;` ` ` `// Add the difference%K to` ` ` `// the count` ` ` `c += (t % K);` ` ` `}` ` ` `count += c;` ` ` `}` ` ` `// Print the answer` ` ` `cout << count << endl;` `}` `// Driver Code` `int` `main()` `{` ` ` `string X = ` `"ABCT"` `, Y = ` `"PBDI"` `;` ` ` `int` `K = 6;` ` ` `countOperations(X, Y, K);` `}` `// This code is contributed by ipg2016107.` |

## Java

`// Java program for the above approach` `import` `java.io.*;` `class` `GFG {` ` ` `// Function to count minimum increments` ` ` `// by 1 or K required to convert X to Y` ` ` `public` `static` `void` `countOperations(` ` ` `String X, String Y, ` `int` `K)` ` ` `{` ` ` `// Convert String to character array` ` ` `char` `ch1[] = X.toCharArray();` ` ` `char` `ch2[] = Y.toCharArray();` ` ` `int` `count = ` `0` `;` ` ` `// Traverse the string X` ` ` `for` `(` `int` `i = ` `0` `; i < X.length(); i++) {` ` ` `int` `c = ` `0` `;` ` ` `// Case 1` ` ` `if` `(ch1[i] == ch2[i])` ` ` `continue` `;` ` ` `// Case 2` ` ` `else` `if` `(ch1[i] < ch2[i]) {` ` ` `// Add the difference/K to` ` ` `// the count` ` ` `if` `(((` `int` `)ch2[i]` ` ` `- (` `int` `)ch1[i])` ` ` `>= K) {` ` ` `c = ((` `int` `)ch2[i]` ` ` `- (` `int` `)ch1[i])` ` ` `/ K;` ` ` `}` ` ` `// Add the difference%K to` ` ` `// the count` ` ` `c += ((` `int` `)ch2[i]` ` ` `- (` `int` `)ch1[i])` ` ` `% K;` ` ` `}` ` ` `// Case 3` ` ` `else` `{` ` ` `int` `t = ` `90` `- (` `int` `)ch1[i];` ` ` `t += (` `int` `)ch2[i] - ` `65` `+ ` `1` `;` ` ` `// Add the difference/K to` ` ` `// the count` ` ` `if` `(t >= K)` ` ` `c = t / K;` ` ` `// Add the difference%K to` ` ` `// the count` ` ` `c += (t % K);` ` ` `}` ` ` `count += c;` ` ` `}` ` ` `// Print the answer` ` ` `System.out.print(count);` ` ` `}` ` ` `// Driver Code` ` ` `public` `static` `void` `main(String[] args)` ` ` `{` ` ` `String X = ` `"ABCT"` `, Y = ` `"PBDI"` `;` ` ` `int` `K = ` `6` `;` ` ` `countOperations(X, Y, K);` ` ` `}` `}` |

## Python3

`# Python program for the above approach` `# Function to count minimum increments` `# by 1 or K required to convert X to Y` `def` `countOperations(X, Y, K):` ` ` `count ` `=` `0` ` ` ` ` `# Traverse the string X` ` ` `for` `i ` `in` `range` `(` `len` `(X)):` ` ` `c ` `=` `0` ` ` ` ` `# Case 1` ` ` `if` `(X[i] ` `=` `=` `Y[i]):` ` ` `continue` ` ` `# Case 2` ` ` `elif` `(X[i] < Y[i]):` ` ` ` ` `# Add the difference/K to` ` ` `# the count` ` ` `if` `((` `ord` `(Y[i]) ` `-` `ord` `(X[i])) >` `=` `K):` ` ` `c ` `=` `(` `ord` `(Y[i]) ` `-` `ord` `(X[i])) ` `/` `/` `K` ` ` ` ` `# Add the difference%K to` ` ` `# the count` ` ` `c ` `+` `=` `(` `ord` `(Y[i]) ` `-` `ord` `(X[i])) ` `%` `K` ` ` ` ` `# Case 3` ` ` `else` `:` ` ` `t ` `=` `90` `-` `ord` `(X[i])` ` ` `t ` `+` `=` `ord` `(Y[i]) ` `-` `65` `+` `1` ` ` ` ` `# Add the difference/K to` ` ` `# the count` ` ` `if` `(t >` `=` `K):` ` ` `c ` `=` `t ` `/` `/` `K` ` ` ` ` `# Add the difference%K to` ` ` `# the count` ` ` `c ` `+` `=` `(t ` `%` `K)` ` ` `count ` `+` `=` `c` ` ` ` ` `# Print the answer` ` ` `print` `(count)` `# Driver Code` `X ` `=` `"ABCT"` `Y ` `=` `"PBDI"` `K ` `=` `6` `countOperations(X, Y, K)` `# This code is contributed by aditya7409.` |

**Output:**

11

**Time Complexity:** O(N)**Auxiliary Space:** O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.