Count of distinct strings that can be obtained after performing exactly one swap

Last Updated : 07 Jun, 2025

Given a string s containing lowercase characters. The task is to calculate the number of distinct strings that can be obtained after performing exactly one swap.

Input: s = "geek"
Output: 6
Explanation: Following are the strings formed by doing exactly one swap:
"egek", "eegk", "geek", "geke", "gkee", "keeg"
Input: s = "aa"
Output: 1

[Naive Approach] Using Hash Set - O(n^3) time and O(n^2) space

The idea is to generate all possible strings by swapping every pair of different indices once, store them in a hash set to ensure uniqueness, and return the count of distinct strings.

C++

// C++ program to find the count of distinct strings 
// that can be obtained after performing exactly one swap
#include <bits/stdc++.h>
using namespace std;

// Function to count distinct strings after one swap
int countStrings(string &s) {
    int n = s.length();
    
    // Set to store unique strings after one swap
    unordered_set<string> set;

    // Try all pairs (i, j) such that i < j
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            // Swap characters at positions i and j
            swap(s[i], s[j]);

            // Insert the resulting string into the set
            set.insert(s);

            // Swap back to restore original string
            swap(s[i], s[j]);
        }
    }

    // Return the number of unique strings obtained
    return set.size();
}

int main() {
    // Input string
    string s = "geek";

    // Output the count of distinct strings after one swap
    cout << countStrings(s);
    return 0;
}

Java

// Java program to find Count of distinct strings that 
// can be obtained after performing exactly one swap

import java.util.HashSet;

class GfG {
    
    // Function to count distinct strings after one swap
    static int countStrings(String s) {
        int n = s.length();
        
        // HashSet to store unique strings after one swap
        HashSet<String> set = new HashSet<>();

        // Try all pairs (i, j) such that i < j
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                
                // Convert string to character array for swapping
                char[] arr = s.toCharArray();
                
                // Swap characters at positions i and j
                char temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;

                // Add new string to set to ensure uniqueness
                set.add(new String(arr));
            }
        }

        // Return the number of unique strings obtained
        return set.size();
    }

    public static void main(String[] args) {
        // Input string
        String s = "geek";

        // Output the count of distinct strings after one swap
        System.out.println(countStrings(s));
    }
}

Python

# Python program to find Count of distinct strings that 
# can be obtained after performing exactly one swap

# Function to count distinct strings after one swap
def countStrings(s):
    n = len(s)
    
    # Set to store unique strings after swaps
    unique = set()

    # Try all pairs (i, j) such that i < j
    for i in range(n):
        for j in range(i + 1, n):
            # Convert string to list for swapping
            lst = list(s)
            
            # Swap characters at positions i and j
            lst[i], lst[j] = lst[j], lst[i]
            
            # Add the resulting string to the set
            unique.add(''.join(lst))
    
    # Return the number of unique strings obtained
    return len(unique)

if __name__ == "__main__":
    # Input string
    s = "geek"

    # Output the count of distinct strings after one swap
    print(countStrings(s))

// C# program to find Count of distinct strings that 
// can be obtained after performing exactly one swap

using System;
using System.Collections.Generic;

class GfG {
    
    // Function to count distinct strings after one swap
    static int countStrings(string s) {
        int n = s.Length;
        
        // HashSet to store unique strings after swaps
        HashSet<string> set = new HashSet<string>();

        // Try all pairs (i, j) such that i < j
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                
                // Convert string to character array for swapping
                char[] arr = s.ToCharArray();
                
                // Swap characters at positions i and j
                char temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;

                // Add the resulting string to the set
                set.Add(new string(arr));
            }
        }

        // Return the number of unique strings obtained
        return set.Count;
    }

    static void Main() {
        // Input string
        string s = "geek";

        // Output the count of distinct strings after one swap
        Console.WriteLine(countStrings(s));
    }
}

JavaScript

// JavaScript program to find Count of distinct strings that 
// can be obtained after performing exactly one swap

// Function to count distinct strings after one swap
function countStrings(s) {
    const n = s.length;
    
    // Set to store unique strings after swaps
    const set = new Set();

    // Try all pairs (i, j) such that i < j
    for (let i = 0; i < n; i++) {
        for (let j = i + 1; j < n; j++) {
            
            // Convert string to array for swapping
            const arr = s.split('');
            
            // Swap characters at positions i and j
            [arr[i], arr[j]] = [arr[j], arr[i]];
            
            // Add the resulting string to the set
            set.add(arr.join(''));
        }
    }

    // Return the number of unique strings obtained
    return set.size;
}

// Driver Code

const s = "geek";
// Output the count of distinct strings after one swap
console.log(countStrings(s));

Output

[Efficient Approach] Using Frequency Array - O(n) time and O(1) space

The idea is to count how many swaps between different characters are possible and then check if any character occurs more than once, allowing for a swap that returns the original string but still counts as a distinct operation.

Step by step approach:

Maintain a count array of size 26 to track character frequencies.
For each index, find the number of characters encountered so far which are different from current character. The count will give the number of unique strings which can obtained by swapping current character.
Increment frequency count of current character.
After traversal, check if any character occurred more than once. If so, increment the result by one to include swap of identical characters.

C++

#include <bits/stdc++.h>
using namespace std;

// Function to count distinct strings after exactly one swap
int countStrings(string &s) {
    int n = s.length();

    // Vector to count occurrences of each character (assuming lowercase letters)
    vector<int> map(26, 0);

    // Variable to store the total number of distinct strings
    int ans = 0;

    // Count pairs (i, j) where swapping s[i] and s[j] gives a new string
    for (int i = 0; i < n; i++) {
        ans += (i - map[s[i] - 'a']); 
        map[s[i] - 'a']++;
    }

    // If there's any duplicate character, one extra swap can result
    // in same string So, one more distinct outcome is possible
    for (int i = 0; i < 26; i++) {
        if (map[i] > 1) {
            ans++;
            break;
        }
    }

    // Return the total number of distinct strings possible
    return ans;
}

int main() {
    // Input string
    string s = "geek";

    // Output the count of distinct strings after one swap
    cout << countStrings(s);
    return 0;
}

Java

class GfG {
    
    // Function to count distinct strings after one swap
    static int countStrings(String s) {
        int n = s.length();

        // Array to count character frequencies
        int[] map = new int[26];

        // Store total distinct strings
        int ans = 0;

        // Count valid swaps by excluding repeated characters seen so far
        for (int i = 0; i < n; i++) {
            ans += (i - map[s.charAt(i) - 'a']);
            map[s.charAt(i) - 'a']++;
        }

        // Check for any duplicate character
        for (int i = 0; i < 26; i++) {
            if (map[i] > 1) {
                ans++; 
                break;
            }
        }

        return ans;
    }

    public static void main(String[] args) {
        // Input string
        String s = "geek";

        // Output the count of distinct strings after one swap
        System.out.println(countStrings(s));
    }
}

Python

# Function to count distinct strings after one swap
def countStrings(s):
    n = len(s)
    
    # Array to count character frequencies
    map = [0] * 26
    ans = 0

    # Count valid swaps, avoiding duplicates
    for i in range(n):
        ans += (i - map[ord(s[i]) - ord('a')])
        map[ord(s[i]) - ord('a')] += 1

    # Check for any duplicate character
    for i in range(26):
        if map[i] > 1:
            ans += 1
            break

    return ans

if __name__ == "__main__":
    s = "geek"
    # Output the count of distinct strings after one swap
    print(countStrings(s))

// C# program to find Count of distinct strings that 
// can be obtained after performing exactly one swap

using System;

class GfG {

    // Function to count distinct strings after one swap
    static int countStrings(string s) {
        int n = s.Length;

        // Array to store character frequencies
        int[] map = new int[26];
        int ans = 0;

        // Count valid swaps excluding previously seen same characters
        for (int i = 0; i < n; i++) {
            ans += (i - map[s[i] - 'a']);
            map[s[i] - 'a']++;
        }

        // Check for duplicate characters
        for (int i = 0; i < 26; i++) {
            if (map[i] > 1) {
                ans++; 
                break;
            }
        }

        // Return total distinct results
        return ans;
    }

    static void Main() {
        // Input string
        string s = "geek";

        // Output result
        Console.WriteLine(countStrings(s));
    }
}

JavaScript

// JavaScript program to find Count of distinct strings that 
// can be obtained after performing exactly one swap

function countStrings(s) {
    const n = s.length;
    
    // Array to count character frequencies
    const map = new Array(26).fill(0);
    let ans = 0;

    // Count valid swaps excluding previously seen same characters
    for (let i = 0; i < n; i++) {
        ans += (i - map[s.charCodeAt(i) - 'a'.charCodeAt(0)]);
        map[s.charCodeAt(i) - 'a'.charCodeAt(0)]++;
    }

    // Check for duplicate characters
    for (let i = 0; i < 26; i++) {
        if (map[i] > 1) {
            ans++; // One extra distinct string possible if duplicates exist
            break;
        }
    }

    // Return total distinct strings count
    return ans;
}

// Driver Code
const s = "geek";
// Output the count of distinct strings after one swap
console.log(countStrings(s));

Output

Analysis of Algorithms

harshalkhond

Improve

Article Tags :

Practice Tags :

Count of distinct strings that can be obtained after performing exactly one swap

[Naive Approach] Using Hash Set - O(n^3) time and O(n^2) space

[Efficient Approach] Using Frequency Array - O(n) time and O(1) space

Similar Reads

Basics & Prerequisites

Data Structures

Algorithms

Advanced

Interview Preparation

Practice Problem

Thank You!

What kind of Experience do you want to share?