Distinct state codes that appear in a string as contiguous sub-strings

Every state is represented by string of length 2. For example DL is used for Delhi, HP for Himachal Pradesh, UP for Uttar Pradesh, PB for Punjab etc. 
Given a string str consisting of uppercase English alphabets only, the task is to find the number of distinct state codes that appear in the string as contiguous sub-strings.
Examples:

Input: str = “UPBRC” 
Output: 4 
UP, PB, BR and RC are 4 different state codes that appear in string as contiguous sub-strings.
Input: str = “UPUP” 
Output: 2 
UP and PU are the only state codes that appear in the given string. 

Approach: Store every sub-string of length 2 in a set and finally return the size of the set which is the required number of distinct state codes appearing in the given string as sub-strings.
Below is the implementation of the above approach:

C++

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;

// Function to return the count of
// distinct state codes
int countDistinctCode(string str)
{
    set<string> codes;
    for (int i = 0; i < str.length() - 1; i++)

        // Insert every sub-string
        // of length 2 in the set
        codes.insert(str.substr(i, 2));

    // Return the size of the set
    return codes.size();
}

// Driver code
int main()
{
    string str = "UPUP";
    cout << countDistinctCode(str);

    return 0;
}

Java

// Java implementation of the above approach.
import java.util.*;

class GFG
{

// Function to return the count of
// distinct state codes
static int countDistinctCode(String str)
{
    Set<String> codes = new HashSet<>();
    for (int i = 0; i < str.length() - 1; i++)

        // Insert every sub-String
        // of length 2 in the set
        codes.add(str.substring(i, i + 2));

    // Return the size of the set
    return codes.size();
}

// Driver code
public static void main(String[] args)
{
    String str = "UPUP";
    System.out.println(countDistinctCode(str));
}
}

// This code has been contributed by 29AjayKumar

Python3

# Python3 implementation of the approach

# Function to return the count of
# distinct state codes
def countDistinctCode(string):

    codes = set()
    for i in range(0, len(string) - 1):

        # Insert every sub-string
        # of length 2 in the set
        codes.add(string[i:i + 2])

    # Return the size of the set
    return len(codes)

# Driver code
if __name__ == "__main__":

    string = "UPUP"
    print(countDistinctCode(string))

# This code is contributed
# by Rituraj Jain

C#

// C# implementation of the above approach.
using System;
using System.Collections.Generic;

class GFG
{

// Function to return the count of
// distinct state codes
static int countDistinctCode(String str)
{
    HashSet<String> codes = new HashSet<String>();
    for (int i = 0; i < str.Length - 1; i++)

        // Insert every sub-String
        // of length 2 in the set
        codes.Add(str.Substring(i,2));

    // Return the size of the set
    return codes.Count;
}

// Driver code
public static void Main(String []args)
{
    String str = "UPUP";
    Console.Write(countDistinctCode(str));
}
}

// This code has been contributed by Arnab Kundu

Javascript

<script>
// Javascript implementation of the
// above approach

// Function to return the count of
// distinct state codes
function countDistinctCode(str)
{
    var codes = new Set();
    for (var i = 0; i < str.length - 1; i++)

        // Insert every sub-string
        // of length 2 in the set
        codes.add(str.substr(i, 2));

    // Return the size of the set
    return codes.size;
}

// Driver code
var str = "UPUP";
document.write(countDistinctCode(str))

// This code is contributed by ShubhamSingh10
</script>

Output:

2

Time Complexity: O(N)
Since we are traversing the given string of length N only once, the time complexity of the above algorithm is O(N).

Space Complexity: O(N)
The set used in the above algorithm is of size N and hence the space complexity of the algorithm is O(N).