Minimum number of keypresses to type the given string

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:

C++

#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;
}

Java

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;
        }
    }
}

C#

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)}");
    }
}

Javascript

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)}`);

Python3

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

Output

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)