【学习笔记】在刷题前--刷题中常见事项

刷题中常见事项

目录

• 刷题中常见事项
  • java
    • 字符和字符串
    • java中关于for循环；
  • python
    • python中正确的创建二维数组：
    • python中链表和list的相互转化
    • python中数学的常用操作
    • python中的排序
    • python中字符串的常用操作
    • python中collections中的计数器Counter
    • python正则表达式
      • re.findall
      • re.match
      • re.search
    • python中range和random
    • python中filter函数的用法
    • python中二分查找函数bisect
    • python中进制的转换
  • 通用
    • 常见的ascii值
    • 关于排序好的数组；

java

字符和字符串

//String的常用方法：
//1.将字符串转为字符数组；
char[] strArr = s.toCharArray(); 
//2.如果有分隔符，可以将其分割转化为字符串数组；
String[] strArr = s.spilt(",") //根据逗号分割；注意这个是String数组；
String[] strArr = s.split("\\s+");  //根据空格分割，正则表达式，可以使一个或多个空格；
//3.获取第i个位置的字符；
char c = s.charAt(i);   
//4.将字符数组转化为字符串；
String str = String.valueOf(char[] ch);
//5.连接字符串（数组或集合）；
String str = String.join("-", arr); //以-连接数组或者是集合；
//6.去掉首尾空格；
String str = s.trim(); //新建了一个字符串；
//7.指定子串；
String str = s.substring(start,end); //指定开始和结束的子串，前开后闭；

//将字符数组转化为字符串：
//1.直接在构造时转换；
char[] data = {'a','b','c'};
String str = new String(data); //"abc";
String str = new String(data, 0, 1) //"a",从0开始读，读一个字符；
//2.方法转换
String.valueOf(char[] ch); 
//将字符串转为字符数组：
char[] ch = str.toCharArray();
//将整形转为字符串；
String str = Integer.toString(n);  
//将字符串转为整形；
int n = Integer.parseInt(str);

//StringBuilder常用方法：
//字符串经常会用到拼接，但是拼接很繁琐，
//而且每次拼接都会创建一个String，既耗时，又浪费空间；   
//所以可以用StringBuffer和StringBuilder来做：
StringBuilder strB = new StringBuilder(); 
strB.append("hello");  //字符串拼接；
strB.chatAt(index); //获取index处的字符；注意千万不能用StrB[index]不是数组！
strB.setCharAt(index,str); //将第i个字符串替换为str；
strB.deleteChatAt(index); //删除指定位置的元素；
strB.toString();       //返回String类型；

java中关于for循环；

//普通for循环：
for（int i = 0； i < nums.length; i++){
    //多用于知道长度而且需要知道索引的时候；
}
//增强for循环；
for(int i : nums){
    //多用于不知道有多长的时候，比如set，list等，或者不关心索引的时候；
}

python

python中正确的创建二维数组：

matrix = [[None]*m for _ in range(n)]    # 这才是正确的创建方法
matrix[0][1] = 1

python中链表和list的相互转化

在做链表的题时，可以将链表转为list进行处理，这样就可以利用list的各种方法，比如排序啊什么的，然后最后再把list转为链表就可以了

def list2linkedlist(l):
    head = None   #防止是空列表
    if l:
        head = ListNode(l[0])
        cur = head
        for i in range(1, len(l)):
            cur.next = ListNode(l[i])
            cur = cur.next
    return head
------------------
def linkedlist2list(head):
    ret = []
    while head:
        ret.append(head.val)
        head = head.next
    return ret

python中数学的常用操作

2/3  #正常除法：0.66666667，所得结果都为float，即使整除也一样
8//3   #取整(地板除）： 2，所得结果为int
round(4.2)  #四舍五入  4
round(4.222,1)  #第二个参数是保留小数位数：4.2
> 实际上，round并不总是能够完全的四舍五入，为什么呢？，因为在python里，数值并不总是精确存储的
例如，1.115，if使用decimal(1.115)来表示一下的话，是1.1149999999999999911182158029987476766109466552734375,所以在四舍五入保留两位的时候肯定就是1.11了；   
所以round在执行的时候，比如要保留两位小数，那就看第三位，假设为c     
if c < 5:那直接舍去；
if c > 5:那直接进位；
if c = 5: 这时候要看整个数字是不是精确存储(可以使用decimal(num)打印看一下是不是精确存储；   
   if 精确存储-》奇进偶舍（c的前1位也就是第2位小数是奇数，那直接进位，if是偶数，那就舍去c）
   if 不精确存储 -》直接截断，所以值肯定会变小

# decimal模块
# decimal模块传入的参数尽量是整型和字符串，这样才能保证精确
from decimal import Decimal
print(1.2+2.1 == 3.3)   # 这是不一定相等的，原因就是不精确表示，答案可能是3.300000001
print(Decimal('1.2')+Decimal('2.1') == Decimal('3.3'))  # True

import decimal
decimal.getcontext().rounding=decimal.ROUND_HALF_UP  # 四舍五入
c = decimal.Decimal('2.135').quantize(decimal.Decimal('0.00')   # 2.14 保留两位小数；
decimal.getcontext().rounding=decimal.ROUND_HALF_DOWN # 四舍五不入
c = decimal.Decimal('2.135').quantize(decimal.Decimal('0.00')   # 2.13 保留两位小数；
# math模块
math.ceil(4.2)   #向上取整 5
math.floor(4.2)  #向下取整 4
math.trunc(4.4)  #截取整数位  4
a = math.gcd(6, 8)  #最大公约数  2
6*8/a  #最小公倍数 24.0

python中的排序

对一个可迭代序列进行排序有两种方法，一个是sort方法，一个是sorted函数

lst.sort()  # lst可以是列表，元祖，字典，字符串等，默认按照升序排序，可以设置reverse = True来进行降序排列；     
# 还有一个关键参数key，其可以指定按照什么规则进行排序，例如     
lst.sort(key = len)   #按照列表中元素的长度进行排序
lst.sort(key = lambda x : x[0]）   #比如lst的元素还是列表，这就是按照元素的第一个升序进行排序
lst.sort(key = lambda x : (-x[0],x[1]))  # lst的元素还是列表，按照元素的第一个降序排序，if第一个相等，再按照第二个升序排序
lst1 = sorted(lst)   #和sort方法基本一致，唯一区别是有返回值，对原始序列不做修改
# 例如字典是这种类型：
hashtable = {'a': [2,2,3,4], 'b':[0,1,3,4], 'c':[3,2,3,4]}
print(hashtable.items())  #这里返回的是列表，列表里是元祖： [('a', [2, 2, 3, 4]), ('b', [0, 1, 3, 4]), ('c', [3, 2, 3, 4])] 
sort_list = sorted(hashtable.items(), key = lambda x : (x[1][1],x[1][0]))  #按value值的索引1位置排序，if相等再按索引0位置排序，注意最后返回的是列表
print(sort_list)  # [('b', [0, 1, 3, 4]), ('a', [2, 2, 3, 4]), ('c', [3, 2, 3, 4])]

#对字符串列表使用sort进行排序时，默认是按照ascii码进行排序，所以if是字母，则大写字母是在小写字母前面。
spam = ['a', 'z', 'A', 'Z']
spam.sort()  #['A','Z','a','z']
所以可以指定sort函数后面的关键字key，这个key的值是一个函数
spam.sort(key=str.lower)  #['a','A','z','Z'] 
这个就是用这个函数执行这个list的所有元素，然后进行排序；再比如，if想要按照每个元素的长度进行排序
spam.sort(key=len)  #按照元素长度进行排序   

s1 = ['1','12','21',2]
s1.sort()  #['1','12','2','21']  并不是从大到小，所以可以
s1.sort(key=int) #转换为整数进行排序，if再指定reverse=True则可以降序排序

python中字符串的常用操作

#字符串和数字的转换：
num = int('123')  #字符串转为数字
s1 = str(123)   #数字转为字符串‘123’

在python中不能对字符直接进行减操作：例如 'a'-'b'    
而是需要将其用ascii码进行相减：  ord('a')-ord('b')  #ord为将制定字符转为ascii码

#字符串常用方法
name = "xiao ming"
i_count = name.count("i")  #统计某字符出现的次数：2 

name = ['aa','bb','cc','dd']
'--'.join(name)  #连接元素，以'--'进行连接，name必须为字符串序列！
aa--bb--cc--dd

name.replace(old, new[,max])  #用new字符来代替old字符，最多不超max次，max不指定就是全部替换，返回新的字符串

name.rjust(12,'0')  #右对齐，向左填充0至12个字符  '000xiao ming'
name.ljust(11,'1')  #左对齐，向右填充1至11个字符  'xiao ming11'； 都是返回新字符串，原字符串不发生改变；默认是以空格填充
name.zfill(11)      #右对齐，向左填充0至11个字符  '00xiao ming'

name.split('i')  #以字符i进行分割,返回字符串数组，默认是所有的空字符，例如空格等
# ['x','ao m','ng']   
name.splitlines()  #以换行(\n)进行分割
python自带的split只能指定一个分隔符，需要使用多个分隔符时，要用re.split
print(re.split(r'i|o|g', name)   #['x','a',' m','n','']

ming_index = name.find("ming") #查找字符串在原始字符串中的位置，返回索引：5   
#其后可以指定参数，分别为start和end，在指定范围内[start,end)查找，默认为0和原始字符串的长度，if没找到返回-1    

name.islower() #判断是否全部为小写
name.isupper() #判断是否全部为大写
name_upper = name.upper() #全部变为大写
name_lower = name.lower() #全部变为小写，但是原始字符串不变!!!   
name.capitalize() #将字符串首字母变为大写    

name.endswith("ming") #判断是否以某字符串结尾  
name.isalnum() #判断是否只由字母和数字组成
name.isalpha() #判断是否只由纯字母组成
name.isdigit() #判断是否只由数字组成
name.strip() #默认去除头尾的字符(包括包括\n、\r、\t、' '，即：换行、回车、制表符、空格)   
#相对应的就是lstrip()和rstrip()分别是去头和去尾，这都是返回副本，原始字符串本身不会发生变化    
#当然也可以指定元素：  
name.lstrip("ab") #这时候就是删除头部的ab，注意这时候是把ab当成了两个字符，和ab的顺序无关，并且这时候空格什么的都不会被删除了；
# if要删除字符串中间的空字符：
''.join(name.split())

#python中不允许直接修改字符串
name[2] = "h"  #这是不对的，因为字符串是不可变类型，所以改变字符串需要新建一个新的字符串    
1.可以将字符串转为列表进行修改
s1 = list(s)   #转为列表
s1[2] = "h"    #进行修改
s = ''.join(s1)#用空串进行连接生成新的字符串
2.使用上面的replace方法

#对字符串列表使用sort进行排序时，默认是按照ascii码进行排序，所以if是字母，则大写字母是在小写字母前面。
spam = ['a', 'z', 'A', 'Z']
spam.sort()  #['A','Z','a','z']
所以可以指定sort函数后面的关键字key，这个key的值是一个函数
spam.sort(key=str.lower)  #['a','A','z','Z'] 
这个就是用这个函数执行这个list的所有元素，然后进行排序；再比如，if想要按照每个元素的长度进行排序
spam.sort(key=len)  #按照元素长度进行排序   

s1 = ['1','12','21',2]
s1.sort()  #['1','12','2','21']  并不是从大到小，所以可以
s1.sort(key=int) #转换为整数进行排序，if再指定reverse=True则可以降序排序

python中collections中的计数器Counter

from collections import Counter
c = Counter("abcac")  #参数是一个序列，例如list，string等，返回一个字典，key是元素，value是数值
c['a']  # 2
c['e']  # 不存在的返回0，而不是报错

python正则表达式

re.findall

import re
re.findall(规则，字符串)  #返回一个字符串序列，if都没找到，返回一个空列表   

下面是常用的一些语法规则：
\d   :匹配0-9一个数字
\D   :表示匹配非数字，等价于[^0-9]
\w   :匹配字母和数字，等价于[a-zA-Z0-9]
\W   :匹配非字母和数字，等价于[^a-zA-Z0-9]
\b   :表示一个单词的边界，比如常见的空格
\s   :匹配任何空白字符
s = 'abc abcde bc bcd'
re.findall(r'\bbc\b',s)  #['bc']
re.findall(r'\sbc\s',s)  #[' bc ']
+    :+号表示匹配前面的字符一次以上
*    :*号表示匹配前面的字符0次以上
?    :?号表示匹配前面字符0次或1次
$    :以前面的符号结尾
.    ：.表示任意字符
{2}  ：大括号表示匹配2次，{2,5}至少比配两次，最多匹配5次
[]   :大括号表示一个字符集合：
    [abc123]表示这里面任意一个字符都满足；
    [a-zA-Z]表示匹配所有字母；
    if在大括号里有^，则表示取非：[^a-zA-Z]表示不匹配所有英文字母
|    :表示只要满足一个就可以
    [a-zA-Z]|[0-9]表示字母和数字都可以，等价于[a-zA-Z0-9]

#要注意正则表达式中的括号
rel1 = r'\d{2}[a-z]{1}'   #['24k', '43l'] 匹配整个表达式的值，返回字符串列表
rel2 = r'(\d{2})[a-z]{1}'  #['24', '43']  先整个表达式匹配，匹配完成后再匹配括号里的内容，返回字符串列表
rel3 = r'((\d{2})[a-z]{1})' #[('24k', '24'), ('43l', '43')] 先匹配，然后逐个括号再进行匹配。列表里放的是元祖，元祖的对象分别是第一个括号匹配到的内容，第二个括号匹配到的内容
str1 = 'sdjaksj12324kdjk43le1'
print(re.findall(rel, str1))

#其次要注意匹配过的东西就不会再次尝试匹配了，只会一直往后走：   
import re
rel = r'[0-9]{2}-[0-9]{2}'
str = '01-02-03-04-05-06-07'
str1 = re.findall(rel, str)
print(str1)    # ['01-02', '03-04', '05-06']，答案不会说是01-02,02-03，前面匹配上了，只会从后面再重新开始

re.match

import re
re.match(规则， 字符串）
# 它的特点是只从起始位置开始匹配，if起始就匹配不上就直接返回None，匹配成功则返回第一个匹配成功的；不会返回所有
m = re.match('(\w\w\w)-(\d?)', 'abc-123')   # 这时候的m并不是要的结果，而是一个re.match的对象；
print(m.group())  # abc-1
print(m.groups())  # ('abc', '1') 返回的是各个组，括号是一个组，返回一个元祖；
print(m.group(0))  # 返回全部字符串 abc-1，0和group一样
print(m.group(1))  # 返回分组的第一个 abc，从1开始
print(m.group(2))  # 1

re.search

和re.match基本一样，唯一区别就是不再从起始位置开始匹配，而是扫描整个字符串，返回第一个匹配成功的；

python中range和random

range(start, stop, step)  # 生成一个序列
range(x)   # 生成[0,x)的整数序列
range(x, y)  # 生成[x, y)的整数序列，注意x必须小于y
range(x, y, z)  # 生成序列，按照x+z去生成，所以if步长是正的，那就是1,2,3,4； if是步长是负的，那就得是range(4, 1, -1)：  # 4,3,2，

import random   #必须引入模块
random.randint(1,10)  #生成[1,10]范围内的整数，左闭右闭
random.random()  #生成[0,1)范围内的实数
random.uniform(1.1, 5,4) #生成[1,1,5.4]内的实数
random.choice('xulie') #在序列中随机获取一个元素
random.randrange(1, 100, 2) #间隔为2，其实就是1到100的随机奇数
random.shuffle(xulie)  #随机打乱

python中filter函数的用法

filter函数用于过滤序列，过滤掉不符合条件的元素，返回符合条件的元素组成新的列表
filter(function, iterable)
序列中的每个元素作为参数传递给function，返回true或false，将返回true的元素放到新列表中。

#筛选出序列为奇数的元素
def is_odd(n):
    return n%2 == 1
lst1 = filter(is_odd, [1,2,3,4])

python中二分查找函数bisect

import bisect  #只适用于有序
arr = [2,2,3,4,5]
i = bisect.bisect_left(arr,2) #返回该插入的位置，if相等，返回最左边：0
i = bisect.bisect_right(arr,2.5) #2
# 注意上面并没有插入
arr.insert(i, 2.5)  # 找到位置后再插入
bisect.insort_left(arr,2)  # 直接真正插入，[2,2,2,3,4,5]

python中进制的转换

int('11', 16)   #将16进制转为十进制，前面是十六进制字符串，后者指明是几进制，结果是int 17
int('0010', 2)  #二进制转为十进制， 2；其他都一样
----------
hex(17)  #十进制转为十六进制，结果为一个字符串“0x11”
bin(10)  #十进制转为二进制，结果为一个字符串“0b1010”
oct(11)  #十进制转为八进制，结果为一个字符串“0o13”

通用

常见的ascii值

• 空格：\n :32
• 数字0-9: 48-57
• A-Z：65-90
• a-z: 97-122

关于排序好的数组；

排序好的数组有以下几种常见的处理方法：

• 1.二分查找：二分查找的使用前提就是数组必须是有序的，这样才能每次取中间值去逼近；二分查找总结
• 2.首尾双指针：首尾双指针也常常用在排序数组上，尤其是涉及到两个数之和时，因为如果和大了或者小了可以去移动首或尾指针；

__EOF__

本文作者：Curryxin
本文链接：https://www.cnblogs.com/Curryxin/p/16134125.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！