Date: 2019-08-03
1.
给定一个不下降的序列Sn{s1, s2... sn},以及一个m,* * * * */
找到最小的k,使得s[k] = m,如果不存在输出-1 test case :S = {1,3,4} m = 3 , k = 2 S = {1,2,2,2,,2} m = 2, k = 2
思路：因为S序列是不下降序列，所以一次二分查找即可。
A：
2.
给定正整数n(n < 100000),找到最小的由0,1组成的十进制正整数m,满足m = k * n, k为正整数。输入n,输出最小的正整数m,若不存在,则输出-1. (和两个子序列的题组合)例如:输入: 2输出10，输入3输出111，输入18输出1111111110。可以使用标准的数据结构list, set, map, que,样例简单解释。
n=2, m=10 =5*n
n = 3 m =111 = 37 * n
n = 18 m = 1111111110 = 61728395 * n
def m01(n) :
if n == 1 :
return '1'
m_dict = {1 : '1'}
while True :
find = False
m_dict2 = {}
for k,v in m_dict.items():
k1 = (k * 10) % n
v1 = v + '0'
k2 = (k * 10 + 1) % n
v2 = v + '1'
if k1 not in m_dict :
if k1 not in m_dict2 :
m_dict2[k1] = v1
elif v1 < m_dict2[k1] :
m_dict2[k1] = v1
if k2 not in m_dict :
if k2 not in m_dict2 :
m_dict2[k2] = v2
elif v2 < m_dict2[k2] :
m_dict2[k2] = v2
for k, v in m_dict2.items() :
if k == 0 :
if find :
if v < m :
m=v
else :
find = True
m=v
if find :
return m #check need search if len(m_dict2) > 0 :
m_dict = m_dict2
else :
return '-1'
3.
0-100的N个数(数的值范围为0~100 1 < N <= 1000),分成两组A、B:怎样分|meanA-meanB|最大?
a = list(map(int, input().strip().split()))
a.sort()
A = a[0]
B = a[1：]
m1 = mean(A)
m2 = mean(B)
print(abs(m1-m2) # 并没有说需要进行5：5划分，则只需要进行划分计算即可，选择最小的一个数作为一组，然后与剩下的数组均值进行比较即可。4. 已知一个NxN的矩阵A,求矩阵中所有边长为m的正方形的子矩阵内元素的中位数。(m<N, m%2=1,正方形中的点必须都在原始矩阵中)
思路： 暴力解，遍历每个正方形，取出正方形中的所有数，因为m%2=1，所以取出的数为3m=3*（2n+1）个，肯定为奇数个，所以中位数总是存在在于数组中一个，对取得的正方形，展开成一维后可以使用快排的思想查找TOP K,这里K=（3m-1）/2，这样每个中位数就可以用O(n)的复杂度找到
A：
2017 年笔试题 共12题 5选+5简答+2编程题
1. IPv6地址的长度为()。 128
2. 在数据库的数据模型中有()。 网状模型 、关系模型、层次模型
3. 在TCP/IP参考模型中，实现可靠到端通信的层次是()。 传输层
4. 在邮件服务器之间实现邮件投递的协议是()。 SMTP
5. 关于Linux操作系统的描述中，正确的是()。 符合POSIX标准
6. 对任意a，b，-100000≤a≤b≤100000如何判断a×（a+1）×（a+2）×...×b结果的符号。
主要是根据a 和 b的符号进行分类讨论。
a, b = map(int, input().strip().split())
if a >= 0 and b >= 0:
res = '+'
elif a <0 and b >=0 :
if abs(a) %2 ==0:
res = '+'
else:
res = '-'
elif a<0 and b<0:
if abs(a) %2 ==0:
res = '-'
else:
res = '+'7. 一个高度为N且只有N个不同颜色的节点的二叉树有多少种形状（颜色不同算不同）？用^表示次方！表示阶乘。
2^N-1*N!
8. 简单解释什么是锁，什么是乐观锁，乐观锁和悲观锁的区别。
A：
何谓悲观锁与乐观锁
乐观锁对应于生活中乐观的人总是想着事情往好的方向发展，悲观锁对应于生活中悲观的人总是想着事情往坏的方向发展。这两种人各有优缺点，不能不以场景而定说一种人好于另外一种人。
悲观锁
总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁（共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程）。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。Java中synchronized和ReentrantLock等独占锁就是悲观锁思想的实现。
乐观锁
总是假设最好的情况，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号机制和CAS算法实现。乐观锁适用于多读的应用类型，这样可以提高吞吐量，像数据库提供的类似于write_condition机制，其实都是提供的乐观锁。在Java中java.util.concurrent.atomic包下面的原子变量类就是使用了乐观锁的一种实现方式CAS实现的。
9. 已知中缀表达式a+b+c*a*(a+b)/e+f求等价后缀表达式。
A:
中缀表达式转化为相应的等价后缀表达式的方法： 先将原来的中缀表达式按照计算的先后顺序添加相应的括号；然后用每个运算符去替代该运算符最近的右边的“）”符号，替换完成后就可以得到相应的后缀表达式。
后缀表达式是： ab+caab+**e/f+
10. 给出三种常见的HTTP Status Code 的数值和解释。
A：HTTP Status Code 所有情况的展示
HTTP Sataus Code 是HTTP状态码。
1 ** 临时响应
2** 表示成功处理了请求的状态代码
3** 表示重定向： 需要进一步完成需要的状态，需要进一步的操作。
4** 表示请求错误 :这些请求状态请求代码出错了，可能妨碍了服务器的处理
5** 表示 服务器错误： 这些状态代码表示服务器在尝试处理请求时发生内部错误。 这些错误可能是服务器本身的错误，而不是请求出错
11. 翻转一个环形的链表，下面给出LinkNode数据结构和需要实现的函数。（环形链表没有头指针，即空链表用NULL/null表示）。 （反转环形链表）
A：
12.
有长度为length（0<length≤100000)的一个括号序列sequence，只有“（”或者“）”两种字符，每个括号的左右两边都能插一个括号，总共有length+1个位置可以插入括号，在第i个位置插入任意括号的代价是cost[i](0<cost[i]≤10000)同一个位置只能插入一个括号，求使得括号序列合法的最小代价，并给出解法的时间复杂度和空间复杂度。
例如输入length=6,sequence="()))((",cost=[1,2,5,5,3,4,1],输出8.
A:
public static int getMininumCost(int length, List<Character> sequence, List<Integer> cost){
int res = 0;
boolean[] visited = new boolean[length+1];
Stack<Integer> stack = new Stack<>();
for (int i=0;i<sequence.size();i++){
if (sequence.get(i) == '('){
stack.push(i); // 插入的是左括号的索引
}else {
if (stack.isEmpty())
res += minCost(cost,visited,0,i);
else {
stack.pop();
}
}
}
while (!stack.isEmpty()){
int start = stack.pop()+1;
res += minCost(cost,visited,start,length);
}
return res;
}
public static int minCost(List<Integer> cost, boolean[] visited, int start, int end){
int index = -1, min = Integer.MAX_VALUE;
for (int i=start;i<=end;i++){
if (!visited[i]){
if (cost.get(i) < min){
min = cost.get(i);
index = i;
}
}
}
visited[index] = true;
return min;
}2017年笔试套题 (一)
1. SQL语句中，删除一个表的命令是()。 DROP
注意： 删除一张表的命令是DROP , 但是删除表中具体的内容信息是DELETE。
2. 在关系代数运算中，五种基本运算为()。 并、差、选择、投影、乘积
3. 关于OSI参考模型的描述中，正确的是()。
** 按功能可以分为7个层次 （OSI参考模型按功能分别为：
物理层 数据链路层 网络层 传输层 会话层 表示层 应用层
TCP/IP四层模型为：
链路层 网络层 传输层 应用层
）
** OSI是开放式系统互连，由ISO制定，按功能可分为物理层、数据链路层、网络层、传输层、会话层、表示层和应用层共七层
4. 关于进程与线程的描述中，正确的是(B)。
A.进程和线程具有相同的概念 （不同的概念，线程是进程的子集，一个线程只属于一个进程，但一个进程可以包含多个线程）
B. 进程需要存储空间 （YES）
C. 一个线程可以包含多个进程 （应该是： 一个进程可以包含多个线程）
D.一个线程不需要分时器进行切换
补充解释；
进程是表示资源分配的基本单位，又是调度运行的基本单位。
线程是进程中执行运算的最小单位，亦即执行处理机调度的基本单位。如果把进程理解为在逻辑上操作系统所完成的任务，那么线程表示完成该任务的许多可能的子任务之一。
进程和线程的关系
（1）一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程。线程是操作系统可识别的最小执行和调度单位。
（2）资源分配给进程，同一进程的所有线程共享该进程的所有资源。 同一进程中的多个线程共享代码段(代码和常量)，数据段(全局变量和静态变量)，扩展段(堆存储)。但是每个线程拥有自己的栈段，栈段又叫运行时段，用来存放所有局部变量和临时变量。
（3）处理机分给线程，即真正在处理机上运行的是线程。
（4）线程在执行过程中，需要协作同步。不同进程的线程间要利用消息通信的办法实现同步。
5. 关于UNIX操作系统的描述中，错误的是()。 C
A. 属于多用户操作系统 （正确，UNIX是属于多用户操作系统）
B. 由内核与外壳组成 （正确）
C. 内核的操作原语对硬件不起作用 （错误）
D. 主要用C语言写成 （正确，UNIX操作系统的底层是C写的。）
6. 请分别描述信号量和互斥锁的异同，并对使用场景进行举例。
“信号量用在多线程多任务同步的，一个线程完成了某一个动作就通过信号量告诉别的线程，别的线程再进行某些动作（大家都在semtake的时候，就阻塞在 哪里）。而互斥锁是用在多线程多任务互斥的，一个线程占用了某一个资源，那么别的线程就无法访问，直到这个线程unlock，其他的线程才开始可以利用这 个资源。比如对全局变量的访问，有时要加锁，操作完了，在解锁。有的时候锁和信号量会同时使用的”
也就是说，信号量不一定是锁定某一个资源，而是流程上的概念，比如：有A,B两个线程，B线程要等A线程完成某一任务以后再进行自己下面的步骤，这个任务 并不一定是锁定某一资源，还可以是进行一些计算或者数据处理之类。而线程互斥量则是“锁住某一资源”的概念，在锁定期间内，其他线程无法对被保护的数据进 行操作。在有些情况下两者可以互换。
两者之间的区别:
作用域
信号量: 进程间或线程间(linux仅线程间的无名信号量pthread semaphore)
互斥锁: 线程间
上锁时
信号量: 只要信号量的value大于0，其他线程就可以sem_wait成功，成功后信号量的value减一。若value值不大于0，则sem_wait使得线程阻塞，直到sem_post释放后value值加一,但是sem_wait返回之前还是会将此value值减一
互斥锁: 只要被锁住，其他任何线程都不可以访问被保护的资源
互斥量和信号量的区别
1. 互斥量用于线程的互斥，信号量用于线程的同步。
这是互斥量和信号量的根本区别，也就是互斥和同步之间的区别。
互斥：是指某一资源同时只允许一个访问者对其进行访问，具有唯一性和排它性。但互斥无法限制访问者对资源的访问顺序，即访问是无序的。
同步：是指在互斥的基础上（大多数情况），通过其它机制实现访问者对资源的有序访问。在大多数情况下，同步已经实现了互斥，特别是所有写入资源的情况必定是互斥的。少数情况是指可以允许多个访问者同时访问资源
2. 互斥量值只能为0/1，信号量值可以为非负整数。
也就是说，一个互斥量只能用于一个资源的互斥访问，它不能实现多个资源的多线程互斥问题。信号量可以实现多个同类资源的多线程互斥和同步。当信号量为单值信号量是，也可以完成一个资源的互斥访问。
3. 互斥量的加锁和解锁必须由同一线程分别对应使用，信号量可以由一个线程释放，另一个线程得到。
7. 请列出至少三种TCP拥塞控制机制，并请就其中一种描述其工作原理。
四种拥塞控制算法分别是：慢启动，拥塞控制，快重传和快恢复。
TCP 主要通过四种算法来进行拥塞控制：慢开始、拥塞避免、快重传、快恢复。
发送方需要维护一个叫做拥塞窗口（cwnd）的状态变量，注意拥塞窗口与发送方窗口的区别：拥塞窗口只是一个状态变量，实际决定发送方能发送多少数据的是发送方窗口。
为了便于讨论，做如下假设：
- 接收方有足够大的接收缓存，因此不会发生流量控制；
- 虽然 TCP 的窗口基于字节，但是这里设窗口的大小单位为报文段。
1. 慢开始与拥塞避免
发送的最初执行慢开始，令 cwnd=1，发送方只能发送 1 个报文段；当收到确认后，将 cwnd 加倍，因此之后发送方能够发送的报文段数量为：2、4、8 ...
注意到慢开始每个轮次都将 cwnd 加倍，这样会让 cwnd 增长速度非常快，从而使得发送方发送的速度增长速度过快，网络拥塞的可能也就更高。设置一个慢开始门限 ssthresh，当 cwnd >= ssthresh 时，进入拥塞避免，每个轮次只将 cwnd 加 1。
如果出现了超时，则令 ssthresh = cwnd/2，然后重新执行慢开始。
2. 快重传与快恢复
在接收方，要求每次接收到报文段都应该对最后一个已收到的有序报文段进行确认。例如已经接收到 M1 和 M2，此时收到 M4，应当发送对 M2 的确认。
在发送方，如果收到三个重复确认，那么可以知道下一个报文段丢失，此时执行快重传，立即重传下一个报文段。例如收到三个 M2，则 M3 丢失，立即重传 M3。
在这种情况下，只是丢失个别报文段，而不是网络拥塞。因此执行快恢复，令 ssthresh = cwnd/2 ，cwnd = ssthresh，注意到此时直接进入拥塞避免。
慢开始和快恢复的快慢指的是 cwnd 的设定值，而不是 cwnd 的增长速率。慢开始 cwnd 设定为 1，而快恢复 cwnd 设定为 ssthresh。
8. 5个PM和3个QA围一圆桌而坐，只考虑每个人左边和右边是谁，要求3个QA互不相邻，问有多少种坐法。
1440 ; 思路分析：先放5个PM ，然后基于他们剩下的可坐位置对QA进行分配。
先5个人坐，考虑方向问题，以其中一个为最左边，所有元素在其右边排列，应该有种排法
然后1 @ 2@3@4@5@
有5个@位可以用来选择放3个QA 选择3个位子，有种选择
然后三个QA之间的顺序有中排法
综合有24*10*6=1440
9. 4个RD来到公司并将雨伞留在门外，下班时他们每人随机带走一把雨伞，问所有人都拿错的概率。
所有分配的情况会是 ,
直接正面推倒： 1. 第一个人拿伞，有 3 种拿法(除自己的) 2. 第二个人拿伞，让这个人是被上次拿错伞的人，则其有 3 种拿法(随便拿) 3. 第三个人拿伞，让这个人是被上次拿错伞的人，则其只有一种拿法，才能使最后一拿错 因此 3 x 3 x 1 = 9 (分子)
所以最后的情况是： 9/24=3/8.
10. 给出平面上四个点A，B，C，D的坐标A(x1,y1),B(x2,y2),C(x3,y3),D(x4,y4)，请给出向量AB和CD共线的条件。
A:
AB的斜率是(y2-y1)/(x2-x1)
CD的斜率是(y4-y3)/(x4-x3)
则AB与CD共线的条件时 两者相等：(y2-y1)/(x2-x1) = (y4-y3)/(x4-x3)
11. 小明认为某些数字不吉利，付账时会尽可能少的多付一些钱，使得价格中不包含这些不吉利数字，并且不出现0.例如，不吉利数字为1，4，7，8，商品价格为1000，小明实际支付2222.实现程序，输入商品原来的价格price，不吉利数字集合unlucky_numbers，求小明付账时的价格lucky_price.
思路： 取出每一位的数字，从个位开始，不吉利就加1，注意进位，直到吉利。
或者累加，直到没有不吉利的数字为止，这是最小的符合条件的价格。
def get_lucky_price(price, unlucky_numbers):
new_unlucky_numbers = unlucky_numbers + [0]
price_list = [int(i) for i in str(price)]
inter_list = list(set(price_list).intersection(set(new_unlucky_numbers)))
if inter_list == []:
lucky_price = price
return lucky_price
else:
price += 1
return get_lucky_price(price, unlucky_numbers)
price = int(input())
unlucky_numbers = list(map(int, input().strip().split()))
print(get_lucky_price(price, unlucky_numbers))12. 一个一维维数组中只有1和-1，实现程序，求和为0的最长子串长度，并在注释中给出时间和空间复杂度。
def foo(arr):
dp = [0] * (len(arr) + 1)
dp[0] = 0
dp[1] = 0
for i in range(1, len(arr)):
if arr[i] == -arr[i - 1]:
dp[i + 1] = dp[i - 1] + 2
elif arr[i] == -arr[i - dp[i] - 1]:
dp[i + 1] = dp[i] + 2
else:
dp[i + 1] = 0
print(dp)
return max(dp)2019年猿辅导校招技术类笔试
1. 猿辅导公司某研发小组一共有 12 名同学，其中 9 人能做后端开发，6 人能做前端开发。现在要抽调 4 名同学成立项目小组，负责公司的一项“机密”项目。其中 2 名同学做后端开发，2 名同学做前端开发。有多少种选派方法？
(1)仅会后端:6个人；
(2)仅会前端:3个人；
(3)既会后端又会前端:3个人;
一.从(1)和(2)分别挑两个人，C(2,6)*C(2,3)=15*3=45;
二.从(3)挑1个放前端，有C(1,3)*C(1,3)*C(2,6) = 135; 挑一个放后端,有C(1,3)*C(1,6)*C(2,3)=54;
三.从(3)挑2个放前端,有C(2,3)*C(2,6)=45; 挑2个放后端,有C(2,3)*C(2,3)=9; 1前1后，有C(2,3)*C(1,2)*C(1,3)*C(1,6)=108;
四.从(3)全部选择，2前端,1后端,C(2,3)*C(1,6)=18; 1前端,2后端,有C(2,3)*C(1,3)=9;
全部相加:45+135+54+45+9+108+18+9=423
2. 关于数据库，以下描述错误的是 D
A. 任意两行的主键值都不相同 （YES）
B. 主键列不允许NULL值 （YES）
C. 表可包含多个唯一约束，但每个表只允许一个主键 （YES）
D. 唯一约束列不允许NULL值 (错误，可以含有NULL值; 唯一键可以包含NULL值，并且每个NULL值都是唯一的（即NULL！=NULL） -- 《Effective MySQL之SQL语句最优化》 )
补充解释：
一个表中可以有多个字段声明为 UNIQUE ，但只能有一个 PRIMARY KEY 声明；
声明为 PRIMARY KEY 的列不允许有空值，但是声明为 UNIQUE 的字段允许空值的存在。
3. 有一个虚拟存储系统，若进程在内存中占 3 页，开始内存为空。若采用 LRU 页面淘汰算法，当执行如下访问页号序列 [1，2，3，4，1，2，5，1，2，3，5，4] 会产生多少次缺页？ 10此缺页 （没懂）
解释：
FIFO
1.访问1，缺页，内存中1，，；
2.访问2，缺页，内存中1,2，；
3.访问3，缺页，内存中1,2,3；
4.访问4，缺页，内存中2,3,4；
5.访问1，缺页，内存中3,4,1；
6.访问2，缺页，内存中4,1,2；
7.访问5，缺页，内存中1,2,5；
8.访问1，不缺页，内存中2,5,1；
9.访问2，不缺页，内存中5,1,2；
10.访问3，缺页，内存中1,2,3；
11.访问5，缺页，内存中2,3,5；
12.访问4,缺页，内存中3,5,4；
共10次缺页，注：超出缓存上限时，删除的时最先访问的，最近访问的保留。
4. 假设解决某问题的算法复杂度为F(n)，其中n为问题规模，该问题总是可以通过g(n)的代价划分为2个规模为n/2的同类子问题，即F(n)=2F(n/2)+g(n),当g(n)为O(n)，时F(n)为多少？ O( n log n )
其实就是归并排序，折半，合并，合并是 O(N)，但是会发生 O(logN) 次折半，也就是 O(NlogN)
5. 猿辅导公司某部门月会上，有 5 名同学在依次领取入职周年的礼物，一束鲜花。HR 共准备有 5 种不同颜色的鲜花供他们挑选。则有且仅有两名同学挑选了相同颜色的鲜花的概率是多少？ 48/125
解析： 共有5*5*5*5*5=3125种情况，再算有且只有两个人选同一种颜色的情况， 1.选出两个人; 2.选同一种颜色有5种情况; 3.其他3个人从剩下4种颜色选：4*3*2=24. 共有10*5*24=1200 概率为1200/3125=48/125.
6.
给定 yfd_interviewer 数据库表结构如下：
| 1 2 3 4 5 6 7 8 9 10 |
|
给定以下SQL：
S1: SELECT * FROM `yfd_interviewer` WHERE name = ‘kebi’;
S2: SELECT * FROM `yfd_interviewer` WHERE age = 20;
S3: SELECT * FROM `yfd_interviewer` WHERE name = ‘kenan’ AND age = 20;
S4: SELECT * FROM `yfd_interviewer` WHERE age = 20 AND name = ‘kenan’;
以下关于索引使用描述不正确的是哪个？D
A.S1 可能使用索引 name_index
B.S2 可能使用索引 age_index
C.S3 可能使用索引 name_index 或 age_index
D.相比S3，S4 会优先使用 age_index (WHER筛选条件中AND没有先后顺序之分)
7. 关于 HTTP 协议，下列说法错误的是 C
A. HTTP 是无状态协议
B.HTTP 是应用层协议
C.HTTP 是基于二进制的协议(HTTP超文本协议当然是基于文本的协议)
D. HTTP 状态码 200 表示成功
补充： HTTP协议（超文本协议）是无连接、无状态的基于文本的应用层协议，HTTP Status Code（HTTP 状态码）分别有1**，2**，3**，4**，5**开头的，分别表示不同的含义，其中2**表示连接成功。
8. 关于进程和线程，下列说法错误的是 B
A. 同一进程内的线程共享内存等系统资源 （正确）
B.进程之间不能通信（进程之间是可以通信的，依据信号量……，但是一般不能相互进行访问。）
C.进程有独立的虚拟地址空间 （正确）
D.线程可以创建另外一个线程 （正确）
补充解释： 进程间通信（IPC，InterProcess Communication）是指在不同进程之间传播或交换信息。 IPC的方式通常有管道（包括无名管道和命名管道）、消息队列、信号量、共享存储、Socket、Streams等。其中 Socket和Streams支持不同主机上的两个进程IPC。
进程之间可以进行通信，虽然一般是不能互相访问的，但是有特殊情况，共享内存区就是唯一的例外。
9. 将 A B C D 四个元素次序进栈（中间可能有出栈操作，例如 A 进栈后出栈，B 再进栈），则可能的出栈系列是 B D C A
栈的规则是先进后出(FILO)
10. 关于 TCP 协议，下列说法错误的是 B
A. TCP 是面向连接的协议
B.TCP 是基于数据报文的协议 （错误， TCP是面向连接的，可靠的，基于字节流的传输层协议，提供四种拥塞控制的方法。)
C. TCP 提供了拥塞控制的机制
D.TCP 属于传输层协议
补充：
TCP是面向连接的，可靠的，基于字节流的传输层协议，提供四种拥塞控制的方法 :慢开始、拥塞避免、快重传、快恢复四种。
HTTP协议（超文本协议）是无连接、无状态的基于文本的应用层协议，HTTP Status Code（HTTP 状态码）分别有1**，2**，3**，4**，5**开头的，分别表示不同的含义，其中2**表示连接成功。
UDP才是基于数据报文的协议
11. 在线编程题1
某天猿辅导 HR 组织大家去漂流，早上，参加团建的同学都到齐了，并且按到达公司的先后顺序排好队了。 由于员工太多，一个大巴车坐不下，需要分多个车，车是足够的，但所有人需要按一定顺序上车，按如下规则安排上车的顺序：
假设大巴车容量为 m，从队首开始，每 m 个人分成一个小组，每个小组坐一辆车。同时只有一个车打开车门供员工上车。 小组之间按从队尾到队首顺序依次上车，同一小组内先到的同学先上，求所有人上车的顺序。
例如： 员工数 8， 车容量 3， 员工到达顺序为 1 2 3 4 5 6 7 8， 3个人一个小组，分三个小组， 小组一： 1， 2， 3， 小组二： 4， 5， 6，小组三： 7，8。 小组上车顺序为： 小组三，小组二，小组一 。 所有员工上车顺序为 7 8 4 5 6 1 2 3
分析思路： 首先对员工序列A=[ 1 2 3 4 5 6 7 8],根据车容量m(3)进行分割成多个小列表，然后放在一张大列表中(该子元素是列表)；然后从后往前打印该张大列表中的元素，注意在具体打印子元素列表中的元素时，打印之后要删除，并注意打印的方法(有空格)。
n, m = map(int, input().strip().split()) # n 员工人数， m 大巴容量
A = list(map(int, input().strip().split()))
res = []
for i in range (0, n, m):
res.append(A[i:i+m])
res1 = ''
for i in range(1, len(res)+1):
a = res[-i]
while a :
res1 += str(a[0])
res1 += str(' ')
del a[0]
print(res1)12.
猿辅导公司的 N位（N>=4）研发同学组织了一次秋游活动，某同学带了个无人机在高空拍照，活动结束时，先拍了一张所有同学排成公司猴头Logo的照片， 接着有人提议再排成“猿”的首字母Y字形来拍一张合照。
用字符串中的每一个字符（不是换行符或结束符'\0'）代表一位老师，输出排好后的队形。要求 Y字除去中心点外，上下半部分等高，按照从左到右，从上到下进行排序。队形中没人的部分用空格占位。
输入数据保证可以排出一个完整的Y字，即长度为 3k+1 （k>=1）
例如: 7个 x ，排成队形为（为了方便说明，这里用‘-’代替空格）：
x---x
-x-x
--x
--x
--x
还有其它例子：
观察上面的例子可以发现有如下的规律：
k =(N-1)//3
* 将空格算在内， 每行有2k+1个元素， 前面k行中每行有2个来自于原字符串A的元素，总共有2k-1个空格。
* 一共有2k+1行元素，前面k行print一次，后面k+1按照另一种规则进行打印。
* i 从0到k-1进行遍历打印前k行时， 想应的中间空格有2k-1-2*i个。
* 注意每行打印格式。
N = int(input())
A = [i for i in input()]
k = (N - 1) // 3
for i in range(int(k)):
print(str(' ')*int(i) + str(A[0]) + str(' ')*int(2*k-1-2*i) + str(A[1]) + str(' ')*int(i))
del A[0]
del A[0]
while A:
print(str(' ')*int(k) + str(A[0]) + str(' ')*int(k))
del A[0]但自己在本地调试时，是正确的：
N = 10
A = ['i', 'i', 'i', 'i', 'i', 'i', 'i', 'i', 'i', 'i']
k = (N - 1) // 3
for i in range(int(k)):
print(str('-')*int(i) + str(A[0]) + str('-')*int(2*k-1-2*i) + str(A[1]) + str('-')*int(i))
del A[0]
del A[0]
while A:
print(str('-')*int(k) + str(A[0]) + str('-')*int(k))
del A[0]
# 结果：
i-----i
-i---i-
--i-i--
---i---
---i---
---i---
---i---
3338
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
