65 votes

Comment puis-je imprimer toutes les combinaisons de lettres possibles qu'un numéro de téléphone donné peut représenter?

J'ai juste essayé pour ma première interview de programmation et l'une des questions était d'écrire un programme qui, étant donné un 7 chiffres du numéro de téléphone, peut imprimer toutes les combinaisons possibles de lettres que chaque nombre peut représenter.

Une deuxième partie de la question était comme si cela aurait été un 12 chiffres du numéro international? Comment serait-ce l'effet de votre conception.

Je n'ai pas le code que j'ai écrit dans l'interview, mais j'ai eu l'impression qu'il n'était pas heureux avec elle.
Quelle est la meilleure façon de le faire?

47voto

Nick Johnson Points 79909

En Python, itératif:

 digit_map = {
    '2': 'abc',
    '3': 'def',
    '4': 'ghi',
    '5': 'jkl',
    '6': 'mno',
    '7': 'pqrs',
    '8': 'tuv',
    '9': 'wxyz',
}

def word_numbers(input):
  input = str(input)
  ret = ['']
  for char in input:
    letters = digit_map.get(char, '')
    ret = [prefix+letter for prefix in ret for letter in letters]
  return ret
 

ret est une liste de résultats à ce jour; Initialement, il contient un élément, la chaîne vide. Ensuite, pour chaque caractère de la chaîne d'entrée, il recherche la liste de lettres qui lui correspond dans le dict défini en haut. Il remplace ensuite la liste ret par toutes les combinaisons de préfixes existants et de lettres possibles.

17voto

azheanda Points 51

Cela ressemble à une question appelée combinaison de lettres d’un numéro de téléphone . Voici ma solution.
Cela fonctionne pour un nombre arbitraire de chiffres, tant que le résultat ne dépasse pas la limite de mémoire.

 import java.util.HashMap;
public class Solution {
    public ArrayList<String> letterCombinations(String digits) {
        ArrayList<String> res = new ArrayList<String>();
        ArrayList<String> preres = new ArrayList<String>();
        res.add("");

        for(int i=0;i<digits.length();i++){
            for(String str: res)
                String letters = map.get(digits.charAt(i));
                for(int j=0;j<letters.length();j++)
                    preres.add(str+letters.charAt(j));

            res = preres;
            preres = new ArrayList<String>();
        }      
        return res;
    }

    static final HashMap<Character,String> map = new HashMap<Character,String>(){{
        put('2',"abc");
        put('3',"def");
        put('4',"ghi");
        put('5',"jkl");
        put('6',"mno");
        put('7',"pqrs");
        put('8',"tuv");
        put('9',"wxyz");
    }} ;
}
 

Je ne sais pas comment les numéros internationaux à 12 chiffres affectent la conception.

4voto

William Brendel Points 15453

En Java en utilisant la récursivité:

 import java.util.LinkedList;
import java.util.List;

public class Main {  
    // Number-to-letter mappings in order from zero to nine
    public static String mappings[][] = {
        {"0"}, {"1"}, {"A", "B", "C"}, {"D", "E", "F"}, {"G", "H", "I"},
        {"J", "K", "L"}, {"M", "N", "O"}, {"P", "Q", "R", "S"}, 
        {"T", "U", "V"}, {"W", "X", "Y", "Z"}
    };

    public static void generateCombosHelper(List<String> combos, 
            String prefix, String remaining) {
        // The current digit we are working with
        int digit = Integer.parseInt(remaining.substring(0, 1));

        if (remaining.length() == 1) {
            // We have reached the last digit in the phone number, so add 
            // all possible prefix-digit combinations to the list
            for (int i = 0; i < mappings[digit].length; i++) {
                combos.add(prefix + mappings[digit][i]);
            }
        } else {
            // Recursively call this method with each possible new 
            // prefix and the remaining part of the phone number.
            for (int i = 0; i < mappings[digit].length; i++) {
                generateCombosHelper(combos, prefix + mappings[digit][i], 
                        remaining.substring(1));
            }
        }
    }

    public static List<String> generateCombos(String phoneNumber) {
        // This will hold the final list of combinations
        List<String> combos = new LinkedList<String>();

        // Call the helper method with an empty prefix and the entire 
        // phone number as the remaining part.
        generateCombosHelper(combos, "", phoneNumber);

        return combos;
    }

    public static void main(String[] args) {
        String phone = "3456789";
        List<String> combos = generateCombos(phone);

        for (String s : combos) {
            System.out.println(s);
        }
    }
}
 

3voto

Ofir Points 5760

La solution la plus évidente est une fonction de la carte un chiffre à une liste de clés, puis une fonction qui permettrait de générer les combinaisons possibles:

La première est évidente, la seconde est plus problématique parce que vous avez autour de 3^nombre de combinaisons de chiffres, qui peuvent être d'un très grand nombre.

Une façon de le faire est de regarder à chaque possibilité, pour les chiffres correspondants pour un chiffre dans un nombre (sur la base de 4) et de mettre en œuvre quelque chose de proche d'un compteur (saut à plus de certains cas, car il y a généralement moins de 4 lettres transposable à un chiffre).

La plus évidente des solutions serait de boucles imbriquées ou la récursivité, qui sont à la fois moins élégant, mais à mon avis valable.

Une autre chose pour laquelle il faut prendre soin de est pour éviter les problèmes d'échelle (par exemple en gardant les possibilités de la mémoire, etc.) puisque nous parlons de beaucoup de combinaisons.

P. S. une Autre extension intéressante de la question de la localisation.

3voto

Jerky Points 758

En numérique, les claviers, les textes et les chiffres sont placés sur la même touche. Pour l'exemple 2, a "ABC" si nous voulions écrire tout ce qui commence par "A", nous avons besoin de taper la touche 2 une fois. Si nous voulions type "B", appuyez sur la touche 2 deux fois et trois fois pour écrire "C". ci-dessous est l'image d'un tel clavier.

keypad

Compte tenu d'un clavier comme indiqué dans le schéma, et d'un n nombre de chiffre, de la liste de tous les mots qui sont possibles en appuyant sur ces chiffres.

Par exemple, si le numéro d'entrée est de 234, mots possibles qui peuvent être formés sont (par ordre Alphabétique): adg adh adi aeg aeh aei afg afh, l'afi bdg bdh bdi beg beh bei bfg bfh bfi cdg cdh cdi ceg ceh cei cfg cfh fci

Nous allons faire quelques calculs en premier. Combien de mots sont possibles avec sept chiffres avec les chiffres représentant les n lettres? Pour le premier chiffre, nous avons tout au plus quatre choix, et pour chaque choix de la première lettre, nous avons tout au plus quatre choix pour le deuxième chiffre, et ainsi de suite. Il est donc simple de maths, il sera O(4^n). Depuis les touches 0 et 1 n'ont pas d'alphabet, et de nombreux personnages ont 3 personnages, 4^n serait à la limite supérieure du nombre de mots et le minimum de mots.

Maintenant, nous allons faire quelques exemples.

Pour le numéro ci-dessus 234. Voyez-vous de n'importe quel motif? Oui, nous remarquons que le dernier caractère toujours soit G,H ou I et à chaque fois qu'il remet à sa valeur de I à G, le chiffre à gauche de celle-ci est changé. De la même façon à chaque fois que l'avant-dernière de l'alphabet réinitialise sa valeur, le troisième de la dernière de l'alphabet est modifiée et ainsi de suite. Premier caractère réinitialise une seule fois, lorsque nous avons généré tous les mots. Ceci peut être vu à partir de l'autre extrémité également. C'est-à-dire chaque fois que le caractère à la position i les changements, le caractère à la position i+1 passe par tous les caractères possibles et il crée l'effet d'entraînement jusqu'à nous rejoindre à la fin. Puisque 0 et 1 n'ont pas de caractères qui leur sont associés. nous devons casser car il n'y aura pas d'itération pour ces chiffres.

Prenons la deuxième approche, comme il sera facile à mettre en œuvre en utilisant la récursivité. Nous allons jusqu'à la fin et revenir un par un. Parfait état pour la récursivité. nous allons chercher la base de cas. Lorsque nous arrivons au dernier caractère, nous imprimons la parole avec tous les caractères possibles pour le dernier chiffre et le retour. Simple de la base de cas.Lorsque nous arrivons au dernier caractère, nous imprimons la parole avec tous les caractères possibles pour le dernier chiffre et le retour. Simple de la base de cas.

La suite C est de la mise en œuvre de l'approche récursive pour l'impression de tous les mots possibles correspondant à un n chiffres du numéro d'entrée. Noter que le nombre d'entrée est représenté comme un tableau pour simplifier le code.

#include <stdio.h>
#include <string.h>

// hashTable[i] stores all characters that correspond to digit i in phone
const char hashTable[10][5] = {"", "", "abc", "def", "ghi", "jkl",
                           "mno", "pqrs", "tuv", "wxyz"};

// A recursive function to print all possible words that can be obtained
// by input number[] of size n.  The output words are one by one stored
// in output[]
void  printWordsUtil(int number[], int curr_digit, char output[], int n)
{
    // Base case, if current output word is prepared
int i;
if (curr_digit == n)
{
    printf("%s ", output);
    return ;
}

// Try all 3 possible characters for current digir in number[]
// and recur for remaining digits
for (i=0; i<strlen(hashTable[number[curr_digit]]); i++)
{
    output[curr_digit] = hashTable[number[curr_digit]][i];
    printWordsUtil(number, curr_digit+1, output, n);
    if (number[curr_digit] == 0 || number[curr_digit] == 1)
        return;
}
}

// A wrapper over printWordsUtil().  It creates an output array and
// calls printWordsUtil()
void printWords(int number[], int n)
{
char result[n+1];
result[n] ='\0';
printWordsUtil(number, 0, result, n);
}

//Driver program
int main(void)
{
int number[] = {2, 3, 4};
int n = sizeof(number)/sizeof(number[0]);
printWords(number, n);
return 0;
}

Sortie:

adg adh adi aeg aeh aei afg afh afi bdg bdh bdi beg beh bei bfg bfh bfi cdg cdh cdi ceg ceh cei cfg cfh cfi

Le Temps De La Complexité:

Le temps de la complexité de code ci-dessus est O(4^n) où n est le nombre de chiffres dans le numéro d'entrée.

Références:

http://www.flipkart.com/programming-interviews-exposed-secrets-landing-your-next-job-3rd/p/itmdxghumef3sdjn?pid=9788126539116&affid=sandeepgfg

Prograide.com

Prograide est une communauté de développeurs qui cherche à élargir la connaissance de la programmation au-delà de l'anglais.
Pour cela nous avons les plus grands doutes résolus en français et vous pouvez aussi poser vos propres questions ou résoudre celles des autres.

Powered by:

X