月嫂的个人简历网站模板什么是网站推广?

一、07.13 周六

1.0）算法题：字符串中的单词反转

字符串中的单词反转
题解实现：https://leetcode.cn/problems/fan-zhuan-dan-ci-shun-xu-lcof/solutions/2842057/fang-xiang-bian-li-bing-jie-qu-chu-dan-c-s5j7/

class Solution:def reverseMessage(self, message: str) -> str:        listWord = []# 去掉开头结束的空格message = message.strip()i = j = len(message) - 1while i >= 0:# 寻找第一个空格的位置while i >= 0 and message[i] != ' ': i -= 1listWord.append(message[i+1:j+1])# 是空格的略过while i >= 0 and message[i] == ' ': i -= 1j = ireturn ' '.join(listWord)

1.1） 问题01:可靠性计算中的MTTR MTTF MTBF 分别指什么？他们之间有什么联系？

在可靠性工程和维护管理中，MTTR、MTTF 和 MTBF 是三个重要的指标。它们用于评估系统或设备的可靠性和维护需求。以下是每个指标的定义及它们之间的联系：

MTTR (Mean Time to Repair)

平均修复时间（MTTR）是指系统或设备发生故障后，从故障发生到修复完成并恢复正常运行所需的平均时间。MTTR 是衡量维护效率的重要指标，表示系统在出现故障后的平均修复时间。

公式：
[ \text{MTTR} = \frac{\text{总修复时间}}{\text{修复次数}} ]

MTTF (Mean Time to Failure)

平均故障间隔时间（MTTF）是指系统或设备在正常运行状态下，从开始运行到首次发生故障的平均时间。MTTF 通常用于不可修复系统或设备（例如一次性使用的产品），表示设备在首次故障前的平均运行时间。

公式：
[ \text{MTTF} = \frac{\text{总运行时间}}{\text{故障次数}} ]

MTBF (Mean Time Between Failures)

平均故障间隔时间（MTBF）是指系统或设备在两次故障之间的平均运行时间。MTBF 是衡量系统可靠性的一个关键指标，表示在多个故障循环中的平均无故障运行时间。MTBF 通常用于可修复系统或设备。

公式：
[ \text{MTBF} = \text{MTTF} + \text{MTTR} ]

关系和区别

1. MTTF 与 MTBF：

   • MTTF 适用于不可修复的系统或设备，表示设备从开始运行到首次故障的平均时间。
   • MTBF 适用于可修复的系统或设备，表示两次故障之间的平均时间。MTBF 包含了 MTTF 和 MTTR。

2. MTTR 与 MTBF：

   • MTTR 仅表示修复时间，不包含正常运行时间。
   • MTBF 包含了 MTTR 和 MTTF，表示两次故障之间的完整周期，包括正常运行时间和修复时间。

3. 公式关系：

   • 对于可修复系统，MTBF 可以分解为 MTTF 和 MTTR 的和：
     [ \text{MTBF} = \text{MTTF} + \text{MTTR} ]

举例说明

假设一个系统在 100 小时内发生了 4 次故障，总修复时间为 8 小时。

• MTTR：
  [ \text{MTTR} = \frac{8 \text{小时}}{4 \text{次}} = 2 \text{小时/次} ]

• MTTF：
  [ \text{MTTF} = \frac{92 \text{小时}}{4 \text{次}} = 23 \text{小时/次} ]
  （因为总运行时间 100 小时 - 总修复时间 8 小时 = 92 小时）

• MTBF：
  [ \text{MTBF} = 23 \text{小时/次} + 2 \text{小时/次} = 25 \text{小时/次} ]

通过以上例子，可以看到 MTTR、MTTF 和 MTBF 是如何计算并相互联系的。理解这些指标有助于评估和改进系统的可靠性和维护策略。

1.2） 问题02 java中，list的 toArray()方法怎么使用

在Java中，List接口提供了toArray()方法，用于将List转换为数组。toArray()方法有两种形式：

1. Object[] toArray()
2. <T> T[] toArray(T[] a)

下面分别介绍这两种形式的使用方法。

1. Object[] toArray()

这个方法将List中的所有元素返回为一个Object数组。由于返回的是Object数组，因此在需要特定类型的数组时，需要进行类型转换。

import java.util.ArrayList;
import java.util.List;public class ToArrayExample {public static void main(String[] args) {List<String> list = new ArrayList<>();list.add("Apple");list.add("Banana");list.add("Cherry");// 使用 toArray() 方法Object[] array = list.toArray();// 输出数组内容for (Object element : array) {System.out.println(element);}}
}

2. <T> T[] toArray(T[] a)

这个方法将List中的所有元素返回为一个指定类型的数组。如果传入的数组长度足够大，则使用该数组存储元素；否则，将创建一个新的数组并返回。

import java.util.ArrayList;
import java.util.List;public class ToArrayExample {public static void main(String[] args) {List<String> list = new ArrayList<>();list.add("Apple");list.add("Banana");list.add("Cherry");// 使用 toArray(T[] a) 方法String[] array = list.toArray(new String[0]);// 输出数组内容for (String element : array) {System.out.println(element);}}
}

在这个例子中，我们传递了一个长度为0的字符串数组给toArray方法。Java会根据列表的大小创建一个新的字符串数组，并返回包含所有列表元素的数组。

使用示例

import java.util.ArrayList;
import java.util.List;public class ToArrayExample {public static void main(String[] args) {List<Integer> list = new ArrayList<>();list.add(1);list.add(2);list.add(3);// 使用 toArray() 方法转换为 Object 数组Object[] objectArray = list.toArray();System.out.println("Object Array:");for (Object obj : objectArray) {System.out.println(obj);}// 使用 toArray(T[] a) 方法转换为 Integer 数组Integer[] intArray = list.toArray(new Integer[0]);System.out.println("Integer Array:");for (Integer num : intArray) {System.out.println(num);}}
}

总结

• Object[] toArray(): 将List转换为Object数组，适用于不关心数组类型或需要进行类型转换的情况。
• <T> T[] toArray(T[] a): 将List转换为指定类型的数组，推荐使用这种方法，因为它避免了类型转换，提供了类型安全性。

1.3） 问题03: 文件系统节点法中的逻辑号，与地址索引和单个文件最大长度的关系及计算

在文件系统中，文件的逻辑块号与索引节点（inode）中的地址索引方式紧密相关。通过理解这些地址索引方式，可以推算出单个文件的最大长度。下面逐步介绍这一过程。

文件逻辑块号与地址索引

地址索引方式

文件系统中的索引节点通常使用以下几种地址索引方式：

1. 直接指针：索引节点直接包含指向数据块的指针。
2. 单级间接指针：指向一个间接块，间接块中包含指向数据块的指针。
3. 双级间接指针：指向一个双重间接块，双重间接块中包含指向间接块的指针，间接块中再包含指向数据块的指针。
4. 三级间接指针：指向一个三级间接块，三级间接块中包含指向双重间接块的指针，双重间接块中再包含指向间接块的指针，间接块中再包含指向数据块的指针。

计算逻辑块号

假设每个块的大小为B，每个指针的大小为P，则每个块中可以存储B / P个指针。

1. 直接指针：如果索引节点有N个直接指针，则它们可以直接指向N个数据块。
2. 单级间接指针：一个单级间接块可以存储B / P个指针，每个指针指向一个数据块，因此单级间接指针可以访问B / P个数据块。
3. 双级间接指针：一个双级间接块可以存储B / P个指向间接块的指针，每个间接块又可以存储B / P个指向数据块的指针，因此双级间接指针可以访问(B / P) * (B / P)个数据块。
4. 三级间接指针：一个三级间接块可以存储B / P个指向双级间接块的指针，每个双级间接块可以存储(B / P) * (B / P)个指向间接块的指针，因此三级间接指针可以访问(B / P) * (B / P) * (B / P)个数据块。

单个文件最大长度的计算

总数据块数

假设索引节点包含D个直接指针、一个单级间接指针、一个双级间接指针和一个三级间接指针，计算总数据块数T如下：

[ T = D + \frac{B}{P} + \left(\frac{B}{P}\right)^2 + \left(\frac{B}{P}\right)^3 ]

最大文件大小

最大文件大小为总数据块数乘以每个数据块的大小：

[ \text{最大文件大小} = T \times B ]

示例

假设：

• 每个块大小B = 4096字节（4KB）
• 每个指针大小P = 4字节
• 索引节点有12个直接指针（D = 12）

计算如下：

1. 直接指针块数：12
2. 单级间接指针块数：[ \frac{4096}{4} = 1024 ]
3. 双级间接指针块数：[ \left(\frac{4096}{4}\right)^2 = 1024 \times 1024 = 1048576 ]
4. 三级间接指针块数：[ \left(\frac{4096}{4}\right)^3 = 1024 \times 1024 \times 1024 = 1073741824 ]

总数据块数：

[ T = 12 + 1024 + 1048576 + 1073741824 = 1074790656 ]

最大文件大小：

[ \text{最大文件大小} = 1074790656 \times 4096 \approx 4 \text{TB} ]

总结

通过理解索引节点中的直接指针和多级间接指针的结构，我们可以计算出文件的逻辑块号以及单个文件的最大长度。这些计算依赖于块的大小、指针的大小以及索引节点中的指针数量。以上概述了如何推算这些值，并提供了一个具体的示例进行说明。