如何实现基于位置值的乘法算法？

Question

放置值（位置）编码数

为了能够以基于位置值的方式乘以数字，我以列表格式编码数字，以相反的顺序逐位编号。比方说34是[4 3]而12是[2 1]。

要编码我使用的数字：

def eN(n):
    return list(map(int, reversed(str(n))))

解码我使用：

def dN(l):
    return int(''.join(map(str, reversed(l))))

这样：dN(eN(34)) -> 34

正整数可以是0到任何数字长。

乘法约束

现在，我需要创建一个带有下一个约束的乘法算法：

1

找出满足此函数的分数的整数和余数部分的除法方法：

from math import floor
# div(5, 3) -> [1, 2]
def div(n, base = 10):
    return [floor(n / base), n % base]

1. 只允许算术运算是div，*和+方法，但这些方法可以与递归一起使用
2. 数字必须按上述方式编码，但基数为2及以上的原生整数
3. 算法编号的任何部分都不能超过两位数。例如，9 + 9 = 18或9 * 9 = 81是好的，但100是太多
4. 结果也应该是以反向列表格式编码的数字列表。列表中的数字必须是单个数字，以便我们可以使用解码函数（dN）将其转换回原生整数
根据@ShadowRanger的建议，
5. 算法应使用div或内置Python divmod处理任意数字。

当建议给出答案时，可能需要其他限制来强调。

涉嫌算法

我会想到一个与此类似的根函数，其中两个编码的数字作为参数给出，加上一个可选的基数，默认为10：

def mul(a, b, base = 10):
    def _(c, d, e):
        # arithmetics, carrying digits, list processing, recursive calls goes here
        pass
    # initially, the first digit of the number a is reduced and 10^0 parts of the both numbers are multiplied and "div"ided
    return _(a[1:], b, div(a[0]*b[0], base))

最后，预期的结果是：

mul(eN(34), eN(12)) # [8, 0, 4] 

或

dN([8, 0, 4]) # 408

如果有必要，我可以在乘法_函数中添加更多内容，此函数目前仅通过...

稍后添加......

算法的工作，但凌乱和未经优化的版本

有人可能希望将此作为优化的起点。我应该注意，这应该已经完全按照我的需要完成工作，但欢迎其他方法：

def mul(a, b, base = 10):
    # init function with some default values
    def _(c, d, f = [], g = [], h = [], e = 0):
        # if there are no more items in list d, this is the end result
        if not d:
            return h + f
        # if there are items in list list c, get integer and reminder parts and other stuff 
        # and proceed with the rest of the list c
        if c:
            x = divmod(c[0] * d[0] + (f.pop(1) if len(f) > 1 else 0) + e, base)
            return _(c[1:], d, f, g + [x[1]], h, x[0])
        # else we have reached the end of the list c and must begin again with the rest of the list d!
        # also append reminders to the result lists h and f, not that content of f comes from g at this point
        return _(a, d[1:], (g + [e] if e else g), [], (h + [f[0]] if f else h))
    # start calling the recursive function and return the end result
    return _(a, b)

我会接受任何做同样工作的答案，即使是使用上述代码的答案，如果解决方案做出了很好的改进，例如缩小了列表的需求，即使用内存，或者其他方式简化并解释了解决方案。