编程|??万字阿里技术岗笔面试题+参考答案，自信的可以来试试??建议收藏编程语言|程序员|面试|阿里巴

前些日子在网上偶然间看到了一波阿里的技术笔面试题，自己自信地尝试做了一波，但结果很可惜，在不上网搜参考的情况下，20道题我只做出来8个…真尴尬。

文章图片

题目水平高低起伏，这里我先把所有题目给大家看一遍，大多数题目后面都有参考答案，个别的确实没找着答案，大家可以现在这里看一遍题目去思考一下你自己的答案，看你在不看答案的情况下能做出几个来。
一、题目预览

1.如何实现两金额数据相加（最多小数点两位）？
.
2.有一批气象观测站，现需要获取这些站点的观测数据，并存储到 Hive 中。但是气象局只提供了 api 查询，每次只能查询单个观测点。那么如果能够方便快速地获取到所有的观测点的数据？
.
3.请计算XILINX公司VU9P芯片的算力相当于多少TOPS，给出计算过程与公式。
.
4.给定一个整数数组和一个整数，返回两个数组的索引，这两个索引指向的数字的加和等于指定的整数。需要最优的算法，分析算法的空间和时间复杂度。
.
5.MySQL 的数据如何恢复到任意时间点？
.
6.给定一个二叉搜索树(BST)，找到树中第 K 小的节点。
.
7.一颗现代处理器，每秒大概可以执行多少条简单的MOV指令，有哪些主要的影响因素？
.
8. 在云计算大数据处理场景中，每天运行着成千上万的任务，每个任务都要进行 IO 读写。存储系统为了更好的服务，经常会保证高优先级的任务优先执行。当多个作业或用户访问存储系统时,如何保证优先级和公平性？
.
9.如何实现一个高效的单向链表逆序输出？
.
10. 你理解常见如阿里，和友商大数据平台的技术体系差异以及发展趋势和技术瓶颈，在存储和计算两个方面进行概述。
.
11.如果让你来设计一个支持数据库、NOSQL 和大数据之间数据实时流动的数据流及处理的系统，你会考虑哪些问题？如何设计？
.
12.假如给你一个新产品，你将从哪些方面来保障它的质量？
.
13.已知 sqrt (2)约等于 1.414，要求不用数学库，求 sqrt (2)精确到小数点后 10 位。
.
14.LRU 缓存机制，设计和实现一个 LRU（最近最少使用）缓存数据结构，使它应该支持一下操作：get 和 put。 get(key) - 如果 key 存在于缓存中，则获取 key 的 value（总是正数），否则返回 -1。 put(key,value) - 如果 key 不存在，请设置或插入 value。当缓存达到其容量时，它应该在插入新项目之前使最近最少使用的项目作废。
.
15.给定一个链表，删除链表的倒数第 N 个节点，并且返回链表的头结点。
.
16.输入 ping IP 后敲回车，发包前会发生什么？
.
17.请解释下为什么鹿晗发布恋情的时候，微博系统会崩溃，如何解决？
.
18. 关于并行计算的一些基础开放问题。
.
19.请评估一下程序的执行结果？
.
20.现有一批邮件需要发送给订阅顾客，且有一个集群（集群的节点数不定，会动态扩容缩容）来负责具体的邮件发送任务，如何让系统尽快地完成发送？请详述技术方案！

阿里的笔面试题和答案我已整理成文档，如果你文章看不习惯文章的话，可以找我要文档去看的。
二、参考答案以下只是网上的一些大神以及小哥自己做出的一些参考答案，并非出自阿里内部的答案，大家没有头绪的情况下可以参考参考。
1.如何实现两金额数据相加（最多小数点两位）？出题人：阿里巴巴出题专家：御术／蚂蚁金服数据可视化高级技术专家
参考答案：
其实问题并不难，就是考察候选人对 JavaScript 数据运算上的认知以及考虑问题的缜密程度，有很多坑，可以用在笔试题，如果用在面试，回答过程中还可以随机加入有很多计算机基础的延伸。
回到这个问题，由于直接浮点相与加会失精，所以要转整数；（可以插入问遇到过吗？是否可以举个例子？）。
转整数是第一个坑，虽然只有两位可以通过乘以100转整数，但由于乘以一百和除以一百都会出现浮点数的运算，所以也会失精，还是要通过字符串来转；（可以插入问字符串转整数有几种方式？）字符串转整是第二个坑，因为最后要对齐计算，如果没考虑周全先toFixed(2)，对于只有一位小数点数据进入计算就会错误；转整数后的计算是个加分点，很多同学往往就是直接算了，如果可以考虑大数计算的场景，恭喜同学进入隐藏关卡，这就会涉及如何有效循环、遍历、算法复杂度的问题。
2.有一批气象观测站，现需要获取这些站点的观测数据，并存储到 Hive 中。但是气象局只提供了 api 查询，每次只能查询单个观测点。那么如果能够方便快速地获取到所有的观测点的数据？出题人：阿里巴巴出题专家：江岚／阿里巴巴数据技术高级技术专家
参考答案：
A. 通过 shell 或 python 等调用 api，结果先暂存本地，最后将本地文件上传到 Hive 中。
B. 通过 datax 的 httpReader 和 hdfsWriter 插件，从而获取所需的数据。
C. 比较理想的回答，是在计算引擎的 UDF 中调用查询 api，执行UDF 的查询结果存储到对应的表中。一方面，不需要同步任务的导出导入；另一方面，计算引擎的分布式框架天生提供了分布式、容错、并发等特性。
3.请计算XILINX公司VU9P芯片的算力相当于多少TOPS，给出计算过程与公式。出题人：阿里巴巴出题专家：隐达／阿里云异构计算资深专家
参考答案：基于不同的算法，这个值在十几到几百之间。但是，如果只是单纯比算力，FPGA和ASIC、GPU相比并无太大优势，甚至大多时候有较大劣势。FPGA的优势在于高度的灵活性和算法的针对性。

文章图片

4.给定一个整数数组和一个整数，返回两个数组的索引，这两个索引指向的数字的加和等于指定的整数。需要最优的算法，分析算法的空间和时间复杂度参考答案：

Ha public int[] twoSum(int[] nums, int target) {if(nums==null || nums.length<2) return new int[]{ 0,0}; HashMap map = new HashMap(); for(int i=0; i



 分析：空间复杂度和时间复杂度均为 O(n)

  

文章图片 



 5.MySQL 的数据如何恢复到任意时间点？ 出题人：阿里巴巴出题专家：近秋／阿里云数据库产品技术部技术专家参考答案

 参考答案：恢复到任意时间点以定时的做全量备份，以及备份增量的 binlog 日志为前提。恢复到任意时间点首先将全量备份恢复之后，再此基础上回放增加的 binlog 直至指定的时间点。

 6.给定一个二叉搜索树(BST)，找到树中第 K 小的节点。 出题人：阿里巴巴出题专家：文景／阿里云 CDN 资深技术专家

 参考答案：

 
 
考察点
 基础数据结构的理解和编码能力
 递归使用 
示例 
 
5
/ \
36
/ \
24
/
 1


 说明：保证输入的 K 满足 1<=K<=(节点数目）

 解法1：

 树相关的题目，第一眼就想到递归求解，左右子树分别遍历。联想到二叉搜索树的性质，root 大于左子树，小于右子树，如果左子树的节点数目等于 K-1，那么 root 就是结果，否则如果左子树节点数目小于 K-1，那么结果必然在右子树，否则就在左子树。因此在搜索的时候同时返回节点数目，跟 K 做对比，就能得出结果了。

 
/**
 * Definition for a binary tree node.
 **/public class TreeNode {int val;

TreeNode left;

TreeNode right;

TreeNode(int x) {
val = x;
 }
}class Solution {private class ResultType {boolean found;
// 是否找到int val;
// 节点数目
ResultType(boolean found, int val) {this.found = found;

this.val = val;

}
}public int kthSmallest(TreeNode root, int k) {return kthSmallestHelper(root, k).val;

}private ResultType kthSmallestHelper(TreeNode root, int k) {if (root == null) {return new ResultType(false, 0);

}ResultType left = kthSmallestHelper(root.left, k);
// 左子树找到，直接返回
if (left.found) {return new ResultType(true, left.val);

}// 左子树的节点数目 = K-1，结果为 root 的值
if (k - left.val == 1) {return new ResultType(true, root.val);

}// 右子树寻找
ResultType right = kthSmallestHelper(root.right, k - left.val - 1);

if (right.found) {return new ResultType(true, right.val);

}// 没找到，返回节点总数
return new ResultType(false, left.val + 1 + right.val);

}
}


 解法2：

 基于二叉搜索树的特性，在中序遍历的结果中，第k个元素就是本题的解。 最差的情况是k节点是bst的最右叶子节点，不过每个节点的遍历次数最多是1次。 遍历并不是需要全部做完，使用计数的方式，找到第k个元素就可以退出。 下面是go的一个简单实现。

 
// BST is binary search tree
type BST struct {	key, valueint
	left, right *BST
}func (bst *BST) setLeft(b *BST) {	bst.left = b
}func (bst *BST) setRight(b *BST) {	bst.right = b
}// count 查找bst第k个节点的值，未找到就返回0
func count(bst *BST, k int) int {	if k < 1 {return 0
	}	c := 0
	ok, value := countRecursive(bst, &c, k)	if ok {return value
	}	return 0
}// countRecurisive 对bst使用中序遍历
// 用计数方式控制退出遍历，参数c就是已遍历节点数
func countRecursive(bst *BST, c *int, k int) (bool, int) {	if bst.left != nil {ok, value := countRecursive(bst.left, c, k)
if ok {return ok, value
}
	}	if *c == k-1 {return true, bst.value
	}	*c++	if bst.right != nil {ok, value := countRecursive(bst.right, c, k)
if ok {return ok, value
}
	}	return false, 0
}// 下面是测试代码，覆盖了退化的情况和普通bstfunc createBST1() *BST {	b1 := &BST{
key: 1, value: 10}
	b2 := &BST{
key: 2, value: 20}
	b3 := &BST{
key: 3, value: 30}
	b4 := &BST{
key: 4, value: 40}
	b5 := &BST{
key: 5, value: 50}
	b6 := &BST{
key: 6, value: 60}
	b7 := &BST{
key: 7, value: 70}
	b8 := &BST{
key: 8, value: 80}
	b9 := &BST{
key: 9, value: 90}	b9.setLeft(b8)
	b8.setLeft(b7)
	b7.setLeft(b6)
	b6.setLeft(b5)
	b5.setLeft(b4)
	b4.setLeft(b3)
	b3.setLeft(b2)
	b2.setLeft(b1)	return b9
}func createBST2() *BST {	b1 := &BST{
key: 1, value: 10}
	b2 := &BST{
key: 2, value: 20}
	b3 := &BST{
key: 3, value: 30}
	b4 := &BST{
key: 4, value: 40}
	b5 := &BST{
key: 5, value: 50}
	b6 := &BST{
key: 6, value: 60}
	b7 := &BST{
key: 7, value: 70}
	b8 := &BST{
key: 8, value: 80}
	b9 := &BST{
key: 9, value: 90}	b1.setRight(b2)
	b2.setRight(b3)
	b3.setRight(b4)
	b4.setRight(b5)
	b5.setRight(b6)
	b6.setRight(b7)
	b7.setRight(b8)
	b8.setRight(b9)	return b1
}func createBST3() *BST {	b1 := &BST{
key: 1, value: 10}
	b2 := &BST{
key: 2, value: 20}
	b3 := &BST{
key: 3, value: 30}
	b4 := &BST{
key: 4, value: 40}
	b5 := &BST{
key: 5, value: 50}
	b6 := &BST{
key: 6, value: 60}
	b7 := &BST{
key: 7, value: 70}
	b8 := &BST{
key: 8, value: 80}
	b9 := &BST{
key: 9, value: 90}	b5.setLeft(b3)
	b5.setRight(b7)
	b3.setLeft(b2)
	b3.setRight(b4)
	b2.setLeft(b1)
	b7.setLeft(b6)
	b7.setRight(b8)
	b8.setRight(b9)	return b5
}func createBST4() *BST {	b := &BST{
key: 1, value: 10}
	last := b	for i := 2;
 i < 100000;
 i++ {n := &BST{
key: i, value: i * 10}
last.setRight(n)last = n
	}	return b
}func createBST5() *BST {	b := &BST{
key: 99999, value: 999990}
	last := b	for i := 99998;
 i > 0;
 i-- {n := &BST{
key: i, value: i * 10}
last.setLeft(n)last = n
	}	return b
}func createBST6() *BST {	b := &BST{
key: 50000, value: 500000}
	last := b	for i := 49999;
 i > 0;
 i-- {n := &BST{
key: i, value: i * 10}
last.setLeft(n)last = n
	}	last = b	for i := 50001;
 i < 100000;
 i++ {n := &BST{
key: i, value: i * 10}
last.setRight(n)last = n
	}	return b
}func TestK(t *testing.T) {	bst1 := createBST1()
	bst2 := createBST2()
	bst3 := createBST3()
	bst4 := createBST4()	check(t, bst1, 1, 10)
	check(t, bst1, 2, 20)
	check(t, bst1, 3, 30)
	check(t, bst1, 4, 40)
	check(t, bst1, 5, 50)
	check(t, bst1, 6, 60)
	check(t, bst1, 7, 70)
	check(t, bst1, 8, 80)
	check(t, bst1, 9, 90)	check(t, bst2, 1, 10)
	check(t, bst2, 2, 20)
	check(t, bst2, 3, 30)
	check(t, bst2, 4, 40)
	check(t, bst2, 5, 50)
	check(t, bst2, 6, 60)
	check(t, bst2, 7, 70)
	check(t, bst2, 8, 80)
	check(t, bst2, 9, 90)	check(t, bst3, 1, 10)
	check(t, bst3, 2, 20)
	check(t, bst3, 3, 30)
	check(t, bst3, 4, 40)
	check(t, bst3, 5, 50)
	check(t, bst3, 6, 60)
	check(t, bst3, 7, 70)
	check(t, bst3, 8, 80)
	check(t, bst3, 9, 90)	check(t, bst4, 1, 10)
	check(t, bst4, 2, 20)
	check(t, bst4, 3, 30)
	check(t, bst4, 4, 40)
	check(t, bst4, 5, 50)
	check(t, bst4, 6, 60)
	check(t, bst4, 7, 70)
	check(t, bst4, 8, 80)
	check(t, bst4, 9, 90)	check(t, bst4, 99991, 999910)
	check(t, bst4, 99992, 999920)
	check(t, bst4, 99993, 999930)
	check(t, bst4, 99994, 999940)
	check(t, bst4, 99995, 999950)
	check(t, bst4, 99996, 999960)
	check(t, bst4, 99997, 999970)
	check(t, bst4, 99998, 999980)
	check(t, bst4, 99999, 999990)
}func check(t *testing.T, b *BST, k, value int) {	t.Helper()	checkCall(t, b, k, value, count)
	// 此处可添加其他解法的实现
}func checkCall(t *testing.T, b *BST, k, value int, find func(bst *BST, kth int) int) {	t.Helper()	got := find(b, k)
	if got != value {t.Fatalf("want:%d, got:%d", value, got)
	}
}


 7.一颗现代处理器，每秒大概可以执行多少条简单的MOV指令，有哪些主要的影响因素？ 出题人：阿里巴巴出题专家：子团／创新产品虚拟化&稳定性资深技术专家

 参考答案：

 及格： 每执行一条mov指令需要消耗1个时钟周期，所以每秒执行的mov指令和CPU主频相关。

 加分： 在CPU微架构上，要考虑数据预取，乱序执行，多发射，内存stall(前端stall和后端stall)等诸多因素，因此除了cpu主频外，还和流水线上的效率(IPC)强相关，比较复杂的一个问题。

  

文章图片 



 8. 在云计算大数据处理场景中，每天运行着成千上万的任务，每个任务都要进行 IO 读写。存储系统为了更好的服务，经常会保证高优先级的任务优先执行。当多个作业或用户访问存储系统时,如何保证优先级和公平性？ 暂时没有答案。

 9.如何实现一个高效的单向链表逆序输出？ 出题人：阿里巴巴出题专家：昀龙／阿里云弹性人工智能负责人

 参考答案：下面是其中一种写法，也可以有不同的写法，比如递归等。供参考。

 
typedef struct node{intdata;

struct node*next;

node(int d):data(d), next(NULL){
}
}node;
void reverse(node* head)
{if(head == NULL){return;

}node* pleft = NULL;

node* pcurrent = head;

node* pright = head->next;
while(pright){pcurrent->next = pleft;

node *ptemp = pright->next;

pright->next = pcurrent;

pleft = pcurrent;

pcurrent = pright;

pright = ptemp;

}while(pcurrent != NULL){cout<< pcurrent->data << "\t";

pcurrent = pcurrent->next;

}
}


 
class Solution {public void reverse(ListNode head) {if (head == null || head.next == null) {return ;

}
ListNode currentNode = head;

Stack> stack = new Stack<>();

while (currentNode != null) {stack.push(currentNode);

ListNode tempNode = currentNode.next;

currentNode.next = null;
 // 断开连接
currentNode = tempNode;

}head = stack.pop();

currentNode = head;
while (!stack.isEmpty()) {currentNode.next = stack.pop();

currentNode = currentNode.next;

}
}
}class ListNode{	T val;

	public ListNode(T val) {this.val = val;

	}
	ListNode next;

}


 10. 你理解常见如阿里，和友商大数据平台的技术体系差异以及发展趋势和技术瓶颈，在存储和计算两个方面进行概述。 出题人： 阿里巴巴出题专家：映泉／阿里巴巴高级技术专家

 参考答案：开放性问题，无标准答案。

 11.如果让你来设计一个支持数据库、NOSQL 和大数据之间数据实时流动的数据流及处理的系统，你会考虑哪些问题？如何设计？ 出题人：阿里巴巴出题专家：千震／阿里云数据库高级技术专家

 参考答案：开放性问题，无标准答案。

  

文章图片 



 12.假如给你一个新产品，你将从哪些方面来保障它的质量？ 出题人：阿里巴巴出题专家：晨晖 ／阿里云中间件技术部测试开发专家

 参考答案：

 可以从代码开发、测试保障、线上质量三个方面来保障。

 在代码开发阶段，有单元测试、代码Review、静态代码扫描等；

 【编程|??万字阿里技术岗笔面试题+参考答案，自信的可以来试试??建议收藏】测试保障阶段，有功能测试、性能测试、高可用测试、稳定性测试、兼容性测试等；

 在线上质量方面，有灰度发布、紧急回滚、故障演练、线上监控和巡检等。

 13.已知 sqrt (2)约等于 1.414，要求不用数学库，求 sqrt (2)精确到小数点后 10 位。 出题人：——阿里巴巴出题专家：文景／阿里云 CDN 资深技术专家

 参考答案：

 
 
考察点
 1）基础算法的灵活应用能力（二分法学过数据结构的同学都知道，但不一定往这个方向考虑；如果学过数值计算的同学，应该还要能想到牛顿迭代法并解释清楚）
 2）退出条件设计 
 二分法

 
 
 已知 sqrt(2)约等于 1.414，那么就可以在(1.4, 1.5)区间做二分
 查找，如： a) high=>1.5 b) low=>1.4 c) mid => (high+low)/2=1.45 d) 1.45*1.45>2 ? high=>1.45 : low => 1.45 e) 循环到 c)

  
 退出条件
 a) 前后两次的差值的绝对值<=0.0000000001, 则可退出

  
 
const double EPSILON = 0.0000000001;
double sqrt2() {double low = 1.4, high = 1.5;

double mid = (low + high) / 2;
while (high - low > EPSILON) {if (mid * mid > 2) {high = mid;

} else {low = mid;

}
mid = (high + low) / 2;

}return mid;

}


 牛顿迭代法

 1.牛顿迭代法的公式为：

 xn+1 = xn-f(xn)/f’(xn)

 对于本题，需要求解的问题为：f(x)=x2-2 的零点

 
EPSILON = 0.1 ** 10
def newton(x):
if abs(x ** 2 - 2) > EPSILON:
return newton(x - (x ** 2 - 2) / (2 * x))
else:
return x


  

文章图片 



 14.LRU 缓存机制，设计和实现一个 LRU（最近最少使用）缓存数据结构，使它应该支持一下操作：get 和 put。 get(key) - 如果 key 存在于缓存中，则获取 key 的 value（总是正数），否则返回 -1。 put(key,value) - 如果 key 不存在，请设置或插入 value。当缓存达到其容量时，它应该在插入新项目之前使最近最少使用的项目作废。 出题人：文景／阿里云 CDN 资深技术专家

 参考答案：

 python版本的：

 
class LRUCache(object):
def __init__(self, capacity):
"""
:type capacity: int
"""
self.cache = {
}
self.keys = []
self.capacity = capacitydef visit_key(self, key):
if key in self.keys:
self.keys.remove(key)
self.keys.append(key)def elim_key(self):
key = self.keys[0]
self.keys = self.keys[1:]
del self.cache[key]def get(self, key):
"""
:type key: int
:rtype: int
"""
if not key in self.cache:
return -1
self.visit_key(key)
return self.cache[key]def put(self, key, value):
"""
:type key: int
:type value: int
:rtype: void
"""
if not key in self.cache:
if len(self.keys) == self.capacity:
self.elim_key()
self.cache[key] = value
self.visit_key(key)def main():
s =
[["put","put","get","put","get","put","get","get","get"],[[1,1],[2,2],[1],[3,3],[2],[
4,4],[1],[3],[4]]]
obj = LRUCache(2)
l=[]
for i,c in enumerate(s[0]):
if(c == "get"):
l.append(obj.get(s[1][i][0]))
else:
obj.put(s[1][i][0], s[1][i][1])
print(l)if __name__ == "__main__":
main()


 C++版本：

 
class LRUCache{public:
LRUCache(int capacity) {cap = capacity;

}int get(int key) {auto it = m.find(key);

if (it == m.end()) return -1;

l.splice(l.begin(), l, it->second);

return it->second->second;

}void set(int key, int value) {auto it = m.find(key);

if (it != m.end()) l.erase(it->second);

l.push_front(make_pair(key, value));

m[key] = l.begin();

if (m.size() > cap) {int k = l.rbegin()->first;

l.pop_back();

m.erase(k);

}
}
}


 15.给定一个链表，删除链表的倒数第 N 个节点，并且返回链表的头结点。 ? 示例： 给定一个链表: 1->2->3->4->5, 和 n = 2. 当删除了倒数第二个节点后，链表变为 1->2->3->5. 说明： 给定的 n 保证是有效的。 要求： 只允许对链表进行一次遍历。

 出题人：阿里巴巴出题专家：屹平／阿里云视频云边缘计算高级技术专家

 参考答案：

 我们可以使用两个指针而不是一个指针。第一个指针从列表的开头向前移动 n+1 步，而第二个指针将从列表的开头出发。现在，这两个指针被 n 个结点分开。我们通过同时移动两个指针向前来保持这个恒定的间隔，直到第一个指针到达最后一个结点。此时第二个指针将指向从最后一个结点数起的第 n 个结点。我们重新链接第二个指针所引用的结点的 next 指针指向该结点的下下个结点。

 参考代码：

 
public ListNode removeNthFromEnd(ListNode head, int n)
{ListNode dummy = new ListNode(0);

dummy.next = head;

ListNode first = dummy;

ListNode second = dummy;

// Advances first pointer so that the gap between first
and second is n nodes apart
for (int i = 1;
 i <= n + 1;
 i++) {first = first.next;

}
// Move first to the end, maintaining the gap
while (first != null) {first = first.next;

second = second.next;

}
second.next = second.next.next;

return dummy.next;

}


 复杂度分析：

 
 
时间复杂度：O(L)，该算法对含有 L 个结点的列表进行了一次遍历。因此时间复杂度为 O(L)。 
空间复杂度：O(1)，我们只用了常量级的额外空间。 
  

文章图片 



 16.输入 ping IP 后敲回车，发包前会发生什么？ 出题人：阿里巴巴出题专家：怀虎／阿里云云效平台负责人

 参考答案：

 ping目标ip时，先查路由表，确定出接口

 如果落在直连接口子网内，此时若为以太网等 多路访问网络 则先查询arp缓存，命中则直接发出，否则在该接口上发arp询问目标ip的mac地址，取得后发出，若为ppp等 点对点网络 ，则直接可以发出；

 如果查表落在缺省路由上，此时若为以太网等 多路访问网络 则先查询网关arp缓存，命中则直接发出，否则在该接口上发arp询问网关的mac地址，取得后发出，若为ppp等 点对点网络 ，则直接可以发出；

 若查表未命中，则返回不可达。

 17.请解释下为什么鹿晗发布恋情的时候，微博系统会崩溃，如何解决？ 出题人：阿里巴巴出题专家：江岚／阿里巴巴数据技术高级技术专家

 参考答案：

 A. 获取微博通过 pull 方式还是 push 方式

 B. 发布微博的频率要远小于阅读微博

 C. 流量明星的发微博，和普通博主要区分对待，比如在 sharding的时候，也要考虑这个因素

  

文章图片 



 18. 关于并行计算的一些基础开放问题。 
 ? 如何定义并计算，请分别阐述分布式内存到共享内存模式行编程的区别和实现（例子代码）？

 ? 请使用 MPI 和 OpenMP 分别实现 N 个处理器对 M 个变量的求和？

 ? 请说明 SIMD 指令在循环中使用的权限？向量化优化有哪些手段？

 ? 请用 Amdahl定律说明什么是并行效率以及并行算法的扩展性？并说明扩展性的性能指标和限制因素，最后请说明在共享内存计算机中，共享内存的限制？OpenMP是怎样实现共享内存编程环境的？MPI 阻塞和非阻塞读写的区别？

 
 出题人：阿里巴巴出题专家：何万青／阿里云高性能计算资深技术专家

 参考答案：

 （简要答案，但必须触及，可以展开）

 
 ?同时执行多个/算法/逻辑操作/内存访问/IO，相互独立同时运行，分三个层次：进程级，多个节点分布式内存通过MPI通信并行；线程级，共享内存的多路机器，通过OpenMP实现多线程并行；指令集：通过SIM指令实现单指令多数据。。。。举例吧啦吧啦。

 ? MPI代码，，，OpenMP代码，分别写出来 M个元素，N个处理器的累加，后者注意private 参数。

 ? SIMD在循环中的应用，限制在于 SIMD指令处理的每一个数组的长度，cache line利用，内部循环间的依赖和条件调用等。

 ? 向量化，主要看SSE和AVX指令占比率，通过编译器优化… 在loop代码中使用。

 ? 性能和计算规模随处理器增加的变化曲线，实测HPL和峰值HPL比率，能用用Amdahl定律表达Tpar(N) = (an +(1-a)n/N )t + C (n,N),能够讲明白串行部分对整个并行的天花板效应，扩展性能够解释清楚算法的扩展性=并行效率随处理器数目的变化关系，画出来。

 ? 共享内存计算机OpenMP对变量的限制描述，EREW，CREW，ERCW，CRCW等区别，NUMA概念，如何保持coherent等。

 ? 写出OpenMP和MPI的核心函数，回答问题即可。

 
 19.请评估一下程序的执行结果？ 
public class SynchronousQueueQuiz {public static void main(String[] args) throws Exception {BlockingQueue queue = new
SynchronousQueue<>();

System. out .print(queue.offer(1) + " ");

System. out .print(queue.offer(2) + " ");

System. out .print(queue.offer(3) + " ");

System. out .print(queue.take() + " ");

System. out .println(queue.size());

}
}


 A. true true true 1 3

 B. true true true (阻塞)

 C. false false false null 0

 D. false false false (阻塞)

 出题人：阿里巴巴出题专家：桃谷／阿里云中间件技术专家

 参考答案：D

 20.现有一批邮件需要发送给订阅顾客，且有一个集群（集群的节点数不定，会动态扩容缩容）来负责具体的邮件发送任务，如何让系统尽快地完成发送？请详述技术方案！ 出题人：阿里巴巴出题专家：江岚／阿里巴巴数据技术高级技术专家

 参考答案：

 A. 借助消息中间件，通过发布者订阅者模式来进行任务分配

 B. master-slave 部署，由 master 来分配任务

 C. 不借助任何中间件，且所有节点均等。通过数据库的 update-returning，从而实现节点之间任务的互斥

 今天的分享就到这里了，我是最近没有换岗的打算所以没刷题，但凡是再给我点时间，这种题目我也能做出来个七八成，所有题目我已经整成文档，要的话找我就行。

  

文章图片 





		  	

    
    




    
    
    


推荐阅读

           
                  
              
                  ea下载 
                
                   
                
              
            

                  
              
                  为日更勉为其难 
                
                   
                
              
            

                  
              
                  池上古诗带拼音 关于池上古诗带拼音 
                
                   
                
              
            

                  
              
                  十年过去了，90后的你还在使用QQ吗（） 
                
                   
                
              
            

                  
              
                  五绝.石佛 
                
                   
                
              
            

                  
              
                  天秤座因何而贪财呢 天秤座因何而贪财 
                
                   
                
              
            

                  
              
                  面签现场查征信看负债吗 招行卡是先查征信还是先面签 
                
                   
                
              
            

                  
              
                  芹菜怎么吃 芹菜怎么吃治便秘最快 
                
                   
                
              
            

                  
              
                  如何调整共享服务器的配额？ 共享服务器怎么调整配额 
                
                   
                
              
            

                  
              
                  爱普生打印数量清零 
                
                   
                
              
            

                  
              
                  redis如何快速查找key 查找redis进程 
                
                   
                
              
            

                  
              
                  photoshop修改逆光图片 
                
                   
                
              
            

                  
              
                  嗓子干疼怎么办最简单的方法 
                
                   
                
              
            

                  
              
                  ibm数据分析师,IBM数据分析师面试 
                
                   
                
              
            

                  
              
                  闲鱼自动收货时间 
                
                   
                
              
            

                  
              
                  大数据分析 重要性,数据分析对市场营销的重要性 
                
                   
                
              
            

                  
              
                  狗与羊能锁在一起吗 
                
                   
                
              
            

                  
              
                  空调安装注意事项 
                
                   
                
              
            

                  
              
                  端午五黄有哪些 端午五黄有什么 
                
                   
                
              
            

                  
              
                  窗帘品种和价格及图片 – 各种布料价格表 
                
                   
                
              
            

          

python青少年编程比赛_第十一届蓝桥杯大赛青少年创意编程组比赛细则 
 HTML基础--基本概念--跟着李南江学编程 
 我的软件测试开发工程师书单 
 芯灵思SinlinxA33开发板Linux内核定时器编程 
 关于响应式编程的十个问题 
 iOS-Swift-map|iOS-Swift-map filter reduce、函数式编程 
 零基础学习Python作业本（13） 
 网络编程基础--HTTP 
 CentOS7 阿里云镜像配置方法 
 《Unix网络编程》第一卷第三版|《Unix网络编程》第一卷第三版 源码编译