递归的一次简单探讨

在看某篇javascript文档递归部分的时候，发现原本以为很熟悉的递归，其实还是有些地方做的不求甚解了，再细细看了下书中的代码，倒是觉得挺有意思：

function findSolution(target) {
  function find(current, history) {
    if (current == target) {
      return history;
    } else if (current > target) {
      return null;
    } else {
      return find(current + 5, `(${history} + 5)`) ||
             find(current * 3, `(${history} * 3)`);
    }
  }
  return find(1, "1");
}

console.log(findSolution(24));
// → (((1 * 3) + 5) * 3)

顺手就用python在实现了一遍， 发现作为动态类型语言，两者的确有某种异曲同工的地方

def findSolution(target):
    def find(current, history):

        if current == target: return history
        elif current > target: pass
        else:
            return find(current + 5, "({} + 5)".format(history)) or find(current*3,  "({}*3)".format(history))

    return find(1, "1")

print(findSolution(13))

因为最近在看golang相关方面的东西，所以想用go来实现一遍，结果就一直卡在这里大半天，静态语言不熟悉，请大佬指导一下总算有一个大概的解法了

func findSolution(target int, current int, history string) (string, error){

    if current == target{
        return history, nil
    }else if current > target{
        return "", fmt.Errorf("no resulet")
    }else{
        rst, err := findSolution(target, current + 5, fmt.Sprintf("(%s + 5)", history))
        if err != nil {
            rst, err = findSolution(target, current*3, fmt.Sprintf("(%s * 3)", history))
        }
        return rst, err
    }
}

findSolution(13, 1, "1")

总结就是：动态语言诸如python、ruby之类， 开发起来效率确实快，很多时候所思所想就是代码实现
而golang之类的静态语言，开发效率可能没那么高，写代码的时候更多就是要思考、设计了， 但是胜在静态语言本身的性能以及执行效率可谓非常之高了