Reduce string to shortest length by deleting a pair of same adjacent characters

Given a string str of lowercase characters. The task is to count the number of deletions required to reduce the string to its shortest length. In each delete operation, you can select a pair of adjacent lowercase letters that match, and then delete them. The task is to print the count of deletions done. 

Examples:

Input: str = "aaabccddd"
Output: 3
Following are sequence of operations:
aaabccddd -> abccddd -> abddd -> abd

Input: str = "aa"
Output: 1

Approach:

1. Initialize count = 1 initially.
2. Iterate for every character, increase count if s[i]==s[i-1].
3. If s[i]!=s[i-1], add count/2 to the number of steps, and re-initialize count to 1.

If s[i]!=s[i-1], then the number of deletions is increased by count/2. If the count is even, number of pairs will be count/2. If count is odd, then the number of deletions will be (count-1)/2 which is the same as (int)count/2. 

Below is the implementation of the above approach:  

C++

// C++ program to count deletions
// to reduce the string to its shortest
// length by deleting a pair of
// same adjacent characters
#include <bits/stdc++.h>
using namespace std;

// Function count the operations
int reduceString(string s, int l)
{

    int count = 1, steps = 0;

    // traverse in the string
    for (int i = 1; i < l; i++) {
        // if adjacent characters are same
        if (s[i] == s[i - 1])
            count += 1;

        else {
            // if same adjacent pairs are more than 1

                steps += (count / 2);

            count = 1;
        }
    }


        steps += count / 2;
    return steps;
}

// Driver Code
int main()
{

    string s = "geeksforgeeks";

    int l = s.length();
    cout << reduceString(s, l) << endl;
    return 0;
}

Java

// Java program to count deletions
// to reduce the string to its
// shortest length by deleting a
// pair of same adjacent characters
import java.io.*;
import java.util.*;
import java.lang.*;

class GFG
{

// Function count
// the operations
static int reduceString(String s,
                        int l)
{

    int count = 1, steps = 0;

    // traverse in the string
    for (int i = 1; i < l; i++)
    {
        // if adjacent characters
        // are same
        if (s.charAt(i) == s.charAt(i - 1))
            count += 1;

        else
        {
            // if same adjacent pairs
            // are more than 1
            steps += (count / 2);

            count = 1;
        }
    }
        steps += count / 2;
    return steps;
}

// Driver Code
public static void main(String[] args)
{
    String s = "geeksforgeeks";

    int l = s.length();
    System.out.print(reduceString(s, l) + "\n");
}
}

Python3

# Python3 program to count
# deletions to reduce
# the string to its
# shortest length by
# deleting a pair of
# same adjacent characters

# Function count
# the operations
def reduceString(s, l):
    count = 1;
    steps = 0;

    # traverse in
    # the string
    for i in range(1,l):
        # if adjacent
        # characters are same
        if (s[i] is s[i - 1]):
            count += 1;

        else:
            # if same adjacent pairs
            # are more than 1
            steps +=(int)(count / 2);

            count = 1;
        steps +=(int)(count / 2);
    return steps;


# Driver Code
s = "geeksforgeeks";

l = len(s);
print(reduceString(s, l));


# This code contributed by Rajput-Ji

C#

// C# program to count deletions
// to reduce the string to its
// shortest length by deleting a
// pair of same adjacent characters
using System;

class GFG
{

// Function count
// the operations
static int reduce(string s,
                  int l)
{

    int count = 1, step = 0;

    // traverse in
    // the string
    for (int i = 1; i < l; i++)
    {
        // if adjacent characters
        // are same
        if (s[i] == s[i - 1])
            count += 1;

        else
        {
            // if same adjacent pairs
            // are more than 1
            step += (count / 2);
            count = 1;
        }
    }
        step += count / 2;
    return step;
}

// Driver Code
public static void Main()
{
    string s = "geeksforgeeks";

    int l = s.Length;
    Console.WriteLine(reduce(s, l));
}
}

// This code is contributed by
// Akanksha Rai(Abby_akku)

PHP

<?php
// PHP program to count
// deletions to reduce
// the string to its
// shortest length by
// deleting a pair of
// same adjacent characters

// Function count
// the operations
function reduceString($s, $l)
{
    $count = 1;
    $steps = 0;

    // traverse in
    // the string
    for ($i = 1; $i < $l; $i++)
    {
        // if adjacent
        // characters are same
        if ($s[$i] == $s[$i - 1])
            $count += 1;

        else
        {
            // if same adjacent pairs
            // are more than 1
            $steps +=(int)($count / 2);

            $count = 1;
        }
    }
        $steps +=(int)($count / 2);
    return $steps;
}

// Driver Code
$s = "geeksforgeeks";

$l = strlen($s);
echo reduceString($s, $l);

// This code is contributed by ajit
?>

Javascript

<script>

// Javascript program to count deletions
// to reduce the string to its
// shortest length by deleting a
// pair of same adjacent characters

// Function count
// the operations
function reduce(s, l)
{
    let count = 1, step = 0;

    // Traverse in the string
    for(let i = 1; i < l; i++)
    {

        // If adjacent characters
        // are same
        if (s[i] == s[i - 1])
            count += 1;
        else
        {

            // If same adjacent pairs
            // are more than 1
            step += parseInt(count / 2, 10);
            count = 1;
        }
    }
    step += parseInt(count / 2, 10);
    return step;
}

// Driver code
let s = "geeksforgeeks";
let l = s.length;

document.write(reduce(s, l));

// This code is contributed by mukesh07

</script>

Output:

2

Time Complexity: O(N), where N is the length of the given string.
Auxiliary Space: O(1)