编程练习题

笑大爷

已于 2023-08-17 10:31:49 修改

阅读量746

点赞数 2

文章标签： python 算法开发语言

于 2023-04-19 18:27:05 首次发布

本文链接：https://blog.csdn.net/qq_44645338/article/details/130249455

版权

乐博乐博柚子老师整理

一、python

求1到N之间的奇数

int(input())+1:输入转整型，
因为顾前不顾后，所以要加一，前面的奇数加2等于后面的奇数,所以步长为2

for i in range(1, int(input()) + 1, 2): print(i)

排序问题（可对单词、字母、数字排序）

使用sorted函数来对目标进行排序，默认是从小到大排序，
如果想从大到小那么就要，在后面加上，reverse=True

# 升序
print(','.join(sorted(map(str,input().split()))))
# 降序
print(','.join(sorted(map(str,input().split()),reverse=True)))

找出最大最小值

# 最大值
print(max(map(str,input().split())))
# 最小值
print(min(map(str,input().split())))

输入数字N,从1-N能组成多少个互不相同且无重复数字的三位数？各是多少？

使用python内置模块itertools中的permutations，来对元素遍历进行全排列
后面的数字为从中选几个元素来进行排列

from itertools import permutations

for i in permutations(map(str, input().split()), 3): print(''.join(i))

输出100到999之间的水仙花数

水仙花数指的是百十个位数的三次方加起来正好等与这个数的本身
比如153=1³+5³+3³
样例输出：
153
370
371
407

for i in range(100,1000):
    s=str(i)
    if int(s[0])**3+int(s[1])**3+int(s[2])**3==i:print(i)

6.输出第N个斐波那契数列

斐波那契数列是典型的递归问题，这种类型的题目主要是第n相与n的前几项有关，
样例输入：
10
样例输出：
55

# 斐波那契数列：1 1 2 3 5 8 13 21... F(n)=F(n-1)+F(n-2)
first=1 #第一项
second=1# 第二项

# 求第n项
for i in range(int(input())-2):
	# 下一个数就是前面两个数相加
    next=first + second
    print(next)
    # 开始进行下一次迭代
    # 第一个变第二个
    first=second
    # 第二个变第三个，以此类推
    second=next

计算N的阶乘

计算一些基本的数学题，基本上用到的都是math模块，调用factorial函数直接计算阶乘

import math
print(math.factorial(int(input())))

输出1000到9999之间的回文数

回文数就是数字正着读，反着读都是一样的，比如12321，121等
判断是否是回文数首先要把数字一个一个的拆开，比如123 我们转化成字符串就是‘1’，‘2’，‘3’，最后呢我们给他取反，比较一下原来的数字是不是等于它取反后的数字，如果等于那就是回文数
样例输出：
1001
1111
1221
1331
1441
1551
1661
1771
1881
1991
2002
2112
2222
2332
2442
2552
2662
2772
2882
2992
3003
3113
3223
3333
3443
3553
3663
3773
3883
3993
4004
4114
4224
4334
4444
4554
4664
4774
4884
4994
5005
5115
5225
5335
5445
5555
5665
5775
5885
5995
6006
6116
6226
6336
6446
6556
6666
6776
6886
6996
7007
7117
7227
7337
7447
7557
7667
7777
7887
7997
8008
8118
8228
8338
8448
8558
8668
8778
8888
8998
9009
9119
9229
9339
9449
9559
9669
9779
9889
9999

for i in range(1000, 10000):
    if str(i) == str(i)[::-1]: print(i)

问题描述
给出一个包含n个整数的数列，问整数a在数列中的第一次出现是第几个。
输入格式
第一行包含n个非负整数，为给定的数列，数列中的每个数都不大于10000。
第二行包含一个整数a，为待查找的数。
输出格式
如果a在数列中出现了，输出它第一次出现的位置(位置从1开始编号)，否则输出-1。
样例输入
1 9 4 8 3 9
9
样例输出
2 6

判断数字是否存在，那么我们就需要把我们输入的数字存入列表里面，然后遍历这个列表的长度，列表里面有5个数字我们就遍历5次，有三个就遍历三次，之后我们就对列表里面的元素挨个比较，如果和输入的n相同的话那就把序号打印下来，因为列表是从0开始的，所以我们的索引值要加一

nums = list(map(str, input().split()))
n = input()
for i in range(len(nums)):
    if nums[i] == n:
        print(i+1,end=" ")

给定一个以秒为单位的时间t，要求用 “< H> :< M> :< S> ”的格式来表示这个时间。< H> 表示时间，< M> 表示分钟，而< S> 表示秒，它们都是整数且没有前导的“0”。例如，若t=0，则应输出是“0:0:0”；若t=3661，则输出“1:1:1”。
输入
输入只有一行，是一个整数t（0< =t< =86399）。
输出
输出只有一行，是以“< H> :< M> :< S> ”的格式所表示的时间，不包括引号。
样例输入
5436
样例输出
1:30:36

这题就是秒分时之间的换算，没啥讲的

n = int(input())
h = n // 3600
m = n % 3600 // 60
s = n % 3600 % 60
print(h, ':', m, ':', s, ':')

阿里巴巴走进了装满宝藏的藏宝洞。藏宝洞里面有N(N <100)堆金币，第i堆金币的总重量和总价值分别是m;, v;(1 < m;,u;≤ 100)。阿里巴巴有一个承重量为T(T <1000)的背包，但并不一定有办法将全部的金币都装进去。他想装走尽可能多价值的金币。所有金币都可以随意分割，分割完的金币重量价值比(也就是单位价格）不变。请问阿里巴巴最多可以拿走多少价值的金币?
输入格式
第一行两个整数N,T。
接下来N行，每行两个整数m, v.
输出格式
—个实数表示答案，输出两位小数
输入样例
4 50
10 60
20 100
30 120
15 45
输出样例
240.00

经典的背包问题：
遇到输入一个二维列表怎么办，就是像这题一样输入一个表格，这有一套模板死记硬背就行,但是也要根据实际情况做出相应的更改
n, m = map(int, input().split()) # 定义几行几列
lst=[] # 定义一个数组存放表格数据
for _ in range(n) :#对每一行进行遍历，（行是你输入空格的次数，列是你输入元素的个数·
temp = list(map(int, input().split())) # 循环n次输入的列表数据
lst.append(temp) # 把我们输入的数据存储到列表里面去
以上就是输入表格的模板，万变不离其宗
比如这道题目就是输入一个n行两列的表格，但是我们不仅需要把数据存到列表里面去，我们还需要把性价比存到里面去，肯定是性价比越高的放在背包里面越划算，所有我们的列表就存储：m,v,v/m三个参数，因为是三个为一组，所以我们需要用元组存储起来

# 定义金币有几堆，和背包容量
n, t = map(int, input().split())
# 定义列表存储质量、价值、性价比的数据
lst = []
# 循环遍历行，循环输入数据
for i in range(n):
	# m:是质量，v代表价值
    m, v = map(int, input().split())
    # 往列表里添加质量、价值、性价比
    lst.append((m, v, v / m))
# 性价比越大越好，性价比是最后一个，所有我们要对最后一个进行排序
# sort和sorted要分清，sort是属性、方法，而sorted是一个内置函数# sort可以对原列表进行修改，而sorted不会修改原列表
# reverse=True从大到小排序，没有就默认从小到大
# key=lambda x: x[-1] 利用匿名函数的方法找到最后一个进行排序
lst.sort(key=lambda x: x[-1], reverse=True)
# 定义背包剩余容量
surplus = t
# 定义背包内的总价值
sumValue = 0
# 循环拿金子
for i in range(n):
	# 如果金币的重量比背包的剩余容量小
    if lst[i][0] <= surplus:
    	# 剩余容量-金币的重量
        surplus -= lst[i][0]
        # 背包里面的总价值就加上金币的价值
        sumValue += lst[i][1]
    # 如果背包的容量放不下金币了
    else:
    	# 那么就把一部分的金币放进背包，一点空间也不浪费
        sumValue += surplus * lst[i][-1]
        # 结束循环
        break
# 打印总价值
print('%.2f'%sumValue)

有一片区域，0代表海域，1代表陆地，用编程实现有多少独立存在的陆地（独立存在即陆地上下左右都被海域包围，范围之外全部默认为是海域）

def dfs(lst, i, j):
    if not 0 <= i < len(lst) \
            or not 0 <= j < len(lst[0]) \
            or not lst[i][j] == 1:
        return

    lst[i][j] = 0
    dfs(lst, i + 1, j)
    dfs(lst, i - 1, j)
    dfs(lst, i, j - 1)
    dfs(lst, i, j + 1)


# n行m列
n, m = map(int, input().split())
lst = []
count = 0
for _ in range(n):
    temp = list(map(int, input().split()))
    lst.append(temp)

for i in range(n):
    for j in range(m):
        if lst[i][j] == 1:
            count += 1
            dfs(lst, i, j)
print(count)

背包问题

# n:总行数，t:背包容量
n, t = map(int, input().split())
lst = []
for _ in range(n):
    # m:重量，v:价值
    m, v = map(int, input().split())
    lst.append((m, v, v / m))
lst.sort(key=lambda x: x[-1], reverse=True)
surplus = t  # 剩余重量
sumValue = 0  # 总价值
for i in range(n):
    # 物品是不是比剩余容量小
    if lst[i][0] <= surplus:
        surplus -= lst[i][0]
        sumValue += lst[i][1]
    else:
        print(sumValue)

统计字符个数

n = input()
# 统计字母个数
print(sum(1 for i in n if i.isalpha()))
# 统计空格个数
print(sum(1 for i in n if i.isspace()))
# 统计数字个数
print(sum(1 for i in n if i.isdigit()))
# 统计其他个数
print(sum(1 for i in n if not i.isdigit() \
          and not i.isalpha() \
          and not i.isspace()))

计算约数

输入：
10
输出：
2
5

n = int(input())
for i in range(2, n):
    if n % i == 0:
        print(i)

判断2020以内包含多少个2（不是统计含有2的数字）

count = 0
for i in range(1, 2021):
    count += (str(i).count('2'))
print(count)

编写一个程序，计算并输出1到n之间所有偶数的和。

使用列表推导式解决此问题非常方便：
[i for i in range()]表示在某个范围内遍历所有数字，然后结果返回给第一个变量i，这样的话，列表里面就有1~n所有的数字
int(input())+1相当于输入n，因为for循环顾前不顾后原则，并不会拿到n本身，所以要加一
最后使用sum函数相加即可
输入：
100
输出：
2500

print(sum([i for i in range(1, int(input())+1, 2)]))

编写一个程序，从用户输入的数据中删除所有数字

输入：
hello123
输出：
hello

result = ''  # 定义一个变量接受字符串
for i in input():  # 在输入的字符里面遍历
    if not i.isdigit():  # 如果不是数字的话：
        result += i  # 把i加到里面去
print(result)  # 全部遍历完后打印结果

有两只兔子，三个月可繁殖三只小兔子，小兔子在三个月后又可以繁殖，假设无死亡的前提下，第n个月后有几只兔子

由题意可知，兔子每三个月就会生一窝小兔子，那么3、6、9、12…个月后就会生一窝，
由此可知第n个月就会生n//3窝兔子，取整数，余数舍掉
每次生小兔子的时候都要把前面的机智大兔子加上，所以递推公式为：i=i+(3xi) i为兔子的总数

# 初始两只兔子
x = 2
# 输入月份
n = int(input())
# 月份对三整除，结果是繁殖的次数
n1 = n // 3
# 对兔子繁殖几次进行遍历
for i in range(n1):
    # 公式
    x += (3 * x)
print(x)

输入一组数字，用空格隔开，计算这一组数字两两相加，哪个和离12最接近（可以等于，必须是两个数字相加）

# 输入数组
lst = list(map(int, input().split()))
# 定义一个列表，存放所有结果的和
nums=[]
# 在定义一个列表存放所以满足条件的和
result=[]
# 定义慢指针，定义渠道的数i，i不能取最后一个数
for i in range(len(lst)-1):
    # 定义快指针,取i后面的那个数
    # 当快指针走完一圈后，慢指针才加一
    for j in range(i+1,len(lst)):
        sum=int(lst[i])+int(lst[j])
        nums.append(sum)
# 对所有的和进行遍历，找到两数和绝对值最接近12的
for i in range(len(nums)):
    s=abs(12-nums[i])
    result.append(s)
print(sorted(result)[0])

观察下面的现象，某个数字的平方，按位累加仍然等于自身，
比如：1³=1 8³=512 5+1+2=8 17³=4193 4+9+1+3=17…
请你计算包括1，8，17在内，符合这个性质的正整数一共有多少个

# 8^3=512 5+1+2=8
n = 1
while True:
    t = sum(list(map(int, str(n ** 3))))
    if t == n:
        print(t)
    n += 1

有一组连续正整数，随机乱序后生成一组数据后，小蓝不小心删掉了其中一个数，已知所删掉的这个数
不是这组数据中最小的也不是最大的，现在请你编写程序帮助小蓝找到删除的那个数。

输入描述：
按照“编程实现”中的描述模仿输入一组这样的正整数数（正整数之间以英文逗号隔开），在输入的时候少
一个数（这个数不是这组数据中最小的也不是最大的），这个数作为小蓝删除掉的那个数，且加上小蓝删除的那个数这组数据是连续的
输出描述：输出删除掉的是哪个数

样例输入： 3,2,4,6,7
样例输出： 5

n = sorted(list(map(int, input().split(','))), reverse=True)
for i in range(1, len(n) + 1):
    if n[i] - 1 != n[i + 1]:
        print(n[i] - 1)
        break

n皇后问题

n = 8
lst = [0 for i in range(n)]
flag = [0 for i in range(n)]
d1 = [0 for i in range(2 * n - 1)]
d2 = [0 for i in range(2 * n - 1)]
count = 0


def label(lst):
    for i in range(n):
        for j in range(n):
            if lst[i] == j:
                print('*', end=' ')
            else:
                print('0', end=' ')
        print()


def search(row):
    global count
    for col in range(n):
        if flag[col] == 0 and d1[row + col] == 0 and d2[row - col + n - 1] == 0:
            lst[row] = col
            flag[col] = 1
            d1[row + col] = 1
            d2[row - col + n - 1] = 1
            if row < n - 1:
                search(row + 1)
            else:
                count += 1
                print()
                label(lst)
            flag[col] = 0
            d1[row + col] = 0
            d2[row - col + n - 1] = 0


search(0)
print(count)

找出两个数的最大公因数

n = int(input())
m = int(input())
lst1 = []
lst2 = []
for i in range(1, n + 1):
    if n % i == 0:
        lst1.append(i)
for i in range(1, m + 1):
    if m % i == 0:
        lst2.append(i)
# set(lst1) & set(lst2):转成集合用&符号连接可找出相同的元素
# set(lst1) - set(lst2):转成集合用-符号连接可找出不同的元素
print(sorted(list(set(lst1) & set(lst2)))[-1])

求最小公倍数

n = int(input())
m = int(input())
lst1 = []
lst2 = []
for i in range(1, m + 1):
    lst1.append(n * i)
for i in range(1, n + 1):
    lst2.append(m * i)
print(sorted(list((set(lst1) & set(lst2))))[0])

第二种蛇形填数

n, x, y, k = 6, 1, 0, 1
lst = [[0 for i in range(n+1)] for j in range(n+1)]
while k <= n ** 2:
    while y < n and lst[x][y + 1] == 0:
        lst[x][y + 1] = k
        y += 1
        k += 1
    while x < n and lst[x + 1][y] == 0:
        lst[x + 1][y] = k
        x += 1
        k += 1
    while y > 1 and lst[x][y - 1] == 0:
        lst[x][y - 1] = k
        y -= 1
        k += 1
    while x > 1 and lst[x - 1][y] == 0:
        lst[x - 1][y] = k
        x -= 1
        k += 1
for i in range(1, n + 1):
    for j in range(1, n + 1):
        print('{:>3}'.format(lst[i][j]), end='')
    print()

输入一行字符串，问可以组成多少组“ABC”

n = input()
A = 0
B = 0
C = 0
for s in n:
    if 'A' in s:
        A += 1
    elif 'B' in s:
        B += 1
    elif 'C' in s:
        C += 1
print(sorted((A, B, C))[0])

python实现：有n根胡萝卜分给三只兔子，要求每只兔子都能分到胡萝卜，并且第一只兔子的胡萝卜大于等于第二只兔子的胡萝卜，第二只兔子的胡萝卜必须大于等于第三只兔子的胡萝卜，问有多少种分配方法

def count_carrot_distributions(n):
    """给定胡萝卜的数量n，返回符合要求的分配方案数量"""
    count = 0  # 计数器，记录符合条件的方案数量

    for i in range(1, n - 1):  # 枚举第一只兔子分到胡萝卜的数量i
        for j in range(i, n - 1):  # 枚举第二只兔子分到胡萝卜的数量j（至少和第一只兔子一样多）
            k = n - i - j  # 第三只兔子分到的胡萝卜数量
            if k >= j:  # 必须满足第三只兔子分到的胡萝卜比第二只兔子多或等于
                count += 1

    return count


n = int(input())
count = count_carrot_distributions(n)
print(f"在{n}根胡萝卜分给三只兔子的情况下，共有{count}种分配方案")  # 输出结果为56

python实现：有N个客户，编号从1到N,到A，B,C三个串口办理业务，起初三个窗口为空闲状态，且A优先于B,B优先于C办理完业务后又重置到空闲状态，输入人数N,和每个人的等待时间，求哪个窗口排队时间最少

def shortest_waiting_window(num_people, wait_times):
    """给定每个窗口等待的人数和时间，返回等待时间最短的窗口编号（从0开始计数）"""
    A = B = C = 0  # 三个串口的等待时间

    for i in range(num_people):
        if A <= B and A <= C:
            total_wait_time = A + wait_times[i]
            A = total_wait_time
        elif B <= A and B <= C:
            total_wait_time = B + wait_times[i]
            B = total_wait_time
        else:  # C <= A and C <= B:
            total_wait_time = C + wait_times[i]
            C = total_wait_time

    min_time = min(A, B, C)
    if min_time == A:
        return "A"
    elif min_time == B:
        return "B"
    else:
        return "C"


num_people = 7
wait_times = [3, 5, 2, 4, 7, 1, 6]
min_index = shortest_waiting_window(num_people, wait_times)
print(f"窗口{min_index}的等待时间最短")  # 输出结果为窗口A的等待时间最短

二、 C++

编写一个程序，计算并输出1到100之间所有偶数的和。

#include <iostream>
using namespace std;

int main() {
    int sum = 0;
    for (int i = 2; i <= 100; i += 2) {
        sum += i;
    }
    cout  << sum << endl;
    return 0;
}

编写一个程序，找到一个数组中的最大值和最小值。

#include <iostream>
#include <climits>
using namespace std;

int main() {
    int arr[] = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5};
    int n = sizeof(arr) / sizeof(arr[0]);
    int max_num = INT_MIN;
    int min_num = INT_MAX;
    for (int i = 0; i < n; i++) {
        if (arr[i] > max_num) {
            max_num = arr[i];
        }
        if (arr[i] < min_num) {
            min_num = arr[i];
        }
    }
    cout << max_num << endl;
    cout << min_num << endl;
    return 0;
}

编写一个程序，判断一个字符串是否是回文字符串。

#include <iostream>
#include <string>
using namespace std;

int main() {
    string str;
    cout << "请输入字符串：";
    getline(cin, str);
    bool is_palindrome = true;
    int n = str.length();
    for (int i = 0; i < n / 2; i++) {
        if (str[i] != str[n - i - 1]) {
            is_palindrome = false;
            break;
        }
    }
    if (is_palindrome) {
        cout << "The string is a palindrome." << endl;
    } else {
        cout << "The string is not a palindrome." << endl;
    }
    return 0;
}

输入一个时间，计算离00：00：00过去了多少秒

#include<iostream>
using namespace std;
int main(){
	int h,m,s;
	scanf("%d %d %d",&h,&m,&s);
	printf("%d",(h*3600+m*60+s));
}

对数组中的元素进行排序
输入样例：
1 3 5 7 9 2 4 6 8 10
输出样例：
1 2 3 4 5 6 7 8 9 10

#include<iostream>
#include<algorithm> 
using namespace std;
int main(){
	int arry[10];//定义数组 
	for(int i=0;i<10;i++) cin>>arry[i]; //循环输入 
	sort(arry,arry+10);//数组从小到大排列，从大到小后面加greater<int>() 
	//遍历数组 
	for (int i=0;i<10;i++){
		cout<<arry[i]<<" ";
	}
	return 0;
}

全班有N个学生(0<N<31),请帮忙算出全班前K名同学的平均成绩；
第一行输入，班级人数
第二行输入，分数
第三行输入前K名
样例输入：
10
93 85 77 68 59 100 43 94 75 82
4
样例输出：
93.00

#include<iostream>
#include<algorithm> 
using namespace std;
int score[35];//定义全班人数上限，用数组形式存储，尽量比条件大一点防止爆掉 
int main(){
	int N,k,sum;//N:全班人数 k:前几名 sum:成绩之和，留着统计平均数 
	scanf("%d",&N);//输入人数 
	for(int i=0;i<N;i++) scanf("%d",&score[i]);//循环输入分数 
	scanf("%d",&k);//输入前几名 
	sort(score,score+N,greater<int>());//从大到小排序 
	for(int i=0;i<k;i++) sum+=score[i];//计算前K名的分数总和 
	printf("%.2f\n",1.0*sum/k);//计算前K名的平均数，并保留两位小数 
	return 0;
}

#include<iostream>
#include<algorithm> 
using namespace std;
int score[35];//定义全班人数上限，用数组形式存储，尽量比条件大一点防止爆掉 
int B[7]; //定义B数组 
int main(){
	int N;
	scanf("%d",&N);
	for(int i=0;i<N;i++) scanf("%d",&score[i]);
	sort(score,score+N,greater<int>());
	for(int i=0;i<N;i++) printf("%d\n",score[i]);
	for(int i=0;i<N;i++){
		if (score[i]==100) B[1]++;
		else if(score[i]>=90) B[2]++;
		else if(score[i]>=80) B[3]++;
		else if (score[i]>=70) B[4]++;
		else if(score[i]>=60) B[5]++;
		else B[6]++;
	}
	// B[1]~B[6] 从一开始，到六结束 
	for (int i=1;i<=6;i++){
		if(i!=6) printf("%d ",B[i]);
		else printf("%d\n",B[i]);
	}
	return 0; 
}

对于每次输入的a,b，输出a+b的值。
样例输入：
5
1 2
3 4
5 6
7 8
9 10
样例输出：
3
7
11
15
19

#include<iostream>
using namespace std;
int main(){
	int T,a,b,sum[10];
	scanf("%d",&T);
	for(int i=0;i<T;i++){
		scanf("%d %d",&a,&b);
		sum[i]=a+b;
	}
	for(int i=0;i<5;i++){
		printf("%d\n",sum[i]);
	}
}

斐波那契数列，输入一个n,表示数列的第n项，并求出f_n对1000000007（10 ⁹ +7)的取模结果
样例输入：
3
样例输出：
2

#include<iostream>
const int mod=1e9+7;
using namespace std;
int main(){
	int n,f[100005];
	f[1]=1,f[2]=1;
	scanf("%d",&n);
	for(int i=3;i<=n;i++){
		f[i]=(f[i-1]+f[i-2])%mod;
	}
	printf("%d",f[n]);
}

[NOIP2002 普及组] 过河卒

题目描述

棋盘上 $A$ 点有一个过河卒，需要走到目标 $B$ 点。卒行走的规则：可以向下、或者向右。同时在棋盘上 $C$ 点有一个对方的马，该马所在的点和所有跳跃一步可达的点称为对方马的控制点。因此称之为“马拦过河卒”。

棋盘用坐标表示， $A$ 点 $(0, 0)$ 、 $B$ 点 $(n, m)$ ，同样马的位置坐标是需要给出的。

现在要求你计算出卒从 $A$ 点能够到达 $B$ 点的路径的条数，假设马的位置是固定不动的，并不是卒走一步马走一步。

输入格式

一行四个正整数，分别表示 $B$ 点坐标和马的坐标。

输出格式

一个整数，表示所有的路径条数。

样例 #1

样例输入 #1

6 6 3 3

样例输出 #1

提示

对于 $\%$ 的数据， $\le n, m \le 20$ ， $\le$ 马的坐标 $\le 20$ 。

【题目来源】

NOIP 2002 普及组第四题

#include<cstdio>
long long a,b,c,d,s,n[25][25];
int main(){
	scanf("%lld %lld %lld %lld",&a,&b,&c,&d);
	n[0][0]=1;
	for(int i=1;i<=a;i++){
		int j=0;
		if((i==c&&j==d)||(i==c-1&&j==d-2)||(i==c-1&&j==d+2)||(i==c-2&&j==d-1)||(i==c-2&&j==d+1)||(i==c+1&&j==d-2)||(i==c+1&&j==d+2)||(i==c+2&&j==d-1)||(i==c+2&&j==d+1))
			continue;
		n[i][j]=n[i-1][j];
	}
	for(int j=1;j<=b;j++){
		int i=0;
		if((i==c&&j==d)||(i==c-1&&j==d-2)||(i==c-1&&j==d+2)||(i==c-2&&j==d-1)||(i==c-2&&j==d+1)||(i==c+1&&j==d-2)||(i==c+1&&j==d+2)||(i==c+2&&j==d-1)||(i==c+2&&j==d+1))
			continue;
		n[i][j]=n[i][j-1];
	}
	for(int i=1;i<=a;i++){
		for(int j=1;j<=b;j++){
			if((i==c&&j==d)||(i==c-1&&j==d-2)||(i==c-1&&j==d+2)||(i==c-2&&j==d-1)||(i==c-2&&j==d+1)||(i==c+1&&j==d-2)||(i==c+1&&j==d+2)||(i==c+2&&j==d-1)||(i==c+2&&j==d+1))
				continue;
			n[i][j]=n[i-1][j]+n[i][j-1];
		}
	}
	printf("%lld",n[a][b]);
	return 0;
}

11.# [NOIP2011 提高组] 铺地毯

题目描述

为了准备一个独特的颁奖典礼，组织者在会场的一片矩形区域（可看做是平面直角坐标系的第一象限）铺上一些矩形地毯。一共有 $n$ 张地毯，编号从 $1$ 到 $n$ 。现在将这些地毯按照编号从小到大的顺序平行于坐标轴先后铺设，后铺的地毯覆盖在前面已经铺好的地毯之上。

地毯铺设完成后，组织者想知道覆盖地面某个点的最上面的那张地毯的编号。注意：在矩形地毯边界和四个顶点上的点也算被地毯覆盖。

输入格式

输入共 $n + 2$ 行。

第一行，一个整数 $n$ ，表示总共有 $n$ 张地毯。

接下来的 $n$ 行中，第 $i + 1$ 行表示编号 $i$ 的地毯的信息，包含四个整数 $a, b, g, k$ ，每两个整数之间用一个空格隔开，分别表示铺设地毯的左下角的坐标 $(a, b)$ 以及地毯在 $x$ 轴和 $y$ 轴方向的长度。

第 $n + 2$ 行包含两个整数 $x$ 和 $y$ ，表示所求的地面的点的坐标 $(x, y)$ 。

输出格式

输出共 $1$ 行，一个整数，表示所求的地毯的编号；若此处没有被地毯覆盖则输出 -1。

样例 #1

样例输入 #1

样例输出 #1

样例 #2

样例输入 #2

样例输出 #2

-1

提示

【样例解释 1】

如下图， $1$ 号地毯用实线表示， $2$ 号地毯用虚线表示， $3$ 号用双实线表示，覆盖点 $(2, 2)$ 的最上面一张地毯是 $3$ 号地毯。

【数据范围】

对于 $30\%$ 的数据，有 $\le 2$ 。
对于 $50\%$ 的数据， $\le a, b, g, k \le 100$ 。
对于 $100\%$ 的数据，有 $\le n \le 10^4$ , $\le a, b, g, k \le {10}^5$ 。

noip2011 提高组 day1 第 $1$ 题。

#include<iostream>
using namespace std;
int a[10005],b[10005],g[10005],k[10005];
int main(){
	int n,x,y,j=-1;
	scanf("%d",&n);
	//循环输入a,b,g,k 
	for(int i=0;i<n;i++){
		scanf("%d %d %d %d",&a[i],&b[i],&g[i],&k[i]);
	}
	//输入覆盖点坐标 
	scanf("%d %d",&x,&y);
	for(int i=0;i<n;i++){
		//确定地毯边界， 
		if(x>=a[i]&&x<=a[i]+g[i]&&y>=b[i]&&y<=b[i]+k[i]){
			j=i;
		}
	}
	printf("%d",j); 
}