周报----3.2

1.coding笔记

        454题-四数相加ll：力扣  

        349题-两个数组的交集：力扣

2.读书笔记

1.1

题干：

给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：

0 <= i, j, k, l < n
nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0
 

思路：利用hashmap，把前两个数的和存再hashmap中并赋值为1，出现相同数时，使hashmap加一。求key=0-后两个数的和，当key存在于hashmap中时，把hashmap的值赋给count，返回hashmap

代码：

class Solution:

    def fourSumCount(self, nums1: List[int], nums2: List[int], nums3: List[int], nums4: List[int]) -> int:

        hashmap = dict()

        for n1 in nums1:

            for n2 in nums2:

                if n1 + n2 in hashmap:

                    hashmap[n1 + n2] += 1

                else:

                    hashmap[n1 + n2] = 1

        count = 0

        for n3 in nums3:

            for n4 in nums4:

                key = - n3 - n4

                if key in hashmap:

                    count += hashmap[key]

        return count

1.2 

题干：

给定两个数组 nums1 和 nums2 ，返回 它们的交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。

思路：

利用set（）方法去重，用&取同时存在的字符，再有将结果用list（）转化为列表来表示

代码：

class Solution: def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:

        return list(set(nums1) & set(nums2))

2.读书笔记《fluent python》

        

map(function,iterable)

def square(x):

return x**2

map(square,[1,2])

----<map object at 0x100d3d550>

list(map(square,[1,2]))

----[1,4]

list(map(lambda x: x**2, [1, 2]))

----[1,4]

生成器表达式：遵循了迭代器协议，能够节省内存。类似于列表，只是把方括号换成圆括号

ord（c）：返回c的ascii数值，十进制

ord(‘a’)

----97

元组：不可变列表，没有字段名的记录：元组中的每个元素都存放了一个字段的数据，外加这个字段的位置

list.sort：就地排序列表，不会把原列表复制一份，返回值是none。

（如果一个函数或方法对对象就地改动，返回值是none。例如random，shuffle）

sorted：建立一个列表作为返回值，接受任何形式的可迭代对象作为参数

参数，reverse，key

reverse默认是flase，true时以降序输出

key排序算法以来的对比关键字。

fruits = [‘grape’,’raspberry’,’apple’,’banana’]

sorted(fruits, key=len, reverse=True)

----[‘raspberry’, ’banana’, ‘grape’, ’apple’]

存放浮点数时，数组在背后存的不是float对象，而是数字的机器翻译

数组从文件读取和存入文件的方法：.frombytes   .tofile

from array import array    #引入array类型

from random import random

froats = array(‘d’,(random() for i in range(10**7)))    #利用一个迭代对象来建立一个双精度浮点数组

floats[-1]

----0.0257907358

fp = open(‘float.bin’, ‘wb’)

float.tofile(fp)    #把数组存入一个二进制数组里

fp.close()

floats2 = array(‘d’)

fp = open(‘floats.bin’, ‘rb’)

float2.fromfile(fp, 10**7)    #把10**7个浮点数从二进制文件里读出

fp.close()

floats2[-1]

----0.0257907358

floats2 == floats

----True

“B”类型：无符号数； memory.cast：能用不同的方式读写同一块内存数据，而且内容字节不会随意移动。

#二维数组

import numpy

a = numpy.arange(12)

a

----array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

type(a)

<class ‘numpy.ndarray’>

a.shape   #查看数组维度

----(12,)

a.shape = 3 , 4  #把数组变成二维

a

----array([ [0, 1, 2, 3],

[4, 5, 6, 7],

[8, 9, 10, 11]])

a[2]

----array([8, 9, 10, 11])

a[2, 1]

----9

a[:, 1] #打印第一列

----array[1, 5, 9]

a.transpose() #行和列交换，形成一个新的数组

----array([[0, 4, 8]

[1, 5, 9]

[2, 6, 10]

[3, 4, 11]])