首页 > 其他分享 >字节青训-小C的类二进制拼图、小M的奶酪问题、小T的密码变换规则、数值操作的期望计算问题、数组重排最小化差值、选择题反选效果分析、二进制反码转换问题、充电总时间计算

字节青训-小C的类二进制拼图、小M的奶酪问题、小T的密码变换规则、数值操作的期望计算问题、数组重排最小化差值、选择题反选效果分析、二进制反码转换问题、充电总时间计算

时间：2024-11-19 20:17:12浏览次数：3  
标签：std 输出 反码 二进制 样例 反选 int include

目录

一、小C的类二进制拼图

问题描述

测试样例

解题思路：

问题理解

数据结构选择

算法步骤

第一版代码：

最终代码： 

 

二、小M的奶酪问题

问题描述

测试样例

解题思路：

问题理解

数据结构选择

算法步骤

 

最终代码：

运行结果：

 三、小T的密码变换规则

问题描述

测试样例

 解题思路：

问题理解

数据结构选择

算法步骤

具体步骤

最终代码：

 

运行结果：

 四、数值操作的期望计算问题

问题描述

测试样例

 解题思路：

问题理解

关键点

期望值计算

可能的操作组合

概率计算

期望值公式

最终代码：

运行结果：

​编辑

 五、数组重排最小化差值

问题描述

测试样例

解题思路：

关键点

最终代码：

运行结果：

​编辑 

 六、选择题反选效果分析

问题描述

测试样例

解题思路：

问题理解

解题思路

数据结构选择

算法步骤

最终代码：

运行结果：

​编辑 

 七、二进制反码转换问题

问题描述

测试样例

解题思路： 

 

问题理解

数据结构选择

算法步骤

特殊情况

最终代码：

运行结果：

​编辑 

 八、充电总时间计算

问题描述

测试样例

 解题思路：

问题理解

数据结构选择

算法步骤

 最终代码：

运行结果：

​编辑 

一、小C的类二进制拼图

问题描述

小C发现了一种特殊的数字，称为类二进制数字，即仅由数字0和1组成的十进制数。例如，101和1100都是类二进制数字，而112和3001则不是。现在，小C手上有一个正整数n，他想知道最少需要多少个类二进制数字相加才能得到n。

测试样例

样例1：

输入：n = "10101"
输出：1

样例2：

输入：n = "212"
输出：2

样例3：

输入：n = "1000000"
输出：1

样例4：

输入：n = "123456789"
输出：9

样例5：

输入：n = "9876543210"
输出：9

解题思路：

问题理解

我们需要找到最少的类二进制数字（即仅由0和1组成的数字）相加，使得它们的和等于给定的正整数 n。

数据结构选择

由于 n 是一个字符串表示的数字，我们可以将其转换为整数进行处理，或者直接在字符串上进行操作。

算法步骤

  1. 逐位处理：从 n 的最高位开始，逐位处理。
  2. 构建类二进制数字：对于每一位，如果当前位是 1，则可以直接使用该位作为类二进制数字的一部分；如果当前位是 0，则不需要处理。
  3. 进位处理：如果当前位是 2 或更高，则需要将其减去 1，并将进位加到下一位。
  4. 计数：每处理一个非零位，计数器加一。

第一版代码：

#include <iostream>
using namespace std;

int solution(string n) {
    int count = 0;  // 用于记录最少需要的类二进制数字的个数
    int carry = 0;  // 用于处理进位

    // 从最高位开始逐位处理
    for (int i = 0; i < n.size(); ++i) {
        int digit = n[i] - '0' + carry;  // 当前位的数字，加上进位

        if (digit > 0) {
            // 如果当前位大于0，则需要一个类二进制数字
            count++;
            // 处理进位
            carry = digit - 1;
        } else {
            // 如果当前位为0，则不需要处理
            carry = 0;
        }
    }

    return count;
}

int main() {
    cout << (solution("10101") == 1) << endl;
    cout << (solution("212") == 2) << endl;
    cout << (solution("1000000") == 1) << endl;
    cout << (solution("123456789") == 9) << endl;
    cout << (solution("9876543210") == 9) << endl;
    return 0;
}

但实际上并没过，不过反应过来了有一个更简单的思路，只要找到这串数字的每个位上的数字最大值就是答案

最终代码： 

 

#include <iostream>
#include <algorithm>
using namespace std;

int solution(string n) {
    int max_digit = 0;  // 用于记录最大位数

    // 遍历字符串 n，找到最大位数
    for (char c : n) {
        int digit = c - '0';  // 将字符转换为数字
        max_digit = max(max_digit, digit);  // 更新最大位数
    }

    return max_digit;
}

int main() {
    cout << (solution("10101") == 1) << endl;
    cout << (solution("212") == 2) << endl;
    cout << (solution("1000000") == 1) << endl;
    cout << (solution("123456789") == 9) << endl;
    cout << (solution("9876543210") == 9) << endl;
    return 0;
}

二、小M的奶酪问题

问题描述

小M在集市上买了一公斤奶酪回家。然而，在小M不在的时候，小F偷偷地偷走了 ABBA​ 公斤的奶酪。现在，小M想知道他还剩下多少奶酪。要求答案以分数的形式表示，并且分数的分母必须为 BB。

测试样例

样例1：

输入：A = 2,B = 7
输出：'5/7'

样例2：

输入：A = 1,B = 3
输出：'2/3'

样例3：

输入：A = 3,B = 5
输出：'2/5'

解题思路：

问题理解

小M原本有一公斤奶酪，小F偷走了 BA​ 公斤的奶酪。我们需要计算小M还剩下多少奶酪，并且结果需要以分数的形式表示，分母必须是 B。

数据结构选择

由于我们需要表示一个分数，并且分母是固定的 B，我们可以直接使用整数来表示分子。

算法步骤

  1. 初始化：小M原本有1公斤奶酪，即 BB​ 公斤。
  2. 计算剩余奶酪：小F偷走了 BA​ 公斤奶酪，所以小M剩下的奶酪是 BB​−BA​。
  3. 简化分数：由于分母已经是 B，我们只需要计算分子即可。分子可以通过 B−A 得到。
  4. 返回结果：将分子和分母组合成字符串形式的分数。

 

最终代码：

#include <iostream>
#include <string>

std::string solution(int A, int B) {
    // 计算分子
    int numerator = B - A;
    
    // 构建分数字符串
    std::string result = std::to_string(numerator) + "/" + std::to_string(B);
    
    // 返回结果
    return result;
}

int main() {
    std::cout << (solution(2, 7) == "5/7") << std::endl;
    std::cout << (solution(1, 3) == "2/3") << std::endl;
    std::cout << (solution(3, 5) == "2/5") << std::endl;
}

运行结果：

 

 三、小T的密码变换规则

问题描述

小T设计了一套密码变换规则，将输入的字符串转换成一串数字密码。变换规则如下：

  1. 小写字母按以下映射关系进行转换：
  • a, b, c -> 2
  • d, e, f -> 3
  • g, h, i -> 4
  • j, k, l -> 5
  • m, n, o -> 6
  • p, q, r, s -> 7
  • t, u, v -> 8
  • w, x, y, z -> 9

  1. 大写字母先转为小写字母，再跳到字母表中的前一个字母，并按上述规则转换为对应的数字。例如，B 转换为 a，再转换为 2；A 特殊处理，先变为 Z，再转换为 9。

  2. 非字母字符保持不变。

例如：对于输入字符串 "LIming0701"，转换后的数字密码为 5464640701。

测试样例

样例1：

输入：s = "LIming0701"
输出：'5464640701'

样例2：

输入：s = "PassW0rd"
输出：'62778073'

样例3：

输入：s = "helloWORLD123"
输出：'4355686752123'

 解题思路：

问题理解

我们需要将输入的字符串按照特定的规则转换成一串数字密码。规则包括对小写字母、大写字母和非字母字符的处理。

数据结构选择

我们可以使用一个字符串来存储最终的转换结果。对于字母的转换，我们可以使用一个映射表（例如 std::unordered_map 或 std::array）来存储字母到数字的映射关系。

算法步骤

  1. 初始化映射表：创建一个映射表，存储小写字母到对应数字的映射关系。
  2. 遍历输入字符串：
    • 对于每个字符，判断其是否为字母。
    • 如果是大写字母，先转换为小写字母，然后跳到字母表中的前一个字母。
    • 如果是小写字母，直接查找映射表。
    • 如果是非字母字符，保持不变。
  3. 构建结果字符串：将每个字符的转换结果依次添加到结果字符串中。

具体步骤

  1. 初始化映射表：
    • 例如，a, b, c 映射到 2，d, e, f 映射到 3，依此类推。
  2. 遍历输入字符串：
    • 对于每个字符，使用 isalpha() 判断是否为字母。
    • 如果是大写字母，使用 tolower() 转换为小写字母，然后根据规则跳到前一个字母。
    • 如果是小写字母，直接查找映射表。
    • 如果是非字母字符，直接添加到结果字符串中。
  3. 返回结果字符串。

最终代码：

 

#include <iostream>
#include <string>
#include <unordered_map>

std::string solution(const std::string& s) {
    // 初始化映射表
    std::unordered_map<char, char> charToDigit = {
        {'a', '2'}, {'b', '2'}, {'c', '2'},
        {'d', '3'}, {'e', '3'}, {'f', '3'},
        {'g', '4'}, {'h', '4'}, {'i', '4'},
        {'j', '5'}, {'k', '5'}, {'l', '5'},
        {'m', '6'}, {'n', '6'}, {'o', '6'},
        {'p', '7'}, {'q', '7'}, {'r', '7'}, {'s', '7'},
        {'t', '8'}, {'u', '8'}, {'v', '8'},
        {'w', '9'}, {'x', '9'}, {'y', '9'}, {'z', '9'}
    };

    std::string result;

    // 遍历输入字符串
    for (char c : s) {
        if (std::isalpha(c)) {
            // 如果是大写字母，先转换为小写字母，然后跳到前一个字母
            if (std::isupper(c)) {
                c = std::tolower(c);
                // 特殊处理 'a' 和 'A'
                if (c == 'a') {
                    c = 'z';
                } else {
                    c -= 1;
                }
            }
            // 查找映射表并添加到结果字符串
            result += charToDigit[c];
        } else {
            // 非字母字符保持不变
            result += c;
        }
    }

    return result;
}

int main() {
    std::cout << (solution("LIming0701") == "5464640701") << std::endl;
    std::cout << (solution("PassW0rd") == "62778073") << std::endl;
    std::cout << (solution("helloWORLD123") == "4355686752123") << std::endl;
    return 0;
}

运行结果：

 

 四、数值操作的期望计算问题

问题描述

小R有两个正整数aa和bb，她将随机选择其中一个数并将其乘以22。这个操作会进行两次，操作后的两个数之和会有所变化。小R想知道，操作结束后，两个数之和的期望值是多少？

例如：如果 a=3a=3 和 b=3b=3，那么有 1/21/2 的概率两数之和为 1212，1/21/2 的概率两数之和为 1515。因此，期望值为 13.513.5。

测试样例

样例1：

输入：a = 3 ,b = 3
输出：'13.50'

样例2：

输入：a = 5 ,b = 7
输出：'27.00'

样例3：

输入：a = 1 ,b = 1
输出：'4.50'

 解题思路：

问题理解

小R有两个正整数 a 和 b，她会随机选择其中一个数并将其乘以 2。这个操作会进行两次。我们需要计算操作结束后，两个数之和的期望值。

关键点

  1. 随机选择：每次操作有 1/2 的概率选择 a，1/2 的概率选择 b。
  2. 操作两次：每次操作后，数会乘以 2。

期望值计算

我们需要考虑所有可能的操作组合，并计算每种组合的概率和结果。

可能的操作组合
  1. 第一次选择 a，第二次选择 a：结果是 2a+2a=4a
  2. 第一次选择 a，第二次选择 b：结果是 2a+2b
  3. 第一次选择 b，第二次选择 a：结果是 2b+2a
  4. 第一次选择 b，第二次选择 b：结果是 2b+2b=4b
概率计算

每种组合的概率是 1/4，因为每次选择是独立的，且每次选择 a 或 b 的概率都是 1/2。

期望值公式

期望值 E 可以表示为：
[ E = \frac{1}{4} \times (4a) + \frac{1}{4} \times (2a + 2b) + \frac{1}{4} \times (2b + 2a) + \frac{1}{4} \times (4b) ]

简化后：
[ E = \frac{1}{4} \times (4a + 2a + 2b + 2b + 2a + 4b) ]
[ E = \frac{1}{4} \times (8a + 8b) ]
[ E = 2a + 2b ]

最终代码：

#include <iostream>
#include <string>
#include <iomanip>  // 用于格式化输出
using namespace std;

string solution(int a, int b) {
    // 计算期望值
    // 1. 计算所有可能的操作结果
    // 2. 计算每种结果的概率
    // 3. 使用加权平均的方法计算期望值
    
    // 计算每种组合的概率和结果
    double expected_value = (1.0/4) * (4*a + b) + (1.0/2) * (2*a + 2*b) + (1.0/4) * (a + 4*b);
    
    // 格式化输出为两位小数的字符串
    ostringstream oss;
    oss << fixed << setprecision(2) << expected_value;
    return oss.str();
}

int main() {
    // 打印实际输出以便调试
    cout << solution(3, 3) << endl;
    cout << solution(5, 7) << endl;
    cout << solution(1, 1) << endl;
    
    // 测试样例
    cout << (solution(3, 3) == "13.50") << endl;
    cout << (solution(5, 7) == "27.00") << endl;
    cout << (solution(1, 1) == "4.50") << endl;
    return 0;
}

运行结果：

 五、数组重排最小化差值

 

问题描述

小C 和小U 有两个数组，分别是 a 和 b，它们的长度相同。小U 想通过重新排列数组 a 的元素，来最小化 a 和 b 之间的差异。具体来说，他们要最小化所有元素差值绝对值之和，即 sum(abs(a[i] - b[i]))。
你能帮助小C 和小U 找到这个最小化的值吗？

测试样例

样例1：

输入：a = [2, 1, 3, 2], b = [5, 2, 4, 2]
输出：5

样例2：

输入：a = [1, 4, 6], b = [2, 5, 7]
输出：3

样例3：

输入：a = [1, 9, 6], b = [2, 5, 7]
输出：4

解题思路：

  1. 理解问题：

    • 我们需要重新排列数组 a 的元素，使得 a 和 b 中对应元素的差值绝对值之和最小。
    • 这意味着我们需要找到一种排列方式，使得 a 中的元素尽可能接近 b 中的对应元素。

  2. 数据结构的选择：

    • 由于我们需要对数组 a 进行排列，因此可以考虑对 a 进行排序。
    • 排序后，我们可以尝试将 a 中的元素与 b 中的元素进行匹配，使得差值绝对值之和最小。

  3. 算法步骤：

    • 首先，对数组 a 进行排序。
    • 然后，对数组 b 进行排序。
    • 计算排序后的 a 和 b 中对应元素的差值绝对值之和。

关键点

  • 通过排序，我们可以确保 a 中的元素与 b 中的元素尽可能接近，从而最小化差值绝对值之和。
  • 排序的时间复杂度为 O(n log n)，计算差值绝对值之和的时间复杂度为 O(n)，因此整体时间复杂度为 O(n log n)。

最终代码：

#include <iostream>
#include <vector>
#include <algorithm> // 用于排序

using namespace std;

long long solution(vector<int> a, vector<int> b) {
    // 对数组 a 和 b 进行排序
    sort(a.begin(), a.end());
    sort(b.begin(), b.end());
    
    // 初始化差值绝对值之和
    long long sum = 0;
    
    // 遍历数组 a 和 b，计算差值绝对值之和
    for (int i = 0; i < a.size(); ++i) {
        sum += abs(a[i] - b[i]);
    }
    
    return sum;
}

int main() {
    vector<int> a1 = {2, 1, 3, 2}, b1 = {5, 2, 4, 2};
    vector<int> a2 = {1, 4, 6}, b2 = {2, 5, 7};
    vector<int> a3 = {1, 9, 6}, b3 = {2, 5, 7};
    
    cout << (solution(a1, b1) == 5) << endl;
    cout << (solution(a2, b2) == 3) << endl;
    cout << (solution(a3, b3) == 4) << endl;
    
    return 0;
}

运行结果：

 

 六、选择题反选效果分析

问题描述

小U正在检查某同学的选择题答案。试卷共有 n 道题目，每道题目只有两个选项 A 和 B。当前小U手上有两组答案：

  1. s：该同学的原始答案。
  2. t：标准答案。

小U想知道，如果将该同学的所有答案都反选（即：如果某题的答案是 A 则改成 B，如果是 B 则改成 A），那么在反选之后，正确的答案数量是否会增加？具体结果有三种可能：

  1. 如果反选后的正确答案数 增加，输出 "yes"。
  2. 如果反选后的正确答案数 不变，输出 "draw"。
  3. 如果反选后的正确答案数 减少，输出 "no"。

测试样例

样例1：

输入：n = 2,s = "AB",t = "AA"
输出：'draw'

样例2：

输入：n = 3,s = "BAA",t = "ABB"
输出：'yes'

样例3：

输入：n = 4,s = "ABAB",t = "BABA"
输出：'yes'

解题思路：

问题理解

  1. 输入：

    • n：题目数量。
    • s：该同学的原始答案，长度为 n，每个字符为 A 或 B。
    • t：标准答案，长度为 n，每个字符为 A 或 B。

  2. 输出：

    • 如果反选后的正确答案数 增加，输出 "yes"。
    • 如果反选后的正确答案数 不变，输出 "draw"。
    • 如果反选后的正确答案数 减少，输出 "no"。

解题思路

  1. 计算原始正确答案数：

    • 遍历 s 和 t，统计原始答案 s 中与标准答案 t 相同的字符数量，记为 original_correct。

  2. 计算反选后的正确答案数：

    • 反选后的正确答案数可以通过 n - original_correct 计算得到，因为反选后，原来正确的答案会变成错误的，原来错误的答案会变成正确的。

  3. 比较原始正确答案数和反选后的正确答案数：

    • 如果 n - original_correct 大于 original_correct，输出 "yes"。
    • 如果 n - original_correct 等于 original_correct，输出 "draw"。
    • 如果 n - original_correct 小于 original_correct，输出 "no"。

数据结构选择

  • 使用简单的字符串遍历和计数即可，不需要复杂的数据结构。

算法步骤

  1. 初始化 original_correct 为 0。
  2. 遍历 s 和 t，统计 s 中与 t 相同的字符数量，累加到 original_correct。
  3. 计算反选后的正确答案数 flipped_correct 为 n - original_correct。
  4. 比较 original_correct 和 flipped_correct，根据比较结果输出相应的字符串。

最终代码：

#include <iostream>
#include <vector>
#include <string>

using namespace std;

std::string solution(int n, std::string s, std::string t) {
    // 初始化原始正确答案数
    int original_correct = 0;
    
    // 遍历 s 和 t，统计原始正确答案数
    for (int i = 0; i < n; ++i) {
        if (s[i] == t[i]) {
            original_correct++;
        }
    }
    
    // 计算反选后的正确答案数
    int flipped_correct = n - original_correct;
    
    // 比较原始正确答案数和反选后的正确答案数
    if (flipped_correct > original_correct) {
        return "yes";
    } else if (flipped_correct == original_correct) {
        return "draw";
    } else {
        return "no";
    }
}

int main() {
    std::cout << (solution(2, "AB", "AA") == "draw") << std::endl;
    std::cout << (solution(3, "BAA", "ABB") == "yes") << std::endl;
    std::cout << (solution(4, "ABAB", "BABA") == "yes") << std::endl;
    return 0;
}

运行结果：

 

 七、二进制反码转换问题

问题描述

小C在学习二进制运算，他了解到每个非负整数都有其二进制表示。例如，整数 5 可以被表示为二进制 "101"，整数 11 可以被表示为二进制 "1011"，并且除了 N = 0 外，任何二进制表示中都不含前导零。

二进制的反码表示是将每个 1 变为 0，每个 0 变为 1。例如，二进制数 "101" 的二进制反码为 "010"。现在小C想知道，给定一个十进制数 N，它的二进制反码对应的十进制数是多少。

测试样例

样例1：

输入：N = 5
输出：2

样例2：

输入：N = 10
输出：5

样例3：

输入：N = 0
输出：1

解题思路： 

 

问题理解

我们需要将一个十进制数 N 转换为其二进制表示，然后对这个二进制表示进行反码操作（即 1 变为 0，0 变为 1），最后将反码后的二进制数转换回十进制数。

数据结构选择

  • 二进制表示可以使用字符串来存储。
  • 反码操作可以直接在字符串上进行。

算法步骤

  1. 转换为二进制：将十进制数 N 转换为二进制字符串。
  2. 反码操作：遍历二进制字符串，将每个 1 变为 0，每个 0 变为 1。
  3. 转换回十进制：将反码后的二进制字符串转换回十进制数。

特殊情况

  • 当 N = 0 时，其二进制表示为 "0"，反码后为 "1"，对应的十进制数为 1。

最终代码：

#include <iostream>
#include <string>
#include <bitset>

int solution(int N) {
    std::string binary_representation = std::bitset<32>(N).to_string(); 
    size_t first_one = binary_representation.find('1');
    if (first_one != std::string::npos) {
        binary_representation = binary_representation.substr(first_one);
    } else {
        binary_representation = "0";  
    }

     for (char &bit : binary_representation) {
        bit = (bit == '0') ? '1' : '0'; 
    }

    int result = std::stoi(binary_representation, nullptr, 2);  

    return result;
}

int main() {
    std::cout << (solution(5) == 2) << std::endl;
    std::cout << (solution(10) == 5) << std::endl;
    std::cout << (solution(0) == 1) << std::endl;
    return 0;
}

运行结果：

 

 八、充电总时间计算

问题描述

小R有nn部电脑，每部电脑的电池容量分别为aiai​。她可以使用两种不同的充电方式来给电脑充电：

  1. 普通充电：每单位时间为电脑充电xx单位的电量。
  2. 闪充：每单位时间为电脑充电4x4x单位的电量。

现在，所有电脑的电量都为零。小R希望使用闪充给所有电脑充满电，计算她需要的总充电时间。请保留结果的小数点后两位。

测试样例

样例1：

输入：n = 4 ,x = 1 ,a = [2, 3, 4, 5]
输出：'3.50'

样例2：

输入：n = 3 ,x = 2 ,a = [4, 6, 8]
输出：'2.25'

样例3：

输入：n = 2 ,x = 1 ,a = [10, 5]
输出：'3.75'

 解题思路：

问题理解

小R有n部电脑，每部电脑的电池容量分别为a_i。她可以使用两种不同的充电方式来给电脑充电：

  1. 普通充电：每单位时间为电脑充电x单位的电量。
  2. 闪充：每单位时间为电脑充电4x单位的电量。

目标是计算使用闪充给所有电脑充满电所需的总充电时间，并保留结果的小数点后两位。

数据结构选择

  • 输入：整数n（电脑数量），整数x（普通充电速率），整数数组a（每部电脑的电池容量）。
  • 输出：一个字符串，表示总充电时间，保留两位小数。

算法步骤

  1. 计算每部电脑的充电时间：
    • 对于每部电脑，其充电时间为a_i / (4 * x)，因为闪充的速率是4x。
  2. 累加所有电脑的充电时间：
    • 将所有电脑的充电时间累加起来，得到总充电时间。
  3. 格式化输出：
    • 将总充电时间格式化为字符串，保留两位小数。

 最终代码：

#include <iostream>
#include <vector>
#include <string>
#include <iomanip> // 用于格式化输出

using namespace std;

string solution(int n, int x, vector<int> a) {
    // 初始化总充电时间为0
    double totalTime = 0.0;
    
    // 遍历每部电脑，计算并累加充电时间
    for (int i = 0; i < n; ++i) {
        // 计算当前电脑的充电时间
        double time = a[i] / (4.0 * x); // 注意使用4.0来确保浮点数除法
        // 累加到总充电时间
        totalTime += time;
    }
    
    // 格式化输出总充电时间，保留两位小数
    ostringstream oss;
    oss << fixed << setprecision(2) << totalTime;
    return oss.str();
}

int main() {
    cout << (solution(4, 1, {2, 3, 4, 5}) == "3.50") << endl;
    cout << (solution(3, 2, {4, 6, 8}) == "2.25") << endl;
    cout << (solution(2, 1, {10, 5}) == "3.75") << endl;
    return 0;
}

运行结果：

 

 

标签：std,输出,反码,二进制,样例,反选,int,include
From： https://blog.csdn.net/m0_73302939/article/details/143893662

相关文章

  • 【入门】字符串的反码c++
    #include<bits/stdc++.h>usingnamespacestd;intmain(){ //一、分析问题 //已知：一个长度不超过80个字符的字符串。 //未知：字符串的反码。 //关系：如果这是一个小写字符，则它和字符a的距离与它的反码和字符z的距离相同；如果是一个大写字符，则它和字符A的距离与它......
  • LeetCode 1290[二进制链表转整数]
    题目链接LeetCode1290[二进制链表转整数]详情实例提示题解思路遍历链表，获取链表的值添加到容器内在容器内遍历值，由高位到地位遍历，为权重，然后算值代码/***Definitionforsingly-linkedlist.*structListNode{*intval;*ListNode*next;*......
  • AlmaLinux 9.5 正式版发布 - RHEL 二进制兼容免费发行版
    AlmaLinux9.5正式版发布-RHEL二进制兼容免费发行版由社区提供的免费Linux操作系统，RHEL二进制兼容发行版请访问原文链接：https://sysin.org/blog/almalinux-9/查看最新版。原创作品，转载请保留出处。作者主页：sysin.org由社区提供的免费Linux操作系统一个开源、社区......
  • LeetCode题练习与总结：二进制手表--401
    一、题目描述二进制手表顶部有4个LED代表 小时（0-11），底部的6个LED代表 分钟（0-59）。每个LED代表一个0或1，最低位在右侧。例如，下面的二进制手表读取 "4:51" 。给你一个整数 turnedOn ，表示当前亮着的LED的数量，返回二进制手表可以表示的所有可能时间。你可以......
  • python实现十进制转换二进制，tkinter界面
    目录需求效果代码实现代码解释需求python实现十进制转换二进制效果代码实现importtkinterastkfromtkinterimportmessageboxdefconvert_to_binary():try:#获取输入框中的十进制数decimal_number=int(entry.get())#转......
  • (nice!!!)(LeetCode) 3240. 最少翻转次数使二进制矩阵回文 II (分类讨论、数组)
    题目：3240.最少翻转次数使二进制矩阵回文II思路：分类讨论，需要对行和列的个数进行讨论，时间复杂度为0(nm)，细节看注释。C++版本：classSolution{public:intminFlips(vector<vector<int>>&grid){intans=0;intn=grid.size(),m=grid[0].size();......
  • Kubernetes-高可用k8s集群部署（多Master节点二进制方式）
    前言：Kubernetes（简称k8s）是一个开源的容器编排平台，用于自动化部署、扩展和管理容器化应用程序。以下是k8s的一些关键特性和概念：容器编排：k8s帮助用户管理容器的生命周期，包括部署、扩展和运行。服务发现和负载均衡：k8s可以为容器提供内部和外部的服务发现和负载均衡。存储......
  • 颠倒二进制位
    颠倒给定的32位无符号整数的二进制位。提示：请注意，在某些语言（如Java）中，没有无符号整数类型。在这种情况下，输入和输出都将被指定为有符号整数类型，并且不应影响您的实现，因为无论整数是有符号的还是无符号的，其内部的二进制表示形式都是相同的。在Java中，编译器使用二进制补码......
  • 计算机编程：二进制、八进制、十进制、十六进制转换
    1、二进制我们不妨将思维拓展一下，既然可以用0~9共十个数字来表示数值，那么也可以用0、1两个数字来表示数值，这就是二进制（Binary）。例如，数字0、1、10、111、100、1000001都是有效的二进制。在计算机内部，数据都是以二进制的形式存储的，二进制是学习编程必须掌握的基础。本节......
  • Linux二进制安装 MySQL 5.7.44
    1.下载MySQL5.7.44的二进制文件首先，访问MySQL官网下载页面，选择适合你操作系统架构（如x86_64）的二进制安装包。访问官网：MySQLDownloads在页面中选择适合你系统的版本（比如Linux的 tar 包）。下载Mysql  https://download.csdn.net/download/m0_58223765/89975252例......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99