6

我正在尝试编写一段代码来执行以下操作：

取数字 0 到 9 并为该数字分配一个或多个字母。例如：

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

当我有像 0123 这样的代码时，对它进行编码就很容易了。它显然会构成代码 NLTD。当引入像 5,6 或 8 这样的数字时，情况会有所不同。像 051 这样的数字会导致不止一种可能性：

NVL 和 NFL

很明显，对于较长的数字，包括 5,6 或 8 之类的几个数字，这会变得“更糟”。

由于数学很差，我还没有想出一个像样的解决方案，让我可以给程序输入一堆数字并让它吐出所有可能的字母组合。所以我很想得到一些帮助，因为我似乎无法弄清楚。挖掘了一些关于排列和组合的信息，但没有运气。

感谢您的任何建议/线索。我需要编写代码的语言是 PHP，但任何一般性提示都将受到高度赞赏。

更新：

更多背景信息：（非常感谢您的快速回复！）

我的问题背后的想法是构建一个脚本，帮助人们轻松地将他们想要记住的数字转换为更容易记住的单词。这有时被称为“伪命理”。

我希望脚本为我提供所有可能的组合，然后将这些组合保存在剥离单词的数据库中。这些被删除的单词只是来自字典，并且我在问题中提到的所有字母都被删除了。这样，要编码的数字通常可以很容易地与一个或多个数据库记录相关联。当这种情况发生时，你最终会得到一个单词列表，你可以用它来记住你想记住的数字。

4

9 回答 9

8

它可以很容易地递归地完成。

这个想法是，要处理大小为 n 的整个代码，您必须首先处理 n - 1 位数字。一旦您获得了 n-1 位数字的所有答案，就可以通过在最后一个数字后面附加正确的字符来推断整个答案。

于 2008-09-19T14:55:24.967 回答
3

实际上，有一个比枚举一个数字的所有可能翻译并查找它们更好的解决方案：只需对字典中的每个单词进行反向计算，然后将数字字符串存储在另一个字段中。因此，如果您的映射是：

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。

然后，您所要做的就是遍历字典单词中的每个字母，如果匹配则输出适当的数字，如果不匹配则不执行任何操作。

将所有生成的数字字符串作为另一个字段存储在数据库中。当您想查找某些内容时，只需对输入的数字执行一个简单的查询，而不必对潜在单词进行数十（或数百或数千）次查找。

于 2008-09-19T17:00:56.273 回答
2

您要保存数字 -> 字母分配的一般结构是一个或多个数组，类似于：

// 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
$numberMap = new Array (
    0 => new Array("N"),
    1 => new Array("L"),
    2 => new Array("T"),
    3 => new Array("D"),
    4 => new Array("R"),
    5 => new Array("V", "F"),
    6 => new Array("B", "P"),
    7 => new Array("Z"),
    8 => new Array("H", "CH", "J"),
    9 => new Array("G"),
);

然后，一些递归逻辑给了我们一个类似的函数：

function GetEncoding($number) {
    $ret = new Array();
    for ($i = 0; $i < strlen($number); $i++) {
        // We're just translating here, nothing special.
        // $var + 0 is a cheap way of forcing a variable to be numeric
        $ret[] = $numberMap[$number[$i]+0];
    }
}

function PrintEncoding($enc, $string = "") {
    // If we're at the end of the line, then print!
    if (count($enc) === 0) {
        print $string."\n";
        return;
    }

    // Otherwise, soldier on through the possible values.
    // Grab the next 'letter' and cycle through the possibilities for it.
    foreach ($enc[0] as $letter) {
        // And call this function again with it!
        PrintEncoding(array_slice($enc, 1), $string.$letter);
    }
}

为递归喝彩三声！这将通过以下方式使用：

PrintEncoding(GetEncoding("052384"));

如果你真的想要它作为一个数组，使用输出缓冲并使用“\n”作为你的拆分字符串来爆炸。

于 2008-09-19T15:14:28.697 回答
2

这类问题通常用递归来解决。在红宝石中，一个（快速而肮脏的）解决方案是

@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

这与蛮力搜索和回溯有关

于 2008-09-19T15:35:28.273 回答
1

这是 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']
于 2008-09-19T15:30:09.690 回答
0

你能做到以下几点： 创建一个结果数组。在数组中创建一个值为“”的项目

循环遍历这些数字，比如 051 分别分析每个数字。

每次找到数字之间的 1 到 1 匹配时，将正确的值添加到结果数组中的所有项目。所以“”变成了N。

每次找到一对多匹配时，使用一个选项将新行添加到结果数组，并使用另一个选项更新现有结果。所以 N 变成 NV 并创建了一个新项目 NF

然后最后一个数字是 1 对 1 匹配，因此结果数组中的项目变为 NVL 和 NFL

要通过结果数组循环生成结果，打印它们，或者其他什么。

于 2008-09-19T15:04:58.813 回答
0

让是给定数字字符串直到数字的所有可能字母组合的列表。pnsnth

然后，以下算法将生成：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是未定义的。您可以简单地将 p 0初始化为第一个字符的所有可能字符的列表。

因此，您的 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}
    }
}
于 2008-09-19T15:13:00.370 回答
0

你想要的形式可能是这样的：

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

这很难看，pidgin-php 所以请先验证一下。基本思想是从 [1..n] 生成字符串的每个组合，然后在所有这些组合的前面添加 str[0] 的每个可能代码。请记住，在最坏的情况下，这将使您的字符串长度呈指数级增长，因为您的编码方案中实际上存在很多歧义。

于 2008-09-19T15:17:11.233 回答
0

诀窍不仅在于生成与给定数字匹配的所有可能的字母组合，还在于选择最容易记住的字母序列。一个建议是在每个序列上运行soundex算法，并尝试与Wordnet等英语词典进行匹配，以找到最“真实单词”的序列。

于 2008-09-19T15:22:12.313 回答