讨论/技术交流/面试题|2021 届秋招支付宝前端笔试题/
面试题|2021 届秋招支付宝前端笔试题

image.png

本次支付宝的笔试题是面试官单独发过来的,时间两小时,做完之后微信发给他就可以了,可以使用 npm 自测。

太菜了,只做出了三道,感觉挺难的,希望大神指点。

问题一

/**
 * --- 问题描述 ---
 *
 * 算出两个数组的补集,数组只包含字符串和数字
 *
 * --- 说明 ---
 *
 * - 补集:如果 b 是 a 的子集,返回存在于 a 不存在于 b 的元素集合,反之返回空集合
 */

function findComplementarySet(a, b) {
  // TODO
  let sa = new Set(a);
  let sb = new Set(b);
  let res = [...a.filter(x => !sb.has(x)), ...b.filter(x => !sa.has(x))];
  if (res.length === a.length + b.length) {
    return [];
  } else {
    return res.sort();
  }
}

问题二

/**
 * --- 问题描述 ---
 *
 * 实现一个函数生成器,接收一个原函数和一组 index,生成一个新函数
 * 调用新函数时,按照 index 数组中定义的顺序将参数传入原函数中
 *
 */

function createRearFunc(func, indexes) {
  // TODO
  return function () {
    let argus = Array.from(arguments);
    let nums = [];
    for (let i = 0; i < argus.length; i++) {
      nums[indexes[i]] = argus[i]
    }
    return func(...nums);
  }
}

问题三

/**
 * --- 问题描述 ---
 *
 * 实现一个简易版的微博,包含 client 和 server 两部分,并实现四个基础功能:关注、取关、发微博、获取用户微博列表
 *
 * --- 说明 ---
 * 
 * - A 关注 B 后,A 和 B 就成为好友关系(即使 B 没有关注 A)
 * - 某个用户的微博列表,包含他本人和他所有好友的所有微博
 * - 数据存储在 server 端
 * - 具体执行逻辑,参见本题的测试部分
 */

class WeiboClient {
  /**
   * @param { userId, server } options
   */
  constructor(options) {
  }

  // 关注指定用户
  follow(userId) {

  }

  // 取关指定用户
  unfollow(userId) {

  }

  // 发微博
  postNewWeibo(content) {

  }

}

class WeiboServer {
  constructor() {

  }

  // 获取对应用户微博列表
  getWeiboList(userId) {

  }

}

类似题目:

355. 设计推特

这道题当时没有做出来。

问题四

/**
 * --- 问题描述 ---
 *
 * 给出一组异步任务方法,和允许同时执行的个数,实现一个方法,用于并发执行异步任务
 *
 * --- 说明 ---
 *
 * - 当有任务执行完毕后,自动补充任务,始终保持正在执行的任务有 `concurrency` 个
 * - 返回 { resolved: [], rejected: [] }
 *
 */

async function parallel(tasks, concurrency) {
  // TODO
}

/*******测试部分*******/
module.exports = async function doTest() {
  try {
    const child_process = require('child_process');
    const fs = require('fs');
    const path = require('path');
    const util = require('util');
    const readFile = util.promisify(fs.readFile);
    const exec = util.promisify(child_process.exec);

    const tasks = [
      () => readFile(__filename, 'utf-8'),
      () => Promise.resolve('foo'),
      () => exec('npm -v'),
      () => readFile(path.join(__dirname, '../package.json'), 'utf-8'),
      () => process.cpuUsage(),
      () => exec('node -v'),
      () => Promise.reject(new Error('bar')),
      () => exec('ls -al'),
      () => new Promise(resolve => process.nextTick(resolve)),
      () => exec('whoami')
    ];
    const { resolved, rejected } = await parallel(tasks, 3);
    assert.equal(resolved.length, 9);
    assert.equal(rejected.length, 1);
    return '通过';
  } catch (err) {
    return '不通过';
  }
};

看了半天测试用例,还是没做出来,😭 希望大神能指导一下~

问题五

/**
 * --- 问题描述 ---
 *
 * 重新排列一个字符串,使得每个相邻字符都不同,列出所有情况
 *
 * --- 说明 ---
 *
 * - 字符串只包含小写字母或者数字
 */

function reorganize(str) {
  // 使用笨办法,生成所有字符串,再剔除重复的串
  const res = new Set();
  const visited = {};
  function dfs(path) {
    if (path.length === str.length) return res.add(path);
    for (let i = 0; i < str.length; i++) {
      if (visited[i]) continue;
      visited[i] = true;
      dfs(path + str[i]);
      visited[i] = false;
    }
  }
  dfs('');
  let ans = [...res];
  let words = [];
  for (let word of ans) {
    for (let i = 1; i < word.length; i++) {
      if (word[i] === word[i - 1]) {
        break;
      } else {
        if (i === word.length - 1) {
          words.push(word);
        }
      }
    }
  }
  return words.sort();
}

第一次接触这么难的前端笔试题目,没有实习经验,js 基础不牢的话做起来还是有些吃力的,考察的也比较全面。

最后面试官给了三点建议:

  • 算法题主要刷 LeetCode
  • 语法题主要是深入看书
  • 业务题主要考察理解能力,和平时代码写得多不多

搭建完整代码测试环境将 GitHub 仓库 Clone 到本地

7

尝试了一下问题4:

function parallel(tasks, concurrency) {
	const resolved = [];
	const rejected = [];
	let index = 0;
	let finished = 0;
	
	async function runner(resolve) {
		if (index < tasks.length) {
			let fn = tasks[index];
			let i = index++;
			
			try {
				const result = await fn();
				resolved.push({ status: 'fulfiled', index: i, result });
			} catch (reason) {
				rejected.push({ status: 'rejected', index: i, reason });
			}
			
			finished++;
			runner(resolve);
		}
		
		if (finished === tasks.length) {
			resolve({ 
				resolved: resolved.sort((a, b) => a.index - b.index), 
				rejected: rejected.sort((a, b) => a.index - b.index)
			});
		}
	}
	
	return new Promise(resolve => {
		while (concurrency-- > 0) {
			runner(resolve);
		}
	});
}
展开全部 7 讨论