【Kata Daily 190904】Calculating with Functions（函数计算）

原题：

This time we want to write calculations using functions and get the results. Let's have a look at some examples:

seven(times(five())) # must return 35
four(plus(nine())) # must return 13
eight(minus(three())) # must return 5
six(divided_by(two())) # must return 3

Requirements:

• There must be a function for each number from 0 ("zero") to 9 ("nine")
• There must be a function for each of the following mathematical operations: plus, minus, times, dividedBy (divided_by in Ruby and Python)
• Each calculation consist of exactly one operation and two numbers
• The most outer function represents the left operand, the most inner function represents the right operand
• Divison should be integer division. For example, this should return 2, not 2.666666...:

eight(divided_by(three()))

-----------------------------------------------------------------------------------------------------------------------------
题目的要求就是利用函数的方式进行加减乘除，如：seven(times(five())) ------->相当于：7*5=35

解题过程

这道理不会做 o(╥﹏╥)o。


以下是一位网友的解决思路：

def zero(a='0'):
    if a != '0':
        if a[0]=='+':
            return 0+int(a[1])
        if a[0]=='-':
            return 0-int(a[1])
        if a[0]=='*':
            return 0*int(a[1])
        if a[0]=='/':
            return int(0/int(a[1]))
    else:
        return '0'
def one(a='1'):
    if a != '1':
        if a[0]=='+':
            return 1+int(a[1])
        if a[0]=='-':
            return 1-int(a[1])
        if a[0]=='*':
            return 1*int(a[1])
        if a[0]=='/':
            return int(1/int(a[1]))
    else:
        return '1'
def two(a='2'):
    if a != '2':
        if a[0]=='+':
            return 2+int(a[1])
        if a[0]=='-':
            return 2-int(a[1])
        if a[0]=='*':
            return 2*int(a[1])
        if a[0]=='/':
            return int(2/int(a[1]))
    else:
        return '2'
def three(a='3'):
    if a != '3':
        if a[0]=='+':
            return 3+int(a[1])
        if a[0]=='-':
            return 3-int(a[1])
        if a[0]=='*':
            return 3*int(a[1])
        if a[0]=='/':
            return int(3/int(a[1]))
    else:
        return '3'
def four(a='4'):
    if a != '4':
        if a[0]=='+':
            return 4+int(a[1])
        if a[0]=='-':
            return 4-int(a[1])
        if a[0]=='*':
            return 4*int(a[1])
        if a[0]=='/':
            return int(4/int(a[1]))
    else:
        return '4'
def five(a='5'):
    if a != '5':
        if a[0]=='+':
            return 5+int(a[1])
        if a[0]=='-':
            return 5-int(a[1])
        if a[0]=='*':
            return 5*int(a[1])
        if a[0]=='/':
            return int(5/int(a[1]))
    else:
        return '5'
def six(a='6'):
    if a != '6':
        if a[0]=='+':
            return 6+int(a[1])
        if a[0]=='-':
            return 6-int(a[1])
        if a[0]=='*':
            return 6*int(a[1])
        if a[0]=='/':
            return int(6/int(a[1]))
    else:
        return '6'
def seven(a='7'):
    if a != '7':
        if a[0]=='+':
            return 7+int(a[1])
        if a[0]=='-':
            return 7-int(a[1])
        if a[0]=='*':
            return 7*int(a[1])
        if a[0]=='/':
            return int(7/int(a[1]))
    else:
        return '7'
def eight(a='8'):
    if a != '8':
        if a[0]=='+':
            return 8+int(a[1])
        if a[0]=='-':
            return 8-int(a[1])
        if a[0]=='*':
            return 8*int(a[1])
        if a[0]=='/':
            return int(8/int(a[1]))
    else:
        return '8'
def nine(a='9'):
    if a != '9':
        if a[0]=='+':
            return 9+int(a[1])
        if a[0]=='-':
            return 9-int(a[1])
        if a[0]=='*':
            return 9*int(a[1])
        if a[0]=='/':
            return int(9/int(a[1]))
    else:
        return '9'
 
def plus(a):
    return '+'+a
def minus(a):
    return '-'+a
def times(a):
    return '*'+a
def divided_by(a):
    return '/'+a

这位网友的思路很好理解：

　　数字函数的传值默认为本身，且默认传回自身的值。如果参数值为其他，则根据参数值判断算法类型符合哪种算法，最后进行相加减。  算法函数只要是将算法的符号和值进行字符串合并，用于在数字函数中进行判断。如：seven(times(five()))

　　第一步：先执行five()函数，由于没有参数值，因此使用默认的参数值，返回自身，即：5。

　　第二步：处理times(5)函数，将5和算法符号进行合并，即：符号'*'和5合并，返回字符串"*5"

　　第三步：处理seven("*5")函数，由于数字函数有参数，因此执行else里面的内容，根据a[0]即字符串的第一个字符来判断符合哪种算法，再将值（即a[1]）进行运算，即：5*7=35

优质解答：

def zero(f = None): return 0 if not f else f(0)
def one(f = None): return 1 if not f else f(1)
def two(f = None): return 2 if not f else f(2)
def three(f = None): return 3 if not f else f(3)
def four(f = None): return 4 if not f else f(4)
def five(f = None): return 5 if not f else f(5)
def six(f = None): return 6 if not f else f(6)
def seven(f = None): return 7 if not f else f(7)
def eight(f = None): return 8 if not f else f(8)
def nine(f = None): return 9 if not f else f(9)
 
def plus(y): return lambda x: x+y
def minus(y): return lambda x: x-y
def times(y): return lambda  x: x*y
def divided_by(y): return lambda  x: int(x/y)

我们来探讨一下这种算法的思路：

　　数字函数中，先判断是否为None，为None则返回自身。如果不为None则执行函数f。算术函数返回一个匿名函数。还是选择例子：seven(times(five()))

　　第一步：先处理five()函数，即返回自身5。times(5)

　　第二步：处理times(5)，结果为返回一个匿名函数，函数内部的y值为5。

　　第三步：处理f函数，函数f为算术函数处理结果，即返回的匿名函数。f(7)相当于执行匿名函数：lambda 7：7*5处理结果为35。

知识点：

　　1、使用了函数默认参数值：

　　　　def one(a=1):  即默认参数a默认传值为1，可自行定义a的参数值。

　　2、使用了匿名函数lambda

　　　　lambda 的格式为：lambda x, y: x + y。x和y是需要传入的形参。x+y是函数的处理结果。

　　3、使用了闭包

　　　　算术函数的返回值是一个函数，即将先一步处理的结果（y=5）和匿名函数一起保存了下来。而seven(f)，就是将这个包赋给了f，f变成了含有y值的匿名函数。

　　4、