算法题--华为od机试考试（字符串筛选排序、非严格递增连续数字序列、最大括号深度）

function codeSort(str, k) {
    let len = str.length
    // 大于长度取最大的
    if (k > len) {
        k = len
    }
    // 根据ASCII码值从小到大排序
    let arr = str.split('').sort((a, b) => a.charCodeAt() - b.charCodeAt())
    let target = arr[k - 1]
    return str.indexOf(target)
}
console.log(codeSort('AbCdeFG', 3))
console.log(codeSort('fAdDAkBbBq', 4))

非严格递增连续数字序列

考察转换思想，简单题。

题目描述

输入一个字符串仅包含大小写字母和数字,求字符串中包含的最长的非严格递增连续数字序列长度（比如12234属于非严格递增数字序列）。

输入描述

abc2234019A334bc

输出描述

说明

2234为最长的非严格递增连续数字序列,所以长度为4

解析

遍历字符串，当为数字的时候判断是否为连续递增的序列，记录长度。当为字符时，序列置空。

答案

function ascendSequence(str) {
    let max = 0
    let tmp = 0
    let cur = ''
    for (let a of str) {
        if (!Number.isNaN(Number(a))) {
            if (a >= tmp) {
                tmp = a
                cur = cur + a
                if (cur.length > max) {
                    max = cur.length
                    maxStr = cur
                }
            } else {
                cur = ''
                tmp = 0
            }
        } else {
            cur = ''
            tmp = 0
        }
    }
    return max
}
console.log(ascendSequence('abc2234019A334bc'))

最大括号深度

考察栈的使用、正则表达式。

题目描述

现有一字符串仅由’(‘ ,’ )’ , ‘{‘ , ‘}’ , ‘[‘ , ‘]’六种括号组成。若字符串满足以下条件之一，则为无效字符串：

1、任一类型的左右括号数量不相等；

2、存在未按正确顺序（先左后右）闭合的括号。

输出括号的最大嵌套深度，若字符串无效则输出0.

0<=字符串长度<=100000

输入描述

一个只包( , ) , { , } , [ , ]的字符串。

输出描述

一个整数，最大括号深度

示例1

输入

[]

输出

说明

有效字符串，最大嵌套深度为3

示例2

输入

([]{()})

输出

说明

有效字符串，最大嵌套深度为3

示例3

输入

(]

输出

说明

无效字符串，有两种类型的左右括号数量不相等。

示例4

输入

([)]

输出

说明

无效字符串，存在未按正确顺序闭合的括号

示例5

输入

)(

输出

说明

无效字符串，存在未按正确顺序闭合的括号

解析

方法一：

利用栈先进后出的特性，当栈中无元素时只能入栈左括号，当栈中有元素时，只有左括号能入栈，为右括号时，判断与栈顶元素是否匹配，匹配则记录当前的栈长度为括号的深度。

方法二：

每一轮将对所有为{}、[]、()字符进行替换为空字符串，当无{}、[]、()字符可以替换时结束，此时字符长度为0，则返回替换的轮次为最大的括号深度。

注意最后需要判断栈中是否还有元素，如果有多的左括号，说明为无效字符。

答案

// 方法一
function maxBracket(str) {
    let len = str.length
    let arr = []
    let max = 0
    for (let i = 0; i < len; i++) {
        if (!arr[0]) {
            // 第一入栈的括号只能为左括号
            if (['(', '[', '{'].includes(str[i])) {
                arr.push(str[i])
            } else {
                return 0
            }
        } else {
            // 栈顶有元素时，只有与当前元素匹配才能出栈
            switch (str[i]) {
                case '{':
                case '[':
                case '(':
                    arr.push(str[i])
                    break;
                case ')':
                    if (arr[arr.length - 1] === '(') {
                        // 出栈前记录当前深度
                        if (max < arr.length) {
                            max = arr.length
                        }
                        arr.pop()
                    } else {
                        return 0
                    }
                    break
                case '}':
                    if (arr[arr.length - 1] === '{') {
                        // 出栈前记录当前深度
                        if (max < arr.length) {
                            max = arr.length
                        }
                        arr.pop()
                    } else {
                        return 0
                    }
                    break
                case ']':
                    if (arr[arr.length - 1] === '[') {
                        // 出栈前记录当前深度
                        if (max < arr.length) {
                            max = arr.length
                        }
                        arr.pop()
                    } else {
                        return 0
                    }
                    break
            }
        }

    }
    // 匹配完后判断是否有多的左括号
    if (arr.length !== 0) {
        return 0
    }
    return max
}

// 方法二
function maxBracket(str){
    let flag = true;
    let i = 0
    while(str.length && flag) {
      flag = false;
      if (str.includes('()')||str.includes('[]')||str.includes('{}')) {
        i++;
        flag = true;
        str = str.replace(/\(\)|\[\]|\{\}/g, '');
      }
    }
    if (str.length) {
      return 0
    } else {
      return i
    }
}
console.log(maxBracket('[]'))
console.log(maxBracket('([]{()})'))
console.log(maxBracket('(]'))
console.log(maxBracket('([)]'))
console.log(maxBracket(')('))