我们都已经做到了，也许没有，但是制作自己的外语和数字系统是幻想写作的主要内容，但大部分只是一项有趣的活动。

任务很简单，需要两个输入：

1. 有序列表输入10 [十]个唯一的“数字”（任何可打印的ASCII字符），并按顺序将它们解释为值0、1、2、3，...，9

   +这里可能会有数字例外。算术运算符（+，-，*，/），括号和空格不能用作数字之一。

2. 仅使用那些“数字”的算术问题

并以给定的形式输出等效的整数结果。

这是一个例子：

INPUT

abcdefghij

bcd + efg + hij

OUTPUT

bdgi

在该示例中，“ abcdefghij”的输入列表（您可以选择列表的形式）对应于“ 0123456789”，就像“ hjkloiwdfp”也将与“ 0123456789”一对一对应，而不是与“ a”关联零，“ h”确实如此。后面的算术“翻译”为123 + 456 + 789，等于1368。然后必须以我们给定的形式输出，因此b（代表1）d（代表2）g（代表6）和i（代表8）。

测试用例

abcdefghij
abc + def - ghij

-gedc

qwertyuiop
qwerty / uiop

e

%y83l;[=9|
(83l * 9) + 8%

y9|8

更多规则

• 禁止使用标准漏洞！
• 这是代码高尔夫，因此以字节为单位的最短答案将获胜。
• 必须是完整的程序或函数，以最适合您的格式接受输入和输出。（仅不能在输入中添加附加信息，而只能在“数字”和表达式中添加。
• 使用您想要的任何语言（只要符合其他规则）

05AB1E，10 9 字节

žh‡.Eò¹Åв

（现在）输出为字符列表。

在线尝试或验证所有测试用例。

说明：

  ‡        # Transliterate the second (implicit) input, replacing every character of 
           # the first (implicit) input with:
žh         # The builtin "0123456789"
   .E      # Then evaluate it as Elixir code
     ò     # Round it to the nearest integer
      ¹Åв  # And change it back by using a custom base-conversion with the first input as
           # base (which results in a character list)
           # (after which that result is output implicitly)

新版本的05AB1E是在Elixir中构建的。该.E函数将调用call_unary(fn x -> {result, _} = Code.eval_string(to_string(x)); result end, a)，其中Code.eval_string是Elixir内置的。

请注意，传统版本05AB1E不适用于该版本，因为它是在Python中构建的。前导数字0不会被评估：
请查看旧版（使用10字节版本，因为Åв内置是新版）的所有测试用例。

R，58个字节

function(d,s,`[`=chartr)'0-9'[d,eval(parse(t=d['0-9',s]))]

在线尝试！

使用字符转换chartr来交换数字parses和evals，然后将chartrs返回原始数字。

如果需要舍入到最接近的整数，则为

R，65个字节

function(d,s,`[`=chartr)'0-9'[d,round(eval(parse(t=d['0-9',s])))]

在线尝试！

T-SQL，117个字节

DECLARE @ CHAR(99)
SELECT @='SELECT TRANSLATE('+TRANSLATE(e,c,'0123456789')+',''0123456789'','''+c+''')'FROM t
EXEC(@)

换行符仅供阅读。

根据我们的IO规则，输入是通过预先存在的带有文本列c（字符）和e（等式）的表t进行的。

使用SQL 2017函数TRANSLATE在字符之间切换并生成不仅包含方程式而且包含转换回原始字符的代码的字符串：

SELECT TRANSLATE(123 + 456 + 789,'0123456789','abcdefghij') 

然后使用评估此字符串EXEC()。

可能会有一些字符（例如单引号'）会破坏此代码；我尚未测试所有可能的ASCII字符。

根据挑战，我将评估给定的表达式，具体取决于我的语言如何解释这些运算符。这样，由于整数除法，第二个测试用例返回1（w），而不返回2（e）。

Perl 6、38个字节

{*.trans($_=>^10).EVAL.trans(^10=>$_)}

在线尝试！

我不确定四舍五入应该如何工作。如果轮末尾，则我可以添加.round为+6个字节。如果的行为/不同，则可能会更长。像咖喱一样接受输入f(arithmetic)(numerals)(arithmetic)。

说明：

{                                    }  # Anonymous codeblock
 *                                      # Returning a whatever lambda
  .trans($_=>^10)       # That translates the numerals to digits
                 .EVAL  # Evaluates the result as code
                      .trans(^10=>$_)   # And translates it back again

Stax，74 66 65 字节

┼ö8Q#xóπcM~oÖ÷╦├mî☼yº─▐4ç≥e╘o▄ê‼ø_k╜ø8%N╫ ╗e<.╗P[─╛èA±!xêj«w╠°{B♪

运行并调试

Stax在这里表现不佳，缺少真正的“评估”指令。它在文档中有一个称为“ eval”的名称，但仅适用于文字值，不适用于完整表达式。

Bash，97个字节

IFS=''
read S
read O
A=`echo "$O"|tr "$S" 0-9`
printf %0.f `bc<<<"(${A[@]##0})+0.5"`|tr 0-9 "$S"

如果我们可以截断而不是四舍五入的话，可能会更少。由于Bash会将以0开头的数字解释为八进制，因此很难处理前导零（如在测试用例2中一样）。

Bean，94个 90字节

十六进制转储

00000000: 53d0 80d6 d800 d3d0 80a0 1f20 8047 53a0  SÐ.ÖØ.ÓÐ. . .GS 
00000010: 1753 d080 d3d0 80a0 5e20 800a a181 8100  .SÐ.ÓÐ. ^ ..¡...
00000020: 40a0 5f52 cac3 4da0 6580 53d0 80a0 5d20  @ _RÊÃM e.SÐ. ] 
00000030: 8089 205f a065 205f 2080 0aa1 8181 0123  .. _ e _ ..¡...#
00000040: 0058 0020 800a a181 8102 40a0 6550 84a0  .X. ..¡...@ eP. 
00000050: 5d20 652e dce2 b02b dc64                 ] e.Üâ°+Üd

的JavaScript

`${Math.round(
  eval(
    b.replace(
      /./g,
      c => ~(i = a.indexOf(c)) ? i : c
    ).replace(
      /\b0+/g,
      ''
    )
  )
)}`.replace(
  /\d/g,
  i => a[i]
)

说明

该程序隐式地将输入的第一行和第二行作为字符串分别分配给变量a和b。

每个字符c线b被替换为相应的索引i的字符的行上发现的a，或本身如果未找到它。

然后，它0从结果字符串中删除每个以一个或多个s开头并带有边界的序列。这是为了防止eval()评估0以八进制文字开头的任何数字序列。

在eval()和之后Math.round()，结果被强制返回字符串，每个数字字符i被a索引处的对应字符替换i。

测试用例

演示版

abcdefghij
abcd + efg + hij

bdgi

演示版

abcdefghij
abc + def - ghij

-gedc

演示版

qwertyuiop
qwerty / uiop

e

演示版

%y83l;[=9|
(83l * 9) + 8%

y9|8

Perl -p 5，63个字节

$p=<>;eval"y/$p/0-9/";s/\b0+\B//g;$_=int.5+eval;eval"y/0-9/$p/"

在线尝试！

在输入的第一行中使用表达式，在第二行中使用翻译列表。

Perl 5，130个字节

sub f{eval sprintf"'%.0f'=~y/%s/%s/r",eval(eval(sprintf"\$_[1]=~y/%s/%s/r",@r=map"\Q$_",$_[0],'0123456789')=~s,\b0,,gr),reverse@r}

在线尝试！

也许双重评估可以变成现实s/.../.../geer。

木炭，14字节

⍘ＵＶ⭆η⎇№θι⌕θιιθ

在线尝试！链接是详细版本的代码。注意：表达式是根据Python 3语义求值的，因此例如在非零数字上的前导零是非法的。说明：

   ⭆η           Map over expression's characters and join
        ι       Current character
      №θ        Count matches in first input
     ⎇          If non-zero
         ⌕θι    Replace with position in first input
            ι   Otherwise keep character unchanged
 ＵＶ             Evaluate as Python 3
⍘            θ  Convert to base using first input as digits

Python 3，137字节

一种非正则表达式方法，使用str.translate和str.maketrans替换字符。在修整前导零时，我失去了很多角色...

lambda s,t,d='0123456789',e=str.translate,m=str.maketrans:e(str(round(eval(' '.join(c.lstrip('0')for c in e(t,m(s,d)).split())))),m(d,s))

在线尝试！

Python 3，167字节

import re
a=[*enumerate(input())]
e=input()
for i,c in a:e=re.sub(c,str(i),e)
e=str(round(eval(re.sub(r'\b0+(?!\b)','',e))))
for i,c in a:e=re.sub(str(i),c,e)
print(e)

在线尝试！

有待改进...

Wolfram语言（Mathematica），121字节

我用两个参数定义一个纯函数。由于重复了某些功能，因此我将它们保存在变量中以保存一些字符。这段代码只是简单地进行了一些字符串替换，然后使用ToExpressionWolfram内核对表达式进行求值。

(r=Thread[StringPartition[#,1]->(t=ToString)/@Range[0,9]];u[(u=StringReplace)[#2,r]//ToExpression//Round//t,Reverse/@r])&

在线尝试！

的Lua，162个 151 150字节

• -11个字节感谢我的使用load而不是function(...) end
• -1字节，省略换行符

l,p=...print(((math.ceil(load('return '..p:gsub('.',load'n=l:find(...,1,1)return n and n-1'))()-0.5)..''):gsub('%d',load'c=...+1 return l:sub(c,c)')))

在线尝试！

这不是世界上最短的事情（Lua迫使您花大力气，尤其是使用大关键字），但创建起来却很有趣。完整程序，将输入作为参数并打印结果。

说明

介绍

l,p=...

将参数中的值分配给变量。我们的字典是l，表达式是p。

以下表达式很难理解，因为它的执行顺序很奇怪，因此我将逐步解释它：

转换为普通数字

p:gsub('.',
load'n=l:find(...,1,1)return n and n-1')

在表达式字符串上执行替换：取每个符号并将其传递给函数（load在这里证明自己比正常声明更短）。

函数使用来为传递的符号找到字典字符串中出现的位置find。...是第一个（也是唯一一个）参数，因为我们在vaarg函数（任何loaded是）中，这是当前的符号。需要使用以下参数来find忽略特殊符号（1只是短值，其true转换为布尔值时的计算结果）：起始位置（此处为默认值）和plain，实际上会禁用模式处理。如果没有这些程序，则会由于%特殊而导致第三个测试用例失败。

如果找到匹配项，则减去1，因为Lua字符串（和数组btw）基于1。如果未找到匹配项，则它将不返回任何内容，从而导致无法进行替换。

解决

math.ceil(load('return '..ABOVE)()-0.5)

放在return我们的表达式之前，让它返回结果，通过编译为Lua函数并调用它来计算结果，然后进行舍入（这反过来使它更短）。

最后，我们获得了解决问题的数值方法，只剩下将其转换回去了。

再次变得疯狂

(ABOVE..'')
:gsub('%d',load'c=...+1 return l:sub(c,c)')

第一行是将数字转换为字符串的一种简短方法，因此现在我们可以以一种简短的方式调用字符串方法。来吧！

现在gsub再次被召唤，以取代一切恢复精神错乱。由于我们的函数可能并且必须仅处理数字（使用负数会导致错误），因此%d使用该时间代替.替代模式.。此时间函数（load再次编辑以保存字节）首先添加1到其第一个（也是唯一的）参数中，将其转换为字典字符串中的位置，然后从该位置返回字符。

万岁，快到了！

戏剧性的结局，或者为什么括号很重要

print((ABOVE))

好吧……为什么还是要有两副括号？现在该谈论平行……呃，Lua中的多次返回。问题是一个函数一次调用可能返回的值很少（有关更多示例，请参见此元问题）。

在这里，最后一个gsub返回两个值：我们需要的答案字符串和完成的替换次数（实际上是位数，但谁在乎）。如果不是用于内部配对，则将同时打印字符串和数字，这使我们很困惑。因此，在这里我们牺牲了两个字节来省略第二个结果，并最终打印出这个疯狂工厂的产品。

好吧，我很喜欢解释高尔夫，几乎是第一名，希望您能了解这里发生的一切。