python高级练习题:代数列表【难度：4级】--景越Python编程实例训练营,不同难度Python习题，适合自学Python的新手进阶

python高级练习题:代数列表【难度:4级】:

语境和定义

你是负责开发一个新酷JavaScript库,它提供类似的[Underscore.js(http://underscorejs/)功能.

你已经加入了新的** 列表数据类型** 到库开始.你想出了表示为一对元件的代数数据类型的数据结构的一个设计:

功能缺点(头,尾){
    this.head =头;
    this.tail =尾;
}

一流的缺点:
  DEF __init __(个体,头,尾):
    self.head =头
    self.tail =尾

生锈
# [派生(调试,PartialEq,等式)]
枚举缺点 {
  缺点(T,框<缺点>),
  空值
}

IMPL 缺点 {
  酒馆FN新(头:T,尾:自) - >自{
    缺点::缺点(头,箱::新(尾))
  }
}

你是很聪明的,因为使用这种新的数据类型,我们可以轻松地构建元素的列表.例如,数字列表:

VAR =数字新缺点(1,新的缺点(2,新的缺点(3,新的缺点(4,新缺点(5,NULL)))));

号码=缺点(1,反对(2,反对(3,缺点(4,反对(5,无)))))

生锈
让号码=缺点::新的(1,缺点::新(2,缺点::新的(3,缺点::新的(4,缺点::新(5,缺点::空)))));

在与你的老板代码审查,你解释他的每* cons单元* 如何包含它的头一个"值",并在它的尾巴它包含任何其他缺点细胞或空.我们知道,我们已经达到了数据结构的末尾时尾部为空.

所以,你的老板很高兴这个新的数据结构,并想知道如果你将能够建立一个围绕它的一些更多的功能.在演示中,你这个星期做你的团队的其他成员,以说明这是如何工作的,你给他们的方法来改变你的列表数据类型的项目清单到JavaScript数组:

功能指定者(列表){
如果(名单){
VAR =更多list.tail;
返回[list.head] .concat(更指定者(更):[]);
}
返回[];
}

Cons.prototype.toArray =函数(){返回指定者(本); };

# 添加到类实现:
  高清to_array(个体经营):
    尾= self.tail
    new_tail =(tail.to_array()如果尾不是无别的[])
    返回[self.head] + new_tail

生锈
IMPL 缺点 {
  酒馆FN to_vec(自) - > VEC  {
    比赛自{
      &反对::空=> VEC![],
      &反对::缺点(参照头,尾REF)=> {
        让MUT头= VEC [head.clone()]!;
        head.extend(tail.to_vec());
        头
      }
    }
  }
}

而且他们很惊讶,当你只是这样做:

的console.log(numbers.toArray()); //产量[1,2,3,4,5]

打印(numbers.to_array())# 收率[1,2,3,4,5]

生锈
!调用println( "{:?}",numbers.to_vec()); //产量[1,2,3,4,5]

的新要求

现在,球队相信,这是去和他们想建立一个围绕这个很酷的新的数据类型库的方式,但他们希望你能为他们提供一些更多的功能,这样他们就可以开始解决在使用这种类型的一些现实问题.

你一直在念叨一个名为[应用性编程(http://quod.lib.umich.edu/s/spobooks/bbv9810.0001.001/1:15?rgn=div1;view=fulltext)技术基本上在于把一个功能列表中的每个元素.所以,你给它一些思考,你已经决定开始加入的功能,如** ** 过滤器,** 地图** 和** ** 减少.基本上你要到JavaScript数组中,并在未来更提供相同的功能.

所以,你现在将添加:

- 过滤:创建只包含满足谓词函数的元素的新的代数列表.
- 图:创建一个新的列表,其中每个元素是将作为参数所提供的功能的结果.
- fromArray:创建列表出JavaScript数组矩阵的一个方便的补充方法.

对于这个习题,Cons和原型/类方法’的定义toArray/to_array/into_vec`已经加载在您的环境.

用法的例子

VAR =数字Cons.fromArray([1,2,3,4,5]);
numbers.filter(功能(N){返回N%2 === 0;})指定者(); //产率[2,4]
numbers.map(功能(N){返回N * N;}).指定者(); //产量[1,4,9,16,25]

VAR =位数Cons.fromArray([ "1", "2", "3", "4", "5"]);
VAR =整数digits.map((多个)功能{返回parseInt函数(一个或多个);})
                     .filter(功能(N){返回N> 3;})
                     .toArray(); //产率[4,5]

号码= Cons.from_array([1,2,3,4,5])
numbers.filter(拉姆达X:X%2 == 0).to_array()# 产率[2,4]
numbers.map(拉姆达X:X * X).to_array()# 收率[1,4,9,16,25]

位数= Cons.from_array([ "1", "2", "3", "4", "5"])
整数= digits.map(INT)\
                 .filter(拉姆达N:N> 3)\
                 .to_array()# 产率[4,5]

生锈
让号码=缺点:: from_iter(VEC [1,2,3,4,5]!);
numbers.filter(| X | X%2 == 0).into_vec(); //产率[2,4]
numbers.map(| X | X * X).into_vec(); //产量[1,4,9,16,25]

让位数=缺点:: from_iter(VEC [ "1", "2", "3", "4", "5"]!);
让整型= digits.map(STR ::解析:: )
                 .MAP(结果::展开)
                 .filter(|&N | N> 3)
                 .into_vec()//产率[4,5]

换一种说法:

- 静态方法Cons.fromArray(或from_array,from_iter)产生缺点(1,反对(2,反对(3,4缺点,缺点5,NULL))))).
- 上述过滤创建一个新的列表:缺点(2,缺点(4,NULL)).
- 也是如此上述地图:缺点(1,COS(4,反对(9,反对(16,反对(25,NULL))))).

编程目标:

class Cons:
    def __init__(self, head, tail):
        self.head = head
        self.tail = tail
    def to_array(self):
        return [self.head] + (self.tail.to_array() if self.tail is  None else [])
    @classmethod
    def from_array(cls, arr):
        #TODO: convert a Python list to an algebraic list.
        pass
    def filter(self, fn):
        #TODO: construct new algebraic list containing only elements
        pass
    def map(self, fn):
        #TODO: construct a new algebraic list containing all elements
        #      resulting from applying the mapper function to a list.
        pass

测试样例:

test.describe("Kata Test Suite")
test.it("should create a list out of an array")
test.assert_equals(Cons.from_array([]), None)
test.assert_equals(Cons.from_array([1,2,3,4,5]).to_array(), [1,2,,,5])
test.it("should filter elements from a list")
test.assert_equals(Cons.from_array([1,2,3,4,5])
                       .filter(lambda n: n > 3)
                       .filter(lambda n: n > 5), None)
test.it("should create a new transformed list out of a source list")
test.assert_equals(Cons.from_array(["1","2","3","4","5"])
                       .map(int)
                       .to_array(), [1,2,3,4,5])
18