算法1

function longestEvenOddSubstring(str) {
  const len = str.length;
  let count = 0;
 
  // 遍历字符串，统计 o 字符出现的次数
  for (let chr of str) {
    if (chr === 'o') {
      count += 1;
    }
  }
  // 如果 o 字符出现偶数次，则最长子串的长度为 count
  if (count % 2 === 0) {
    console.log(len);
  } else {
    // 如果 o 字符出现奇数次，则最长子串的长度为 count - 1
    console.log(len - 1);
  }
}

// 遍历数组中的每个座位，如果当前座位为0（没有坐人），且其左右两侧的座位也为0或者不存在，那么我们可以在当前座位安排一名观众
function findMaximumCapable(seats) {
  const seatArr = seats.split('');
  let len = seatArr.length;
  let maxCount = 0;
  // 处理第一个座位
  if (seatArr[0] === '0' && seats[1] === '0') {
    maxCount += 1;
    seatArr[0] = '1';
  }
  // 处理中间的座位
  for (let i = 1; i < seatArr.length - 1; i++) {
    if (seatArr[i] === '0' && seatArr[i - 1] === '0' && seatArr[i + 1] === '0') {
      maxCount += 1;
      seatArr[i] = '1';
    }
  }
  // 处理最后一个座位
  if (seatArr[len - 1] === '0' && seats[len - 2] === '0') {
    maxCount += 1;
  }
 
  console.log(maxCount);
}

// 通过遍历寿司价格数组并计算每个寿司的最优价格来解决。
// 我们可以使用一个栈来维护寿司的价格，并根据栈顶元素的价格来确定是否可以免费获得下一盘寿司
function findShousiPrices(prices) {
  let length = prices.length;
  let stack = [];
  let res = new Array(length).fill(0);
 
  for (let i = 0; i < 2 * length - 1; i++) {
    let index = i % length;
 
    while (stack.length && prices[stack[stack.length - 1]] > prices[index]) {
      const topIndex = stack.pop();
      res[topIndex] = prices[topIndex] + prices[index];
    }
 
    if (i < length) {
      stack.push(index);
    }
  }
 
  while (stack.length > 0) {
    const topIndex = stack.pop();
    res[topIndex] = prices[topIndex]
  }
 
  console.log(res.join(' '))
}

输入：
2
100 95
 
输出：
0 0
 
说明：
第一个小朋友身高100，站在队尾位置，向队首看，没有比他身高高的小朋友，所以输出第一个值为0。
第二个小朋友站在队首，前面也没有比他身高高的小朋友，所以输出第二个值为0。
 
输入：
8
123 124 125 121 119 122 126 123
 
输出
1 2 6 5 5 6 0 0

const readline = require('readline');
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
})
 
let n = 0; // 人数
let height = []; // 身高数组
 
rl.on('line', (line) => {
  if (!n) {
    n = parseInt(line.trim());
  } else {
    height = line.trim().split(' ').map(Number);
 
    let friends = new Array(n).fill(0);
    let stack = [0];
    for (let i = 1; i < n; i++) {
      while (stack.length && height[i] > height[stack[stack.length - 1]]) {
        friends[stack.pop()] = i;
      }
      stack.push(i);
    }
 
    let result = '';
    for (let i = 0; i < n; i++) {
      result += friends[i] + ' ';
    }
    console.log(result.trim());
  }
})

// 思路：通过二分查找来解决
// 我们可以在1到最大桃子数之间进行二分查找，找到最小的速度K，使得在H小时内可以吃完所有的桃子
function findMinimumSpeed(piles, H) {
  let maxPile = Math.max(...piles);
  let left = 1;
  let right = maxPile;
  let result = 0;
 
  while (left <= right) {
    let mid = Math.floor((left + right) / 2); // 中间值 mid，表示当前尝试的速度K
    let hours = 0;
    for (let pile of piles) {
      hours += Math.ceil(pile / mid);
    }
    if (hours <= H) {
      result = mid;
      right = mid - 1;
    } else {
      left = mid + 1;
    }
  }
 
  console.log(result);
}

let res = Number.MAX_SAFE_INTEGER;
let totalSum = 0;
let targetSum = 0;
function dfs (nums, idx, count, currentSum) {
  if (count === 5) {
    let ohterTeamSum = totalSum - currentSum;
    res = Math.min(res, Math.abs(ohterTeamSum - currentSum));
    return;
  }
 
  if (idx === 10) {
    return
  }
 
  dfs(nums, idx + 1, count + 1, currentSum + nums[idx]);
 
  dfs(nums, idx + 1, count, currentSum);
}
function main(nums) {
  for (let num of nums) {
    totalSum += num;
  }
  targetSum = totalSum / 2;
  dfs(nums, 0, 0, 0);
  console.log(res);
}

输入：
abC124ACb
 
输出：
4
 
说明：
满足条件的最长子串是C124或者124A，长度都是4

遍历字符串，记录当前连续的字母和数字的数量。
如果遇到一个字母，将字母计数器加1；如果遇到一个数字，将数字计数器加1。
如果字母计数器大于1，说明当前子串不满足条件，需要重新开始计算子串长度。
如果数字计数器为0，说明当前子串不满足条件，需要重新开始计算子串长度。
如果字母计数器为1且数字计数器大于0，说明当前子串满足条件，更新最长子串长度。
遍历结束后，返回最长子串长度。如果没有找到满足条件的子串，返回-1。

function findMaxLength(str) {
  // 初始化最长子传长度
  let maxLength = 0;
  // 初始化一个标志，表示是否找到了包含字母的子串
  let hasLetter = false;
  // 初始化双指针L和R，分别表示子串的左右边界
  let l = 0; let r = 0;
  // 创建一个双端队列用于存储字母索引
  let letterIdx = [];
 
  while (r < str.length) {
    let char = str.charAt(r);
 
    if (char.match(/[a-zA-Z]/)) {
      hasLetter = true;
      letterIdx.push(r);
 
      if (letterIdx.length > 1) {
        l = letterIdx.shift() + 1;
      }
      if (r === l) {
        r++;
        continue;
      }
    }
    maxLength = Math.max(maxLength, r - l + 1);
 
    r++;
  }
 
  if (hasLetter) {
    console.log(maxLength);
  } else {
    console.log(-1);
  }
}

输入
XXYYXY
 
输出
2
 
备注
分割后的子串，是原字符串的连续子串。

function splitString(str) {
  let ans = 0;
  let count = 0;
  for (let i = 0; i < str.length; i++) {
    if (str.charAt(i) === 'X') {
      count++;
    } else {
      count--;
    }
    if (count === 0) {
      ans++;
    }
  }
  console.log(ans);
}

输入：
30 12 25 8 19
 
输出：
15

function robatDoWork (blocks, limittime = 8) {
  if (blocks.length > limittime) {
    console.log(-1);
    return;
  }
  let left = 1;
  let right = Math.max(...blocks);
  while (left < right) {
    let mid = Math.floor((left + right) / 2);
    let allhours = 0;
    for (let i = 0; i < blocks.length; i++) {
      allhours += Math.ceil(blocks[i] / mid);
    }
    if (allhours <= limittime) {
      right = mid;
    } else {
      left = mid + 1;
    }
  }
  let lastTime = 0;;
  for (let i = 0; i < blocks.length; i++) {
    lastTime += Math.ceil(blocks[i] / left);
  }
  if (lastTime > limittime) {
    console.log(-1);
  } elss {
    console.log(left);
  }
}

// 56 4+
function realFun(nums) {
  let realMoney = 0;
  nums = String(nums);
  for (let i = 0; i < nums.length; i++) {
    let digit = parseInt(nums[i]);
    if (digit > 4) {
      digit--;
    }
    realMoney = realMoney * 9 + digit;
  }
  console.log(realMoney);
}