1.

/**
   *  0-arr .length（不包括）  之间的所有数是不是都在arr
   * 如果少了2个及以上  那就返回false  无缺失返回true
   * 不然就返回 缺失的数量
   */
  isHaveAll(arr: number[]): boolean | number {
    const length = arr.length
    //首先去重
    const set = new collections.Set<number>()
    for (const value of arr) {
      set.add(value)
    }
    //缺失的数量
    let notNum = 0
    //然后制造一个 0-length的 循环
    for (let i = 0; i < length; i++) {
      if (!set.has(i)) {
        notNum++
      }
    }
    if(notNum === 0){
      return true
    }else if(notNum>= 2){
      return false
    }else {
      return notNum
    }
  }

 2.

/**
   * 把 传入的str中 等于 aeiouAEIOU 的改成大写 其他改成小写
   */
  uplowStr(input : string) : string{
    //判断类型
    const typestr ='aeiouAEIOU'

    //遍历输入字符串的每一个 字节
    let outputStr =''
    for (let i = 0; i < input.length; i++) {
      let char = input.charAt(i)
      //不等于-1 表示找到了数据
      if(typestr.indexOf(char)  != -1){
        outputStr+=char.toUpperCase()
      }else{
        outputStr+=char.toLowerCase()
      }
    }
    return outputStr
  }

3.

 /**
   * 给一个无重复的升序数组，输入一个给定值
   * 如果数组内有给定值 那么返回他的索引
   * 没有的话 就返回他插入数组应该有的索引
   */
  getIndex(arr: number[], tar: number) : number{
    const  curArr = new collections.Array<number>()
    arr.forEach((ele)=>{
      curArr.push(ele)
    })
    const index = curArr.findIndex((ele)=>{
      return ele === tar
    })
    //没有找到
    if(index===-1){
      const newArr = curArr.push(tar)
      const a=curArr.sort((a,b)=>{
        return a-b
      })
      return a.indexOf(tar)
    }else{
      return index
    }

  }

4.

/**
   * 给一个特定字符串 找到输入字符串中 有特定字符串组成的字符串
   */
  getLength(str: string): number {
    //判断类型
    const typestr = 'aeiouAEIOU'
    const set = new Set<string>()
    for (let i = 0; i < typestr.length; i++) {
      set.add(typestr.charAt(i))
    }
    let length = 0
    let maxlength = 0
    for (let i = 0; i < str.length; i++) {
      let char = str.charAt(i)
      if (set.has(char)) {
        length++
        maxlength =Math.max(length,maxlength)
      } else {
        length = 0
      }
    }
    return maxlength
  }

5.整数阶乘

/**
   * 整数阶乘
   */
  getJieCheng(num: number): number {
    let count = 1
    for (let index = 1; index <= num; index++) {
      count = count * index
    }
    return count
  }

  /**
   * 整数阶乘
   */
  getJC(num: number): bigint {
    if (num === 0) {
      return BigInt(1)
    }
    return BigInt(num) * this.getJC(num - 1)
  }

6.最大公因数

/**
   * 最大公因数
   */
  getYinshu(a: number, b: number): number {

    while (b!== 0){
      let temp =b
      b=a%b
      a=temp
    }
    return a
  }

7.