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 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 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 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));
[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;
}
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));
}
}
# 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 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));
Similar Reads
Count of distinct permutation of a String obtained by swapping only unequal characters Given a string find the number of unique permutations that can be obtained by swapping two indices such that the elements at these indices are distinct. NOTE: Swapping is always performed in the original string. Examples: Input: str = "sstt"Output: 5Explanation: Swap str[0] with str[2], string obtai
11 min read
Count of distinct possible strings after performing given operations Given a numeric string S consisting of only three types of characters 0, 1, and 2 initially and following two operations: The occurrence of two consecutive 1 can be replaced by 3.The occurrence of two consecutive 2 can be replaced by 4.The given task is to find the total number of different strings
10 min read
Check if two non-duplicate strings can be made equal after at most two swaps in one string Given two strings A and B consisting of unique lowercase letters, the task is to check if both these strings can be made equal by using at most two swaps. Print Yes if they can. Otherwise, print No. Example: Input: A="abcd", B="badc"Output: YesFirst swap a and b, and then swap c and d, in string A.I
15+ min read
Count new pairs of strings that can be obtained by swapping first characters of pairs of strings from given array Given an array arr[] consisting of N strings, the task is to find the pair of strings that is not present in the array formed by any pairs (arr[i], arr[j]) by swapping the first characters of the strings arr[i] and arr[j]. Examples: Input: arr[] = {"good", "bad", "food"}Output: 2Explanation:The poss
13 min read
Count of possible distinct Binary strings after replacing "11" with "0" Given a binary string str of size N containing 0 and 1 only, the task is to count all possible distinct binary strings when a substring "11" can be replaced by "0". Examples: Input: str = "11011"Output: 4Explanation: All possible combinations are "11011", "0011", "1100", "000". Input: str = "1100111
15 min read
Meta Strings (Check if two strings can become same after a swap in one string) Given two strings, the task is to check whether these strings are meta strings or not. Meta strings are the strings which can be made equal by exactly one swap in any of the strings. Equal string are not considered here as Meta strings.Examples: Input: s1 = "geeks" , s2 = "keegs"Output: TrueExplanat
5 min read