一、实操题
1、编程实现：
个位数
题目描述：
给定一个正整数N（10<N<1000），输出正整数个位上的数字。
输入描述
输入一个正整数N（10<N<1000）
输出描述
输出正整数N个位上的数字
样例输入
123
样例输出
3
参考答案：对于给定的正整数N，我们可以通过取模运算得到其个位数字。具体来说，可以使用N对10取模，得到的结果即为N的个位数字。
解析：【喵呜刷题小喵解析】：
对于这个问题，我们可以使用取模运算来得到正整数N的个位数字。取模运算是一种基本的数学运算，它返回两个数相除的余数。在这个问题中，我们关心的是N除以10的余数，因为这个余数就是N的个位数字。具体来说，我们可以使用以下公式来计算N的个位数字：
个位数字 = N % 10
其中，%表示取模运算。这个公式的作用是，将N除以10，然后返回余数，这个余数就是N的个位数字。
因此，对于给定的样例输入123，我们可以使用上述公式得到其个位数字为3。
2、编程实现：
判断数字
题目描述：
给定一个正整数N（100≤N<100000），统计出100到N（包含100和N）之间的正整数中，有多少个正整数满足以下条件：
1）正整数个位数不为3；
2）正整数十位数不为5；
3）正整数百位数不为7。
输入描述
输入一个正整数N（100≤N<100000）
输出描述
输出100到N（包含100和N）之间有多少个正整数满足条件
样例输入
110
样例输出
10
参考答案：br />```pythondef count_numbers(n):count = 0for i in range(100, n+1):if i % 10 != 3 and i // 10 % 10 != 5 and i // 100 != 7:count += 1return countN = int(input())print(count_numbers(N))```
解析：【喵呜刷题小喵解析】
这个问题是一个简单的编程问题，需要我们编写一个函数来计算在100到N（包含100和N）之间的正整数中，有多少个正整数满足给定的条件。
函数`count_numbers`接收一个参数`n`，表示需要计算的范围的上限。在函数内部，我们使用一个循环从100遍历到`n`，对于每个数字，我们检查它是否满足给定的条件：个位数不为3，十位数不为5，百位数不为7。如果满足条件，我们就将计数器`count`加1。最后，函数返回计数器的值。
在主程序中，我们首先读取输入的正整数`N`，然后调用`count_numbers`函数来计算满足条件的正整数的数量，并将结果打印出来。
注意，在Python中，`//`表示整数除法，`%`表示取余数。所以，`i // 10`可以得到一个数字的十位数，`i // 10 % 10`可以得到一个数字的个位数，`i % 10`也可以得到一个数字的个位数。`i // 100`可以得到一个数字的百位数。
3、编程实现：
去重
题目描述：
给定一个长度小于200的字符串s，且字符中只包含小写字母，然后按照以下要求对字符串s进行去重，并输出去重后的字符串。
要求：
1）如果有重复出现的字母，只保留1个，其他的去掉；
2）不得改变各字母相对位置；
3）保证去重后的字符串的字典序最小。
例如：
s=“cacd”，重复的字母有c，如果去掉第一个字母c，结果为acd；如果去掉第二个字母c结果为cad.比较两个去重后的结果，第一个结果的字典序小于第二个结果的字典序，故选择去掉第一个c，输出acd。
输入描述
输入一个长度小于200的字符串s。且字符串中只包含小写字母
输出描述
按照要求对字符串s进行去重，并输出
样例输入
cdacd
样例输出
acd
提示信息：
字典序大小，是指字符串中字母在字母表中的先后顺序，即字母表中越靠前的字母，字典序越小。
例如：两个字符串acd和cad，两个字符率的第一个字母分别为“a”和“c”，其中“a”在字母表中排在“c”的前边，故字符串acd字典序小于字符出cad。假如第一个字母相同。就比较第二个字母，以此类推。
参考答案：br />根据题目要求，我们可以按照以下步骤对字符串进行去重操作：1. 创建一个长度为26的数组（用于记录每个字母是否出现过）2. 遍历输入字符串，对于每个字母，检查其是否已出现过，如果没有出现过，则将其加入到结果字符串中，并标记该字母已出现过。3. 返回结果字符串。
解析：【喵呜刷题小喵解析】
对于这个问题，我们可以使用贪心算法的思想，即每次选择字典序最小的未出现过的字母。
具体步骤如下：
1. 创建一个长度为26的数组`visited`，用于记录每个字母是否出现过。初始时，所有字母都未出现过，即所有元素都为`false`。
2. 遍历输入字符串`s`，对于每个字符`ch`，我们可以通过`ch - 'a'`将其转换为0-25的索引。如果`visited[ch - 'a']`为`false`，说明该字母未出现过，我们可以将其加入到结果字符串`result`中，并将`visited[ch - 'a']`设置为`true`，表示该字母已经出现过。
3. 遍历完输入字符串后，返回结果字符串`result`即可。
这种算法的时间复杂度为O(n)，其中n为输入字符串的长度。因为我们只需要遍历一次输入字符串，所以该算法的效率较高。
4、编程实现：
路径最小和
题目描述：
有一个N*M的矩阵方格，每个方格中都有一个正整数，现从左上角方格出发向右下角方格移动，每次只能向下或句右移动一个方格，请你找出一条最小路径、并输出该路径上的正整数之和。
最小路径：这条路径上的正整数之和最小。
例如：
N=2、M=3。2*3的矩阵方格中的正整数如下，按照移动规则，从左上角方格移动到右下角方格的路径共3条，分别为1->3->5->6；1->3->4->6；1->2->4->6。3条路径上的正整数之和分别为15、14和13。其中正整故之和最小的一条路径是1->2->4->6。和为13。故输出13。
输入描述
第一行输入两个正整数N和M（2≤N≤100，2≤M≤100），N表示矩阵方格的行数，M表示矩阵方格的列数，两个正整数之间以一个空格隔开
第二行开始输入N行，每行M平整数（1≤正整数≤200）。正整数之间以一个空格隔开
输出描述
输出一个整数，表示最小路径上的正整数之和
样例输入
2 3 1 3 5 2 4 6
样例输出
13
参考答案：```pythondef min_path_sum(matrix):if not matrix or not matrix[0]:return 0n, m = len(matrix), len(matrix[0])dp = [[0] * (m + 1) for _ in range(n + 1)]dp[0][1:] = [row[0] for row in matrix]for i in range(1, n + 1):dp[i][0] = dp[i - 1][0] + matrix[i - 1][0]for i in range(1, n + 1):for j in range(1, m + 1):dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]) + matrix[i - 1][j - 1]return dp[n][m]N, M = map(int, input().split())matrix = [list(map(int, input().split())) for _ in range(N)]print(min_path_sum(matrix))```
解析：【喵呜刷题小喵解析】：
这个问题是一个典型的动态规划问题，可以使用动态规划算法来解决。
首先，我们需要定义一个二维数组`dp`，其中`dp[i][j]`表示从左上角方格移动到位置`(i, j)`方格的最小路径和。然后，我们需要根据题目的规则来更新`dp`数组的值。
我们可以发现，从左上角方格到任意位置`(i, j)`方格的最小路径和，可以通过从上方方格`(i-1, j)`和左方方格`(i, j-1)`移动到位置`(i, j)`方格的最小路径和中的较小值，加上位置`(i, j)`方格的值得到。
因此，我们可以使用动态规划算法，从左上角方格开始，逐步更新`dp`数组的值，直到更新到右下角方格。最后，`dp[n][m]`即为最小路径和。
在代码中，我们首先将`dp`数组的第一行和第一列初始化，然后逐步更新`dp`数组的值，最后输出`dp[n][m]`即可。
5、操作字符串
题目描述：
给定两个字符串S1和S2（1<S1长度<100，1<S2长度<100），然后按照以下三种操作，将S1转为S2，问最少操作几次可以完成。
可对字符串进行三种操作：
1）插入一个字符；
2）删除一个字符；
3）修改一个字符。
例如：
S1=abcd，S2=ebde，S1转为S2最少需要操作3次，
第一次操作：将abcd中的字符a修改成e,修改后为ebcd;
第二次操作：将ebcd中的字符c删除,删除后为ebd;
第三次操作：在ebd末端插入字符e,插入后为ebde，
经过3次操作，字符串abcd转为字符串ebde。
输入描述：
第一行输入一个字符串S1（1<S1长度<100）
第二行输入一个字符串S2（1<S2长度<100）
输出描述：
输出一个整数，表示将S1转为S2的最少操作次数
样例输入：
abcd ebde
样例输出：
3
参考答案：对于给定的字符串S1和S2，我们可以使用动态规划算法来解决这个问题。我们定义一个二维数组dp[i][j]，其中dp[i][j]表示将S1的前i个字符转换为S2的前j个字符所需的最少操作次数。我们可以通过以下递推关系来填充这个数组：1. 如果S1的第i个字符和S2的第j个字符相等，那么不需要进行任何操作，即dp[i][j] = dp[i-1][j-1]。2. 如果S1的第i个字符和S2的第j个字符不相等，那么我们可以选择进行插入、删除或修改操作。因此，dp[i][j] = min(dp[i-1][j] + 1, dp[i][j-1] + 1, dp[i-1][j-1] + 1)。最后，dp[m][n]就是我们要找的结果，其中m是S1的长度，n是S2的长度。
解析：【喵呜刷题小喵解析】：
这个问题是一个经典的动态规划问题，可以使用动态规划算法来解决。动态规划算法是一种通过把原问题分解为相对简单的子问题的方式来求解复杂问题的方法。在这个问题中，我们使用一个二维数组dp来记录子问题的解，然后通过递推关系来填充这个数组。
首先，我们定义dp[i][j]为将S1的前i个字符转换为S2的前j个字符所需的最少操作次数。然后，我们根据S1的第i个字符和S2的第j个字符是否相等来分情况讨论。如果相等，那么不需要进行任何操作，即dp[i][j] = dp[i-1][j-1]。如果不相等，那么我们可以选择进行插入、删除或修改操作，因此dp[i][j] = min(dp[i-1][j] + 1, dp[i][j-1] + 1, dp[i-1][j-1] + 1)。
最后，我们返回dp[m][n]，其中m是S1的长度，n是S2的长度，就是我们要找的结果。这个算法的时间复杂度是O(mn)，其中m和n分别是S1和S2的长度。
喵呜刷题：让学习像火箭一样快速，快来微信扫码，体验免费刷题服务，开启你的学习加速器！
