字节跳动bytecamp夏令营在线笔试编程题

就不吐槽牛客网的bug了，在线笔试体验极差。当时是严重影响了心情，心理素质还是要再提高啊，无论什么时候，编程都要保持平和的心态。

直接说解法吧，总共四道题，第一题很简单，二三题给出解法，第四题来不及做了，题目都没看。

第二题

找矩阵有几组1，1的周围八格有1的话，视为同一组。
我是从左上角开始遍历的，所以八个方向，只需要递归了五个方向。即右上，右，右下，正下，左下，在用一个flag数组存一下记录，遍历过的不再遍历。

let arr = [[1, 0, 1, 0], [1, 1, 0, 0], [0, 0, 0, 1], [1, 0, 1, 0]];
getOne(arr);

function getOne(arr) {
  let row = arr.length;
  let col = arr[0].length;
  let flag = [];
  let sum = 0;
  for (let i = 0; i < row; i++) {
    flag.push([]);
  }
  for (let i = 0; i < row; i++) {
    for (let j = 0; j < col; j++) {
      if (!flag[i][j]) {
        isOne(i, j, true);
      }
    }
  }
  return sum;

  function isOne(i, j, origin) {
    if (i < row && i >= 0 && j < col && j >= 0) {
      if (!flag[i][j]) {
        flag[i][j] = true;
        if (arr[i][j] === 1) {
          isOne(i + 1, j, false);
          isOne(i, j + 1, false);
          isOne(i + 1, j + 1, false);
          isOne(i + 1, j - 1, false);
          isOne(i - 1, j + 1, false);
          if (origin) {
            console.log(i, j);
            sum++;
          }
        }
      }

    }
  }
}

第三题
n%xxxx#，%#是定界符，要求把里面的xxxx重写n遍。允许嵌套。

function trans(line) {
  if (line.indexOf('#') === -1) {
    return line;
  }
  let newLine = [];
  let times_arr = [];
  let times = 0;
  let temp = [];
  let flag = false;
  let headnum = 0;
  while (line.length !== 0) {
    let item = line.shift();
    if (!flag) {
      if (item === '%') {
        headnum++;
        flag = true;
        while (newLine[newLine.length - 1] >= '0' && newLine[newLine.length - 1] <= '9') {
          times_arr.unshift(newLine.pop());
        }
        times = parseInt(times_arr.join(''));
        times_arr = [];
      }
      else if (item >= 'a' && item <= 'z' || item >= '0' && item <= '9') {
        newLine.push(item);
      }
    }
    else {
      if (item === '%') {
        headnum++;
        temp.push(item);
      }
      else if (item === '#') {
        headnum--;
        if (headnum === 0) {
          flag = false;
          for (let i = 0; i < times; i++) {
            newLine = newLine.concat(temp);
          }
          temp = [];
        }
        else {
          temp.push(item);
        }
      }
      else {
        temp.push(item);
      }
    }
  }
  return trans(newLine);
}
var line = '2a2%a10%f##'.split('');
trans(line);



function tran(line) {
  let last = line.lastIndexOf('%');
  while(last !== -1) {
    for (let i = last + 1; i < line.length; i++) {
      if(line[i] === '#') {
        let substr = line.slice(last + 1, i);
        let times_start;
        for(let i = last - 1; i >= 0; i--) {
          if(line[i] < '0' || line[i] > '9') {
            times_start = i + 1;
            break;
          }
        }
        let line_left = line.slice(0, times_start);
        let line_right = line.slice(i + 1);
        let times = parseInt(line.slice(times_start, last).join(''));
        for(let i = 0; i < times; i++) {
          line_left = line_left.concat(substr);
        }
        line = line_left.concat(line_right);
        console.log(line.join(''));
        last = line.lastIndexOf('%');
        break;
      }
    }
  }
  return line.join('');
}

trans函数是递归做法，tran函数是迭代做法。事实证明，这道题的确用迭代要更方便。二十多行代码搞定。
递归做法: 读到%#把里面的字符存起来，直接翻倍。直到不再有#或者%。
迭代做法：从最后的%开始做起，不断往左迭代。直到没有%。
节省时间，没有做什么错误处理。