华为od计试

T1.第一行输入一个字符串以逗号分隔，第二行输入一个目标值。找出字符串中连续字串之和等于目标值，符合该条件的最大字串。输出最大字串的长度。如果没有返回-1。
eg: ‘1,2,3,4,5,6,7,1,2,4,5,6’ ‘6’ => 3 解释(1,2,3)
eg: ‘1,2,3,4,5,6,7,1,1,1,1,1,1,1,1’ ‘6’ => 6 解释(1,1,1,1,1,1)

 const arr = [1,2,3,4,5,1,1,1,1,1,1,1,1,1,1,90]
  const target = 7
  let left = 0
  let right = 0
  let max = -1
  const len = arr.length
  let sum = arr[0]
  while(left < len && right < len){
   if(sum === target){
    max = Math.max(max,right-left+1)
    sum-=arr[left]
    left++
   }
   if(sum > target){
    sum-=arr[left++]
   }
   if(sum<target){
    right++
    sum+=arr[right]
   }
  }
  console.log(max);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

T2给一段话很长的句子，第二行输入一个前缀，找出以以这个为前缀的单词并进行排序，如果没有返回-1。注意don’t看成don 和 t
eg：'Happiness is like a pebble dropped into a pool to set in motion an ever-widening circle of ripples As Stevenson has said, being happy is a duty ’
// 前缀：dr 输出 dropped
(建立字典是为了后续查找)

const str = "adf abc aef bf ab don't"
const per = 'a'
const searchSuggest = (str) => {
    const dict = {}
    const handleDict = (str,dict) => {
        const arr = str.split(' ')
        const createDict = (word,dict) => {
            if(word.length === 1){
                if(!dict[word]){
                    // 根单词添加标识
                    dict[word] = {isRootWord:true}
                    return dict
                }else{
                    // 根单词添加标识
                    return Object.assign(dict[word],{isRootWord:true})
                }
            }
            if(dict[word[0]]){
                // 给当前层继续挂载属性
                createDict(word.slice(1),dict[word[0]])
            }else{
                dict[word[0]] = createDict(word.slice(1),{})
            }
            return dict
        }

        // 因为涉及到某些单词可能是词根单词，所以需要把长度大的放在前面，这样后续处理词根单词会方便一点
        arr.forEach(word=>{
            if(word.includes("'")){
                word.split("'").forEach(w=>{
                    createDict(w,dict)
                })
            }else{
                createDict(word,dict)
            }
        })
    }

    const searchWordInDict = (per,dict) => {
        // 找出前缀树
        const findPerTree = (per,dict) => {
            if(per.length === 1){
                return dict[per]
            }
            if(dict[per[0]]){
                return findPerTree(per.slice(1),dict[per[0]])
            }
        }

        const joinStr = (per,obj) => {
            const rstArr = []
            for(let key in obj){
                // 如果key是根单词说明要拼接
                if(key === 'isRootWord'){
                    rstArr.push(`${per}`)
                }else{
                    rstArr.push(...joinStr(`${per}${key}`,obj[key]))
                }
            }
            return rstArr
        }
        const obj = findPerTree(per,dict)
        let strArr = []
        // 遍历树形成word
        if(obj){
            strArr =  joinStr(per,obj)
        }

        // 排序
        const sortFun = (a,b) => {
            if(!a) return -1
            if(!b) return 1
            if(a.charCodeAt() === b.charCodeAt()){
                return sortFun(a.slice(1),b.slice(1))
            }
            return a.charCodeAt() - b.charCodeAt()
        }
        strArr.sort(sortFun)
        return strArr.length > 0 ? strArr : -1
    }

    handleDict(str,dict)
    return function(per = ''){
        return searchWordInDict(per,dict)
    }
}

console.log(searchSuggest(str)(per));
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

T3第一行输入一串字符串，请计算结果。其中sub( a b) 表示 a-b , add(a b) 表示 a + b ， mult(a b)表示 a * b, div(a b)表示 a / b 。如果被除数是0，则输出error eg:
add(3 div(4 0)) => error
add(3 mult(2 6)) => 15.0
add(1 div(1 2)) => 1.5

const str = '(add 3 (sub 4 1))'
handlekh = str => {
  let rst = ''
  const len = str.length
  for(let i = 0; i < len ; i++){
    if(str[i] === '('){
      rst += '( '
    }else if(str[i] === ')'){
      rst += ' )'
    }else{
      rst += str[i]
    }
  }
  return rst
}
const arr = handlekh(str).split(' ')
const stack = []
const getRst = (f,left,right) => {
  left = Number(left)
  right = Number(right)
  if(f === 'add') return left + right
  if(f === 'sub') return left - right
  if(f === 'div'){
    if(right === 0){
      return false
    }
    return Math.floor(left/right)        
  }
  if(f === 'mul') return left * right
}
arr.forEach(item=>{
  if(item[0] !== ')'){
    stack.push(item)
  }else{
    const right = stack.pop()
    const left = stack.pop()
    const f = stack.pop()
    // 把'（'移出去
    stack.pop()
    const rst = getRst(f,left,right)
    if(rst===false){
      return console.log('error')
    }
    stack.push(rst)
  }
})
console.log(stack[0]);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47