Handling and Manipulating Strings in C#

Introduction

Hello there! Today, we’re going to delve into handling and manipulating strings in C#, a skill that is invaluable in many areas of programming. Specifically, we'll learn how to identify consecutive groups of equal characters in a string. Are you curious to know more and enhance your skills? Then let's get started!

Task Statement

In this lesson, our goal is to write a C# function that accepts a string as input and identifies all consecutive groups of identical characters within it. A group can be defined as a segment of the text where the same character is repeated consecutively. Your function should return a list of tuples. Each tuple will consist of the repeating character and the length of its repetition. For instance, if the input string is "aaabbcccaae", your function should output: [('a', 3), ('b', 2), ('c', 3), ('a', 2), ('e', 1)] . It's important to note that while processing the input string, we are interested only in alphanumeric characters (i.e., alphabets and digits), whether they are upper or lower case. Any other characters present won’t factor into the formation of these groups. Are you ready to unravel how to accomplish this task? Let's dive in!

Solution Building, Step 1: Initialization

As is always the case when attempting to solve a problem, it's a good idea to take preliminary steps to establish our scope. First, we will initialize an empty list groups to store our results. We will also declare two variables, currentGroupChar and currentGroupLength, which will help us keep track of the current group's character and the length of its consecutive sequence. Additionally, we will set up a foreach loop to iterate over each character in the string and an if condition within the loop to process only alphanumeric characters. These sections will be implemented in detail in the upcoming steps. C# using System; using System.Collections.Generic; public class Solution {public static List<(char, int)> GetConsecutiveGroups(string s) {List<(char, int)> groups = new List<(char, int)>(); char? currentGroupChar = null; int currentGroupLength = 0; // Identify the Groups in foreach loop foreach(char ch in s) {// Additional logic will be added in the next steps} // Last check if (currentGroupChar != null) {// Additional logic to be implemented} return groups;}}

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Step 2: Identify the Groups

During our loop, if a character is the same as currentGroupChar, it means that the group is continued, and we merely increment currentGroupLength. However, if the character is different from currentGroupChar, it signifies the start of a new group.

At the start of a new group, we append the tuple (currentGroupChar, currentGroupLength) to groups, and then update currentGroupChar and currentGroupLength with the new character and 1, respectively.

using System;
using System.Collections.Generic;

public class Solution
{
    public static List<(char, int)> GetConsecutiveGroups(string s)
    {
        List<(char, int)> groups = new List<(char, int)>();
        char? currentGroupChar = null;
        int currentGroupLength = 0;

        foreach (char ch in s)
        {
            if (char.IsLetterOrDigit(ch))
            {
                if (ch == currentGroupChar)
                {
                    currentGroupLength++;
                }
                else
                {
                    if (currentGroupChar != null)
                    {
                        groups.Add((currentGroupChar.Value, currentGroupLength));
                    }

                    currentGroupChar = ch;
                    currentGroupLength = 1;
                }
            }
        }
    }
}

using System;
using System.Collections.Generic;

public class Solution
{
    public static List<(char, int)> GetConsecutiveGroups(string s)
    {
        List<(char, int)> groups = new List<(char, int)>();
        char? currentGroupChar = null;
        int currentGroupLength = 0;

        foreach (char ch in s)
        {
            if (char.IsLetterOrDigit(ch))
            {
                if (ch == currentGroupChar)
                {
                    currentGroupLength++;
                }
                else
                {
                    if (currentGroupChar != null)
                    {
                        groups.Add((currentGroupChar.Value, currentGroupLength));
                    }

                    currentGroupChar = ch;
                    currentGroupLength = 1;
                }
            }
        }
    }
}

Step 3: Wrap Up

After ending the loop, we need to be aware of the potential for a leftover group that has not yet been added to groups. This can happen because we only add a group to groups when we identify a new group. To ensure we don't miss any groups, we make a final check on currentGroup and, if necessary, add it to groups.

using System;
using System.Collections.Generic;

public class Solution
{
    public static List<(char, int)> GetConsecutiveGroups(string s)
    {
        List<(char, int)> groups = new List<(char, int)>();
        char? currentGroupChar = null;
        int currentGroupLength = 0;

        foreach (char ch in s)
        {
            if (char.IsLetterOrDigit(ch))
            {
                if (ch == currentGroupChar)
                {
                    currentGroupLength++;
                }
                else
                {
                    if (currentGroupChar != null)
                    {
                        groups.Add((currentGroupChar.Value, currentGroupLength));
                    }

                    currentGroupChar = ch;
                    currentGroupLength = 1;
                }
            }
        }

        if (currentGroupChar != null)
        {
            groups.Add((currentGroupChar.Value, currentGroupLength));
        }

        return groups;
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        string input = "aaabbcccaae";
        List<(char, int)> result = Solution.GetConsecutiveGroups(input);
        
        foreach (var group in result)
        {
            Console.WriteLine($"Character: {group.Item1}, Count: {group.Item2}");
        }
    }
}

using System;
using System.Collections.Generic;

public class Solution
{
    public static List<(char, int)> GetConsecutiveGroups(string s)
    {
        List<(char, int)> groups = new List<(char, int)>();
        char? currentGroupChar = null;
        int currentGroupLength = 0;

        foreach (char ch in s)
        {
            if (char.IsLetterOrDigit(ch))
            {
                if (ch == currentGroupChar)
                {
                    currentGroupLength++;
                }
                else
                {
                    if (currentGroupChar != null)
                    {
                        groups.Add((currentGroupChar.Value, currentGroupLength));
                    }

                    currentGroupChar = ch;
                    currentGroupLength = 1;
                }
            }
        }

        if (currentGroupChar != null)
        {
            groups.Add((currentGroupChar.Value, currentGroupLength));
        }

        return groups;
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        string input = "aaabbcccaae";
        List<(char, int)> result = Solution.GetConsecutiveGroups(input);
        
        foreach (var group in result)
        {
            Console.WriteLine($"Character: {group.Item1}, Count: {group.Item2}");
        }
    }
}

When run with the input "aaabbcccaae", the expected output will be:

Character: a, Count: 3
Character: b, Count: 2
Character: c, Count: 3
Character: a, Count: 2
Character: e, Count: 1

Character: a, Count: 3
Character: b, Count: 2
Character: c, Count: 3
Character: a, Count: 2
Character: e, Count: 1