Reduce operations to make String palindrome by incrementing prefix by 1

    0
    68


    View Dialogue

    Enhance Article

    Save Article

    Like Article

    View Dialogue

    Enhance Article

    Save Article

    Like Article

    Given a string S of numbers of size N, the duty is to seek out the minimal variety of operations required to vary a string into palindrome and we will carry out the next process on the string :

    • Select an index i (0 ≤ i < N) and for all 0 ≤ j ≤ i, set Sj = Sj + 1 (i.e. add 1 to each factor within the prefix of size i).

    Observe: Whether it is not possible to transform S to a palindrome, print −1.

    Examples:

    Enter: S = “1234”
    Output: 3
    
Clarification: We will carry out the next operations:
    Choose i=1, “1234”→”2234″
    Choose i=2, “2234”→”3334″
    Choose i=1, “3334”→”4334″ 
    Therefore 3 variety of operations required to vary a string into palindrome.

    Enter:  S = “2442”
    
Output: 0
    Clarification: The string is already a palindrome.

    Strategy: The issue will be solved primarily based on the next commentary: 

    Initially examine if the string is already a palindrome or not. If it’s not a palindrome, then it may be transformed right into a palindrome provided that all the weather in the appropriate half of the string is larger than those within the left half and the distinction between the characters nearer to finish is larger or equal to the distinction between those nearer to the centre.

    Comply with the steps talked about beneath to implement the concept:

    • First set i = 0, j = N -1 and max = IntegerMaximumValue and ans = 0.
    • After that iterate a loop till j > i 
      • Test if S[j] < S[i], whether it is true then we will’t change the string into palindrome and return -1.
      • In any other case, take absolutely the distinction of S[j] and S[i] and evaluate it with ans to seek out the utmost between them:
        • If the utmost worth is lower than absolutely the distinction of S[j] and S[i], return -1.
        • In any other case, max is absolutely the distinction between S[j] and S[i]
    • Return ans which is the minimal variety of operations required to vary a string right into a palindrome.

    Beneath is the implementation of the above method.

    Java

      

    import java.io.*;

    import java.util.*;

      

    class GFG {

      

        

        

        public static int minOperation(String str, int n)

        {

            int j = n - 1;

            int i = 0;

            int max = Integer.MAX_VALUE;

            int ans = 0;

            whereas (j > i) {

                if (str.charAt(j) < str.charAt(i)) {

                    return -1;

                }

                int okay = Math.abs(str.charAt(j) - str.charAt(i));

                ans = Math.max(ans, okay);

                if (max < okay) {

                    return -1;

                }

                max = okay;

                i++;

                j--;

            }

            return ans;

        }

      

        

        public static void predominant(String[] args)

        {

            String S = "1234";

            int N = S.size();

      

            

            System.out.println(minOperation(S, N));

        }

    }

    Time Complexity: O(N) 
    Auxiliary Area: O(1)

    LEAVE A REPLY

    Please enter your comment!
    Please enter your name here