KMP 算法
理解
A字符串（n）在B字符串(m)中各次出现的位置。

暴力做法肯定是枚举每个位置，向后看n个长度，时间复杂度时O(nm)

注意到一件事情：

其实匹配到不成功的时候，可以跳跃式匹配。

详情请看书。

这里记录一下一些比较难理解的地方。

1、P67页上方，自匹配的时候，为什么a[i]和a[j+1]匹配不成功时，直接找next[next[j]]?

这是因为后半段等于前面的后半段，画个图看一下即可。
2、f是哈？

f是记录了B每个位置记录的可以匹配的最大A 的长度位置。
模板
void calc_next()
{
    for(int i=2,j=0;i<=n;i++)
    {
        while(j>0&&str[i]!=str[j+1])j=Next[j];
        if(str[i]==str[j+1])j++;
        Next[i]=j;
    }
}

void kmp()
{
for(int i=1;j=0;i<=m;i++)
{
	while(j>0&&(j==n||b[i]!=a[j+1]))j=next[j];
	if(b[i]==a[j+1])j++;
	f[i]=j;
}
}

141. 周期
做法
i-next[i]~i这个是一个循环节。 且i-next[i]|i;

例如书中的那个题

而这里补充一点：

abcccab这种的，显然i-next[i]是>n/2.因此显然不可能整除。故这种情况天然排除
还有就是next是c++关键字，注意换个叫法
代码
#include<iostream>
using namespace std;

const int N=1000010;
int n,T;
char str[N];
int Next[N];


void calc_next()
{
    for(int i=2,j=0;i<=n;i++)
    {
        while(j>0&&str[i]!=str[j+1])j=Next[j];
        if(str[i]==str[j+1])j++;
        Next[i]=j;
    }
}
int main()
{
    while(~scanf("%d",&n)&&n)
    {
        scanf("%s",str+1);
        calc_next();
        printf("Test case #%d\n",++T);
        for(int i=2;i<=n;i++)
        {
            if(i%(i-Next[i])==0&&i/(i-Next[i])>1)printf("%d %d\n",i,i/(i-Next[i]));
        }
        printf("\n");
        
    }
}

Task1 - 部分学习内容解析与补充
Python基础入门：从变量到异常处理(3天)
1.3 运算符 - 位运算符
补充
0b100 中0b表示什么？
当没有前导0时会出现问题。Python的变量命名约定是，它必须以字母字符开头。如果前导0，则解释器可以判断它是文字还是变量。
请勿将二进制文字与变量混淆，0b指二进制，0x 指十六进制
其中0b开头表示正数， -0b表示负数
0b100即 0100
-0b101 即 1101
两个方法求解负整数的补码
将其对应正数(无符号数)二进制表示所有位取反(包括符号位，0变1，1变0)后加1
如 -5 的对应正数(无符号数) 即 5 的二进制表示为 0101，所有位取反为 1010， 加1为 1011，故 -5 的补码为 1011
x先得出原码，然后符号位不变，其余位取反加1
先得出 -5 的原码，即 1101， 再求其补码，即符号位不变，其余位取反加1，得 1011
记住，对于正整数， 原码 = 反码 = 补码
解析
print(bin(~4),~4)   # -0b101 -5
python里，使用原码进行展示，补码参与运算
4 的原码是 0b100 , 补码也是 0b100
print(bin(4))  # 0b100
补码进行运算操作
~4 -> ~0b100 -> ~0100 -> 1011 -> -0b011
运算完毕结果为补码-0b011 需要将其转换为原码进行展示
-0b011 -> 1011 符号位不变其它位取反加1
即 1100 + 0001 = 1101 -> -0b101
print(bin(~4)) # -0b101
print(bin(~4),~4) # -0b101  -5
再举例 负数例子
print(bin(-6))       # -0b110
print(bin(~-6),~-6)  # 0b101 5
先求-6的补码，即 +6(0110)取反后再+1：
(1001)+(0001)=(1010)
计算机中-6是用(1010)来存储的,(1010) 按位取反得到(0101)即5
-6
无符号数 0110(无符号数)
原码 1110 即： -0b110
补码 1010 即： -0b010
按位取反 0101 即： 0b101
2.9 利用位运算实现整数集合
一个数的二进制表示可以看作是一个集合(0 表示不在集合中，1 表示在集合中)。
比如集合 {1, 3, 4, 8}，可以表示成 01 00 01 10 10 而对应的位运算也就可以看作是对集合进行的操作。
元素与集合的操作：
集合之间的操作：a | (1 << i) -> 把i插入到集合中
a & ~(1<< i)-> 把i从集合中删除
a & (1<< i) -> 判断i是否属于该集合 (零不属于, 非零属于)
解析
所以，这个集合与二进制的对应关系的操作具体是怎样的呢？
我自己捣鼓了一下(只针对正整数的二进制哟，刚好对应集合里的正整数)
def set_to_num(x):
list_zeros = [0 for x in range(0,max(x)+1)]
location_set = [max(x)-i for i in x]
for j in location_set:
list_zeros[j] = 1
list_out = [str(i) for i in list_zeros]
to_num = str(''.join(list_out))
str_l = '0b'+to_num
out_num = int(str_l, 2)
return out_num
def num_to_set(x):
name = [int(v) for v in(bin(x))[2:]]
location = 0
find = 1
location_set = set()
for i in range(name.count(find)):
location += name[location:].index(find)
location_set.add(location)
location += 1
location_set = [len(name)-1-i for i in location_set]
location_set = sorted(location_set)
print(type(location_set))
print(location_set)
a = 0b100011010    # [1, 3, 4, 8]
b = 0b100010010    # [1, 4, 8]
list_a = [1, 3, 4, 8]
num_to_set(a)                 # [1, 3, 4, 8]
result = set_to_num(list_a)
i = 5
# 集合之间的操作：
# a | (1 << i)  -> 把i插入到集合中
insert_i = a | (1 << i)
num_to_set(insert_i)
# [1, 3, 4, 5, 8]
print('After insert_i, insert_i is :',bin(insert_i))
# After insert_i, insert_i is : 0b100111010
# a & ~(1<< i)-> 把i从集合中删除
i = 4
remove_i = a & ~(1<< i)
num_to_set(remove_i)
# [1, 3, 8]
print('After remove_i, remove_i is :',bin(remove_i))
# After remove_i, remove_i is : 0b100001010
# a & (1<< i) -> 判断i是否属于该集合 (零不属于, 非零属于)
i = 6
assert_i = a & (1<< i)
num_to_set(assert_i)
# []
print('After assert_i, assert_i is :',bin(assert_i))
# After assert_i, assert_i is : 0b0
# a 交 b
c = a & b
num_to_set(c)
# [1, 4, 8]
print('After a & b, a & b is :',bin(c))
# After a & b, a & b is : 0b100010010
望批评指正
如果认为对你学习有帮助，欢迎收藏❤，帮我点个赞👍
谢谢你哦❤
未经同意不准转载^ . ^
部分材料来源于 阿里云天池Python训练营

Java入门-03
测试java中的数值型的字面常量的值的表现形式
（1）整型:
二进制: 只能有0,1组成    前面 0b开头 ,大小写都可以。 
八进制: 只能有0~7数字组成  以0开头。
十进制: 默认十进制
十六进制:0~9,a~f组成  以0x开头,大小写都可以。
   	其他进制转十进制: 从后往前,从最后一位开始*当前的进制数^0(次方从0开始,每次加一),最后求和
		十进制转为其他进制:使用这个数一致除以进制数,看余数
（2）浮点型:
			整数位为0的时候0可以省略
			    科学技术法 表示:  e->10    1.23E2   1.23e-2
（3）转义字符从开始  +要转义的字符
	'
	"
	b 退格   
	n 换行 ln
	r 光标回到行首 
	t 制表符  一个汉字占2个空格,一个字母占1个空  一个制表符位8个空格
	（4）运算符:
		1)算数运算符
		2)赋值运算符
		3)比较运算符
		4)逻辑运算符
		5)条件运算符
		6)位运算符(了解)
		操作数: 运算符左右两边的就是操作数
		表达式: 运算符连接操作数整体为表达式
		语句: ;代表语句的结束
		单目运算符|一元运算符 : 操作只有一个的运算符  + -号  ++ --
		双目运算符|二元运算符 : + - * / ..
		三目运算符|三元运算符 : 条件运算符
		算数运算符:
	+ - * / % 
+ 
					1)正号 (省略)；
					2)加法运算；
					3)字符串的连接符: 当+左右两边如果一旦有字符串的出现,就作为字符串的连接符使用。
% 取余数|模以
			第一个操作数小于第二个操作数,结果就为第一个操作数
	++ --
++  自增|自身+1
 a++ --> a=a+1
		          ++a --> a=a+1
	             --  自减|自身-1
  a-- --> a=a-1
		         --a --> a=a-1
		  操作自己
 ++放在操作数的前面还是后面,都是自身+1。
			--放在操作数的前面还是后面,都是自身-1。
		  操作别人(1.赋值 2.打印  3.运算)
 ++--放在操作数的前面,先自身+1-1,再去参与运算
			++--放在操作数的后面,先参与运算,再去自身+1-1
赋值运算符
		 基本赋值运算符
			=   java中唯一一个自右向左运算的符号。
		扩展赋值运算符(算数运算符+基本赋值运算符)
			+= -= *= /= %=
				a+=b-> a=a+b 
				a*=b-> a=a*b;
			推荐使用:
				1.提高执行效率
				2.自动做强制类型转换
			缺点:不直观
比较运算符|关系运算符
		>  <  >=  <= 
			Byte、 short、 int 、long 、float、 double、 char、== 、!=
		基本数据类型|引用数据类型
		最终的结果肯定为boolean类型的结果
逻辑运算符
		操作数要求都要值值为boolean类型的表达式
		&与  :两个都为true才是true,一个为false就是false
		|或  :一个为true就是true,两个都是false才是false
		!非  :取反   !true-->false  !false-->true   
		^  :相同为false,不同为true
		推荐
		短路:第一个操作数就已经能够决定最终的结果了,第二个操作数将不再执行
		&&
		||
条件运算符
		条件表达式 ? 值1 : 值2;
		1)执行条件表达式-->值为boolean类型的表达式。
		2)如果为true,最终的结果取值1。
		3)如果为false,最终的结果取值2。
位运算符
		所有的操作数先转为二进制的形式参与运算,再把结果转为十进制的形式
		& :同一位置的两个数,一个0就是0,两个都1才是1
		| :同一位置的两个数,一个为1就是1,两个都为0才是0
		^ :相同为0,不同为1
		位移运算符
		左移:<< 二进制的操作数,向左移动第二个操作数的位数,空余的位置补0,得到的结果转为十进制。
			*2  -->第一个操作数*2的第二个操作数次方。
		右移:>> 二进制的操作数,向右移动第二个操作数的位数,分水岭右侧的结果不要,只保留左侧,得到的结果转为十进制。
			/2   -->第一个操作数/2的第二个操作数次方。
	运算符的优先级:
		单目算数位关系,逻辑三目后赋值（口诀）。
数据类型
基本数据类型
		int a=5;
	引用数据类型
		1.创建某个类型的变量|引用
			引用数据类型  变量名 = new 引用数据类型();
			Scanner sc=new Scanner();  ---sc就是scanner类型的变量。
		2.使用功能
			变量.功能名字();
	Scanner类:可以接收键盘输入的内容
		1.导包:指明Scanner类的位置
			import +包名+类名;  import java.util.Scanner;
			位置:类的上面
		2.创建某个类型的变量|引用
			Scanner sc=new Scanner(); 
		3.引用.功能名字();
			 1）next() 接收字符串  结束功能:enter,不会接收enter。
			   从有效字符开始接收,遇到空格,tab不接受了,但是必须遇到enter结束功能。
			 2）nextLine()  只要没有换行,都能接收   遇到enter结束功能,接收enter
			 3）nextInt() 
			  4）nextByte()
			  5）nextShort()
			  6）nextDouble()....
		4.引用.close();
			注意:一定在一个类中使用完毕以后再关闭,否则重新开启也无法使用。
Random:产生随机数
	   1.导包  import java.util.Random;
	   2.创建Random类型的变量|引用
	   3.引用.功能名字()
		nextInt()  产生一个int范围内的随机整数
		nextInt(n) 产生0~n随机整数  [0,n)
		[0,max]   引用.nextInt(max+1) 
		[min,max] 引用.nextInt(max-min+1)+min
		nextDouble() 产生[0,1)之间的随机小数	
注意：此随机数是伪随机数。
测试java中的流程控制语句
顺序结构:从上倒下,从左到右
选择结构:根据选择,决定执行的内容
循环结构:重复执行某些内容
if..else   
单分支|单选泽
				if(条件表达式){
					语句体;
				}
		 条件表达式必须值为boolean类型的表达式。
		 如果条件表达式结果为false,就不执行跳过整个if结构。
		 如果条件表达式结果为true,执行{}中的语句体。
双分支|双选择
				if(条件表达式){
					语句体1;
				}else{
					语句体2;
				}
				无论是否满足条件,都会执行语句体
多分支|多选择:
				if(条件表达式1){
					语句体1;
				}else if(条件表达式2){
					语句体2;
				}else if(条件表达式3){
					语句体3;
				}
				....
				else{
					以上条件都不满足执行的内容
				}
if语句和条件运算符之间的选择:
				1.条件运算符肯定会得到结果。
				2.麻烦的使用if,简单的能使用条件运算符就是用条件运算符。
		       无论是多选还是单选,双选,只要语句体只有1句,前后的{ }可以省略。
switch语句:定值判断
		switch(表达式){
			case 值1:
				语句体1;
				break;
			case 值2:
				语句体2;
				 break;
				....
			default:
				语句体n;
				break;
		}
		1.表达式|变量: byte、short、int、char,枚举(1.5版本才出现),字符串(1.7版本才出现)。
		2.case:拿表达式的结果与case后的值进行判断,如果相同,执行对应的语句体。
		3.break:结束这个switch语句,如果没有break会发生case穿透。
		4.default: else作用一致,以上case都不满足条件,执行default中的语句体。
		5.可以在switch语句中的任何位置,改变位置注意break的问题。
If和switch 的区别：
if语句可以做区间判断,可以做定值判断。
switch 只能做定值判断。

为什么字符大于0x80就能确定这个字符是中文??

汉字由2个字节组成，为了和标准ASCII码(0-127)区别开, 所以汉字每个字节的最高位都置1，即0x80.

其中0x80这是十六进制数，变成十进制数为-128，因为char型在C语言中范围为-128~127，并不是0乘以80

C语言里0x表示后面的数是16进制数，16进制数可以包含0~9,a,b,c,d,e,f。它与10进制对应如：

0x80 = 8 * 16 + 0 = 128

0x0f = 0*16 + 15 = 15

0xf0 = 15 * 16 + 0 = 240

0xc0 = 12 * 16 + 0 = 192

C语言里面乘法是星号*，如4*5