介绍

考虑以下示例：

  CODE
+ GOLF
——————
 GREAT

这是一个等式，其中每个字母代表一个十进制数字，而单词代表自然数（相似的字母代表相似的数字，不同的字母代表不同的数字）。任务是将每个字母与其数字值进行匹配，以使方程式正确。上式的一种解决方案是：

  9265
+ 1278
——————
 10543

你的任务

您的任务是编写一个程序或函数来解决上述等式。

输入值

输入是以下格式的字符串：

[A-Z]+\+[A-Z]+=[A-Z]+

例：

1. CODE+GOLF=GREAT
2. AA+BB=CC

省略空格，仅使用大写字母A和Z之间的字母（不使用特殊字母或小写字母）。

可以从标准输入，文件或功能参数中读取此字符串。

输出量

您有以下两个输出格式选项：

1. 原始方程式已替换数字
2. 字母列表及其值

如果有多个解决方案，则应返回其中的任何一个（但只有一个）。如果没有解决方案，则程序应返回一个空字符串或null。输出可以作为字符串返回，可以写入标准输出或文件。

例：

1. 9265+1278=10543
2. A=1 B=2 C=3 （您可以使用任何定界符）

规则

1. 为了简化起见，数字以0开头是可接受的，但是您可以将数字以0开头作为无效解决方案，这取决于您
2. 相似的字母代表相似的数字，不同的字母代表不同的数字
3. 您可以使用任何语言和所选语言的标准库（无外部库）
4. 您无法连接到Internet上的任何资源（为什么仍要这么做？）
5. 这是一项代码高尔夫任务，最短的代码获胜。连续的空白字符算作单个字符。（因此，用空格编写的任何程序都会自动获胜）

我有一个使用179个字符的解决方案。如果不清楚，请在评论中问我。

Python-48个字符

exec("".join(map(chr,map(len,'                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             '.split("    ")))))

滥用空白规则。

首先，我将CesiumLifeJacket答案中的每个字符都转换为其ASCII值（我可以写自己的字符，但我很懒，无论如何它都不会影响最终分数）。在我的解决方案中，长字符串是这些ASCII值中的每个ASCII码值的一个空格，并用制表符将它们分开。在选项卡上拆分，找到长度，转换回字符并执行。

SE分别将制表符转换为4个空格，因此复制粘贴将不起作用。您只需要相信我:)

Ruby 2.0，122个字符

蛮力洗牌+评估！ 当没有解决方案时，这还不符合返回null / empty字符串的条件；它无限循环。 如果在大约3亿次迭代后找不到结果，它将返回nil。足够近？

f=->s{d=*0..9
d.shuffle!&&$.+=1until$.>9**9||z=eval((r=$_.tr(s.scan(/\w/).uniq*'',d*'')).gsub(/\b0/,'').sub ?=,'==')
z&&r}

它找到输入中的所有唯一字母，然后反复对数字0-9进行混洗，并尝试将它们与字母进行匹配，直到找到有效的配置为止。

该代码以称为的函数的形式出现，该函数f返回替换了数字的字符串，如上面的输出选项1所示。用法示例：

puts f["AA+BB=CC"]
 #=> 22+44=66
puts f["CODE+GOLF=GREAT"]
 #=> 8673+0642=09315

的运行时间 CODE+GOLF=GREAT我的机器上示例的从瞬时到大约6秒不等-取决于您对洗牌有多幸运！

我gsub(/\b0/,'')对删除开头的零特别不满意，但这是我唯一想避免的事情eval将数字解释为八进制整数的。

（BONUS：因为它使用eval，所以它适用于任意Ruby表达式，而不仅仅是加法！）

LiveScript（179个字符）

它具有确定性且相对较快的运行时间，并且还可以与其他运算符（+，-，*）一起使用。

f=(s)->                     # define function that takes parameter s
  c=s.replace /[^A-Z]/g ''  # remove all the non-letters
  if c                      # if any letters remain
    for i from 0 to 9       # loop from 0 to 9
       if s.indexOf(i)<0&&a=f s.split(c.0).join i  # if i is not present in the number, replace the first letter with i and call the function recursively
         return a           # if there is a solution, return it
  else                      # if there are no letters left
    if eval s.replace(/(^|\D)0+(\d)/g,'$1$2').replace \= \==  # if the expression is correct (we need to remove leading 0, because javascript interprets numbers with leading 0 as octal)
       return s  # return solution



f("CODE+GOLF=GREAT")

Python，256 213个字符

恐怖的运行时间，将尝试进一步改善：

q='='
e=input()
v=set(e)-set([q,'+'])
for x in __import__('itertools').permutations(range(10),len(v)):
    t=e
    for l,n in zip(v,x):t=t.replace(l,str(n))
    try: 
        if eval(t.replace(q,q*2)):print(t);break
    except:pass

JavaScript 138

for(s=prompt(p='1');eval(p.replace('=','!='));)for(p=s,i=64;i++<90;)p=p.replace(new RegExp(String.fromCharCode(i),'g'),10*Math.random()|0)

随机暴力。
可能需要一段时间（我的最佳拍摄时间CODE+GOLF=GREAT为3秒，最糟糕的3分钟）。
用一个简单的表达式尝试一下A+B=C

哈斯克尔（222）

import Data.List
z=(\(b,(_:c))->b:z c).span Data.Char.isUpper
j(Just g)=g
main=interact$(\d@[a,b,c]->show$take 1[e|e<-map(zip$nub$d>>=id)$permutations['0'..'9'],(\f->f a+f b==(f c::Int))(read.map(j.(`lookup`e)))]).take 3.z

蛮力。尝试所有可能的匹配，直到找到匹配的对象，或者在尝试所有匹配之后。我扩展了输出规则：打印类似[[('C','3'),('O','8'),('D','6'),('E','7'),('G','0'),('L','5'),('F','2'),('R','4'),('A','1'),('T','9')]]解决方案的内容，如果不存在，则打印print []。让我知道是否需要更改此设置。

果酱-17

"





























































































































































































































































































































    ""  
"f#3b127b:c~

总共975个字符，但是其中960个字符是2个序列中的空白，因此这些字符算作2个字符，再加上其他15个字符，我们得到17个
字符。975看起来很多，但是请注意，undergroundmonorail的python解决方案具有18862个字符，它们只是在一行上:)

您可以在http://cjam.aditsu.net/上运行它以获取简短的单词，但是您可能应该将Java解释器用于更长的单词。在笔记本电脑上安装Java之后，SEND+MORE=MONEY运行时间为30-40秒CODE+GOLF=GREAT，几乎需要3分钟。它不接受以0开头的数字（因为它不酷）。

这是一个生成上述程序的程序（如果StackExchange无法正确显示空白，这也将有所帮助）：

"{L__&=}:U;
{L!!{L))_9>{;:L;I}{+:L;}?}*}:I;
{{U!_{I}*}g}:M;
{L,N<L,g&}:K;
{I{K{L0+:L;}*MK}g}:G;
{{C#L=}%si}:R;
{XRYR+ZR=PRAb0#0<&}:F;
l'+/~'=/~:Z;:Y;:X;
[X0=Y0=Z0=]:P;
XYZ++_&:C,:NB<{0a:L;{F0{GL}?}g}*
L{XR'+YR'=ZR}{L}?"
127b3b[32 9 A]:cf='"\'"_32c9cAc"\"f#3b127b:c~"

前11行以字符串形式包含原始程序（不是真正的高尔夫），最后一行进行转换并添加解码部分。

Powershell，137个字节

LiveScript的端口

$f={param($s)if($c=$s-replace'[^A-Z]'){0..9|?{$s-notmatch$_}|%{&$f ($s-replace$c[0],$_)}|Select -f 1}elseif($s-replace'=','-eq'|iex){$s}}

取消测试的脚本：

$f={

param($s)                           # parameter string
$c=$s-replace'[^A-Z]'               # remove all the non-letters
if($c){                             # if any letters remain
    0..9|?{                         # loop from 0 to 9
        $s-notmatch$_               # if $s is not contains current number
    }|%{
        &$f ($s-replace$c[0],$_)    # replace the first letter with current number and call the function recursively
    }|Select -f 1                   # seelct first non-null value (break if found)
}
elseif($s-replace'=','-eq'|iex){    # else if evaluated value if the expression is $true
    $s                              # return $s as solution
}

}

&$f "AA+BB=CC"
&$f "A+AB=A"            # empty because it has no solution
&$f "CODE+GOLF=GREAT"

输出：

11+22=33
2846+0851=03697

PHP，118113字节

for(;;)eval(strtr($argn,"=".$w=substr(count_chars($argn,3),2),"-".$n=str_shuffle(1234567890))."||die('$w
$n');");

在字母下方打印数字并退出程序；如果无法解决，则无限循环。与一起作为管道运行-nr。

分解

for(;;)
    eval(                               # 6. evaluate
        strtr($argn,                    # 4. translate letters to digits, "=" to "-"
            "=".$w=substr(              # 2. remove non-letters
                count_chars($argn,3)    # 1. get characters used in the argument
                ,2),
            "-".$n=str_shuffle(1234567890)  # 3. shuffle digits
        )."||die('$w\n$n');"            # 5. if falsy (`A+B-C==0`), print translation and exit
    )
;

PHP，145字节

function f($s){for(;$i<10*preg_match("/[A-Z]/",$s,$m);)strpos(_.$s,++$i+47)||f(strtr($s,$m[0],$i-1));$i||eval(strtr($s,"=","-")."||die('$s');");}

递归函数，打印解出的方程式并退出程序；NULL在无法解决时返回。

在线尝试

分解

function f($s)
{
    for(;
        $i<10                   # loop $i from 0 to 9
        *preg_match("/[A-Z]/",$s,$m)    # find a letter; if not found: $i<10*0 == falsy
        ;
    )
        strpos(_.$s,++$i+47)            # find $i in string
        ||f(strtr($s,$m[0],$i-1));      # if not found, replace letter with $i, recurse
    $i||                        # no letter found ($i is unset):
        eval(                   # evaluate:
            strtr($s,"=","-")       # replace "=" with "-"
            ."||die('$s');"         # if falsy (A+B-C==0), print equation, exit program
        );
    # else implicitly return NULL
}