Algorithm practice - 2

1、多组输入（ C 语言）

求A^B的最后三位数表示的整数。
Input : 输入数据包含多个测试实例，每个实例占一行，由两个正整数A和B组成（1<=A,B<=10000），如果A=0, B=0，则表示输入数据的结束，不做处理。
Output : 对于每个测试实例，请输出A^B的最后三位表示的整数，每个输出占一行。

多组输入指的是每次输入一组数据后，程序可以立即做出解答

#include <stdio.h>int main () {int a = 1 ,b = 1;while (1){scanf("%d %d",&a,&b);if(a == 0 && b == 0){break;}if(a != 0 && b == 0){printf("1\n");}else if(a == 0 && b != 0){printf("0\n");}else{int sum = 1;int i;for (i = 0; i < b;i ++){sum = sum * a % 1000;}printf("%d\n", sum);}}return 0;
}

2、大鱼吃小鱼（C语言）

有N条鱼每条鱼的位置及大小均不同，他们沿着X轴游动，有的向左，有的向右。游动的速度是一样的，两条鱼相遇大鱼会吃掉小鱼。从左到右给出每条鱼的大小和游动的方向（0表示向左，1表示向右）。问足够长的时间之后，能剩下多少条鱼？
Input : 第1行：1个数N，表示鱼的数量(1 <= N <= 100000)。第2 ~ N+1行：每行两个数Ai, Bi，中间用空格分隔，分别表示鱼的大小及游动的方向(1 <= Ai <= 10^9，Bi = 0或1）。
Output : 输出1个数，表示最终剩下的鱼的数量。
Sample Input :
5
4 0
3 1
2 0
1 0
5 0
Sample Output : 2

利用栈进行操作。栈为空的情况下，对向左的鱼不做操作，因为后面的鱼无论是向左还是向右，这条鱼永远不可能被吃或者吃别的鱼；遇到向右的鱼进栈，再次遇到向左的鱼a时，在栈不空的情况下进行比较，若a比栈顶的鱼大，则在栈不空的情况下继续比较站内的鱼，若a比栈顶的鱼小，则栈顶吃掉a，继续遍历输入的鱼

#include <stdio.h>int main () {int a = 1 ,b = 1;while (1){scanf("%d %d",&a,&b);if(a == 0 && b == 0){break;}if(a != 0 && b == 0){printf("1\n");}else if(a == 0 && b != 0){printf("0\n");}else{int sum = 1;int i;for (i = 0; i < b;i ++){sum = sum * a % 1000;}printf("%d\n", sum);}}return 0;
}

3、蚂蚁爬行（python）

n只蚂蚁以每秒1cm的速度在长为Lcm的竿子上爬行。当蚂蚁爬到竿子的端点时就会掉落。由于竿子太细，两只蚂蚁相遇时，它们不能交错通过，只能各自反向爬回去。对于每只蚂蚁，我们知道它距离竿子左端的距离xi，但不知道它当前的朝向。请计算各种情况当中，所有蚂蚁落下竿子所需的最短时间和最长时间。
例如：竿子长10cm，3只蚂蚁位置为2 6 7，最短需要4秒(左、右、右)，最长需要8秒（右、右、右）。

Input : 第1行：2个整数N和L，N为蚂蚁的数量，L为杆子的长度(1 <= L <= 10^9, 1 <= N <= 50000) 第2 - N + 1行：每行一个整数Ai，表示蚂蚁的位置(0 < Ai < L)
Output : 输出2个数，中间用空格分隔，分别表示最短时间和最长时间。
Sample Input :
3 10
2
6
7
Sample Output : 4 8

1、最短时间：以整个杆子中间为界，左右两边的蚂蚁分别向两边爬
2、最长时间：最靠近杆子中间的那只蚂蚁，向距离其最远的端点爬行

n,l = map(int,input().split())
li1 = []
minl = 0
maxl = 0
for i in range(n):li1.append(int(input().split()[0]))
li = list(set(li1))
li.sort()
if len(li) == 1:l1 = li[0]l2 = l - li[0]if l1 <= l2 :minl = l1,maxl = l2else:minl = l2,maxl = l1
else:for i in range(n):if li[i] >= l/2 :breakmin1 = li[i-1]min2 = l - li[i]if min1 <= min2:minl = min2else :minl = min1max1 = l-li[0]max2 = li[len(li) - 1]if max1 <= max2 :maxl = max2else : maxl = max1
print(str(minl) + ' ' + str(maxl))

4、1 10 100 （python）

1,10,100,1000…组成序列1101001000…，求这个序列的第N位是0还是1。
Input : 第1行：一个数T，表示后面用作输入测试的数的数量。（1 <= T <= 10000) 第2 - T + 1行：每行1个数N。（1 <= N <= 10⁹)
Output : 共T行，如果该位是0，输出0，如果该位是1，输出1。
Sample Input :
3
1
2
3
Sample Output :
1
1
0

利用等差数列求和的思想，每一行的第一个数字是1，其余数字都是0，只需判断第n位是在哪一行即可。

t = int(input().split()[0])
for i in range(t) :n = int(input().split()[0])j = int((2*n) ** 0.5)sn = int(j*(j+1)/2)while sn < n :j += 1sn += jif n == sn-j+1 :print(1)else :print(0)

5、仙人球残影 (C语言)

在美丽的HDU，有一名大三的同学，他的速度是众所周知的，跑100米仅仅用了2秒47，在他跑步过程中会留下残影的哎，大家很想知道他是谁了吧，他叫仙人球，既然名字这样了，于是他的思想是单一的，他总是喜欢从一点出发，经过3次转折（每次向右转90°），回到出发点，而且呢，他每次转折前总是跑相同长度的路程，所以很多人都想知道如果用‘1’算他跑步出发的第一个残影的话，那么回到起点的时候，他的残影是怎么样的呢？
Input : 测试数据有多行，每一行为一个数N(1<=N<=10)(以0结尾,0不做处理)，即仙人球在没有回到起点的时候，跑过留下N个残影后突然90°右转。
Output : 每组测试数据输出一个结果，并且每个残影的计数位长度为3个字符长度。（当然N等于1的话，它的结果也是占用3个字符位置的）
Sample Input : 4
Sample Output :

仙人球顺时针行走，最后输出是一个正方形，每条边有n个数。一共有2n+(n-2)2 = 4(n-1)个数，四条边分别计算，分别从左上、右上、右下、左下顺时针行走每条边，循环n次，每次加1。左上[0,0]，值为1；右上[0,n-1]，值为n；右下 [n-1,n-1]，值为 2n-1；左下[n-1,0] ，值为4(n-1) 。

#include <stdio.h>int main () {int n;scanf("%d",&n);int a[10][10] = {0};while(n != 0){if(n == 1){printf("%3d",1);}else{int num = 4*(n-1),i,j;int top = 1;int right = n;int bottom = 2*n-1;int left = num-n+2;for(i = 0;i < n-1;i ++ ){a[0][i] = top + i;a[i][n-1] = right + i;a[n-1][n-1-i] = bottom + i;a[n-1-i][0] = left +i;}for(i = 0;i < n;i ++){for(j = 0;j < n;j ++){if(a[i][j] == 0){printf("   ");}else{printf("%3d",a[i][j]);a[i][j] = 0;}}printf("\n");}}scanf("%d",&n);}return 0;
}

6、上台阶（python）

现在小瓜想走上一个一共有n级的台阶，由于小瓜的腿比较短，他一次只能向上走1级或者2级台阶。小瓜想知道他有多少种方法走上这n级台阶，你能帮帮他吗？
Input : 一行一个整数n（n<=100000），表示一共有n级台阶。
Output : 一行一个整数，表示小瓜上台阶的方案数对100003取余的结果。
Sample Input : 3
Sample Output : 3

采用动态规划的思想，最后到达第n级台阶前或者走1级台阶或者走2级台阶，以此类推，第n-1级、n-2级台阶……以此类推。将每次算得的数放在数组中方便计算。

n = int(input().split()[0])
li = []
li.append(1)
li.append(2)
for i in range(2,n):li.append((li[i-1]+li[i-2])%100003)
print(li[n-1])