Skip to content
Related Articles

Related Articles

Related Articles

Save Article
Improve Article
Save Article
Like Article

Minimum replacements to make adjacent characters unequal in a ternary string

  • Last Updated : 29 Apr, 2021

Given a string of ‘0’, ‘1’ and ‘2’. The task is to find the minimum number of replacements such that the adjacent characters are not equal. 
Examples: 
 

Input: s = “201220211” 
Output: 2 
Resultant string after changes is 201210210 
Input: s = “0120102” 
Output: 0

 

Approach: The following problem can be solved using greedy method. We can greedily compare every adjacent pair. If the adjacent pairs which is character at ith and i-1th are same, then replace ith th character with a character which is not equal to the character at i-1th and i+1th index. In case of the last adjacent pair, just replace it with the character which is not equal to the character at i-1th index. 
Below is the implementation of the above approach: 
 

C++




// C++ program to count the minimal
// replacements such that adjacent characters
// are unequal
#include <bits/stdc++.h>
using namespace std;
 
// Function to count the number of
// minimal replacements
int countMinimalReplacements(string s)
{
    // Find the length of the string
    int n = s.length();
 
    int cnt = 0;
 
    // Iterate in the string
    for (int i = 1; i < n; i++) {
 
        // Check if adjacent is similar
        if (s[i] == s[i - 1]) {
            cnt += 1;
 
            // If not the last pair
            if (i != (n - 1)) {
 
                // Check for character which is
                // not same  in i+1 and i-1
                for (auto it : "012") {
                    if (it != s[i + 1] &&
                        it != s[i - 1]) {
                        s[i] = it;
                        break;
                    }
                }
            }
 
            else // Last pair
            {
                // Check for character which is
                // not same in i-1 index
                for (auto it : "012") {
                    if (it != s[i - 1]) {
                        s[i] = it;
                        break;
                    }
                }
            }
        }
    }
 
    return cnt;
}
 
// Driver Code
int main()
{
    string s = "201220211";
    cout << countMinimalReplacements(s);
    return 0;
}
Java



// Java program to count the minimal
// replacements such that adjacent
// characters are unequal
class GFG
{
 
    static final int MAX = 26;
     
    // Function to count the number of
    // minimal replacements
    static int countMinimalReplacements(char[] s)
    {
        // Find the length of the String
        int n = s.length;
 
        int cnt = 0;
 
        // Iterate in the String
        for (int i = 1; i < n; i++)
        {
 
            // Check if adjacent is similar
            if (s[i] == s[i - 1])
            {
                cnt += 1;
 
                // If not the last pair
                if (i != (n - 1))
                {
 
                    // Check for character which is
                    // not same in i+1 and i-1
                    for (char it : "012".toCharArray())
                    {
                        if (it != s[i + 1]
                                && it != s[i - 1])
                        {
                            s[i] = it;
                            break;
                        }
                    }
                }
                else // Last pair
                {
                    // Check for character which is
                    // not same in i-1 index
                    for (char it : "012".toCharArray())
                    {
                        if (it != s[i - 1])
                        {
                            s[i] = it;
                            break;
                        }
                    }
                }
            }
        }
        return cnt;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        String s = "201220211";
        System.out.println(countMinimalReplacements(s.toCharArray()));
    }
}
 
// This code is contributed by 29AjayKumar
Python3



# Python 3 program to count the minimal
# replacements such that adjacent
# characters are unequal
 
# Function to count the number of
# minimal replacements
def countMinimalReplacements(s):
     
    # Find the length of the string
    n = len(s)
 
    cnt = 0
 
    # Iterate in the string
    for i in range(1, n):
         
        # Check if adjacent is similar
        if (s[i] == s[i - 1]):
            cnt += 1;
 
            # If not the last pair
            if (i != (n - 1)):
                 
                # Check for character which is
                # not same in i+1 and i-1
                s = list(s)
                for j in "012":
                    if (j != s[i + 1] and
                        j != s[i - 1]):
                        s[i] = j
                        break
 
                s = ''.join(s)
                 
            # Last pair
            else:
                 
                # Check for character which is
                # not same in i-1 index
                s = list(s)
 
                for k in "012":
                    if (k != s[i - 1]):
                        s[i] = k
                        break
                s = ''.join(s)
         
    return cnt
 
# Driver Code
if __name__ == '__main__':
    s = "201220211"
    print(countMinimalReplacements(s))
 
# This code is contributed by
# Surendra_Gangwar
C#



// C# program to count the minimal
// replacements such that adjacent
// characters are unequal
using System;
 
class GFG
{
    static readonly int MAX = 26;
     
    // Function to count the number of
    // minimal replacements
    static int countMinimalReplacements(char[] s)
    {
        // Find the length of the String
        int n = s.Length;
 
        int cnt = 0;
 
        // Iterate in the String
        for (int i = 1; i < n; i++)
        {
 
            // Check if adjacent is similar
            if (s[i] == s[i - 1])
            {
                cnt += 1;
 
                // If not the last pair
                if (i != (n - 1))
                {
 
                    // Check for character which is
                    // not same in i+1 and i-1
                    foreach (char it in "012".ToCharArray())
                    {
                        if (it != s[i + 1] &&
                            it != s[i - 1])
                        {
                            s[i] = it;
                            break;
                        }
                    }
                }
                else // Last pair
                {
                    // Check for character which is
                    // not same in i-1 index
                    foreach (char it in "012".ToCharArray())
                    {
                        if (it != s[i - 1])
                        {
                            s[i] = it;
                            break;
                        }
                    }
                }
            }
        }
        return cnt;
    }
 
    // Driver Code
    public static void Main(String[] args)
    {
        String s = "201220211";
        Console.WriteLine(countMinimalReplacements(s.ToCharArray()));
    }
}
 
// This code is contributed by Rajput-Ji
PHP



<?php
// PHP program to count the minimal
// replacements such that adjacent
// characters are unequal
 
// Function to count the number of
// minimal replacements
function countMinimalReplacements($s)
{
    // Find the length of the string
    $n = strlen($s);
 
    $cnt = 0;
    $str = "012";
     
    // Iterate in the string
    for ($i = 1; $i < $n; $i++)
    {
 
        // Check if adjacent is similar
        if ($s[$i] == $s[$i - 1])
        {
            $cnt += 1;
 
            // If not the last pair
            if ($i != ($n - 1))
            {
 
                // Check for character which is
                // not same in i+1 and i-1
                for ($it = 0 ; $it < strlen($str); $it++)
                {
                    if ($str[$it] != $s[$i + 1] &&
                        $str[$it] != $s[$i - 1])
                    {
                        $s[$i] = $str[$it];
                        break;
                    }
                }
            }
 
            else // Last pair
            {
                // Check for character which is
                // not same in i-1 index
                for ($it = 0 ; $it< strlen($str); $it++)
                {
                    if ($str[$it] != $s[$i - 1])
                    {
                        $s[$i] = $str[$it];
                        break;
                    }
                }
            }
        }
    }
 
    return $cnt;
}
 
// Driver Code
$s = "201220211";
echo countMinimalReplacements($s);
 
// This code is contributed by Ryuga
?>
Javascript



<script>
      // JavaScript program to count the minimal
      // replacements such that adjacent
      // characters are unequal
 
      // Function to count the number of
      // minimal replacements
      function countMinimalReplacements(s) {
        // Find the length of the string
        var n = s.length;
 
        var cnt = 0;
        var str = "012";
 
        // Iterate in the string
        for (var i = 1; i < n; i++) {
          // Check if adjacent is similar
          if (s[i] === s[i - 1]) {
            cnt += 1;
 
            // If not the last pair
            if (i !== n - 1) {
              // Check for character which is
              // not same in i+1 and i-1
              for (var it = 0; it < str.length; it++) {
                if (str[it] !== s[i + 1] && str[it] !== s[i - 1]) {
                  s[i] = str[it];
                  break;
                }
              }
            } // Last pair
            else {
              // Check for character which is
              // not same in i-1 index
              for (var it = 0; it < str.length; it++) {
                if (str[it] !== s[i - 1]) {
                  s[i] = str[it];
                  break;
                }
              }
            }
          }
        }
 
        return cnt;
      }
 
      // Driver Code
      var s = "201220211";
      document.write(countMinimalReplacements(s));
    </script>
Output: 
2
 
Time Complexity : O(n)
 



My Personal Notes
arrow_drop_up
Previous
Minimum replacements in a string to make adjacent characters unequal
Next

Check if the given string of words can be formed from words present in the dictionary
Recommended Articles
Page :
Minimum replacements to make adjacent characters unequal in a ternary string | Set-2
08, Feb 19
Minimum replacements in a string to make adjacent characters unequal
22, Jul 20
Check if a string can be made palindromic by swapping pairs of characters from indices having unequal characters in a Binary String
31, Mar 21
Minimize replacements by previous or next alphabet required to make all characters of a string the same
19, Oct 20
Minimum characters to be replaced in Ternary string to remove all palindromic substrings for Q queries
19, Oct 21
Minimum number of replacements to make the binary string alternating | Set 2
05, Mar 19
Minimize replacements or swapping of same indexed characters required to make two given strings palindromic
03, Nov 20
Count of distinct permutation of a String obtained by swapping only unequal characters
30, Jul 21
Minimum replacements such that the difference between the index of the same characters is divisible by 3
24, Jan 19
Convert string X to an anagram of string Y with minimum replacements
09, Jan 18
Minimum flips or swapping of adjacent characters required to make a string equal to another
09, Jun 21
Check if two binary strings can be made equal by swapping pairs of unequal characters
20, Jan 21
Minimum string such that every adjacent character of given string is still adjacent
12, May 20
Make all characters of a string same by minimum number of increments or decrements of ASCII values of characters
10, Feb 21
Form lexicographically smallest string with minimum replacements having equal number of 0s, 1s and 2s
28, Jan 19
Convert given string to another by minimum replacements of subsequences by its smallest character
09, Sep 20
Count minimum character replacements required such that given string satisfies the given conditions
29, Oct 20
Minimum replacements required to obtain a K-periodic palindromic string
06, Nov 20
Minimum replacements such that no palindromic substring of length exceeding 1 is present in the given string
27, Jan 21
String with k distinct characters and no same characters adjacent
25, Oct 17
Rearrange the characters of the string such that no two adjacent characters are consecutive English alphabets
25, Jul 19
Rearrange characters in a sorted string such that no pair of adjacent characters are the same
23, Jul 21
Minimize swaps of pairs of characters required such that no two adjacent characters in the string are same
09, Jul 21
Permutation of a string with maximum number of characters greater than its adjacent characters
18, Jul 18
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
Striver
@Striver
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox