45. 机器学习

发表于 2020-12-26

1.思想

创造一种普适的算法，从数据中挖掘出有趣的东西，而不需要针对某个问题去写代码。只需要把数据“投喂”给普适算法，然后在数据上建立自己的逻辑。

机器学习是个筐，什么普适算法都往里装

2. 分类

1. 有监督学习
2. 无监督学习

44. Java快速入门

发表于 2020-12-26

内存单元从0开始编号，称为内存地址。每个内存单元可以看作一间房间，内存地址就是门牌号。
数据类型
1. 基本数据类型/原始类型（primitive type）
2. 用于保存简单的单个数据
3. 首字母一般小写
4. 基本数据类型：
  1. int (4B)
    
    Java的整型数字中间可以加入下划线以便用户识别。
  2. short (2B)
  3. long (8B)
  4. byte (1B)
  5. float (4B)
    1. 对于float类型，需要加上f后缀,如: float f = 3.14e5f;
    2. float类型可最大表示 $3.4 \times 10^{38}$
  6. double (8B)
    
    float类型可最大表示 $1.79 \times 10^{308}$
  7. boolean (1B)
    
    Java语言对布尔类型的存储并没有做规定，因为理论上存储布尔类型只需要1 bit，但是通常JVM内部会把boolean表示为4字节整数。
  8. char (2B)
    1. 布尔类型boolean只有true和false两个值
    2. 字符类型char表示一个字符。Java的char类型除了可表示标准的ASCII外，还可以表示一个Unicode字符，如： char a = '中';
    3. 注意char类型使用单引号’，且仅有一个字符，要和双引号”的字符串类型区分开。
5. 引用类型
  1. 除了上述基本类型的变量，剩下的都是引用类型。例如，引用类型最常用的就是String字符串: String s = "hello";
  2. 引用类型的变量类似于C语言的指针，它内部存储一个“地址”，指向某个对象在内存的位置.
  通俗的解释：引用类型的变量赋值，先申请内存存放内容，然后变量再指向它，若改变变量的值，则会再重新申请内存，放入内容，再将变量指向这块内存，原来的内存还在只不过无法通过变量指向它罢了。
6. 常量
  1. 定义变量的时候，如果加上final修饰符，这个变量就变成了常量
  1
  2
  3
  4
  final double PI = 3.14; // PI是一个常量
  double r = 5.0;
  double area = PI * r * r;
  PI = 300; // compile error!
  1. 常量在定义时进行初始化后就不可再次赋值，再次赋值会导致编译错误。
  2. 常量的作用是用有意义的变量名来避免魔术数字（Magic number），例如，不要在代码中到处写3.14，而是定义一个常量。如果将来需要提高计算精度，我们只需要在常量的定义处修改，例如，改成3.1416，而不必在所有地方替换3.14。
  3. 根据习惯，常量名通常全部大写。
7. var关键字
  1. 有些时候，类型的名字太长，写起来比较麻烦。例如：StringBuilder sb = new StringBuilder();, 这个时候，如果想省略变量类型，可以使用var关键字： var sb = new StringBuilder();,编译器会根据赋值语句自动推断出变量sb的类型是StringBuilder。对编译器来说，语句：var sb = new StringBuilder();,实际上会自动变成：StringBuilder sb = new StringBuilder();
  2. 使用var定义变量，仅仅是少写了变量类型而已。
8. 定义变量时，要遵循作用域最小化原则，尽量将变量定义在尽可能小的作用域，并且，不要重复使用变量名。
整数运算
1. 整数的数值表示不但是精确的，而且整数运算永远是精确的，即使是除法也是精确的，因为两个整数相除只能得到结果的整数部分
2. 特别注意：整数的除法对于除数为0时运行时将报错，但编译不会报错
3. 要特别注意，整数由于存在范围限制，如果计算结果超出了范围，就会产生溢出，而溢出不会出错，却会得到一个奇怪的结果
4. 自增/自减、+=，-=，*=，/=：同C++
5. 移位运算
  1. >>: 根据符号位来补充
  2. 无符号的右移运算>>>: 它的特点是不管符号位，右移后高位总是补0
6. 位运算
  1. 与运算: &
  2. 或运算: |
  3. 非运算: ~
  4. 异或运算: ^
运算优先级
- ()
- ! ~ ++ --
- * / %
- + -
- << >> >>>
- &
- |
- += -= *= /=

浮点数运算

浮点数运算会产生误差

浮点数运算和整数运算相比，只能进行加减乘除这些数值计算，不能做位运算和移位运算。在计算机中，浮点数虽然表示的范围大，但是，浮点数有个非常重要的特点，就是浮点数常常无法精确表示。

举个栗子：

浮点数0.1在计算机中就无法精确表示，因为十进制的0.1换算成二进制是一个无限循环小数，很显然，无论使用float还是double，都只能存储一个0.1的近似值。但是，0.5这个浮点数又可以精确地表示。

因为浮点数常常无法精确表示，因此，浮点数运算会产生误差:

public class Main {
    public static void main(String[] args) {
        double x = 1.0 / 10;
        double y = 1 - 9.0 / 10;
        // 观察x和y是否相等:
        System.out.println(x);
        System.out.println(y);
    }
}

结果为：

1 2	0.1 0.09999999999999998

溢出
整数运算在除数为0时会报错，而浮点数运算在除数为0时，不会报错，但会返回几个特殊值：
1. NaN表示Not a Number
2. Infinity表示无穷大
3. Infinity表示负无穷大
  如：
1
2
3
double d1 = 0.0 / 0; // NaN
double d2 = 1.0 / 0; // Infinity
double d3 = -1.0 / 0; // -Infinity

布尔运算
1. 布尔运算是一种关系运算，包括以下几类：
  - 比较运算符：>，>=，<，<=，==，!=
  - 与运算 &&
  - 或运算 ||
  - 非运算 !
2. 关系运算符的优先级从高到低依次是
  - !
  - >，>=，<，<=
  - ==，!=
  - &&
  - ||
3. 短路运算、三元运算符：同C++

字符与字符串

字符类型

Java在内存中总是使用Unicode表示字符，所以，一个英文字符和一个中文字符都用一个char类型表示，它们都占用两个字节。要显示一个字符的Unicode编码，只需将char类型直接赋值给int类型即可
1
2
int n1 = 'A'; // 字母“A”的Unicodde编码是65
int n2 = '中'; // 汉字“中”的Unicode编码是20013

字符串类型

和char类型不同，字符串类型String是引用类型，我们用双引号"..."表示字符串。一个字符串可以存储0个到任意个字符：

常见的转义字符包括：
- \" 表示字符"
- \' 表示字符'
- \\ 表示字符\
- \n 表示换行符
- \r 表示回车符
- \t 表示Tab
- \u#### 表示一个Unicode编码的字符

字符串连接

Java的编译器对字符串做了特殊照顾，可以使用+连接任意字符串和其他数据类型，这样极大地方便了字符串的处理。例如：

public class Main {
    public static void main(String[] args) {
        String s1 = "Hello";
        String s2 = "world";
        String s = s1 + " " + s2 + "!";
        System.out.println(s);
    }
}

如果用+连接字符串和其他数据类型，会将其他数据类型先自动转型为字符串，再连接：

public class Main {
    public static void main(String[] args) {
        int age = 25;
        String s = "age is " + age;
        System.out.println(s);
    }
}

多行字符串

如果我们要表示多行字符串，使用+号连接会非常不方便：

从Java 13开始，字符串可以用”””…”””表示多行字符串（Text Blocks）了。举个例子：

public class Main {
    public static void main(String[] args) {
        String s = """
                   SELECT * FROM
                     users
                   WHERE id > 100
                   ORDER BY name DESC
                   """; // 因为""" 换行了，所以相当于在 DESC 后面加了一个\n
        System.out.println(s);
    }
}

如果多行字符串的排版不规则，总是以最短的行首空格为基准。

不可变特性

String s = “hello”;时，JVM虚拟机先创建字符串”hello”，然后，把字符串变量s指向它：紧接着，执行s = “world”;时，JVM虚拟机先创建字符串”world”，然后，把字符串变量s指向它：原来的字符串”hello”还在，只是我们无法通过变量s访问它而已。因此，字符串的不可变是指字符串内容不可变。

理解了引用类型的“指向”后，试解释下面的代码输出：

public class Main {
    public static void main(String[] args) {
        String s = "hello";
        String t = s;
        s = "world";
        System.out.println(t); // t是"hello"还是"world"?
    }
}

空值null

引用类型的变量可以指向一个空值null，它表示不存在，即该变量不指向任何对象。例如：
1
2
3
4
String s1 = null; // s1是null
String s2; // 没有赋初值值，s2也是null
String s3 = s1; // s3也是null
String s4 = ""; // s4指向空字符串，不是null
注意要区分空值null和空字符串””，空字符串是一个有效的字符串对象，它不等于null。

数组

定义一个数组类型的变量，使用数组类型 类型[]，例如，int[]。和单个基本类型变量不同，数组变量初始化必须使用new int[5]表示创建一个可容纳5个int元素的数组。
Java的数组有几个特点：
- 数组所有元素初始化为默认值，整型都是0，浮点型是0.0，布尔型是false；
- 数组一旦创建后，大小就不可改变。
数组大小：数组变量.length
数组是引用类型，在使用索引访问数组元素时，如果索引超出范围，运行时将报错
在定义数组时直接指定初始化的元素，这样就不必写出数组大小，而是由编译器自动推算数组大小
对于数组ns来说，执行ns = new int[] { 68, 79, 91, 85, 62 };时，它指向一个5个元素的数组；再执行ns = new int[] { 1, 2, 3 };时，它指向一个新的3个元素的数组：但是，原有的5个元素的数组并没有改变，只是无法通过变量ns引用到它们而已。
字符串数组
1
2
3
String[] names = {
"ABC", "XYZ", "zoo"
};
对names[1]进行赋值，例如names[1] = "cat";，原来names[1]指向的字符串”XYZ”并没有改变，仅仅是将names[1]的引用从指向”XYZ”改成了指向”cat”，其结果是字符串”XYZ”再也无法通过names[1]访问到了。

相当于引用嵌套引用

遍历数组

方法1

for (int i=0; i<ns.length; i++) {
    int n = ns[i];
    System.out.println(n);
}

方法2: for each 循环
1
2
3
4
int[] ns = { 1, 4, 9, 16, 25 };
for (int n : ns) {
System.out.println(n);
}
变量n直接拿到ns数组的元素，而不是索引。

若想直接打印ns，可以这么做：System.out.println(Arrays.toString(ns));

排序数组

冒泡排序

Java的标准库已经内置了排序功能: Arrays.sort()，例如：

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] ns = { 28, 12, 89, 73, 65, 18, 96, 50, 8, 36 };
        // 排序前:
        System.out.println(Arrays.toString(ns));
        // 排序
        Arrays.sort(ns);
        // 排序后：
        System.out.println(Arrays.toString(ns));
    }
}

当我们调用Arrays.sort(ns);后，变量ns指向的数组内容已经被改变了

如果对一个字符串数组(String[] ns = { "banana", "apple", "pear" };)进行排序，原来的3字符串在内存中均没有任何变化，但是ns数组的每个元素指向变化了

多维数组

例子

public class Main {
    public static void main(String[] args) {
        int[][] ns = {
            { 1, 2, 3, 4 },
            { 5, 6, 7 },
            { 9, 10, 11, 12 }
        };
        int[] arr1 = ns[1];
        System.out.println(arr0.length); // 4
    }
}

实际上arr1就获取了ns数组的第1个元素。因为ns数组的每个元素也是一个数组，因此，arr1指向的数组就是{ 5, 6, 7 }

遍历

for (int[] arr : ns) {
    for (int n : arr) {
        System.out.print(n);
        System.out.print(', ');
    }
    System.out.println();
}

小结
- 二维数组就是数组的数组，三维数组就是二维数组的数组；
- 多维数组的每个数组元素长度都不要求相同；
- 打印多维数组可以使用Arrays.deepToString()；
- 最常见的多维数组是二维数组，访问二维数组的一个元素使用array[row][col]

命令行参数

Java程序的入口是main方法，而main方法可以接受一个命令行参数，它是一个String[]数组。

这个命令行参数由JVM接收用户输入并传给main方法：

public class Main {
    public static void main(String[] args) {
        for (String arg : args) {
            System.out.println(arg);
        }
    }
}

我们可以利用接收到的命令行参数，根据不同的参数执行不同的代码。例如，实现一个-version参数，打印程序版本号：

public static void main(String[] args) {
    for (String arg : args) {
        System.out.println(arg);
        if ("-version".equals(arg)) {
            System.out.println("v 1.0");
        } else if ("-test".equals(arg)) {
            System.out.println("test");
        }
    }
}

上面这个程序必须在命令行执行，我们先编译它： javac Main.java

然后，执行的时候，给它传递一个-version参数：java Main -version -version -test

I/O

输出
1. 输出语句
  - System.out.println()
  - System.out.printf()
2. 占位符
  
  占位符说明
  
  %d 格式化输出整数
  
  %x 格式化输出十六进制整数
  
  %f 格式化输出浮点数
  
  %e 格式化输出科学计数法表示的浮点数
  
  %s 格式化字符串
  
  注意，由于%表示占位符，因此，连续两个%%表示一个%字符本身。
  
  占位符本身还可以有更详细的格式化参数。下面的例子把一个整数格式化成十六进制，并用0补足8位：

占位符	说明
%d	格式化输出整数
%x	格式化输出十六进制整数
%f	格式化输出浮点数
%e	格式化输出科学计数法表示的浮点数
%s	格式化字符串

输入

import语句导入java.util.Scanner，import是导入某个类的语句，必须放到Java源代码的开头
创建 Scanner 对象并传入 System.in。System.out 代表标准输出流，而System.in代表标准输入流。直接使用System.in读取用户输入虽然是可以的，但需要更复杂的代码，而通过Scanner就可以简化后续的代码。

Scanner对象后，要读取用户输入的字符串，使用scanner.nextLine()，要读取用户输入的整数，使用scanner.nextInt()。Scanner会自动转换数据类型，因此不必手动转换。
例如：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in); // 创建Scanner对象
        System.out.print("Input your name: "); // 打印提示
        String name = scanner.nextLine(); // 读取一行输入并获取字符串
        System.out.print("Input your age: "); // 打印提示
        int age = scanner.nextInt(); // 读取一行输入并获取整数
        System.out.printf("Hi, %s, you are %d\n", name, age); // 格式化输出
    }
}

使用占位符构建字符串，并打印

1 2	String <name> = String.format("%-10d%d", 20, 25) System.out.println(<name>)

41. 俄罗斯套娃信封问题

发表于 2020-12-26

40. 使用Xshell远程连接CentOS

发表于 2020-12-26

1. 下载Xshell，点击这里

2. 安装CentOS，点击这里，查看如何安装

3. 打开CentOS终端，输入 `ifconfig`，记录 ip地址，例如：`192.168.205.162`，如下图

4. 打开 `Xshell`，步骤如下：

文件

新建

在 主机 输入记录的 ip地址，并更改 名称

点击左侧 终端，更改编码，以及设置 将含糊的大小字符视为宽字符

输入用户名和密码，就可以使用

39. windows本地安装jekyll

发表于 2020-12-26

1. 安装Git

安装包下载地址，点击这里
安装步骤
10. 完成安装之后，就可以使用命令行的 git 工具（已经自带了 ssh 客户端）了，另外还有一个图形界面的 Git 项目管理工具。在开始菜单里找到”Git”->”Git Bash”，会弹出 Git 命令窗口，你可以在该窗口进行 Git 操作。
  
  PS: 除了安装路径其余的都默认安装即可

2. 安装Ruby

安装包下载，点击这里，选择 Ruby <2.6.1-1> <(x64)>
安装注意事项
1. 勾选添加到PATH选项，以便在命令行中使用。
2. 安装完成界面：
  Ps:记得勾选msys2
3. Ps：选择3（MSYS2 and MinGW）
4. 其余默认安装

3. 安装jekyll

打开git
在命令行输入 gem install jekyll

4. 使用jekyll

在Github文件夹中，右键打开 git bash here
在命令行输入 jekyll server

PS: 如看详细教程，请点击这里

38. vscode配置C&C++

发表于 2020-12-26

Windows配置文件

1. c_cpp_properties.json

{
    "configurations": [
        {
            "name": "Win32",
            "includePath": [
                "${workspaceFolder}/**"
            ],
            "defines": [
                "_DEBUG",
                "UNICODE",
                "_UNICODE"
            ],
            "browse": {
                "path": [
                    "${workspaceRoot}",
                    "E:\\MinGW\\lib\\gcc\\mingw32\\8.2.0\\include\\c++"// 自己更改自己对应的地址
                ],
                "limitSymbolsToIncludedHeaders": true,
                "databaseFilename": ""
            },
            "compilerPath": "E:\\MinGW\\bin\\g++.exe",// 自己更改自己对应的地址
            "cStandard": "c11",
            "cppStandard": "c++17",
            "intelliSenseMode": "msvc-x64"
        }
    ],
    "version": 4
}

2. launch.json

{
    // Use IntelliSense to learn about possible attributes.
    // Hover to view descriptions of existing attributes.
    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
    "version": "0.2.0",
    "configurations": [
        {
            "name": "(gdb) Launch",
            "type": "cppdbg",
            "request": "launch",
            "program": "${workspaceFolder}/build/${fileBasenameNoExtension}.exe",
            "args": [],
            "stopAtEntry": false,
            "cwd": "${workspaceFolder}",
            "environment": [],
            "externalConsole": true,
            "MIMode": "gdb",
            "miDebuggerPath": "E:\\MinGW\\bin\\gdb.exe", // 自己更改自己对应的地址
            "preLaunchTask": "build", // 和"tasks.json"的"tasks"-"label"对应
            "setupCommands": [
                {
                    "description": "Enable pretty-printing for gdb",
                    "text": "-enable-pretty-printing",
                    "ignoreFailures": true
                }
            ]
        }
    ]
}

3. tasks.json

{
    // See https://go.microsoft.com/fwlink/?LinkId=733558
    // for the documentation about the tasks.json format
    "version": "2.0.0",
    "tasks": [
        {
            "label": "build",
            "type": "shell",
            "command": "g++",
            "args": [
                "-g", 
                "${file}",
                "-o",
                "${fileDirname}\\build\\${fileBasenameNoExtension}.exe", // 指定输出文件名，不加该参数则默认输出a.exe
            ],
            "group": {
                "kind": "build",
                "isDefault": true
            }
        }
    ]
}

Ps：

在文件夹中创建 build 文件
自己更改MinGW地址，以及配置MinGW，点击这里学会如何安装MinGW，以及如何配置

Windows配置文件(升级)

1. c_cpp_properties.json

{
    "configurations": [
        {
            "name": "Win32",
            "includePath": [
                "${workspaceFolder}/**"
            ],
            "defines": [
                "_DEBUG",
                "UNICODE",
                "_UNICODE"
            ],
            "browse": {
                "path": [
                    "${workspaceRoot}",
                    "E:\\MinGW\\lib\\gcc\\mingw32\\8.2.0\\include\\c++"
                ],
                "limitSymbolsToIncludedHeaders": true,
                "databaseFilename": ""
            },
            "compilerPath": "E:\\MinGW\\bin\\g++.exe",
            "cStandard": "c11",
            "cppStandard": "c++17",
            "intelliSenseMode": "msvc-x64"
        }
    ],
    "version": 4
}

2. launch.json

{
    // Use IntelliSense to learn about possible attributes.
    // Hover to view descriptions of existing attributes.
    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
    "version": "0.2.0",
    "configurations": [
        {
            "name": "(gdb) Launch",
            "type": "cppdbg",
            "request": "launch",
            "program": "${fileDirname}/build/${fileBasenameNoExtension}.exe",
            "args": [],
            "stopAtEntry": false,
            "cwd": "${workspaceFolder}",
            "environment": [],
            "externalConsole": true,
            "MIMode": "gdb",
            "miDebuggerPath": "E:\\MinGW\\bin\\gdb.exe",
            "preLaunchTask": "build",
            "setupCommands": [
                {
                    "description": "Enable pretty-printing for gdb",
                    "text": "-enable-pretty-printing",
                    "ignoreFailures": true
                }
            ]
        }
    ]
}

3. tasks.json

{
    // See https://go.microsoft.com/fwlink/?LinkId=733558
    // for the documentation about the tasks.json format
    "version": "2.0.0",
    "tasks": [
        {
            "label": "build",
            "type": "shell",
            "command": "g++",
            "args": [
                "-g", 
                "${file}",
                "-o",
                "${fileDirname}\\build\\${fileBasenameNoExtension}.exe", // 指定输出文件名，不加该参数则默认输出a.exe      
                // "&&",
                "-O0",
                "-ggdb3",
                "-Wall",
                "-lm", 
                "-std=c++11",  // Tag to compile as c++11
            ],
            "group": {
                "kind": "build",
                "isDefault": true
            },
            "problemMatcher": {
                "owner": "cpp",
                "fileLocation": ["relative", "${workspaceFolder}"],
                "pattern": {
                    "regexp": "^(.*):(\\d+):(\\d+):\\s+(warning|error):\\s+(.*)$",
                    "file": 1,
                    "line": 2,
                    "column": 3,
                    "severity": 4,
                    "message": 5
                }
            }
        }
    ]
}

Ps：

在文件夹中创建 build 文件
自己更改MinGW地址，以及配置MinGW，点击这里学会如何安装MinGW，以及如何配置

插件

1. C/C++

2. C/C++ Complile Run

3. 配置

// Set your c compiler if it is not working
"c-cpp-compile-run.c-compiler": "gcc",

// Flags: e.g. -Wall. default: -Wall -Wextra
"c-cpp-compile-run.c-flags": "-Wall -Wextra",

// Set your cpp compiler if it is not working
"c-cpp-compile-run.cpp-compiler": "g++",

// Flags: e.g. -Wall. default: -Wall -Wextra
"c-cpp-compile-run.cpp-flags": "-Wall -Wextra",

// Run arguments
"c-cpp-compile-run.run-args": "",

// Run in a new external terminal
"c-cpp-compile-run.run-in-external-terminal": false,

// Saves the file before compilation
"c-cpp-compile-run.save-before-compile": true,

3. Code Run

4. clang

37. Sort

发表于 2020-12-26

sort() —— 排序

导入头文件：#include <algorithm>
使用模板
1. sort(start, end)
2. sort(start, end, cmp)
  Ps:
  1. 符号说明
  符号说明
  
  start 起始地址
  
  end 终止地址
  
  cmp 自定义函数
  1. sort()函数，若没有cmp（第三个参数），则默认从小到大排序
  2. start和end，也可以传入迭代器的始末地址
cmp函数如何写

符号	说明
start	起始地址
end	终止地址
cmp	自定义函数

从大到小排序
代码

bool cmp(int a, int b)
{
    return a > b;
}

自定义排序，以两门成绩（假设第一门成绩为语文，第二门成绩为数学）为例，语文成绩以从小到大排序，若语文成绩相同，则数学成绩从小到大排序
代码

bool cmp(pair<int, int>& a, pair<int, int>& b)
{
    if(a.first != b.first)
        return a.first < b.first;
    else
        return a.second > b.second;
}

1.思想

机器学习是个筐，什么普适算法都往里装

2. 分类

1. 下载Xshell，点击这里

2. 安装CentOS，点击这里，查看如何安装

3. 打开CentOS终端，输入 ifconfig，记录 ip地址，例如：192.168.205.162，如下图

4. 打开 Xshell，步骤如下：

1. 安装Git

PS: 除了安装路径其余的都默认安装即可

2. 安装Ruby

Ps:记得勾选msys2

Ps：选择3（MSYS2 and MinGW）

3. 安装jekyll

4. 使用jekyll

PS: 如看详细教程，请点击这里

Windows配置文件

1. c_cpp_properties.json

2. launch.json

3. tasks.json

Ps：

Windows配置文件(升级)

1. c_cpp_properties.json

2. launch.json

3. tasks.json

Ps：

插件

1. C/C++

2. C/C++ Complile Run

3. 配置

3. Code Run

4. clang

sort() —— 排序

导入头文件：#include <algorithm>

使用模板

Ps:

cmp函数如何写

代码

代码

3. 打开CentOS终端，输入 `ifconfig`，记录 ip地址，例如：`192.168.205.162`，如下图

4. 打开 `Xshell`，步骤如下：

导入头文件：`#include <algorithm>`