Given a string S of length N and a keypad of 9 buttons. We have to configure the mapping of all 26 English characters to the keypad button such that each character is mapped to exactly one button, and each button maps to at most 3 characters. To type a character, we have to press the corresponding button a certain number of times. For example, to type the first character matched to a button, we press the button once. To type the second character, we press the button twice, and so on. The task is to find the minimum number of keypresses needed to type a given string S using this keypad.
Note: Characters mapped to each button, and the order they are mapped in, cannot be changed.
Input: S = “geeksforgeeks”
Output: 13
Explanation: Optimal keypad configuration,
- 1 -> ‘g’
- 2 -> ‘e’
- 3 -> ‘k’
- 4 -> ‘s’
- 5 -> ‘f’
- 6 -> ‘o’
- 7 -> ‘r’ and for the remaining letters assign any character to any key.
To write “geeksforgeeks”, press 1 once for ‘g’, press 2 once for ‘e’, press 2 again for ‘e’, press 3 again for ‘k’, press 4 again for ‘s’, press 5 for ‘f’, press 6 for ‘o’, press 7 for ‘r’, press 1 once for ‘g’, press 2 once for ‘e’, press 2 again for ‘e’, press 3 again for ‘k’ and press 4 again for ‘s’. Total key presses will be 13.
Input: S = “aabbccddeeffgghhiijklmnopqrstuvwxyz”
Output:
Explanation: Optimal keypad configuration,
- 1 -> ‘ajs’
- 2 -> ‘bkt’
- 3 -> ‘clu’
- 4 -> ‘dmv’
- 5 -> ‘enw’
- 6 -> ‘fox’
- 7 -> ‘gpy’
- 8 -> ‘hqz’
- 9 -> ‘ir’
Total key presses will be 60.
Approach: To solve the problem, follow the below idea:
The problem can be solved using Greedy approach, the idea is to map the most frequent characters in the string as the first character of the button, then lesser frequent characters as the second character of the button and the least frequent character as the third character of the button. This ensures that the buttons are pressed minimum number of times.
Step-by-step algorithm:
- Create an unordered map to store character frequencies and variables for counting keypresses.
- Calculate character frequencies by iterating through the input string.
- Build pairs of character frequencies and characters, storing them in a vector.
- Sort the vector of pairs based on frequencies in ascending order.
-
Traverse the sorted pairs in reverse order(most frequent to least frequent).
- For the first 9 characters, add their frequencies to the count.
- For the next 9 characters, add twice their frequencies to the count.
- For the remaining characters, add thrice their frequencies to the count.
- Return the total count as the minimum number of keypresses needed.
Below is the implementation of the algorithm:
#include <bits/stdc++.h> using namespace std;
int minimumKeypresses(string s)
{ // Create a map to store the frequency of each character
// in the string
unordered_map< char , int > unmap1;
int count = 0;
vector<pair< int , char > > arr;
// Count the frequency of each character
for ( auto i : s)
unmap1[i]++;
// Store the frequency and character as a pair in a
// vector
for ( auto i : unmap1)
arr.push_back({ i.second, i.first });
// Sort the vector
sort(arr.begin(), arr.end());
// Iterate over the vector in reverse order
for ( int i = arr.size() - 1; i >= 0; i--) {
// If the character is mapped to the first 9 buttons
if (arr.size() - 1 - i + 1 <= 9) {
count += arr[i].first;
}
// If the character is mapped to the next 9 buttons
else if (arr.size() - 1 - i + 1 <= 18) {
count += arr[i].first * 2;
}
// If the character is mapped to the remaining
// buttons
else {
count += arr[i].first * 3;
}
}
// Return the minimum number of keypresses
return count;
} int main()
{ // Define the string
string s = "geeksforgeeks" ;
// Print the minimum number of keypresses needed to type
// the string
cout << "The minimum number of keypresses needed to "
"type the string '"
<< s << "' is: " << minimumKeypresses(s) << endl;
return 0;
} |
import java.util.*;
public class Main {
public static int minimumKeypresses(String s) {
// Create a map to store the frequency of each character
// in the string
Map<Character, Integer> unmap1 = new HashMap<>();
int count = 0 ;
List<Pair<Integer, Character>> arr = new ArrayList<>();
// Count the frequency of each character
for ( char i : s.toCharArray()) {
unmap1.put(i, unmap1.getOrDefault(i, 0 ) + 1 );
}
// Store the frequency and character as a pair in a
// list
for (Map.Entry<Character, Integer> entry : unmap1.entrySet()) {
arr.add( new Pair<>(entry.getValue(), entry.getKey()));
}
// Sort the list
arr.sort(Comparator.comparingInt(Pair::getFirst));
// Iterate over the list in reverse order
for ( int i = arr.size() - 1 ; i >= 0 ; i--) {
// If the character is mapped to the first 9 buttons
if (arr.size() - 1 - i + 1 <= 9 ) {
count += arr.get(i).getFirst();
}
// If the character is mapped to the next 9 buttons
else if (arr.size() - 1 - i + 1 <= 18 ) {
count += arr.get(i).getFirst() * 2 ;
}
// If the character is mapped to the remaining
// buttons
else {
count += arr.get(i).getFirst() * 3 ;
}
}
// Return the minimum number of keypresses
return count;
}
public static void main(String[] args) {
// Define the string
String s = "geeksforgeeks" ;
// Print the minimum number of keypresses needed to type
// the string
System.out.println( "The minimum number of keypresses needed to "
+ "type the string '" + s + "' is: " + minimumKeypresses(s));
}
static class Pair<K, V> {
private K first;
private V second;
public Pair(K first, V second) {
this .first = first;
this .second = second;
}
public K getFirst() {
return first;
}
public V getSecond() {
return second;
}
}
} |
using System;
using System.Collections.Generic;
using System.Linq;
class Program
{ static int MinimumKeypresses( string s)
{
// Create a dictionary to store the frequency of each character
var frequencyMap = new Dictionary< char , int >();
// Count the frequency of each character
foreach ( var ch in s)
{
if (!frequencyMap.ContainsKey(ch))
{
frequencyMap[ch] = 0;
}
frequencyMap[ch]++;
}
// Store the frequency and character as a pair in a list
var list = frequencyMap.Select(kvp => new KeyValuePair< int , char >(kvp.Value, kvp.Key)).ToList();
// Sort the list by frequency
list.Sort((pair1, pair2) => pair1.Key.CompareTo(pair2.Key));
int count = 0;
// Iterate over the list in reverse order
for ( int i = list.Count - 1; i >= 0; i--)
{
// Calculate the number of keypresses based on the position
int position = list.Count - 1 - i;
if (position < 9)
{
count += list[i].Key;
}
else if (position < 18)
{
count += list[i].Key * 2;
}
else
{
count += list[i].Key * 3;
}
}
// Return the minimum number of keypresses
return count;
}
static void Main( string [] args)
{
// Define the string
string s = "geeksforgeeks" ;
// Print the minimum number of keypresses needed to type the string
Console.WriteLine($ "The minimum number of keypresses needed to type the string '{s}' is: {MinimumKeypresses(s)}" );
}
} |
function minimumKeypresses(s) {
// Create a map to store the frequency of each character in the string
let unmap1 = new Map();
let count = 0;
let arr = [];
// Count the frequency of each character
for (let i of s) {
unmap1.set(i, (unmap1.get(i) || 0) + 1);
}
// Store the frequency and character as a pair in a array
for (let [key, value] of unmap1) {
arr.push([value, key]);
}
// Sort the array
arr.sort((a, b) => a[0] - b[0]);
// Iterate over the array in reverse order
for (let i = arr.length - 1; i >= 0; i--) {
// If the character is mapped to the first 9 buttons
if (arr.length - 1 - i + 1 <= 9) {
count += arr[i][0];
}
// If the character is mapped to the next 9 buttons
else if (arr.length - 1 - i + 1 <= 18) {
count += arr[i][0] * 2;
}
// If the character is mapped to the remaining buttons
else {
count += arr[i][0] * 3;
}
}
// Return the minimum number of keypresses
return count;
} // Define the string let s = "geeksforgeeks" ;
// Print the minimum number of keypresses needed to type the string console.log(`The minimum number of keypresses needed to type the string '${s}' is: ${minimumKeypresses(s)}`);
|
def minimum_keypresses(s):
# Create a dictionary to store the frequency of each character
unmap1 = {}
count = 0
arr = []
# Count the frequency of each character
for i in s:
if i in unmap1:
unmap1[i] + = 1
else :
unmap1[i] = 1
# Store the frequency and character as a pair in a list
for i in unmap1.items():
arr.append(i)
# Sort the list
arr.sort()
# Iterate over the list in reverse order
for i in range ( len (arr) - 1 , - 1 , - 1 ):
# If the character is mapped to the first 9 buttons
if len (arr) - 1 - i + 1 < = 9 :
count + = arr[i][ 1 ]
# If the character is mapped to the next 9 buttons
elif len (arr) - 1 - i + 1 < = 18 :
count + = arr[i][ 1 ] * 2
# If the character is mapped to the remaining buttons
else :
count + = arr[i][ 1 ] * 3
# Return the minimum number of keypresses
return count
# Driver Code # Define the string s = "geeksforgeeks"
# Print the minimum number of keypresses needed to type the string print (f "The minimum number of keypresses needed to type the string '{s}' is: {minimum_keypresses(s)}" )
# This code is contributed by shivamgupta310570 |
The minimum number of keypresses needed to type the string 'geeksforgeeks' is: 13
Time Complexity: O(Nlog(N)), where N is the length of input string S.
Auxiliary Space: O(1)