Encode given string by replacing substrings with prefix same as itself with *

Given string str of size N containing only lowercase English letters. The task is to encrypt the string such that the substrings having same prefix as itself are replaced by a *. Generate the encrypted string.

Note: If the string can be encrypted in multiple ways, find the smallest encrypted string. 

Examples:

Input: str = “ababcababcd”
Output: ab*c*d
Explanation: The substring “ababc” starting from 5th index (0 based indexing) can be replaced by a ‘*’. So the string becomes “ababcababcd” ->  “ababc*d”. Now the substring “ab” starting from 2nd index can again be replaced with a ‘*’. So the string becomes “ab*c*d”

Input: str = “zzzzzzz”
Output: z*z*z
Explanation: The string can be encrypted  in 2 ways: “z*z*z” and “z**zzz”. Out of  the two “z*z*z” is smaller in length.

Approach: A simple solution to generate smallest encrypted string is to find the longest non-overlapping repeated substring and encrypt that substring first. To implement this use the following steps:

• Create a stack to store the encrypted string.
• Declare two pointers (i & j) to point to the 1st index and middle index respectively.
• Now start traversing the string and repeat the loop until the entire string is scanned. Follow steps mentioned below for each iteration:
  • Compare both the substring from index i and j.
  • If both substrings are equal, then repeat the same process on this substring and store the remaining string into stack.
  • Else decrement the value of 2nd pointer ( j ) by 1.
• Now pop all the elements from the stack and append a symbol “*” then store it in a output string.
• Return the encrypted string.

Below is the implementation of the above approach.

C++

// C++ code to implement the above approach
#include <bits/stdc++.h>
using namespace std;

// Function to generate the encrypted string
string compress(string str)
{
    // Stack to store encrypted string
    stack<string> st;

    // Variable to store length of string
    int N = str.length();

    // Variable to point 1st and middle index
    int i = 0, j = N / 2;

    // Repeat the loop until
    // the entire string is checked
    while (j > 0) {
        int mid = j;

        // Compare the substring
        // from index 0 to mid-1
        // with the rest of the substring
        // after mid.
        for (i = 0; i < mid && str[i] == str[j]; i++, j++)
            ;

        // If both substrings are equal
        // then repeat the same process
        // on this substring and store
        // the remaining string into stack
        if (i == mid) {
            st.push(str.substr(j, N - 1));

            // Update the value of
            // string 'str' with the
            // longest repeating substring
            str = str.substr(0, i);

            // Set the new string length to n
            N = mid;

            // Initialize the 2nd pointer
            // from the mid of new string
            j = N / 2;
        }

        // If both substrings are not equal
        // then decrement the 2nd pointer by 1
        else {
            j = mid - 1;
        }
    }

    // Pop all the elements from the stack
    // append a symbol '*' and store
    // in a output string
    while (!st.empty()) {
        str = str + "*" + st.top();
        st.pop();
    }

    return str;
}

// Driver code
int main()
{
    // Declare and initialize the string
    string str = "zzzzzzz";

    cout << compress(str) << "\n";
    return 0;
}

Java

// Java code to implement the above approach

import java.util.*;

class GFG{

// Function to generate the encrypted String
static String compress(String str)
{
    // Stack to store encrypted String
    Stack<String> st = new Stack<String>();

    // Variable to store length of String
    int N = str.length();

    // Variable to point 1st and middle index
    int i = 0, j = N / 2;

    // Repeat the loop until
    // the entire String is checked
    while (j > 0) {
        int mid = j;

        // Compare the subString
        // from index 0 to mid-1
        // with the rest of the subString
        // after mid.
        for (i = 0; i < mid && str.charAt(i) == str.charAt(j); i++, j++)
            ;

        // If both subStrings are equal
        // then repeat the same process
        // on this subString and store
        // the remaining String into stack
        if (i == mid) {
            st.add(str.substring(j,  N));

            // Update the value of
            // String 'str' with the
            // longest repeating subString
            str = str.substring(0, i);

            // Set the new String length to n
            N = mid;

            // Initialize the 2nd pointer
            // from the mid of new String
            j = N / 2;
        }

        // If both subStrings are not equal
        // then decrement the 2nd pointer by 1
        else {
            j = mid - 1;
        }
    }

    // Pop all the elements from the stack
    // append a symbol '*' and store
    // in a output String
    while (!st.isEmpty()) {
        str = str + "*" + st.peek();
        st.pop();
    }

    return str;
}

// Driver code
public static void main(String[] args)
{
    // Declare and initialize the String
    String str = "zzzzzzz";

    System.out.print(compress(str)+ "\n");
}
}

// This code is contributed by 29AjayKumar

Python3

# Python code for the above approach

# Function to generate the encrypted string
def compress(str):

    # Stack to store encrypted string
    st = []

    # Variable to store length of string
    N = len(str)

    # Variable to point 1st and middle index
    i = 0
    j = (int)(N / 2)

    # Repeat the loop until
    # the entire string is checked
    while (j > 0):
        mid = j

        # Compare the substring
        # from index 0 to mid-1
        # with the rest of the substring
        # after mid.
        i=0
        while(str[i] == str[j] and i < mid):
            i += 1
            j += 1
        # If both substrings are equal
        # then repeat the same process
        # on this substring and store
        # the remaining string into stack
        if (i == mid):
            st.append(str[j:N])

            # Update the value of
            # string 'str' with the
            # longest repeating substring
            str = str[0:i]

            # Set the new string length to n
            N = mid

            # Initialize the 2nd pointer
            # from the mid of new string
            j = N // 2

        # If both substrings are not equal
        # then decrement the 2nd pointer by 1
        else:
            j = mid - 1

    # Pop all the elements from the stack
    # append a symbol '*' and store
    # in a output string
    while (len(st) != 0):
        str = str + '*' + st[len(st) - 1]
        st.pop()
    return str

# Driver code

# Declare and initialize the string
str = "zzzzzzz"
print(compress(str))

# This code is contributed by Saurabh jaiswal

C#

// C# code to implement the above approach
using System;
using System.Collections.Generic;

public class GFG{

// Function to generate the encrypted String
static String compress(String str)
{
    // Stack to store encrypted String
    Stack<String> st = new Stack<String>();

    // Variable to store length of String
    int N = str.Length;

    // Variable to point 1st and middle index
    int i = 0, j = N / 2;

    // Repeat the loop until
    // the entire String is checked
    while (j > 0) {
        int mid = j;

        // Compare the subString
        // from index 0 to mid-1
        // with the rest of the subString
        // after mid.
        for (i = 0; i < mid && str[i] == str[j]; i++, j++)
            ;

        // If both subStrings are equal
        // then repeat the same process
        // on this subString and store
        // the remaining String into stack
        if (i == mid) {
            st.Push(str.Substring(j,  N-j));

            // Update the value of
            // String 'str' with the
            // longest repeating subString
            str = str.Substring(0, i);

            // Set the new String length to n
            N = mid;

            // Initialize the 2nd pointer
            // from the mid of new String
            j = N / 2;
        }

        // If both subStrings are not equal
        // then decrement the 2nd pointer by 1
        else {
            j = mid - 1;
        }
    }

    // Pop all the elements from the stack
    // append a symbol '*' and store
    // in a output String
    while (st.Count!=0) {
        str = str + "*" + st.Peek();
        st.Pop();
    }

    return str;
}

// Driver code
public static void Main(String[] args)
{
    // Declare and initialize the String
    String str = "zzzzzzz";

    Console.Write(compress(str)+ "\n");
}
}

// This code is contributed by shikhasingrajput

Javascript

<script>
  // JavaScript code for the above approach

  // Function to generate the encrypted string
  function compress(str)
  {

    // Stack to store encrypted string
    let st = [];

    // Variable to store length of string
    let N = str.length;

    // Variable to point 1st and middle index
    let i = 0, j = Math.floor(N / 2);

    // Repeat the loop until
    // the entire string is checked
    while (j > 0) {
      let mid = j;

      // Compare the substring
      // from index 0 to mid-1
      // with the rest of the substring
      // after mid.
      for (i = 0; i < mid && str[i] == str[j]; i++, j++)
        ;

      // If both substrings are equal
      // then repeat the same process
      // on this substring and store
      // the remaining string into stack
      if (i == mid) {
        st.push(str.slice(j, N));

        // Update the value of
        // string 'str' with the
        // longest repeating substring
        str = str.slice(0, i);

        // Set the new string length to n
        N = mid;

        // Initialize the 2nd pointer
        // from the mid of new string
        j = Math.floor(N / 2);
      }

      // If both substrings are not equal
      // then decrement the 2nd pointer by 1
      else {
        j = mid - 1;
      }
    }

    // Pop all the elements from the stack
    // append a symbol '*' and store
    // in a output string
    while (st.length != 0) {
      str = str + '*' + st[st.length - 1];
      st.pop();
    }

    return str;
  }

  // Driver code

  // Declare and initialize the string
  let str = "zzzzzzz";

  document.write(compress(str) + '<br>');

// This code is contributed by Potta Lokesh
</script>

Output

z*z*z

Time Complexity: O(N. Log(N))
Auxiliary Space: O(N)