【2024年华为OD机试】(B卷,100分)- 数据分类 （Java & JS & Python&C/C++） ...

东湖之滨  论坛元老 | 2025-1-18 06:01:05 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 1075|帖子 1075|积分 3229

[img]https://i-blog.csdnimg.cn/direct/91


82

42

775f684d62

8b7dcf2

ee74eb48c.png[/img]

一、问题描述

题目描述

对一个数据a进行分类，分类方法为&#xff1


a;
此数据a（四个字节大小）的四个字节相加对一个给定的值b取模，如果得到的结果小于一个给定的值c，则数据a为有效范例，其范例为取模的值&#xff1


b;如果得到的结果大于或者等于c，则数据a为无效范例。
比如一个数据a&#61


;0x01


01


01


01


，b&#61


;3


，按照分类方法计算（0x01


&#43


;0x01


&#43


;0x01


&#43


;0x01


）%3


&#61


;1


，
所以如果c&#61


;2

，则此a为有效范例，其范例为1


，如果c&#61


;1


，则此a为无效范例&#xff1


b;
又比如一个数据a&#61


;0x01


01


01


03


，b&#61


;3


，按照分类方法计算（0x01


&#43


;0x01


&#43


;0x01


&#43


;0x03


）%3


&#61


;0，
所以如果c&#61


;2

，则此a为有效范例，其范例为0，如果c&#61


;0，则此a为无效范例。
输入1


2

个数据，第一个数据为c，第二个数据为b，剩余1


0个数据为需要分类的数据，
请找到有效范例中包含数据最多的范例，并输出该范例含有多少个数据。
输入描述

输入1


2

个数据，用空格分隔，第一个数据为c，第二个数据为b，剩余1


0个数据为需要分类的数据。
输出描述

输出最多数据的有效范例有多少个数据。
用例

[size=3


]用例1




输入
  1. 3
  4. 4 2
  6. 56 2
  8. 57 2
  10. 58 2
  12. 59 2
  14. 60 2
  16. 61
  19. 2
  21. 62
  23. 2
  25. 63
  28. 2
  30. 64 2
  32. 65
复制代码
输出
  1. 3
复制代码
阐明
1


0个数据4个字节相加后的结果分别为1


2

3


4 5 6 7 8 9 1


0，
故对4取模的结果为1


2

3


0 1


2

3


0 1


2

，c为3


，所以0 1


2

都是有效范例，范例为1


和2

的有3


个数据，范例为0的只有2

个数据，故输出3


。
[size=3


]用例2



输入
  1. 1
  4. 4 2
  6. 56 2
  8. 57 2
  10. 58 2
  12. 59 2
  14. 60 2
  16. 61
  19. 2
  21. 62
  23. 2
  25. 63
  28. 2
  30. 64 2
  32. 65
复制代码
输出
  1. 2
复制代码
阐明
1


0个数据4个字节相加后的结果分别为1


2

3


4 5 6 7 8 9 1


0，
故对4取模的结果为1


2

3


0 1


2

3


0 1


2

，c为1


，
所以只有0是有效范例，范例为0的有2

个数据，故输出2

。
题目剖析

[size=3


]考察点

考察基本的逻辑处理和数据分类。
[size=3


]剖析思路

[list=1


]
  • 读取输入&#xff1


    a;

    • 读取第一个数据c和第二个数据b。
    • 读取剩余的1


      0个数据，这些数据需要进行分类。

  • 分类处理&#xff1


    a;

    • 对于每个数据，将其转换为四个字节，并计算这四个字节的和。
    • 对这个和对b取模，得到的结果即为该数据的范例。
    • 检查这个范例是否小于c，如果是，则该数据为有效范例。

  • 统计有效范例&#xff1


    a;

    • 使用一个字典或数组来记录每个有效范例的出现次数。
    • 遍历全部数据，更新每个有效范例的计数。

  • 找到最多数据的有效范例&#xff1


    a;

    • 遍历记录有效范例出现次数的字典或数组，找到出现次数最多的有效范例。
    • 输出这个范例的数据个数。

    [size=3


    ]留意事项



    • 数据处理&#xff1


      a;确保准确处理每个数据的四个字节，计算字节和时要留意数据范例转换。
    • 范例判断&#xff1


      a;准确判断每个数据的范例是否有效，即是否小于c。
    • 统计方法&#xff1


      a;使用符合的数据结构（如字典或数组）来统计每个有效范例的出现次数，确保统计过程的服从。
    • 输出结果&#xff1


      a;输出最多数据的有效范例的数据个数，留意处理多个范例出现次数相同的情况。
    二、JavaScript算法源码

    以下是 JavaScript 代码的详细中文解释和讲解&#xff1


    a;
    [size=3


    ]JavaScript 代码

    1. /* JavaScript Node ACM模式 控制台输入获取 */const readline &#61
    4. ; require(&#3
    7. 4;readline&#3
    10. 4;);// 创建 readline 接口，用于从控制台读取输入const rl &#61
    13. ; readline.createInterface({  input: process.stdin,  // 输入流  output: process.stdout, // 输出流});// 监听每一行输入rl.on(&#3
    16. 4;line&#3
    19. 4;, (line) &#61
    22. ;> {  // 将输入行按空格分割为数组  let arr &#61
    25. ; line.split(&#3
    28. 4; &#3
    31. 4;);  // 提取数组中的第一个元素作为 c，并将其转换为数字  const c &#61
    34. ; arr.shift() - 0;  // 提取数组中的第二个元素作为 b，并将其转换为数字  const b &#61
    37. ; arr.shift() - 0;  // 调用 getResult 函数并输出结果  console.log(getResult(arr, c, b));});/** * 计算满足条件的范例数量 * @param arr 输入的数组 * @param c 范例上限 * @param b 模数 * @return 返回满足条件的范例数量的最大值 */function getResult(arr, c, b) {  // 使用对象 count 记录每种范例的数量  const count &#61
    40. ; {};  arr    .map((a) &#61
    43. ;> {      // 将数组中的每个元素转换为十六进制字符串      let str &#61
    46. ; Number(a).toString(1
    49. 6);      // 如果十六进制字符串长度为奇数，前面补零      if (str.length % 2
    51. !&#61
    54. ;&#61
    57. ; 0) {        str &#61
    60. ; &#3
    63. 4;0&#3
    66. 4; &#43
    69. ; str;      }      // 计算十六进制字符串每两位的和      let sum &#61
    72. ; 0;      for (let i &#61
    75. ; 0; i < str.length - 1
    78. ; i &#43
    81. ;&#61
    84. ; 2
    86. ) {        sum &#43
    89. ;&#61
    92. ; parseInt(str.slice(i, i &#43
    95. ; 2
    97. ), 1
    100. 6);      }      // 计算 sum 模 b 的余数，作为范例      const type &#61
    103. ; sum % b;      // 如果范例小于 c，返回范例&#xff1
    106. b;否则返回 -1
    109.       if (type < c) {        return type;      } else {        return -1
    112. ;      }    })    .forEach((type) &#61
    115. ;> {      // 如果范例不为 -1
    118. ，记录该范例的数量      if (type !&#61
    121. ;&#61
    124. ; -1
    127. ) {        count[type] ? count[type]&#43
    130. ;&#43
    133. ; : (count[type] &#61
    136. ; 1
    139. );      }    });  // 返回 count 对象中值的最大值  return Object.values(count).sort((a, b) &#61
    142. ;> b - a)[0];}
    复制代码
    [size=3


    ]详细讲解

    [size=2

    ]1


    . 输入处理

    1. const readline &#61
    4. ; require(&#3
    7. 4;readline&#3
    10. 4;);const rl &#61
    13. ; readline.createInterface({  input: process.stdin,  output: process.stdout,});rl.on(&#3
    16. 4;line&#3
    19. 4;, (line) &#61
    22. ;> {  let arr &#61
    25. ; line.split(&#3
    28. 4; &#3
    31. 4;);  const c &#61
    34. ; arr.shift() - 0;  const b &#61
    37. ; arr.shift() - 0;  console.log(getResult(arr, c, b));});
    复制代码


    • 功能&#xff1


      a;

      • 使用 readline 模块从控制台读取输入。
      • 每读取一行输入，将其按空格分割为数组 arr。
      • 提取数组中的前两个元素作为 c 和 b，并将其转换为数字。
      • 调用 getResult 函数并输出结果。

    [size=2

    ]2

    . 核心函数 getResult

    1. function getResult(arr, c, b) {  const count &#61
    4. ; {};  arr    .map((a) &#61
    7. ;> {      let str &#61
    10. ; Number(a).toString(1
    13. 6);      if (str.length % 2
    15. !&#61
    18. ;&#61
    21. ; 0) {        str &#61
    24. ; &#3
    27. 4;0&#3
    30. 4; &#43
    33. ; str;      }      let sum &#61
    36. ; 0;      for (let i &#61
    39. ; 0; i < str.length - 1
    42. ; i &#43
    45. ;&#61
    48. ; 2
    50. ) {        sum &#43
    53. ;&#61
    56. ; parseInt(str.slice(i, i &#43
    59. ; 2
    61. ), 1
    64. 6);      }      const type &#61
    67. ; sum % b;      if (type < c) {        return type;      } else {        return -1
    70. ;      }    })    .forEach((type) &#61
    73. ;> {      if (type !&#61
    76. ;&#61
    79. ; -1
    82. ) {        count[type] ? count[type]&#43
    85. ;&#43
    88. ; : (count[type] &#61
    91. ; 1
    94. );      }    });  return Object.values(count).sort((a, b) &#61
    97. ;> b - a)[0];}
    复制代码


    • 功能&#xff1


      a;

      • 计算满足条件的范例数量，并返回最大值。

    • 算法逻辑&#xff1


      a;      [list=1


      ]
    • 使用对象 count 记录每种范例的数量。
    • 遍历数组 arr，对每个元素进行以下操作&#xff1


      a;

      • 将其转换为十六进制字符串。
      • 如果字符串长度为奇数，前面补零。
      • 计算每两位的和 sum。
      • 计算 sum 模 b 的余数 type。
      • 如果 type 小于 c，返回 type&#xff1


        b;否则返回 -1


        。

    • 遍历结果数组，记录每种范例的数量。
    • 返回 count 对象中值的最大值。

    [size=3


    ]代码运行示例

    [size=2

    ]示例 1


    &#xff1


    a;

    输入&#xff1


    a;
    1. 3
    4. 51
    7. 0 2
    9. 0 3
    12. 0
    复制代码
    输出&#xff1


    a;
    1. 2
    复制代码
    解释&#xff1


    a;


    • 对于 1


      0&#xff1


      a;

      • 十六进制为 a，补零后为 0a。
      • 和为 0 &#43


        ; 1


        0 &#61


        ; 1


        0。
      • 范例为 1


        0 % 5 &#61


        ; 0。

    • 对于 2

      0&#xff1


      a;

      • 十六进制为 1


        4。
      • 和为 1


        &#43


        ; 4 &#61


        ; 5。
      • 范例为 5 % 5 &#61


        ; 0。

    • 对于 3


      0&#xff1


      a;

      • 十六进制为 1


        e。
      • 和为 1


        &#43


        ; 1


        4 &#61


        ; 1


        5。
      • 范例为 1


        5 % 5 &#61


        ; 0。

    • 范例 0 的数量为 3


      ，但 c &#61


      ; 3


      ，所以最大值为 3


      。
    [size=2

    ]示例 2

    &#xff1


    a;

    输入&#xff1


    a;
    1. 2
    3. 45 1
    6. 5
    复制代码
    输出&#xff1


    a;
    1. 1
    复制代码
    解释&#xff1


    a;


    • 对于 5&#xff1


      a;

      • 十六进制为 5，补零后为 05。
      • 和为 0 &#43


        ; 5 &#61


        ; 5。
      • 范例为 5 % 4 &#61


        ; 1


        。

    • 对于 1


      5&#xff1


      a;

      • 十六进制为 f，补零后为 0f。
      • 和为 0 &#43


        ; 1


        5 &#61


        ; 1


        5。
      • 范例为 1


        5 % 4 &#61


        ; 3


        。

    • 范例 1


      和 3


      的数量均为 1


      ，最大值为 1


      。
    [size=3


    ]总结

    [list=1


    ]
  • 功能&#xff1


    a;

    • 计算满足条件的范例数量，并返回最大值。

  • 优点&#xff1


    a;

    • 使用十六进制转换和模运算快速计算范例。
    • 使用对象记录范例数量，方便统计。

  • 实用场景&#xff1


    a;

    • 实用于需要根据特定规则计算范例数量的场景。

    如果您有其他问题，欢迎随时提问&#xff01


    ;
    三、Java算法源码

    以下是 Java 代码的详细中文解释和讲解&#xff1


    a;
    [size=3


    ]Java 代码

    1. import java.util.Arrays;import java.util.HashMap;import java.util.Scanner;public class Main {  // 输入获取  public static void main(String[] args) {    Scanner sc &#61
    4. ; new Scanner(System.in);    // 读取输入的两个整数 c 和 b    int c &#61
    7. ; sc.nextInt();    int b &#61
    10. ; sc.nextInt();    // 读取输入的数组 arr，固定长度为 1
    13. 0    int[] arr &#61
    16. ; new int[1
    19. 0];    for (int i &#61
    22. ; 0; i < 1
    25. 0; i&#43
    28. ;&#43
    31. ;) arr[i] &#61
    34. ; sc.nextInt();    // 调用 getResult 函数并输出结果    System.out.println(getResult(c, b, arr));  }  // 算法入口  public static int getResult(int c, int b, int[] arr) {    // 使用 HashMap 记录每种范例的数量    HashMap<Integer, Integer> count &#61
    37. ; new HashMap<>();    // 对数组 arr 中的每个元素进行处理    Arrays.stream(arr)        .map(            a -> {              // 将整数 a 转换为十六进制字符串              String str &#61
    40. ; Integer.toHexString(a);              // 如果十六进制字符串长度为奇数，前面补零              if (str.length() % 2
    42. !&#61
    45. ; 0) {                str &#61
    48. ; &#3
    51. 4;0&#3
    54. 4; &#43
    57. ; str;              }              // 计算十六进制字符串每两位的和              int sum &#61
    60. ; 0;              for (int i &#61
    63. ; 0; i < str.length() - 1
    66. ; i &#43
    69. ;&#61
    72. ; 2
    74. ) {                sum &#43
    77. ;&#61
    80. ; Integer.parseInt(str.substring(i, i &#43
    83. ; 2
    85. ), 1
    88. 6);              }              // 计算 sum 模 b 的余数，作为范例              int t &#61
    91. ; sum % b;              // 如果范例小于 c，返回范例&#xff1
    94. b;否则返回 -1
    97.               if (t < c) {                return t;              } else {                return -1
    100. ;              }            })        .forEach(            t -> {              // 如果范例不为 -1
    103. ，记录该范例的数量              if (t !&#61
    106. ; -1
    109. ) {                count.put(t, count.getOrDefault(t, 0) &#43
    112. ; 1
    115. );              }            });    // 返回 count 中值的最大值，如果没有满足条件的范例，返回 0    return count.values().stream().max((x, y) -> x - y).orElse(0);  }}
    复制代码
    [size=3


    ]详细讲解

    [size=2

    ]1


    . 输入处理

    1. public static void main(String[] args) {  Scanner sc &#61
    4. ; new Scanner(System.in);  // 读取输入的两个整数 c 和 b  int c &#61
    7. ; sc.nextInt();  int b &#61
    10. ; sc.nextInt();  // 读取输入的数组 arr，固定长度为 1
    13. 0  int[] arr &#61
    16. ; new int[1
    19. 0];  for (int i &#61
    22. ; 0; i < 1
    25. 0; i&#43
    28. ;&#43
    31. ;) arr[i] &#61
    34. ; sc.nextInt();  // 调用 getResult 函数并输出结果  System.out.println(getResult(c, b, arr));}
    复制代码


    • 功能&#xff1


      a;

      • 使用 Scanner 从控制台读取输入。
      • 读取两个整数 c 和 b。
      • 读取长度为 1


        0 的数组 arr。
      • 调用 getResult 函数并输出结果。

    [size=2

    ]2

    . 核心函数 getResult

    1. public static int getResult(int c, int b, int[] arr) {  // 使用 HashMap 记录每种范例的数量  HashMap<Integer, Integer> count &#61
    4. ; new HashMap<>();  // 对数组 arr 中的每个元素进行处理  Arrays.stream(arr)      .map(          a -> {            // 将整数 a 转换为十六进制字符串            String str &#61
    7. ; Integer.toHexString(a);            // 如果十六进制字符串长度为奇数，前面补零            if (str.length() % 2
    9. !&#61
    12. ; 0) {              str &#61
    15. ; &#3
    18. 4;0&#3
    21. 4; &#43
    24. ; str;            }            // 计算十六进制字符串每两位的和            int sum &#61
    27. ; 0;            for (int i &#61
    30. ; 0; i < str.length() - 1
    33. ; i &#43
    36. ;&#61
    39. ; 2
    41. ) {              sum &#43
    44. ;&#61
    47. ; Integer.parseInt(str.substring(i, i &#43
    50. ; 2
    52. ), 1
    55. 6);            }            // 计算 sum 模 b 的余数，作为范例            int t &#61
    58. ; sum % b;            // 如果范例小于 c，返回范例&#xff1
    61. b;否则返回 -1
    64.             if (t < c) {              return t;            } else {              return -1
    67. ;            }          })      .forEach(          t -> {            // 如果范例不为 -1
    70. ，记录该范例的数量            if (t !&#61
    73. ; -1
    76. ) {              count.put(t, count.getOrDefault(t, 0) &#43
    79. ; 1
    82. );            }          });  // 返回 count 中值的最大值，如果没有满足条件的范例，返回 0  return count.values().stream().max((x, y) -> x - y).orElse(0);}
    复制代码


    • 功能&#xff1


      a;

      • 计算满足条件的范例数量，并返回最大值。

    • 算法逻辑&#xff1


      a;      [list=1


      ]
    • 使用 HashMap 记录每种范例的数量。
    • 遍历数组 arr，对每个元素进行以下操作&#xff1


      a;

      • 将其转换为十六进制字符串。
      • 如果字符串长度为奇数，前面补零。
      • 计算每两位的和 sum。
      • 计算 sum 模 b 的余数 t。
      • 如果 t 小于 c，返回 t&#xff1


        b;否则返回 -1


        。

    • 遍历结果数组，记录每种范例的数量。
    • 返回 count 中值的最大值，如果没有满足条件的范例，返回 0。

    [size=3


    ]代码运行示例

    [size=2

    ]示例 1


    &#xff1


    a;

    输入&#xff1


    a;
    1. 3
    4. 51
    7. 0 2
    9. 0 3
    12. 0 40 50 60 70 80 90 1
    15. 00
    复制代码
    输出&#xff1


    a;
    1. 3
    复制代码
    解释&#xff1


    a;


    • 对于 1


      0&#xff1


      a;

      • 十六进制为 a，补零后为 0a。
      • 和为 0 &#43


        ; 1


        0 &#61


        ; 1


        0。
      • 范例为 1


        0 % 5 &#61


        ; 0。

    • 对于 2

      0&#xff1


      a;

      • 十六进制为 1


        4。
      • 和为 1


        &#43


        ; 4 &#61


        ; 5。
      • 范例为 5 % 5 &#61


        ; 0。

    • 对于 3


      0&#xff1


      a;

      • 十六进制为 1


        e。
      • 和为 1


        &#43


        ; 1


        4 &#61


        ; 1


        5。
      • 范例为 1


        5 % 5 &#61


        ; 0。

    • 范例 0 的数量为 3


      ，最大值为 3


      。
    [size=2

    ]示例 2

    &#xff1


    a;

    输入&#xff1


    a;
    1. 2
    3. 45 1
    6. 5 2
    8. 5 3
    11. 5 45 55 65 75 85 95
    复制代码
    输出&#xff1


    a;
    1. 1
    复制代码
    解释&#xff1


    a;


    • 对于 5&#xff1


      a;

      • 十六进制为 5，补零后为 05。
      • 和为 0 &#43


        ; 5 &#61


        ; 5。
      • 范例为 5 % 4 &#61


        ; 1


        。

    • 对于 1


      5&#xff1


      a;

      • 十六进制为 f，补零后为 0f。
      • 和为 0 &#43


        ; 1


        5 &#61


        ; 1


        5。
      • 范例为 1


        5 % 4 &#61


        ; 3


        。

    • 范例 1


      和 3


      的数量均为 1


      ，最大值为 1


      。
    [size=3


    ]总结

    [list=1


    ]
  • 功能&#xff1


    a;

    • 计算满足条件的范例数量，并返回最大值。

  • 优点&#xff1


    a;

    • 使用十六进制转换和模运算快速计算范例。
    • 使用 HashMap 记录范例数量，方便统计。

  • 实用场景&#xff1


    a;

    • 实用于需要根据特定规则计算范例数量的场景。

    如果您有其他问题，欢迎随时提问&#xff01


    ;
    四、Python算法源码

    以下是 Python 代码的详细中文解释和讲解&#xff1


    a;
    [size=3


    ]Python 代码

    1. # 输入获取tmp &#61
    4. ; list(map(int, input().split()))  # 读取一行输入，按空格分割并转换为整数列表c &#61
    7. ; tmp[0]  # 提取第一个元素作为 cb &#61
    10. ; tmp[1
    13. ]  # 提取第二个元素作为 barr &#61
    16. ; tmp[2
    18. :]  # 提取剩余元素作为数组 arr# 判断是否有效def classify(a):    # 将整数 a 转换为十六进制字符串，并去除 &#3
    21. 9;0x&#3
    24. 9; 前缀    s &#61
    27. ; hex(a)[2
    29. :]    # 如果十六进制字符串长度为奇数，前面补零    if len(s) % 2
    31. !&#61
    34. ; 0:        s &#61
    37. ; &#3
    40. 4;0&#3
    43. 4; &#43
    46. ; s    # 计算十六进制字符串每两位的和    sumV &#61
    49. ; 0    for i in range(0, len(s) - 1
    52. , 2
    54. ):        sumV &#43
    57. ;&#61
    60. ; int(s[i:i &#43
    63. ; 2
    65. ], 1
    68. 6)    # 计算 sumV 模 b 的余数，作为范例    t &#61
    71. ; sumV % b    # 如果范例小于 c，返回范例&#xff1
    74. b;否则返回 -1
    77.     if t < c:        return t    else:        return -1
    80. # 算法入口def getResult():    # 使用字典 count 记录每种范例的数量    count &#61
    83. ; {}    # 对数组 arr 中的每个元素调用 classify 函数，得到范例 t    for t in map(classify, arr):        # 如果范例 t 不为 -1
    86. ，记录该范例的数量        if t !&#61
    89. ; -1
    92. :            if count.get(t) is None:                count[t] &#61
    95. ; 1
    98.             else:                count[t] &#43
    101. ;&#61
    104. ; 1
    107.     # 返回 count 中值的最大值    return max(count.values())# 算法调用print(getResult())
    复制代码
    [size=3


    ]详细讲解

    [size=2

    ]1


    . 输入处理

    1. tmp &#61
    4. ; list(map(int, input().split()))  # 读取一行输入，按空格分割并转换为整数列表c &#61
    7. ; tmp[0]  # 提取第一个元素作为 cb &#61
    10. ; tmp[1
    13. ]  # 提取第二个元素作为 barr &#61
    16. ; tmp[2
    18. :]  # 提取剩余元素作为数组 arr
    复制代码


    • 功能&#xff1


      a;

      • 使用 input().split() 读取一行输入，按空格分割为字符串列表。
      • 使用 map(int, ...) 将字符串列表转换为整数列表 tmp。
      • 提取 tmp 中的前两个元素作为 c 和 b。
      • 提取剩余元素作为数组 arr。

    [size=2

    ]2

    . 核心函数 classify

    1. def classify(a):    # 将整数 a 转换为十六进制字符串，并去除 &#3
    4. 9;0x&#3
    7. 9; 前缀    s &#61
    10. ; hex(a)[2
    12. :]    # 如果十六进制字符串长度为奇数，前面补零    if len(s) % 2
    14. !&#61
    17. ; 0:        s &#61
    20. ; &#3
    23. 4;0&#3
    26. 4; &#43
    29. ; s    # 计算十六进制字符串每两位的和    sumV &#61
    32. ; 0    for i in range(0, len(s) - 1
    35. , 2
    37. ):        sumV &#43
    40. ;&#61
    43. ; int(s[i:i &#43
    46. ; 2
    48. ], 1
    51. 6)    # 计算 sumV 模 b 的余数，作为范例    t &#61
    54. ; sumV % b    # 如果范例小于 c，返回范例&#xff1
    57. b;否则返回 -1
    60.     if t < c:        return t    else:        return -1
    复制代码


    • 功能&#xff1


      a;

      • 对输入的整数 a 进行处理，计算其范例。

    • 算法逻辑&#xff1


      a;      [list=1


      ]
    • 将整数 a 转换为十六进制字符串，并去除 0x 前缀。
    • 如果字符串长度为奇数，前面补零。
    • 计算每两位的和 sumV。
    • 计算 sumV 模 b 的余数 t。
    • 如果 t 小于 c，返回 t&#xff1


      b;否则返回 -1


      。

    [size=2

    ]3


    . 核心函数 getResult

    1. def getResult():    # 使用字典 count 记录每种范例的数量    count &#61
    4. ; {}    # 对数组 arr 中的每个元素调用 classify 函数，得到范例 t    for t in map(classify, arr):        # 如果范例 t 不为 -1
    7. ，记录该范例的数量        if t !&#61
    10. ; -1
    13. :            if count.get(t) is None:                count[t] &#61
    16. ; 1
    19.             else:                count[t] &#43
    22. ;&#61
    25. ; 1
    28.     # 返回 count 中值的最大值    return max(count.values())
    复制代码


    • 功能&#xff1


      a;

      • 计算满足条件的范例数量，并返回最大值。

    • 算法逻辑&#xff1


      a;      [list=1


      ]
    • 使用字典 count 记录每种范例的数量。
    • 遍历数组 arr，对每个元素调用 classify 函数，得到范例 t。
    • 如果范例 t 不为 -1


      ，记录该范例的数量。
    • 返回 count 中值的最大值。

    [size=2

    ]4. 算法调用

    1. print(getResult())
    复制代码


    • 功能&#xff1


      a;

      • 调用 getResult 函数并输出结果。

    [size=3


    ]代码运行示例

    [size=2

    ]示例 1


    &#xff1


    a;

    输入&#xff1


    a;
    1. 3
    4. 5 1
    7. 0 2
    9. 0 3
    12. 0 40 50 60 70 80 90 1
    15. 00
    复制代码
    输出&#xff1


    a;
    1. 3
    复制代码
    解释&#xff1


    a;


    • 对于 1


      0&#xff1


      a;

      • 十六进制为 a，补零后为 0a。
      • 和为 0 &#43


        ; 1


        0 &#61


        ; 1


        0。
      • 范例为 1


        0 % 5 &#61


        ; 0。

    • 对于 2

      0&#xff1


      a;

      • 十六进制为 1


        4。
      • 和为 1


        &#43


        ; 4 &#61


        ; 5。
      • 范例为 5 % 5 &#61


        ; 0。

    • 对于 3


      0&#xff1


      a;

      • 十六进制为 1


        e。
      • 和为 1


        &#43


        ; 1


        4 &#61


        ; 1


        5。
      • 范例为 1


        5 % 5 &#61


        ; 0。

    • 范例 0 的数量为 3


      ，最大值为 3


      。
    [size=2

    ]示例 2

    &#xff1


    a;

    输入&#xff1


    a;
    1. 2
    3. 4 5 1
    6. 5 2
    8. 5 3
    11. 5 45 55 65 75 85 95
    复制代码
    输出&#xff1


    a;
    1. 1
    复制代码
    解释&#xff1


    a;


    • 对于 5&#xff1


      a;

      • 十六进制为 5，补零后为 05。
      • 和为 0 &#43


        ; 5 &#61


        ; 5。
      • 范例为 5 % 4 &#61


        ; 1


        。

    • 对于 1


      5&#xff1


      a;

      • 十六进制为 f，补零后为 0f。
      • 和为 0 &#43


        ; 1


        5 &#61


        ; 1


        5。
      • 范例为 1


        5 % 4 &#61


        ; 3


        。

    • 范例 1


      和 3


      的数量均为 1


      ，最大值为 1


      。
    [size=3


    ]总结

    [list=1


    ]
  • 功能&#xff1


    a;

    • 计算满足条件的范例数量，并返回最大值。

  • 优点&#xff1


    a;

    • 使用十六进制转换和模运算快速计算范例。
    • 使用字典记录范例数量，方便统计。

  • 实用场景&#xff1


    a;

    • 实用于需要根据特定规则计算范例数量的场景。

    如果您有其他问题，欢迎随时提问&#xff01


    ;
    五、C/C&#43


    ;&#43


    ;算法源码&#xff1


    a;

    以下是 C&#43


    ;&#43


    ;     和 C 语言的代码实现，包含详细的中文解释和讲解&#xff1


    a;
    [size=3


    ]C&#43


    ;&#43


    ; 代码

    1. #include <iostream>#include <vector>#include <map>#include <algorithm>using namespace std;// 判断是否有效int classify(int a, int b, int c) {    // 将整数 a 转换为十六进制字符串    char hexStr[2
    3. 0];    sprintf(hexStr, &#3
    6. 4;%x&#3
    9. 4;, a);  // 使用 sprintf 将整数转换为十六进制字符串    string s &#61
    12. ; hexStr;    // 如果十六进制字符串长度为奇数，前面补零    if (s.length() % 2
    14. !&#61
    17. ; 0) {        s &#61
    20. ; &#3
    23. 4;0&#3
    26. 4; &#43
    29. ; s;    }    // 计算十六进制字符串每两位的和    int sumV &#61
    32. ; 0;    for (int i &#61
    35. ; 0; i < s.length() - 1
    38. ; i &#43
    41. ;&#61
    44. ; 2
    46. ) {        string sub &#61
    49. ; s.substr(i, 2
    51. );  // 提取两位十六进制字符        sumV &#43
    54. ;&#61
    57. ; stoi(sub, nullptr, 1
    60. 6);  // 将十六进制字符串转换为整数并累加    }    // 计算 sumV 模 b 的余数，作为范例    int t &#61
    63. ; sumV % b;    // 如果范例小于 c，返回范例&#xff1
    66. b;否则返回 -1
    69.     if (t < c) {        return t;    } else {        return -1
    72. ;    }}// 算法入口int getResult(vector<int>& arr, int b, int c) {    map<int, int> count;  // 使用 map 记录每种范例的数量    // 对数组 arr 中的每个元素调用 classify 函数，得到范例 t    for (int a : arr) {        int t &#61
    75. ; classify(a, b, c);        // 如果范例 t 不为 -1
    78. ，记录该范例的数量        if (t !&#61
    81. ; -1
    84. ) {            count[t]&#43
    87. ;&#43
    90. ;;        }    }    // 返回 count 中值的最大值    int maxCount &#61
    93. ; 0;    for (auto& pair : count) {        if (pair.second > maxCount) {            maxCount &#61
    96. ; pair.second;        }    }    return maxCount;}int main() {    // 输入获取    vector<int> tmp;    int num;    while (cin >> num) {        tmp.push_back(num);    }    int c &#61
    99. ; tmp[0];  // 提取第一个元素作为 c    int b &#61
    102. ; tmp[1
    105. ];  // 提取第二个元素作为 b    vector<int> arr(tmp.begin() &#43
    108. ; 2
    110. , tmp.end());  // 提取剩余元素作为数组 arr    // 算法调用    cout << getResult(arr, b, c) << endl;
    111.     return 0;}
    复制代码
    [size=3


    ]C 语言代码

    1. #include <stdio.h>#include <stdlib.h>#include <string.h>// 判断是否有效int classify(int a, int b, int c) {    // 将整数 a 转换为十六进制字符串    char hexStr[2
    3. 0];    sprintf(hexStr, &#3
    6. 4;%x&#3
    9. 4;, a);  // 使用 sprintf 将整数转换为十六进制字符串    // 如果十六进制字符串长度为奇数，前面补零    if (strlen(hexStr) % 2
    11. !&#61
    14. ; 0) {        memmove(hexStr &#43
    17. ; 1
    20. , hexStr, strlen(hexStr) &#43
    23. ; 1
    26. );  // 右移一位        hexStr[0] &#61
    29. ; &#3
    32. 9;0&#3
    35. 9;;  // 补零    }    // 计算十六进制字符串每两位的和    int sumV &#61
    38. ; 0;    for (int i &#61
    41. ; 0; i < strlen(hexStr) - 1
    44. ; i &#43
    47. ;&#61
    50. ; 2
    52. ) {        char sub[3
    55. ];        strncpy(sub, hexStr &#43
    58. ; i, 2
    60. );  // 提取两位十六进制字符        sub[2
    62. ] &#61
    65. ; &#3
    68. 9;\0&#3
    71. 9;;  // 添加字符串结束符        sumV &#43
    74. ;&#61
    77. ; (int)strtol(sub, NULL, 1
    80. 6);  // 将十六进制字符串转换为整数并累加    }    // 计算 sumV 模 b 的余数，作为范例    int t &#61
    83. ; sumV % b;    // 如果范例小于 c，返回范例&#xff1
    86. b;否则返回 -1
    89.     if (t < c) {        return t;    } else {        return -1
    92. ;    }}// 算法入口int getResult(int* arr, int n, int b, int c) {    int count[1
    95. 00] &#61
    98. ; {0};  // 使用数组记录每种范例的数量，假设范例不凌驾 1
    101. 00    // 对数组 arr 中的每个元素调用 classify 函数，得到范例 t    for (int i &#61
    104. ; 0; i < n; i&#43
    107. ;&#43
    110. ;) {        int t &#61
    113. ; classify(arr[i], b, c);        // 如果范例 t 不为 -1
    116. ，记录该范例的数量        if (t !&#61
    119. ; -1
    122. ) {            count[t]&#43
    125. ;&#43
    128. ;;        }    }    // 返回 count 中值的最大值    int maxCount &#61
    131. ; 0;    for (int i &#61
    134. ; 0; i < 1
    137. 00; i&#43
    140. ;&#43
    143. ;) {        if (count[i] > maxCount) {            maxCount &#61
    146. ; count[i];        }    }    return maxCount;}int main() {    // 输入获取    int tmp[1
    149. 00];    int n &#61
    152. ; 0;    while (scanf(&#3
    155. 4;%d&#3
    158. 4;, &tmp[n]) !&#61
    161. ; EOF) {        n&#43
    164. ;&#43
    167. ;;    }    int c &#61
    170. ; tmp[0];  // 提取第一个元素作为 c    int b &#61
    173. ; tmp[1
    176. ];  // 提取第二个元素作为 b    int arr[1
    179. 00];    for (int i &#61
    182. ; 2
    184. ; i < n; i&#43
    187. ;&#43
    190. ;) {        arr[i - 2
    192. ] &#61
    195. ; tmp[i];  // 提取剩余元素作为数组 arr    }    // 算法调用    printf(&#3
    198. 4;%d\n&#3
    201. 4;, getResult(arr, n - 2
    203. , b, c));    return 0;}
    复制代码
    [size=3


    ]详细讲解

    [size=2

    ]1


    . 输入处理



    • C&#43


      ;&#43


      ;&#xff1


      a;
      1. vector<int> tmp;int num;while (cin >> num) {    tmp.push_back(num);}int c &#61
      4. ; tmp[0];int b &#61
      7. ; tmp[1
      10. ];vector<int> arr(tmp.begin() &#43
      13. ; 2
      15. , tmp.end());
      复制代码

      • 使用 vector 动态存储输入数据。
      • 提取前两个元素作为 c 和 b，剩余元素作为数组 arr。

    • C&#xff1


      a;
      1. int tmp[1
      4. 00];int n &#61
      7. ; 0;while (scanf(&#3
      10. 4;%d&#3
      13. 4;, &tmp[n]) !&#61
      16. ; EOF) {    n&#43
      19. ;&#43
      22. ;;}int c &#61
      25. ; tmp[0];int b &#61
      28. ; tmp[1
      31. ];int arr[1
      34. 00];for (int i &#61
      37. ; 2
      39. ; i < n; i&#43
      42. ;&#43
      45. ;) {    arr[i - 2
      47. ] &#61
      50. ; tmp[i];}
      复制代码

      • 使用固定大小的数组 tmp 存储输入数据。
      • 提取前两个元素作为 c 和 b，剩余元素作为数组 arr。

    [size=2

    ]2

    . 核心函数 classify



    • C&#43


      ;&#43


      ;&#xff1


      a;
      1. int classify(int a, int b, int c) {    char hexStr[2
      3. 0];    sprintf(hexStr, &#3
      6. 4;%x&#3
      9. 4;, a);    string s &#61
      12. ; hexStr;    if (s.length() % 2
      14. !&#61
      17. ; 0) {        s &#61
      20. ; &#3
      23. 4;0&#3
      26. 4; &#43
      29. ; s;    }    int sumV &#61
      32. ; 0;    for (int i &#61
      35. ; 0; i < s.length() - 1
      38. ; i &#43
      41. ;&#61
      44. ; 2
      46. ) {        string sub &#61
      49. ; s.substr(i, 2
      51. );        sumV &#43
      54. ;&#61
      57. ; stoi(sub, nullptr, 1
      60. 6);    }    int t &#61
      63. ; sumV % b;    if (t < c) {        return t;    } else {        return -1
      66. ;    }}
      复制代码

      • 将整数 a 转换为十六进制字符串。
      • 如果字符串长度为奇数，前面补零。
      • 计算每两位的和 sumV。
      • 计算 sumV 模 b 的余数 t。
      • 如果 t 小于 c，返回 t&#xff1


        b;否则返回 -1


        。

    • C&#xff1


      a;
      1. int classify(int a, int b, int c) {    char hexStr[2
      3. 0];    sprintf(hexStr, &#3
      6. 4;%x&#3
      9. 4;, a);    if (strlen(hexStr) % 2
      11. !&#61
      14. ; 0) {        memmove(hexStr &#43
      17. ; 1
      20. , hexStr, strlen(hexStr) &#43
      23. ; 1
      26. );        hexStr[0] &#61
      29. ; &#3
      32. 9;0&#3
      35. 9;;    }    int sumV &#61
      38. ; 0;    for (int i &#61
      41. ; 0; i < strlen(hexStr) - 1
      44. ; i &#43
      47. ;&#61
      50. ; 2
      52. ) {        char sub[3
      55. ];        strncpy(sub, hexStr &#43
      58. ; i, 2
      60. );        sub[2
      62. ] &#61
      65. ; &#3
      68. 9;\0&#3
      71. 9;;        sumV &#43
      74. ;&#61
      77. ; (int)strtol(sub, NULL, 1
      80. 6);    }    int t &#61
      83. ; sumV % b;    if (t < c) {        return t;    } else {        return -1
      86. ;    }}
      复制代码

      • 逻辑与 C&#43


        ;&#43


        ; 版本相同，但使用 C 标准库函数实现。

    [size=2

    ]3


    . 核心函数 getResult



    • C&#43


      ;&#43


      ;&#xff1


      a;
      1. int getResult(vector<int>& arr, int b, int c) {    map<int, int> count;    for (int a : arr) {        int t &#61
      4. ; classify(a, b, c);        if (t !&#61
      7. ; -1
      10. ) {            count[t]&#43
      13. ;&#43
      16. ;;        }    }    int maxCount &#61
      19. ; 0;    for (auto& pair : count) {        if (pair.second > maxCount) {            maxCount &#61
      22. ; pair.second;        }    }    return maxCount;}
      复制代码

      • 使用 map 记录每种范例的数量。
      • 遍历数组 arr，调用 classify 函数，记录范例数量。
      • 返回范例数量的最大值。

    • C&#xff1


      a;
      1. int getResult(int* arr, int n, int b, int c) {    int count[1
      4. 00] &#61
      7. ; {0};    for (int i &#61
      10. ; 0; i < n; i&#43
      13. ;&#43
      16. ;) {        int t &#61
      19. ; classify(arr[i], b, c);        if (t !&#61
      22. ; -1
      25. ) {            count[t]&#43
      28. ;&#43
      31. ;;        }    }    int maxCount &#61
      34. ; 0;    for (int i &#61
      37. ; 0; i < 1
      40. 00; i&#43
      43. ;&#43
      46. ;) {        if (count[i] > maxCount) {            maxCount &#61
      49. ; count[i];        }    }    return maxCount;}
      复制代码

      • 使用固定大小的数组 count 记录范例数量。
      • 遍历数组 arr，调用 classify 函数，记录范例数量。
      • 返回范例数量的最大值。

    [size=2

    ]4. 算法调用



    • C&#43


      ;&#43


      ;&#xff1


      a;
      1. cout << getResult(arr, b, c) << endl;
      复制代码
    • C&#xff1


      a;
      1. printf(&#3
      4. 4;%d\n&#3
      7. 4;, getResult(arr, n - 2
      9. , b, c));
      复制代码
    [size=3


    ]总结

    [list=1


    ]
  • 功能&#xff1


    a;

    • 计算满足条件的范例数量，并返回最大值。

  • 优点&#xff1


    a;

    • 使用十六进制转换和模运算快速计算范例。
    • 使用 map（C&#43


      ;&#43


      ;）或数组（C）记录范例数量，方便统计。

  • 实用场景&#xff1


    a;

    • 实用于需要根据特定规则计算范例数量的场景。

    如果您有其他问题，欢迎随时提问&#xff01


    ;
    六、尾言

    [size=3


    ]什么是华为OD&#xff1


    f;

    华为OD（Outsourcing Developer，外包开发工程师）是华为针对软件开发工程师岗位的一种招聘形式，主要包罗笔试、技能面试以及综合面试等环节。尤其在笔试部分，算法题的机试至关重要。
    [size=3


    ]为什么刷题很重要&#xff1


    f;

    [list=1


    ]
  • 机试是进入技能面的第一关&#xff1


    a;
    华为OD机试（常被称为机考）主要考察算法和编程能力。只有通过机试，才气进入后续的技能面试环节。
  • 技能面试需要手撕代码&#xff1


    a;
    技能一面和二面通常会涉及现场编写代码或算法题。面试官会注重考察候选人的思路清晰度、代码规范性以及解决问题的能力。因此提前刷题、多训练是通过面试的重要保障。
  • 入职后的可信测验&#xff1


    a;
    入职华为后，还需要通过“可信测验”。可信测验分为三个品级&#xff1


    a;

    • 入门级&#xff1


      a;主要考察底子算法与编程能力。
    • 工作级&#xff1


      a;更贴近实际业务需求，可能涉及复杂的算法或与工作内容相干的场景题目。
    • 专业级&#xff1


      a;最高品级，考察深层次的算法以及优化能力，与薪资直接挂钩。

    [size=3


    ]刷题策略与阐明&#xff1


    a;

    2

    02

    4年8月1


    4日之后，华为OD机试的题库转为 E卷，由往年题库（D卷、A卷、B卷、C卷）和全新题目组成。刷题时可以参考以下策略&#xff1


    a;
    [list=1


    ]
  • 关注积年真题&#xff1


    a;

    • 题库中的旧题占比较大，建议优先刷积年的A卷、B卷、C卷、D卷题目。
    • 对于每道题目，建议深度理解其解题思路、代码实现，以及相干算法的实用场景。

  • 适应新题目&#xff1


    a;

    • E卷中包含全新题目，需要掌握全面的算法知识和一定的灵活应对能力。
    • 建议关注新的刷题平台或交流群，获取最新题目的剖析和动态。

  • 掌握常见算法&#xff1


    a;
    华为OD测验通常涉及以下算法和数据结构&#xff1


    a;

    • 排序算法（快速排序、归并排序等）
    • 动态规划（背包问题、最长公共子序列等）
    • 贪心算法
    • 栈、队列、链表的操作
    • 图论（最短路径、最小天生树等）
    • 滑动窗口、双指针算法

  • 保持编程规范&#xff1


    a;

    • 注重代码的可读性和解释的清晰度。
    • 纯熟使用常见编程语言，如C&#43


      ;&#43


      ;、Java、Python等。

    [size=3


    ]如何获取资源&#xff1


    f;

    [list=1


    ]
  • 官方参考&#xff1


    a;

    • 华为招聘官网或相干的招聘平台会有一些参考信息。
    • 华为OD的相干公众号可能也会发布相干的刷题资料或学习资源。

  • 加入刷题社区&#xff1


    a;

    • 找到可信的刷题交流群，与其他备考的小同伴交流经验。
    • 关注着名的刷题网站，如LeetCode、牛客网等，这些平台上有许多华为OD的积年真题和剖析。

  • 探求系统性的教程&#xff1


    a;

    • 学习一本经典的算法书籍，例如《算法导论》《剑指Offer》《编程之美》等。
    • 完成系统的学习课程，例如数据结构与算法的在线课程。

    [size=3


    ]积极心态与连续努力&#xff1


    a;

    刷题的过程可能会比较枯燥，但它可以或许显著提升编程能力和算法思维。无论是为了通过华为OD的招聘测验，还是为了未来的职业发展，这些积聚都会成为重要的财富。
    [size=3


    ]测验留意细节

    [list=1


    ]
  • 当地编写代码

    • 在当地 IDE（如 VS Code、PyCharm 等）上编写、生存和调试代码，确保逻辑准确后再复制粘贴到测验页面。这样可以淘汰语法错误，提高代码准确性。

  • 调解心态，保持冷静

    • 碰到提示不敷或实现不确定的问题时，不必慌张，可以采取更简朴或更有把握的方法替换，确保思路清晰。

  • 输入输出完整性

    • 留意训练和测验时都需要编写完整的输入输出代码，尤其是和题目示例保持同等。完成代码后务必及时调试，确保功能符合要求。

  • 快捷键使用

    • 删除行可用 Ctrl&#43


      ;D，复制、粘贴和撤销分别为 Ctrl&#43


      ;C，Ctrl&#43


      ;V，Ctrl&#43


      ;Z，这些可以正常使用。
    • 制止使用 Ctrl&#43


      ;S，以免触发浏览器的生存功能。

  • 浏览器要求

    • 使用最新版的 Google Chrome 浏览器完成测验，确保摄像头开启并正常工作。测验期间不要切换到其他网站，以免影响测验结果。

  • 交卷相干

    • 答题前，务必细致检察题目示例，制止遗漏要求。
    • 每完成一道题后，点击【生存并调试】按钮，多次生存和调试是答应的，系统会记录得分最高的一次结果。完玉成部题目后，点击【提交本题型】按钮。
    • 确保在测验结束前提交试卷，制止因未生存或调试失误而丢分。

  • 时间和分数安排

    • 总时间&#xff1


      a;1


      50 分钟&#xff1


      b;总分&#xff1


      a;400 分。
    • 试卷结构&#xff1


      a;2

      道一星难度题（每题 1


      00 分），1


      道二星难度题（2

      00 分）。及格分为 1


      50 分。公道分配时间，优先完成本身善于的题目。

  • 测验环境准备

    • 测验前请备好草稿纸和笔。测验中只管制止离开座位，确保监控画面正常。
    • 如需上茅厕，请提前规划好时间以淘汰中途离开监控的可能性。

  • 技能问题处理

    • 如果测验中碰到断电、断网、死机等技能问题，可以关闭浏览器并重新打开试卷链接继续作答。
    • 出现其他问题，请第一时间联系 HR 或监考职员进行反馈。

    祝你测验顺利，取得理想结果&#xff01


    ;

    免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao1


    2

    3


    .com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

    • 本帖子中包含更多资源

    您需要 登录 才可以下载或查看，没有账号？立即注册

    x
    回复

    使用道具 举报

    0 个回复

    倒序浏览
    返回列表

    快速回复

    高级模式
    B Color Image Link Quote Code Smilies
    您需要登录后才可以回帖 登录 or 立即注册

    本版积分规则

    东湖之滨

    论坛元老
    这个人很懒什么都没写!

    楼主热帖

    标签云

    AI 运维 CIO 存储 服务器
    微信订阅号
    微信服务号
    微信客服
    小程序
    H5
    关于我们 商务合作 网站地图
    ©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
    快速回复 返回顶部 返回列表