算法，八股

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

import sys
# 多组测试用例
for line in sys.stdin:
    print(line)# 键盘输入，包含回车
    a = line.split()# str类型列表
    print(a,type(a),type(a[0]))
    print(int(a[0]) + int(a[1]))
"""
['1', '5'] <class 'list'> <class 'str'>
6
['10', '20'] <class 'list'> <class 'str'>
30
"""

while True:# 多行测试用例
    try:
        a, b = map(int, input().split(' '))
        print("{}".format(a+b))
    except EOFError:
        break

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

a,b=input().split(' ')
print(int(a)+int(b))

a, b = map(int, input().split(' '))
print("{}".format(a+b))

n = int(input())
a = list(map(int, input().split()))
x, y = map(int, input().split())
print(n,a,x,y)

"""
4
1 2 3 4
1 2
4 [1, 2, 3, 4] 1 2
"""

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

def Abs(a, b):
    return a - b if a > b else b - a
# 直接用 abs(1-3)

n, m = map(int, input().split())
a = [[0] * (m + 1) for _ in range(n + 1)]
# 这个列表将用于存储矩阵的数据。(n+1) × (m+1)
# 原矩阵相当于从1,1开始，00,01,10位置补0，便于11应用公式
pre = [[0] * (m + 1) for _ in range(n + 1)] 
# 前缀，这个列表将用于存储矩阵的前缀和。

for i in range(1, n + 1):
    row = list(map(int, input().split()))
    for j in range(1, m + 1):
        a[i][j] = row[j - 1]
        pre[i][j] = a[i][j] + pre[i - 1][j] + pre[i][j - 1] - pre[i - 1][j - 1]
        # 二维前缀和公式

ans = 1e9
for i in range(1, n):
    ans = min(ans, Abs(pre[i][m], pre[n][m] - pre[i][m]))

for j in range(1, m):
    ans = min(ans, Abs(pre[n][j], pre[n][m] - pre[n][j]))

print(int(ans))
"""
2 2
2 2
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
1 2
3 4
[[0, 0, 0], [0, 1, 2], [0, 3, 4]] [[0, 0, 0], [0, 1, 3], [0, 4, 10]]
2
"""

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

import pdb
from collections import deque

len = int(input())
s = input() # 表示字符矩阵。

dx = [-1, 0, 1, 0]# 分别表示在四个方向上移动的水平和垂直距离。
dy = [0, 1, 0, -1]

def get(n, m):

    # 计算给定二维字符矩阵中的连通区域数量
    # `n` 和 `m`，分别表示字符矩阵的行数和列数。
    q = deque()# 双端队列
    # pdb.set_trace()
    res = 0 #记录连通块的和
    vis = [0] * len # 用于记录每个位置是否被访问过。初始时，所有位置的访问状态都设置为 0。

    for i in range(n):# 1hang 4lie
        for j in range(m):
            if vis[i * m + j]:# =1 被访问过，跳过
                continue
            ch = s[i * m + j] # 将该位置的字符存储在变量 `ch` 中，并将该位置的坐标 `(i, j)` 添加到队列 `q` 中。ch='a'
            q.append((i, j))#入队列 deque([(0, 0)])
            while q: #循环用于进行广度优先搜索。
                top = q.popleft() #从队列的左侧移出一个位置 `(top[0], top[1])`#(0,0)出队列
                for k in range(4):
                    nx = top[0] + dx[k]
                    ny = top[1] + dy[k]# 计算相邻位置 `(nx, ny)` 的坐标 左，上,右，下
                    if nx >= 0 and nx < n and ny >= 0 and ny < m and not vis[nx * m + ny] and s[nx * m + ny] == ch:
                        # 如果相邻位置在合法的范围内、未被访问过且字符与当前位置相同
                        vis[nx * m + ny] = 1 #将相邻位置标记为已访问
                        q.append((nx, ny)) # 并将其坐标添加到队列 `q` 中。
            res += 1
    return res

mid = len // 2
ans = float('inf')

for i in range(1, mid + 1):#枚举可能的矩阵
    if len % i == 0:
        ans = min(ans, get(i, len // i))
        print(ans)

print(ans)

"""
4
abaa
3
2
2
"""

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

import pdb
import math

def dfs(u, fa):# 深度优先搜索,`u` 和 `fa`，分别表示当前节点和其父节点。
    global dp, g, a # 全局变量 `dp`、`g` 和 `a`
    # `dp` 是一个二维列表，用于存储节点的最大路径和
    # `g` 是一个邻接表，用于存储树的连接关系
    # `a` 是一个列表，用于存储每个节点的权值
    pdb.set_trace()
    for v in g[u]: # 遍历节点 `u` 的邻接节点 `v`
        if v == fa: # 如果 `v` 是 `u` 的父节点，则跳过
            continue
        dfs(v, u) # 递归调用 `dfs(v, u)` 进行深度优先搜索
        dp[u][0] += max(dp[v][0], dp[v][1]) # 当前节点 `u` 的路径和 `dp[u][0]` 进行累加

    for v in g[u]:
        if v == fa:
            continue
        val = a[v] * a[u]
        sq = int(math.sqrt(val + 0.5))
        if sq * sq != val:
            continue
        dp[u][1] = max(dp[u][1], (dp[u][0] - max(dp[v][0], dp[v][1])) + dp[v][0] + 2)# 更新节点 `u` 的路径和 `dp[u][1]`

n = int(input())# 表示树的节点数

a = list(map(int, input().split()))# 每个节点的权值

g = [[] for _ in range(n)]

for _ in range(n - 1):# 每行输入两个整数 `u` 和 `v`，表示节点 `u` 和节点 `v` 之间有一条边。
    u, v = map(int, input().split())
    u -= 1
    v -= 1
    g[u].append(v)
    g[v].append(u)

dp = [[0, 0] for _ in range(n)]# 二维列表 `dp`，用于存储每个节点的最大路径和

dfs(0, -1)# 从根节点开始进行深度优先搜索

print(max(dp[0][0], dp[0][1]))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

import java.util.Scanner;  

public class PrintNumbers {  
    public static void main(String[] args) {  
        Scanner input = new Scanner(System.in);  
        System.out.print("Enter a number: ");  
        //int n = input.nextInt(); 
        double n = input.nextDouble();  
          
        System.out.println("Numbers from 1 to " + n + ":");  
        for (int i = 1; i <= n; i++) {  
            System.out.print(i + " ");  
        }  
    }  
}  

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

import java.util.Scanner;  
  
public class SumOfNumbers {  
    public static void main(String[] args) {  
        Scanner input = new Scanner(System.in);  
        System.out.print("Enter a number: ");  
        double n = input.nextDouble();  
          
        int sum = 0;  
        for (int i = 1; i <= n; i++) {  
            sum += i;  
        }  
          
        System.out.println("Sum of numbers from 1 to " + n + ": " + sum);  
    }  
} 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

//编写一个函数，接受一个整数列表作为参数，并返回其中最大的数
import java.util.Scanner;  
  
public class MaxNumberFinder {  
    public static int findMax(int[] numbers) {  
    //定义了一个名为 `findMax` 的公共静态方法，该方法接受一个整数数组 `numbers` 作为参数，并返回一个整数类型的值。
        if (numbers.length == 0) {  
            throw new IllegalArgumentException("The array cannot be empty");  
        }  
  
        int max = numbers[0];  
        for (int i = 1; i < numbers.length; i++) {  
            if (numbers[i] > max) {  
                max = numbers[i];  
            }  
        }  
        return max;  
    }  
      
    public static void main(String[] args) {  
        Scanner input = new Scanner(System.in);  
        System.out.print("Enter the number of elements: ");  
        int n = input.nextInt();  
          
        int[] numbers = new int[n];  //定义长度为n的数组
        System.out.println("Enter the elements:");  
        for (int i = 0; i < n; i++) {  
            numbers[i] = input.nextInt(); //为数组赋值 
        }  
          
        int maxNumber = findMax(numbers);  
        System.out.println("The maximum number is: " + maxNumber);  
    }  
}  
//打印数组 Arrays.toString(arr)
import java.util.Arrays;  
  
public class ArrayPrinter {  
    public static void printArray(int[] arr) {  
        System.out.println(Arrays.toString(arr));  
    }  
  
    public static void main(String[] args) {  
        int[] array = {1, 2, 3, 4, 5};  
        printArray(array); // Output: [1, 2, 3, 4, 5]  
    }  
}  

//如果不输入列表的长度，你可以要求用户输入列表的元素，直到用户输入一个特定的标记来表示输入的结束。例如，用户可以输入一个负数或者输入 “done” 来表示输入的结束。以下是一个简单的示例程序：
	public static void main(String[] args) {  
        Scanner input = new Scanner(System.in);  
        ArrayList<Integer> numbers = new ArrayList<>();  
        System.out.println("Enter the elements (enter a non-numeric value to finish):");  
          
        while (input.hasNextInt()) {  
            numbers.add(input.nextInt());  
        }  
          
        int maxNumber = findMaxInList(numbers);  
        System.out.println("The maximum number is: " + maxNumber);  
    }  

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

//输入一个英文字符串，然后将该字符串中的每个单词反转并输出。
import java.util.Scanner;  
  
public class WordReversal {  
    public static String reverseWords(String sentence) {  
        String[] words = sentence.split("\\s+");  
        StringBuilder reversedSentence = new StringBuilder();  
  
        for (String word : words) {  
            StringBuilder reversedWord = new StringBuilder(word);  
            reversedWord.reverse();  
            reversedSentence.append(reversedWord).append(" ");  
        }  
  
        return reversedSentence.toString().trim();  
    }  
  
    public static void main(String[] args) {  
        Scanner input = new Scanner(System.in);  
        System.out.print("Enter a sentence: ");  
        String sentence = input.nextLine();  
  
        String reversedSentence = reverseWords(sentence);  
        System.out.println("Reversed sentence: " + reversedSentence);  
    }  
}

//Enter a sentence: hello world
//Reversed sentence: olleh dlrow

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

//接受一个长度为n的整数数组，然后返回该数组中的所有元素之和
import java.util.Arrays;  
  
public class ArraySumCalculator {  
    public static int calculateArraySum(int[] arr) {  
        int sum = 0;  
        for (int num : arr) {  
            sum += num;  
        }  
        return sum;  
    }  
      
    public static void main(String[] args) {  
        int[] array = {1, 2, 3, 4, 5};  
        int sum = calculateArraySum(array);  
        System.out.println("Sum of array elements: " + sum);  
    }  
}

import java.util.Scanner;  
  
public class ArrayProcessor {  
    public static int calculateArraySum(int[] arr) {  
        int sum = 0;  
        for (int num : arr) {  
            sum += num;  
        }  
        return sum;  
    }  
  
    public static void main(String[] args) {  
        Scanner input = new Scanner(System.in);  
        System.out.print("Enter the length of the array: ");  
        int length = input.nextInt();  
  
        int[] array = new int[length];  
        System.out.println("Enter the elements of the array:");  
        for (int i = 0; i < length; i++) {  
            array[i] = input.nextInt();  
        }  
  
        int sum = calculateArraySum(array);  
        System.out.println("Sum of array elements: " + sum);  
    }  
}  

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

1、栈（Stack）是一种常见的数据结构，它遵循后进先出（Last-In-First-Out，LIFO）的原则。栈可以被看作是一种容器，其中的元素按照一定的顺序进行存储和访问。
栈具有以下几个主要特点：
后进先出（LIFO）：栈的最后一个添加的元素将成为第一个被移除的元素。也就是说，最后压入（添加）到栈中的元素最先弹出（移除）。
只能在栈顶进行插入和删除操作：栈只允许在栈顶进行元素的插入（称为"压栈"或"入栈"）和删除（称为"弹栈"或"出栈"）操作。插入和删除元素都是在栈顶进行的。
限制性：栈具有一种受限制的访问方式，只能在栈顶进行插入和删除操作，而不能在中间或底部插入或删除元素。这种限制使得栈具有高效的插入和删除操作。
容量有限：栈的容量是有限的，即栈中可以存储的元素数量有限。当栈的容量已满时，继续进行插入操作将导致栈上溢（Stack Overflow）。
栈在计算机科学中有着广泛的应用，例如函数调用栈、表达式求值、括号匹配、逆波兰表达式等。栈的特点使其非常适合解决需要遵循后进先出原则的问题。

2、队列（Queue）是一种常见的数据结构，它遵循先进先出（First-In-First-Out，FIFO）的原则。队列可以被看作是一种容器，其中的元素按照一定的顺序进行存储和访问。
队列具有以下几个主要特点：
先进先出（FIFO）：队列中最早添加的元素将首先被移除。也就是说，最先进入队列的元素最先被取出。
只能在队尾插入，在队头删除：队列只允许在队尾进行元素的插入（称为"入队"）和在队头进行元素的删除（称为"出队"）操作。新元素只能添加到队列的末尾，而只能从队列的头部移除元素。
限制性：队列具有一种受限制的访问方式，只能在队头删除元素和在队尾插入元素，不能在中间或其他位置进行操作。这种限制使得队列具有有序的数据访问方式。
容量有限：队列的容量是有限的，即队列中可以存储的元素数量有限。当队列已满时，继续进行插入操作将导致队列上溢（Queue Overflow）；当队列为空时，继续进行删除操作将导致队列下溢（Queue Underflow）。
队列在计算机科学中有着广泛的应用，例如任务调度、缓冲区管理、消息传递等。队列的特点使其非常适合解决需要按照先进先出原则进行操作的问题。

3、链表（Linked List）是一种常见的数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的引用（指针）。
链表和数组是两种不同的数据结构，它们在以下几个方面有所不同：
存储方式：数组使用连续的内存空间来存储元素，而链表使用离散的内存块来存储元素，每个节点可以在内存的任意位置。
大小固定性：数组的大小是固定的，一旦创建后，大小就不能改变。而链表的大小可以根据需要动态地进行扩展或缩小。
插入和删除操作的效率：对于数组，插入和删除操作需要移动元素，因为数组中的元素是连续存储的。而对于链表，插入和删除操作只需要修改节点之间的指针，效率较高。
随机访问的效率：数组可以通过索引直接访问元素，时间复杂度为O(1)。而链表需要从头节点开始逐个遍历，时间复杂度为O(n)。因此，数组在随机访问元素时效率更高。
空间占用：由于链表每个节点需要存储指针信息，相对于数组来说，链表在存储同样数量的元素时可能会占用更多的内存空间。
总的来说，数组适合在需要随机访问元素和已知大小的情况下使用，而链表适合在需要频繁进行插入和删除操作、大小不确定或动态变化的情况下使用。选择使用哪种数据结构取决于具体的应用需求和操作的特点。

4、树（Tree）是一种抽象数据类型，由n（n≥1）个节点的有限集合构成。树具有以下几个重要概念：
节点（Node）：树中的每个元素称为节点。节点可以包含一个数据元素，也可以不包含。节点之间通过边相连，用于表示节点之间的关系。
根节点（Root）：树中有且仅有一个根节点，它位于树的顶部，没有父节点。根节点是树中唯一的起始节点。
父节点和子节点：除了根节点外，每个节点都有且仅有一个父节点，它们之间通过一条边相连。节点的子节点是该节点的直接后继节点，而该节点是子节点的直接前驱节点。
叶节点（Leaf）：叶节点是没有子节点的节点，它们位于树的末端。
路径（Path）：从树的一个节点到另一个节点的序列被称为路径。路径的长度是路径上的边的数量。
层次（Level）：树的根节点位于第一层，它的子节点位于第二层，以此类推。树中每个节点的层次是从根节点到该节点的路径的长度。
深度（Depth）：树中节点的最大层次称为树的深度。根节点的深度为0。
子树（Subtree）：树中的任意节点及其子孙节点组成的集合称为子树。
森林（Forest）：由m（m≥0）棵互不相交的树组成的集合称为森林。
树是一种重要的数据结构，在计算机科学和信息技术领域有着广泛的应用，例如在数据库系统、操作系统、图形学、人工智能等领域都有树的身影。

树的节点可以不包含元素。
在某些应用场景中，树的节点可能只用于表示节点之间的关系，而不存储实际的数据元素。这种情况下，节点的作用主要是连接不同的部分或提供结构上的组织。
举例来说，考虑一个文件系统的目录结构，每个目录可以看作是树中的一个节点。目录节点可以有子目录和文件作为子节点，而目录本身不需要存储实际的数据元素，只需要存储子节点的引用和一些属性（例如目录名称、权限等）。在这种情况下，节点不包含元素是合理的，因为节点本身并不代表具体的数据。
另外，有时候在算法设计中，我们可能需要使用一种特殊的树结构，例如二叉搜索树（Binary Search Tree），其中节点的关键字（Key）用于比较和排序，而实际的数据元素则存储在节点之外。这种设计可以使得树的结构更加紧凑，减少存储的冗余。

5、哈希表（Hash Table），也被称为散列表，是一种常见的数据结构，用于存储键-值对（Key-Value）的集合。
哈希表的特点如下：
1. 快速的插入和查找：哈希表通过将键映射到一个固定的位置来实现快速的插入和查找操作。具体来说，通过一个哈希函数将键映射为哈希值，然后将该哈希值转换为数组索引，从而可以在常数时间内访问对应位置的元素。
2. 高效的查找操作：在哈希表中，通过哈希函数的映射，键被分散到不同的桶（bucket）中，每个桶存储了一组具有相同哈希值的键-值对。因此，当进行查找操作时，只需计算哈希值并在对应的桶中查找，而不需要逐个比较每个元素，使得查找操作具有常数时间复杂度。
3. 灵活的存储空间：哈希表的大小可以根据需要进行动态调整。通过合理设置负载因子（load factor），可以在时间和空间的平衡之间进行权衡。当负载因子过高时，哈希冲突的可能性增加，可能会导致性能下降；而当负载因子过低时，可能会浪费大量的内存空间。
4. 解决哈希冲突：由于不同的键可能映射到相同的哈希值，称为哈希冲突。哈希表使用冲突解决方法来处理这种情况。常见的冲突解决方法包括链地址法（Chaining），即在同一个桶中使用链表或其他数据结构来存储冲突的键-值对；和开放地址法（Open Addressing），即在发生冲突时，尝试寻找下一个可用的空桶。
总的来说，哈希表通过利用哈希函数和数组的结构，实现了高效的插入、查找和删除操作。它在各种应用场景中广泛使用，例如数据库系统、缓存实现、编译器和哈希算法等。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

1、虚拟内存（Virtual Memory）是一种计算机操作系统提供的抽象概念，它使得应用程序能够访问超出物理内存（RAM）容量的存储空间。
虚拟内存的主要作用包括：
扩大可用的内存空间：虚拟内存允许应用程序使用比实际物理内存更大的地址空间。它通过将不常用的数据从内存中换出到硬盘的存储空间中，释放出物理内存空间供其他程序使用。这样，即使系统的物理内存有限，应用程序也可以运行更大规模的任务。
提供内存的保护和隔离：虚拟内存为每个应用程序提供了独立的地址空间，使得每个应用程序彼此隔离，互不干扰。这样可以提高系统的安全性和稳定性，防止一个应用程序对其他应用程序或操作系统造成损害。
简化内存管理：虚拟内存通过将物理内存和磁盘上的存储空间统一管理，为程序员和操作系统提供了一致的内存模型。程序员不需要关注实际的物理内存布局和使用情况，而是将其视为连续的虚拟地址空间。操作系统负责将虚拟地址映射到物理地址，并负责内存的分配和回收等管理操作。
实现了分页机制：虚拟内存将物理内存和磁盘空间划分为固定大小的页面（page）。每个应用程序的虚拟地址空间也被划分为相同大小的页面。当应用程序访问某个虚拟地址时，操作系统根据页面表（page table）将虚拟地址映射到物理地址。这种分页机制可以有效地管理内存，并提供了更好的内存利用率。
总的来说，虚拟内存是操作系统提供的一种机制，它允许应用程序使用超出物理内存容量的存储空间。通过虚拟内存，系统可以扩大可用的内存空间、提供内存的保护和隔离、简化内存管理，并实现了分页机制，从而提高了系统的性能和稳定性。

2、死锁（Deadlock）是指在多个进程或线程之间发生的一种特殊情况，其中每个进程或线程都在等待一个被其他进程或线程持有的资源，而同时又持有其他进程或线程需要的资源，导致它们都无法继续执行，陷入无限等待的状态。
死锁通常发生在多个进程或线程同时满足以下四个条件时：
互斥条件（Mutual Exclusion）：至少有一个资源只能被一个进程或线程占用，即在一段时间内只允许一个进程或线程访问。
请求与保持条件（Hold and Wait）：一个进程或线程可以在持有某个资源的同时请求其他资源，而不释放已经占有的资源。
不可剥夺条件（No Preemption）：已经被分配给一个进程或线程的资源不能被强制性地剥夺，只能由占有它的进程或线程显式地释放
循环等待条件（Circular Wait）：存在一个进程或线程的资源请求序列，使得每个进程或线程都在等待下一个进程或线程所占有的资源。
当这四个条件同时满足时，就可能发生死锁。死锁的发生是一个潜在的问题，可能导致系统无法继续执行，需要通过适当的死锁检测和解决算法来解决。
要解决死锁问题，可以采取以下几种策略：
预防死锁：通过破坏四个死锁条件中的一个或多个条件来预防死锁的发生，如避免循环等待、强制资源分配顺序等。
避免死锁：在资源分配时，通过安全序列算法等方法来判断是否会发生死锁，只有当系统处于安全状态时才进行资源分配。
检测和恢复死锁：周期性地检测系统中是否存在死锁，并采取相应的措施来解除死锁，如终止某个进程或线程、回滚操作等。
忽略死锁：某些情况下，由于死锁发生的概率极低，可以选择忽略死锁，而不采取主动的死锁处理策略。
总之，死锁是指多个进程或线程因相互等待对方持有的资源而无法继续执行的状态。死锁的发生原因是四个条件同时满足，包括互斥条件、请求与保持条件、不可剥夺条件和循环等待条件。为了解决死锁问题，可以采取预防、避免、检测和恢复等策略。

3、在计算机科学中，进程（Process）是指正在执行的一个程序实例。它是操作系统中进行资源分配和调度的基本单位，可以看作是一个独立的执行环境，包含了程序代码、数据和执行状态等信息。
每个进程都拥有自己的内存空间、文件描述符、打开的文件等资源。进程之间是相互独立的，它们通过进程间通信（Inter-Process Communication，IPC）来实现数据共享和通信。
进程的特点包括：
独立性：每个进程都是相互独立的执行实体，它们有自己的内存空间和资源。
并发性：操作系统可以同时执行多个进程，通过时间片轮转等调度算法来实现进程之间的并发执行。
隔离性：进程之间相互隔离，一个进程的错误或异常不会直接影响其他进程的执行。
资源管理：操作系统负责为进程分配和管理资源，如内存、文件和设备等。

而线程（Thread）是进程中的执行单元，一个进程可以包含多个线程。线程共享同一个进程的资源，包括内存空间、文件和设备等，因此多个线程之间可以直接访问和共享数据。
线程的特点包括：
轻量性：相比进程，线程的创建和切换开销较小，可以更高效地实现并发执行。
共享性：线程可以共享进程的资源，包括内存、文件和设备等。
通信性：线程之间可以通过共享内存和同步机制进行通信和同步。
并发性：多个线程可以同时执行，从而提高程序的执行效率。
总结起来，进程是操作系统中执行的一个程序实例，拥有独立的执行环境和资源，进程之间相互独立；而线程是进程中的执行单元，共享进程的资源，多个线程之间可以并发执行，通过共享内存和同步机制进行通信和同步。进程是资源分配的基本单位，而线程是操作系统调度的基本单位。

4、文件系统（File System）是操作系统用于组织和管理计算机存储设备上文件和目录的一种机制。它提供了一种逻辑结构，使用户和应用程序可以方便地访问和管理文件。
文件系统包含以下重要概念：
文件（File）：文件是存储在存储设备上的命名数据单元，可以是文本文件、图像文件、程序文件等。文件通常具有名称、大小、创建日期和权限等属性。
目录（Directory）：目录是一种特殊的文件，用于组织和管理其他文件和子目录。目录可以形成层次结构，允许用户以逻辑方式组织文件。
路径（Path）：路径是用于定位文件或目录在文件系统中位置的字符串。路径可以是绝对路径（从根目录开始的完整路径）或相对路径（相对于当前工作目录的路径）。
文件描述符（File Descriptor）：文件描述符是操作系统用于标识和访问打开的文件的抽象概念。它是一个整数值，用于在文件操作中唯一标识打开的文件。
文件权限（File Permissions）：文件系统通过权限机制控制对文件的访问权限。权限包括读取（Read）、写入（Write）和执行（Execute）等。
文件系统层次结构（File System Hierarchy）：文件系统通常采用层次结构组织文件和目录。常见的层次结构包括树状结构，其中根目录是顶层目录，下面可以有多个子目录。
文件系统缓存（File System Cache）：为了提高文件访问效率，操作系统通常使用文件系统缓存来缓存最近访问的文件数据。这样可以减少对物理存储设备的访问次数，提高系统性能。
这些概念共同构成了文件系统的基本组成部分，使得用户和应用程序可以方便地进行文件的读取、写入、创建、删除和管理等操作。不同的操作系统和文件系统可能有不同的实现和特性，但上述概念是文件系统中的核心要素。

5、虚拟机（Virtual Machine）是一种软件实体，它在物理计算机上创建了一个独立的、隔离的虚拟环境，可以在这个虚拟环境中运行操作系统和应用程序。虚拟机技术通过在物理硬件上模拟出多个逻辑计算环境，从而使得一台物理计算机可以同时运行多个独立的操作系统和应用程序。
虚拟机的作用包括：
资源隔离：虚拟机可以将物理计算机的资源（如 CPU、内存、存储等）划分为多个独立的虚拟环境，从而实现不同虚拟机之间的资源隔离和保护。
多环境支持：虚拟机允许在同一台物理计算机上运行不同操作系统的多个实例，这样可以在一台机器上同时运行多个不同类型的应用程序。
硬件共享：多个虚拟机可以共享物理计算机的硬件资源，如网络接口、磁盘存储等，从而更有效地利用物理计算机的资源。
开发和测试：虚拟机可以用于应用程序的开发和测试，开发人员可以在虚拟机中模拟不同的操作系统和环境，进行软件开发和测试。
容错和恢复：虚拟机的快照和复制功能使得在虚拟化环境中实现系统的快速备份、恢复和迁移变得更加容易。
资源优化：通过虚拟机管理软件（如VMware、VirtualBox等），可以对虚拟机的资源分配和管理进行优化，以满足不同应用场景下的需求。
总之，虚拟机技术通过软件层面的虚拟化，实现了对物理计算机资源的高效利用和多环境支持，从而提高了计算资源的利用率、灵活性和安全性。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

class test {
	public static void main(String[] args) {
		
		int a =10;
		Integer a1 =10;
		int b =10;
		Integer b1= 10;
		System.out.println(""+(a==b)+(a==a1)+(a1==b1));
	}
}
//truetruetrue

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

n,x = map(int,input().split())

a = list(map(int,input().split()))

flag = 0
for i in range(len(a)):
    if sum(a)-a[i]>=x:
        flag=flag+1

print(flag)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

n = int(input())

a = map(int,input().split())
a = sorted(a)
mod = int(1e9)+7
def chengji(list):
    product =1
    for num in list:
        product*=num
    return product%mod


product =chengji(a)

a[0] = a[0]+1
a[n-1] = a[n-1]-1
product=max(product,chengji(a))



print(product)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

from collections import deque

n,q = map(int,input().split())
s = input()

t =s
s = deque(s)

#t =deque(t)


print(t)
while len(s)>0:
    if len(s)>0:
        s.pop()
        t =t +list(s)

    if len(s)>0:
        s.popleft()

        t =t +list(s)
for i in range(q):
    x = int(input())
    print(t[x-1])

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

class Example {  
    int value;  
  
    Example() {  
        this(0); // 调用另一个构造函数  
    }  
  
    Example(int value) {  
        super(); // 可以在this()后调用super()  
        this.value = value;  
    }  
}  

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

tail -f nginx.log  //实时监视`nginx.log`文件的最新内容，并将其输出到屏幕上。

`cat nginx.log`: 显示nginx.log文件的全部内容。

`less nginx.log`: 逐页显示nginx.log文件的内容，可向上/向下滚动查看。

`grep "keyword" nginx.log`: 在nginx.log文件中搜索包含指定关键字的内容。

`wc -l nginx.log`: 统计nginx.log文件中的行数。

`head -n 10 nginx.log`: 显示nginx.log文件的前10行内容。

`tail -n 10 nginx.log`: 显示nginx.log文件的最后10行内容。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

import java.util.ArrayList;  
  
public class ArrayListExample {  
    public static void main(String[] args) {  
        // 1. 创建 ArrayList 实例  
        ArrayList<String> names = new ArrayList<>(); 
        // 指定初始化容量为 10  
        // ArrayList<String> names = new ArrayList<>(10);
  
        // 2. 向 ArrayList 中添加元素  
        names.add("Alice");  
        names.add("Bob");  
        names.add("Charlie");  
  
        // 3. 访问和修改 ArrayList 中的元素  
        String firstName = names.get(0); // 获取第一个元素  
        System.out.println("第一个名字是: " + firstName); // 输出: 第一个名字是: Alice  
        names.set(0, "Amy"); // 修改第一个元素为 Amy  
        firstName = names.get(0);  
        System.out.println("修改后的第一个名字是: " + firstName); // 输出: 修改后的第一个名字是: Amy  
  
        // 4. 遍历 ArrayList 中的元素  
        for (String name : names) {  
            System.out.println(name);  
        }  
        // 输出:  
        // Amy  
        // Bob  
        // Charlie  
  
        // 5. 执行其他操作  
        names.remove(1); // 删除索引为 1 的元素 (Bob)  
        System.out.println("删除元素后的 ArrayList:");  
        for (String name : names) {  
            System.out.println(name);  
        }  
        // 输出:  
        // Amy  
        // Charlie  
  
        System.out.println("ArrayList 的大小是: " + names.size()); // 输出 ArrayList 的大小  
    }  
}