Проблема алгоритма: сочетания букв

Это может быть сделано легко рекурсивно.

Идея состоит в том, что для обработки целого кода размера n необходимо обработать сначала n - 1 цифра. После того как у Вас есть все ответы для n-1 цифр, ответы для целого выведены путем добавления им корректного (s) символа (символов) для последнего.

Позволить pn будьте списком всех возможных сочетаний букв данной числовой строки s до nth цифра.

Затем следующий алгоритм генерирует pn+1:

digit = s[n+1];
foreach(letter l that digit maps to)
{
    foreach(entry e in p(n))
    {
        newEntry = append l to e;
        add newEntry to p(n+1);
    }
}

Первое повторение является своего рода особым случаем, так как _p-1 не определен. Можно просто инициализировать _p0 как список всех возможных символов для первого символа.

Так, Ваш 051 пример:

Повторение 0:

p(0) = {N}

Повторение 1:

digit = 5
foreach({V, F})
{
    foreach(p(0) = {N})
    {
        newEntry = N + V  or  N + F
        p(1) = {NV, NF}
    }
}

Повторение 2:

digit = 1
foreach({L})
{
    foreach(p(1) = {NV, NF})
    {
        newEntry = NV + L  or  NF + L
        p(2) = {NVL, NFL}
    }
}

Вот рекурсивное решение в Python.

#!/usr/bin/env/python

import sys

ENCODING = {'0':['N'],
            '1':['L'],
            '2':['T'],
            '3':['D'],
            '4':['R'],
            '5':['V', 'F'],
            '6':['B', 'P'],
            '7':['Z'],
            '8':['H', 'CH', 'J'],
            '9':['G']
            }

def decode(str):
   if len(str) == 0:
       return ''
   elif len(str) == 1:
       return ENCODING[str]
   else:
       result = []
       for prefix in ENCODING[str[0]]:
           result.extend([prefix + suffix for suffix in decode(str[1:])])
       return result

if __name__ == '__main__':
   print decode(sys.argv[1])

Пример произвел:

$ ./demo 1
['L']
$ ./demo 051
['NVL', 'NFL']
$ ./demo 0518
['NVLH', 'NVLCH', 'NVLJ', 'NFLH', 'NFLCH', 'NFLJ']

Этот вид проблемы обычно разрешается с рекурсией. В рубине один (быстрый и грязный) решение было бы

@values = Hash.new([])


@values["0"] = ["N"] 
@values["1"] = ["L"] 
@values["2"] = ["T"] 
@values["3"] = ["D"] 
@values["4"] = ["R"] 
@values["5"] = ["V","F"] 
@values["6"] = ["B","P"] 
@values["7"] = ["Z"] 
@values["8"] = ["H","CH","J"] 
@values["9"] = ["G"]

def find_valid_combinations(buffer,number)
 first_char = number.shift
 @values[first_char].each do |key|
  if(number.length == 0) then
     puts buffer + key
  else
     find_valid_combinations(buffer + key,number.dup)
    end
 end
end

find_valid_combinations("",ARGV[0].split(""))

И если Вы выполните это из командной строки, то Вы доберетесь:

$ ruby r.rb 051
NVL
NFL

Это связано с поиском "в лоб" и отслеживанием в обратном порядке

Могли Вы делать следующее: Создайте массив результатов. Создайте объект в массиве со значением""

Цикл через числа, говорит 051 анализ каждого индивидуально.

Каждый раз от 1 до 1 соответствия между числом найден, добавляет правильное значение ко всем объектам в массиве результатов. Так "" становится N.

Каждый раз 1 многим соответствуют, найден, добавьте новые строки к массиву результатов с одной опцией и обновите существующие результаты с другой опцией. Таким образом, N становится NV, и новый объект создается NF

Затем последнее число является от 1 до 1 соответствия, таким образом, объекты в массиве результатов становятся NVL и НФЛ

Произвести цикл результатов через массив результатов, печатая их, или что бы то ни было.

Существует на самом деле намного лучшее решение, чем перечисление всех возможных переводов числа и поиска их: Просто сделайте обратное вычисление на каждом слове в Вашем словаре и сохраните строку цифр в другом поле. Таким образом, если Ваше отображение:

0 = N,
1 = L,
2 = T,
3 = D,
4 = R,
5 = V or F,
6 = B or P,
7 = Z,
8 = H or CH or J,
9 = G

Ваше обратное отображение:

N = 0,
L = 1,
T = 2,
D = 3,
R = 4,
V = 5,
F = 5,
B = 6,
P = 6,
Z = 7,
H = 8,
J = 8,
G = 9

Примечание там не является никаким отображением для 'ch', потому что 'c' будет отброшен, и 'h' будет преобразован в 8 так или иначе.

Затем все, что необходимо сделать, выполняют итерации через каждую букву в слове словаря, производят соответствующую цифру, если существует соответствие, и ничего не сделайте, если нет.

Сохраните все сгенерированные строки цифр как другое поле в базе данных. Когда Вы хотите искать что-то, просто выполнить простой запрос для введенного номера, вместо того, чтобы иметь необходимость сделать десятки (или сотни или тысячи) поисков потенциальных слов.

Форма, которую Вы хотите, является, вероятно, чем-то как:

function combinations( $str ){
$l = len( $str );
$results = array( );
if ($l == 0) { return $results; }
if ($l == 1)
{  
   foreach( $codes[ $str[0] ] as $code )
   {
    $results[] = $code;
   }
   return $results;
}
$cur = $str[0];
$combs = combinations( substr( $str, 1, $l ) );
foreach ($codes[ $cur ] as $code)
{
    foreach ($combs as $comb)
    {
        $results[] = $code.$comb;
    }
}
return $results;}

Это ужасно, гибридный-язык-php, поэтому проверьте его сначала. Основная идея состоит в том, чтобы генерировать каждую комбинацию строки от [1.. n] и затем предварительно ожидайте к передней стороне всех тех комбинаций каждый возможный код для ул. [0]. Примите во внимание, что в худшем случае это будет иметь экспоненциал производительности в длине Вашей строки, потому что так много неоднозначности на самом деле присутствует в Вашей системе кодирования.

Прием не только для генерации всех возможных сочетаний букв, которые соответствуют данному числу, но выбрать последовательность буквы, которую является самым легким помнить. Предложение состояло бы в том, чтобы выполнить soundex алгоритм на каждой последовательности и попытке соответствовать против английского словаря языка, такого как WordNet для нахождения большинства последовательностей 'реального звучания слова'.