华为OD机试 - 九宫格按键输入 - 逻辑分析（Java 2023 B卷 200分）

标题形貌

九宫格按键输入，输出表现内容。有英文和数字两个模式，默认是数字模式。数字模式直接输出数字，英文模式一连按同一个按键会依次出现这个按键上的字母。假如输入“/”或其他字符，则循环停止。
输入形貌

输入范围为数字0~9和字符#、/。输出屏幕表现。比方在数字模式下，输入1234，表现1234；在英文模式下，输入1234，表现,adg。
输出形貌

• #用于切换模式，默认是数字模式，实验#后切换为英文模式。
  
• /表现延伸，比方在英文模式下，输入22/222，表现为bc。
  
• 英文模式下，多次按同一键，比方输入22222，表现为b。
  

解题思绪

这个标题可以通过状态机来办理。我们必要维护当前模式（数字模式或英文模式）以及当前按键的一连按击次数。根据输入字符的差别，我们更新状态并天生相应的输出。
代码实现

Java

1. import java.util.*;
3. public class NineKeyInput {
4.     private static final String[] DIGITS = {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"};
5.     private static final String[] LETTERS = {" ", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
7.     public String processInput(String input) {
8.         boolean isNumberMode = true;
9.         StringBuilder output = new StringBuilder();
10.         int index = 0;
11.         while (index < input.length()) {
12.             char ch = input.charAt(index);
13.             if (ch == '#') {
14.                 isNumberMode = !isNumberMode;
15.                 index++;
16.             } else if (ch == '/') {
17.                 index++;
18.             } else if (Character.isDigit(ch)) {
19.                 int digit = ch - '0';
20.                 if (isNumberMode) {
21.                     output.append(DIGITS[digit]);
22.                     index++;
23.                 } else {
24.                     int count = 0;
25.                     while (index < input.length() && input.charAt(index) == ch) {
26.                         count++;
27.                         index++;
28.                     }
29.                     String letters = LETTERS[digit];
30.                     output.append(letters.charAt((count - 1) % letters.length()));
31.                 }
32.             } else {
33.                 index++;
34.             }
35.         }
36.         return output.toString();
37.     }
39.     public static void main(String[] args) {
40.         NineKeyInput processor = new NineKeyInput();
41.         System.out.println(processor.processInput("123#222235/56")); // 123adjjm
42.     }
43. }

复制代码

Python

1. class NineKeyInput:
2.     DIGITS = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]
3.     LETTERS = [" ", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"]
5.     def process_input(self, input_str):
6.         is_number_mode = True
7.         output = []
8.         index = 0
9.         while index < len(input_str):
10.             ch = input_str[index]
11.             if ch == '#':
12.                 is_number_mode = not is_number_mode
13.                 index += 1
14.             elif ch == '/':
15.                 index += 1
16.             elif ch.isdigit():
17.                 digit = int(ch)
18.                 if is_number_mode:
19.                     output.append(self.DIGITS[digit])
20.                     index += 1
21.                 else:
22.                     count = 0
23.                     while index < len(input_str) and input_str[index] == ch:
24.                         count += 1
25.                         index += 1
26.                     letters = self.LETTERS[digit]
27.                     output.append(letters[(count - 1) % len(letters)])
28.             else:
29.                 index += 1
30.         return ''.join(output)
32. processor = NineKeyInput()
33. print(processor.process_input("123#222235/56"))  # 123adjjm

复制代码

C++

1. #include <iostream>
2. #include <string>
3. #include <vector>
5. using namespace std;
7. class NineKeyInput {
8. private:
9.     vector<string> DIGITS = {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"};
10.     vector<string> LETTERS = {" ", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
12. public:
13.     string processInput(string input) {
14.         bool isNumberMode = true;
15.         string output;
16.         int index = 0;
17.         while (index < input.length()) {
18.             char ch = input[index];
19.             if (ch == '#') {
20.                 isNumberMode = !isNumberMode;
21.                 index++;
22.             } else if (ch == '/') {
23.                 index++;
24.             } else if (isdigit(ch)) {
25.                 int digit = ch - '0';
26.                 if (isNumberMode) {
27.                     output += DIGITS[digit];
28.                     index++;
29.                 } else {
30.                     int count = 0;
31.                     while (index < input.length() && input[index] == ch) {
32.                         count++;
33.                         index++;
34.                     }
35.                     string letters = LETTERS[digit];
36.                     output += letters[(count - 1) % letters.length()];
37.                 }
38.             } else {
39.                 index++;
40.             }
41.         }
42.         return output;
43.     }
44. };
46. int main() {
47.     NineKeyInput processor;
48.     cout << processor.processInput("123#222235/56") << endl; // 123adjjm
49.     return 0;
50. }

复制代码

JavaScript

1. class NineKeyInput {
2.     constructor() {
3.         this.DIGITS = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"];
4.         this.LETTERS = [" ", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"];
5.     }
7.     processInput(input) {
8.         let isNumberMode = true;
9.         let output = '';
10.         let index = 0;
11.         while (index < input.length) {
12.             const ch = input[index];
13.             if (ch === '#') {
14.                 isNumberMode = !isNumberMode;
15.                 index++;
16.             } else if (ch === '/') {
17.                 index++;
18.             } else if (/\d/.test(ch)) {
19.                 const digit = parseInt(ch);
20.                 if (isNumberMode) {
21.                     output += this.DIGITS[digit];
22.                     index++;
23.                 } else {
24.                     let count = 0;
25.                     while (index < input.length && input[index] === ch) {
26.                         count++;
27.                         index++;
28.                     }
29.                     const letters = this.LETTERS[digit];
30.                     output += letters[(count - 1) % letters.length];
31.                 }
32.             } else {
33.                 index++;
34.             }
35.         }
36.         return output;
37.     }
38. }
40. const processor = new NineKeyInput();
41. console.log(processor.processInput("123#222235/56")); // 123adjjm

复制代码

复杂度分析

• 时间复杂度: O(n)，此中n是输入字符串的长度。我们必要遍历整个字符串一次来处置惩罚每个字符。
  
• 空间复杂度: O(1)，除了输出字符串外，我们只利用了常数空间来存储模式和当前按键的一连按击次数。
  

总结

我们利用了状态机来处置惩罚这个标题，通过维护当前模式和按键的一连按击次数，可以或许有用地天生相应的输出。这种方法简单直观，实用于处置惩罚这种模式切换和按键映射的标题。