手机九宫格输入法-526互联

题目描述

手机上的九宫格输入法使用 0-9 十个数字键，除了可以在“数字状态”下输入数字外，还可以在“英文状态”下通过连续多次摁某一数字键来输入对应的英文字符。每个数字键可输入的字符对应关系如图：

说明：

输入法初始默认为“数字状态”，并可在“数字状态”与“英文状态”间切换。
输入法在“数字状态”下，数字键对应为单个数字，摁几次显示几个该数字。
输入法在“英文状态”下，如果数字键为 0，则对应为单字符（空格），摁几次显示几个该字符。
输入法在“英文状态”下，如果数字键为非 0，则对应为多个字符，可通过连续多次快速摁该键循环选择对应字符：
- 以英文状态下的数字键 2 为例，摁1次为 a ，2次为 b ，3次为 c ，4次又循环回 a 。
- 若连续多次摁键循环选择时被其它键或停顿中断，则输出所选择的字符。

现给定一个仅含字符集合为 [0-9#/] 的字符串，表示用户的摁键操作，请输出实际显示出来的字符串。

0-9 为数字键。

# 表示在“数字状态”与“英文状态”之间切换。

/ 停顿符，表示用户有意停顿。

解答要求时间限制：1000ms, 内存限制：128MB

输入

一个字符串，表示用户的摁键操作，长度范围 [1,200]

输出

实际显示出来的字符串

样例

输入样例 1 复制

输出样例 1

提示样例 1

输入法默认为“数字状态”，每个数字键都对应单个字符，摁键即为实际显示出来的字符串，因此输出 123 。

输入样例 2 复制

#22/23044444411

输出样例 2

bad i.

提示样例 2

# 表示输入法切换为“英文状态”；
数字键 2 摁2次后被停顿符 / 中断，显示 b ；
其后，数字键 2、3、0 各摁1次后被其它键中断，显示 a、d、空格；
然后，数字键 4 摁6次后中断，显示 i ；
最后，数字键 1 摁2次后结束，显示 . 。

因此，实际显示出来的字符串为 bad i.

思路：

模拟,双指针

自己做的：

/*
 * Copyright (c) Huawei Technologies Co., Ltd. 2020-2020. All rights reserved.
 * Description: 上机编程认证
 * Note: 缺省代码仅供参考，可自行决定使用、修改或删除
 * 只能import Go标准库
 */
package main

import (
    "bufio"
    "fmt"
    "io"
    "os"
    "strings"
)

func formatNum(encodes []rune) string {
    if len(encodes) == 0 {
        return ""
    }
    num := string(encodes[0])
    switch num { 
        case "1":
            encodeLen := len(encodes) % 2
            if encodeLen == 1 {
                return ","
            }
            return "."
        case "2":
            encodeLen := len(encodes) % 3
            if encodeLen == 1 {
                return "a"
            }
            if encodeLen == 2 {
                return "b"
            }
            return "c"
        case "3":
            encodeLen := len(encodes) % 3      
            if encodeLen == 1 {
                return "d"
            }
            if encodeLen == 2 {
                return "e"
            }
            return "f"
        case "4":
            encodeLen := len(encodes) % 3
            if encodeLen == 1 {
                return "g"
            }
            if encodeLen == 2 {
                return "h"
            }
            return "i"
        case "5":
            encodeLen := len(encodes) % 3
            if encodeLen == 1 {
                return "j"
            }
            if encodeLen == 2 {
                return "k"
            }
            return "l"
        case "6":
            encodeLen := len(encodes) %3
            if encodeLen == 1 {
                return "m"
            }
            if encodeLen == 2 {
                return "n"
            }
            return "o"
        case "7":
            encodeLen := len(encodes) % 4
            if encodeLen == 1 {
                return "p"
            }
            if encodeLen == 2 {
                return "q"
            }
            if encodeLen == 3 {
                return "r"
            }
            return "s"
        case "8":
            encodeLen := len(encodes) % 3
            if encodeLen == 1 {
                return "t"
            }
            if encodeLen == 2 {
                return "u"
            }
            return "v"
        case "9":
            encodeLen := len(encodes) % 4
            if encodeLen == 1 {
                return "w"
            }
            if encodeLen == 2 {
                return "x"
            }
            if encodeLen == 3 {
                return "y"
            }
            return "z"
    }
    return ""
}


func translate(inByte []rune) string { 
    var output string
    enStack := []rune{} 
    for _, in := range inByte{  
        if string(in) != "0" {
            if len(enStack) == 0 {
                enStack = append(enStack, in)   
            } else if enStack[len(enStack)-1] == in {
                enStack = append(enStack, in)
            } else {    
                output += formatNum(enStack)  
                enStack = []rune{} 
                enStack = append(enStack, in)
            }
        } else {
            output += formatNum(enStack)  
            enStack = []rune{} 
            //fmt.Println(string(in), enStack, output) 
            output += " "
        }
    }
    if len(enStack) != 0 {
        output += formatNum(enStack)  
    }
    return output
}

// 待实现函数，在此函数中填入答题代码
func getDisplayString(inputStr string) string {
    // 最终要求的是翻译输出的打印字符
    // 数字态则原样输出 
    // 英文态按规则翻译输出
    var output string
    var numChar []rune
    changeChar := make([]string, 1)
    for _, inByte := range inputStr { 
        if string(inByte) != "#" && changeChar[0] == ""  {
            if string(inByte) == "/" {
                continue
            }
            output += string(inByte)
        } else if string(inByte) == "#"  && changeChar[0] == ""  {
            changeChar[0] = "#"
            continue
        } else if string(inByte) == "#"  && changeChar[0] == "#"  {
            changeChar[0] = "" 
            output += translate(numChar) 
            numChar = []rune{}
            continue
        } else { 
            numChar = append(numChar, inByte) 
        }
    } 
    if changeChar[0] == "#" && len(numChar) != 0 { 
        output += translate(numChar)
    } 
    return output
}

func main() {
    reader := bufio.NewReader(os.Stdin)
    inputStr, err := readInputString(reader)
    if err != nil {
        fmt.Println(err.Error())
        return
    }
    result := getDisplayString(inputStr)
    fmt.Println(result)
}
func readInputString(reader *bufio.Reader) (string, error) {
    lineBuf, err := reader.ReadString('\n')
    if err != nil && err != io.EOF {
        return "nil", err
    }
    lineBuf = strings.TrimRight(lineBuf, "\r\n")
    lineBuf = strings.TrimSpace(lineBuf)
    return lineBuf, nil
}

View Code

其他人写的：

/*
 * Copyright (c) Huawei Technologies Co., Ltd. 2020-2020. All rights reserved.
 * Description: 上机编程认证
 * Note: 缺省代码仅供参考，可自行决定使用、修改或删除
 * 只能import Go标准库
 */
package main

import (
    "bufio"
    "fmt"
    "io"
    "os"
    "strings"
) 

var engMap = map[rune][]rune{
    '1': {',', '.'},
    '2': {'a', 'b', 'c'},
    '3': {'d', 'e', 'f'},
    '4': {'g', 'h', 'i'},
    '5': {'j', 'k', 'l'},
    '6': {'m', 'n', 'o'},
    '7': {'p', 'q', 'r', 's'},
    '8': {'t', 'u', 'v'},
    '9': {'w', 'x', 'y', 'z'},
}

// 待实现函数，在此函数中填入答题代码
func getDisplayString(input string) string {
    // 最终要求的是翻译输出的打印字符
    // 数字态则原样输出 
    // 英文态按规则翻译输出
    var output strings.Builder
    stateNum := true
    for idx := 0; idx < len(input); idx++ {
        if input[idx] == '#' {
            stateNum = !stateNum
            continue
        } else if input[idx] == '/' {
            continue
        } else if stateNum {
            output.WriteByte(input[idx])
        } else if input[idx] == '0' {
            output.WriteByte(' ')
        } else {
            last := input[idx]
            cnt := 1
            for idx+1 < len(input) && input[idx+1] == last {
                idx++
                cnt++
            }
            output.WriteRune(engMap[rune(last)][(cnt-1)%len(engMap[rune(last)])])
        }
    }
    return output.String()
}

func main() {
    reader := bufio.NewReader(os.Stdin)
    inputStr, err := readInputString(reader)
    if err != nil {
        fmt.Println(err.Error())
        return
    }
    result := getDisplayString(inputStr)
    fmt.Println(result)
}
func readInputString(reader *bufio.Reader) (string, error) {
    lineBuf, err := reader.ReadString('\n')
    if err != nil && err != io.EOF {
        return "nil", err
    }
    lineBuf = strings.TrimRight(lineBuf, "\r\n")
    lineBuf = strings.TrimSpace(lineBuf)
    return lineBuf, nil
}

View Code

感悟：

想复杂了，想去靠数据结构栈，其实不用，直接用标志法比较简单；用栈也可以，只是没有相当标志法；

是否熟悉map?

灵魂拷问：是否熟悉题目，是否熟悉语法？