0%

Chrome快捷键

标签页和窗口快捷键

操作 快捷键
打开新窗口 Ctrl + n
在无痕模式下打开新窗口 Ctrl + Shift + n
打开新的标签页,并跳转到该标签页 Ctrl + t
按标签页的关闭顺序重新打开先前关闭的标签页 Ctrl + Shift + t
跳转到下一个打开的标签页 Ctrl + Tab 或 Ctrl + PgDn
跳转到上一个打开的标签页 Ctrl + Shift + Tab 或 Ctrl + PgUp
跳转到特定标签页 Ctrl + 1 到 Ctrl + 8
跳转到最右侧的那个标签页 Ctrl + 9
在当前标签页中打开主页 Alt + Home
打开当前标签页浏览记录中记录的上一个页面 Alt + 向左箭头键
打开当前标签页浏览记录中记录的下一个页面 Alt + 向右箭头键
关闭当前标签页 Ctrl + w 或 Ctrl + F4
关闭当前窗口 Ctrl + Shift + w 或 Alt + F4
最小化当前窗口 Alt + 空格键,然后按 n 键
最大化当前窗口 Alt + 空格键,然后按 x 键
退出 Google Chrome Alt + f,然后按 x 键
## Google Chrome 功能快捷键
操作 快捷键
- -
打开 Chrome 菜单 Alt + f 或 Alt + e
显示或隐藏书签栏 Ctrl + Shift + b
打开书签管理器 Ctrl + Shift + o
在新标签页中打开“历史记录”页 Ctrl + h
在新标签页中打开“下载内容”页 Ctrl + j
打开 Chrome 任务管理器 Shift + Esc
将焦点放置在 Chrome 工具栏中的第一项上 Shift + Alt + t
将焦点放置在 Chrome 工具栏中最右侧的那一项上 F10
将焦点移到未聚焦于的对话框(如果显示)或所有工具栏 F6
打开查找栏搜索当前网页 Ctrl + f 或 F3
跳转到与查找栏中搜索字词相匹配的下一条内容 Ctrl + g
跳转到与查找栏中搜索字词相匹配的上一条内容 Ctrl + Shift + g
打开“开发者工具” Ctrl + Shift + j 或 F12
打开“清除浏览数据”选项 Ctrl + Shift + Delete
在新标签页中打开 Chrome 帮助中心 F1
使用其他帐号登录或以访客身份浏览 Ctrl + Shift + m
打开反馈表单 Alt + Shift + i
## 地址栏快捷键
操作 快捷键
使用默认搜索引擎进行搜索 输入搜索字词并按 Enter 键
使用其他搜索引擎进行搜索 输入搜索引擎名称,然后按 Tab 键
为网站名称添加 www. 和 .com,然后在当前标签页中打开该网址 输入网站名称并按 Ctrl + Enter 键
打开新的标签页并执行 Google 搜索 输入搜索字词并按 Alt + Enter 键
跳转到地址栏 Ctrl + l 或 Alt + d 或 F6
从页面中的任意位置搜索 Ctrl + k 或 Ctrl + e
从地址栏中移除联想查询内容 按向下箭头键以突出显示相应内容,然后按 Shift + Delete 键
## 网页快捷键
操作 快捷键
- -
打开选项以打印当前网页 Ctrl + p
打开选项以保存当前网页 Ctrl + s
重新加载当前网页 F5 或 Ctrl + r
重新加载当前网页(忽略缓存的内容) Shift + F5 或 Ctrl + Shift + r
停止加载网页 Esc
浏览下一个可点击项 Tab
浏览上一个可点击项 Shift + Tab
使用 Chrome 打开计算机中的文件 按住 Ctrl + o 键并选择文件
显示当前网页的 HTML 源代码(不可修改) Ctrl + u
将当前网页保存为书签 Ctrl + d
将所有打开的标签页以书签的形式保存在新文件夹中 Ctrl + Shift + d
开启或关闭全屏模式 F11
放大网页上的所有内容 Ctrl 和 +
缩小网页上的所有内容 Ctrl 和 -
将网页上的所有内容恢复到默认大小 Ctrl + 0
向下滚动网页,一次一个屏幕 空格键或 PgDn
向上滚动网页,一次一个屏幕 Shift + 空格键或 PgUp
转到网页顶部 首页
转到网页底部 末尾
将光标移到文本字段中的上一个字词起始处 Ctrl + 向左箭头键
将光标移到下一个字词起始处 Ctrl + 向右箭头键
删除文本字段中的上一个字词 Ctrl + Backspace
在当前标签页中打开主页 Alt + Home
重置页面缩放级别 Ctrl + 0

成绩排序

描述

期末考试结束后,张老师要对班级同学的成绩进行分析,他需要先对全班n个学生的成绩从高到低的排列。现在请你编一个程序,帮张老师把全班n个学生的成绩从高到低排列;成绩一样的再按名字的字典序递增排序。

输入

第一行有一个整数n(1 <= n <= 100)。接下来有n行,每行有一个表示学生名字的字符串(不超过20个字符)和对应的成绩(百分制整数),两者用空格分隔。

输出

包括n行排好序的名字和成绩,两者间用一个空格分隔。

样例输入

6
Li 87
Sun 95
Zhang 75
Wang 75
Zhao 82
Liu 64

样例输出

Sun 95
Li 87
Zhao 82
Wang 75
Zhang 75
Liu 64

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include <bits/stdc++.h>
using namespace std;
struct Stu
{
char xm[100]; //姓名
int cj; //成绩
}student[100]; //结构体数组

bool compare(Stu a , Stu b) //用于sort的比较函数
{
if (a.cj != b.cj)
return a.cj > b.cj; //成绩从高到低排序
int temp = strcmp(a.xm, b.xm); //用于比较两个字符串长度并根据比较结果返回整数 基本形式为strcmp(str1,str2)
//若str1=str2,则返回零;若str1<str2,则返回负数;若str1>str2,则返回正数
if (temp != 0) //字符串长度不相等
{
return temp < 0; //按名字的字典序递增排序
}
}
int main()
{
int n;
cin>>n;
for(int i = 0; i < n ; i ++ )
cin >> student[i].xm >> student[i].cj ; //输入姓名成绩
sort(student, student+n , compare); //排序,从大到小
for(int i = 0 ; i < n ; i ++ )
cout << student[i].xm <<" "<< student[i].cj << endl;
return 0;
}

特殊字符

描述

所谓特殊字符就是在字符串中最后一次仅出现一次的小写字母。给定一个字符串,请你找出特殊字符。如果没有,输出“No”。

输入

一个字符串,长度小于100000。

输出

输出最后仅出现一次的字符,若没有则输出“No”。

样例输入

abcabd

样例输出

d

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include <bits/stdc++.h>
using namespace std;

int main()
{
string line;
stringstream ss;
char a[150000];
int i=0;
while (getline(cin,line)) //多写了循环
{
ss.str(line);
while (ss>>a[i++]);
}
for (int j=i;j>=0;j--) //应为i-1
{
bool flag=false;
for (int l=j;l>=0;l--) //应为j-1
{
if (a[j]==a[l])
{flag=true; break;}
}
if (flag==true)
{continue;}
else
{printf("%c",a[i]); break;}
if (j==0)
{printf("NO");}
}
return 0;
}

问题

  1. 卡输入循环,无输出(表现)
  2. abcabd中b会被判定为特殊字符(逻辑错误)

改进

  1. 从后向前检索,把和当前项相同的第一个字符排在当前项的前面,并继续从检索到的字符开始上述过程
  2. abcab(d)->abca(b)d->aca(b)bd->ac(a)bbd->c(a)abbd->caabbd
  3. 排序后从后向前检索,如果这项前的字符与其相同则标记此字符,并把之后检索到的此字符都跳过,反之则继续开始上述流程,如果检索到的字符之前没有相同字符则输出此字符,如果检索到首项仍没有满足条件的字符则输出NO
  4. 增强代码完整性的拓展练习,使用链表和文件
1
2


题目描述

有一个m×m的棋盘,棋盘上每一个格子可能是红色、黄色或没有任何颜色的。你现在要从棋盘的最左上角走到棋盘的最右下角。

任何一个时刻,你所站在的位置必须是有颜色的(不能是无色的), 你只能向上、 下、左、 右四个方向前进。当你从一个格子走向另一个格子时,如果两个格子的颜色相同,那你不需要花费金币;如果不同,则你需要花费1个金币。

另外, 你可以花费2个金币施展魔法让下一个无色格子暂时变为你指定的颜色。但这个魔法不能连续使用, 而且这个魔法的持续时间很短,也就是说,如果你使用了这个魔法,走到了这个暂时有颜色的格子上,你就不能继续使用魔法; 只有当你离开这个位置,走到一个本来就有颜色的格子上的时候,你才能继续使用这个魔法,而当你离开了这个位置(施展魔法使得变为有颜色的格子)时,这个格子恢复为无色。

现在你要从棋盘的最左上角,走到棋盘的最右下角,求花费的最少金币是多少?

输入格式

第一行包含两个正整数m,n,以一个空格分开,分别代表棋盘的大小,棋盘上有颜色的格子的数量。

接下来的n行,每行三个正整数x,y,z,分别表示坐标为(x,y)的格子有颜色c。

其中c=1代表黄色,c=0代表红色。 相邻两个数之间用一个空格隔开。 棋盘左上角的坐标为(1,1),右下角的坐标为(m,m)。

棋盘上其余的格子都是无色。保证棋盘的左上角,也就是(1,1) 一定是有颜色的。

输出格式

一个整数,表示花费的金币的最小值,如果无法到达,输出−1。

输入输出样例

输入 #1

5 7
1 1 0
1 2 0
2 2 1
3 3 1
3 4 0
4 4 1
5 5 0

输出 #1

8

输入 #2

5 5
1 1 0
1 2 0
2 2 1
3 3 1
5 5 0

输出 #2

-1

说明/提示

输入输出样例 1 说明

从(1,1)(1,1)开始,走到(1,2)(1,2)不花费金币

从(1,2)(1,2)向下走到(2,2)(2,2)花费 11 枚金币

从(2,2)(2,2)施展魔法,将(2,3)(2,3)变为黄色,花费 22 枚金币

从(2,2)(2,2)走到(2,3)(2,3)不花费金币

从(2,3)(2,3)走到(3,3)(3,3)不花费金币

从(3,3)(3,3)走到(3,4)(3,4)花费 11 枚金币

从(3,4)(3,4)走到(4,4)(4,4)花费 11 枚金币

从(4,4)(4,4)施展魔法,将(4,5)(4,5)变为黄色,花费22 枚金币,

从(4,4)(4,4)走到(4,5)(4,5)不花费金币

从(4,5)(4,5)走到(5,5)(5,5)花费 11 枚金币

共花费 88枚金币。

输入输出样例 2 说明

从( 1, 1)(1,1)走到( 1, 2)(1,2),不花费金币

从( 1, 2)(1,2)走到( 2, 2)(2,2),花费11金币

施展魔法将( 2, 3)(2,3)变为黄色,并从( 2, 2)(2,2)走到( 2, 3)(2,3)花费22 金币

从( 2, 3)(2,3)走到( 3, 3)(3,3)不花费金币

从( 3, 3)(3,3)只能施展魔法到达( 3, 2),( 2, 3),( 3, 4),( 4, 3)(3,2),(2,3),(3,4),(4,3)

而从以上四点均无法到达( 5, 5)(5,5),故无法到达终点,输出-1−1

数据规模与约定
对于 30%30%的数据, 1 ≤ m ≤ 5, 1 ≤ n ≤ 101≤m≤5,1≤n≤10。

对于 60%60%的数据, 1 ≤ m ≤ 20, 1 ≤ n ≤ 2001≤m≤20,1≤n≤200。

对于 100%100%的数据, 1 ≤ m ≤ 100, 1 ≤ n ≤ 1,0001≤m≤100,1≤n≤1,000。

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
#include <bits/stdc++.h>
//#include <limits.h> INT_MAX调用的头文件

#define inf INT_MAX
int m,n; //m为棋盘大小,n为有颜色格子数量

int fx[4]={-1,0,1,0}; //x偏移量
int fy[4]={0,-1,0,1}; //y偏移量
int ans = inf; //ans为结果
int cp[999][999];
int f[999][999];

void dfs(int x,int y,int sum,bool magic)
{
if(x < 1 || y < 1 || x > m || y > m) //超出边界
return;

if(sum >= f[x][y]) //不符合最优解
return;

f[x][y] = sum;

if(x==m && y==m) //终点坐标为(m, m)
{
if(sum < ans) //更新最优解
ans = sum;
return;
}

for(int i = 0; i < 4; ++i)
{
int xx = x + fx[i];
int yy = y + fy[i];
if(cp[xx][yy]) //若下一格有色
{
if(cp[xx][yy] == cp[x][y]) //若颜色相同
dfs(xx, yy, sum, false); //则不花钱
else
dfs(xx, yy, sum+1, false); //否则花费+1
}
else //否则(若下一格无色)
if(!magic) //(且)没有用过魔法
{
cp[xx][yy] = cp[x][y];
dfs(xx, yy, sum+2, true); //使用魔法
cp[xx][yy] = 0; //回溯
}
}
}

int main ()
{
memset(f, 0x7f, sizeof(f));
scanf("%d%d",&m,&n); //输入行列数
for (int i=0;i<n;i++) //填入颜色
{
int x,y,c; //表示横纵坐标
scanf("%d %d %d",&x,&y,&c);
cp[x][y] = c + 1; // 1红色 2黄色 0无色(未赋值,其初值为0)
}
dfs(1,1,0,false);
printf("%d",ans==inf ? -1 : ans); //无解则输出-1
printf("\n");
system("pause");
return 0;
}

移动火柴

描述

在正方形的顶点处放上火柴。开始时在第一个顶点处放1根火柴,其它顶点处空着。移动火柴的规则如下:可以在有火柴的任何顶点处移走任意根数的火柴,并在与之相邻的两个顶点处都放上移走火柴数的两倍。

你的任务是判断是否经过若干次这样的做法,使四个顶点(以顺时针的顺序或逆时针的顺序)处的火柴根数为事先指定的四个非负整数a、b、c、d(第一个数a是第一个顶点对应的火柴数)。

输入

输入文件有若干行,每行上有四个非负整数a、b、c、d,之间用一个空格隔开,0≤a、b、c、d≤10000。

输出

对输入中的每行四个整数a、b、c、d,输出你的判断结果。如果经过有限次移动火柴后四个顶点处的火柴根数分别为整数a、b、c、d,那么输出“YES!”,否则输出“NO!”。

样例输入

2 1 2 2
0 2 3 2
56 46 95 34

样例输出

YES!
NO!
NO!

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <iostream>
using namespace std;
int main()
{
int a, b, c, d;
while (cin >> a >> b >> c >> d)
{
int s = 0;
s = a + b * 4 + c + d * 4;
if (s % 15 == 1)
cout << "YES!" << endl;
else
cout << "NO!" << endl;
}
return 0;
}

实数加法

描述

求2个实数相加的和。

输入输出中出现的实数都有如下的形式: P1P2…Pi.Q1Q2…Qj。对于整数部分,P1P2…Pi是一个非负整数;对于小数部分,至少有一位且最后一位Qj不等于0。

输入

输入2行,分别是两个加数。每个加数不超过100个字符。

输出

输出一行,是相应的和。数据保证一定是一个小数部分不为0的实数。

样例输入1

0.111111111111111111111111111111
0.111111111111111111111111111111

样例输出1

0.222222222222222222222222222222

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
#include<iostream>
#include<cmath>
#include<cstring>
#include<cstdio>
#include<cstdlib>
#include<algorithm>
using namespace std;
const int MAXN=105;

string A,B;
int a[MAXN][2],b[MAXN][2];
int la[2],lb[2],lc[2],c[MAXN][2];

int main()
{
cin>>A>>B;
while(A[la[0]]!='.')
la[0]++;
for(int i=0;i<la[0];i++)
a[la[0]-1-i][0]=A[i]-'0';
la[1]=A.length()-la[0]-1;
for(int i=0;i<la[1];i++)
a[i][1]=A[i+la[0]+1]-'0';

while(B[lb[0]]!='.')
lb[0]++;
for(int i=0;i<lb[0];i++)
b[lb[0]-1-i][0]=B[i]-'0';
lb[1]=B.length()-lb[0]-1;
for(int i=0;i<lb[1];i++)
b[i][1]=B[i+lb[0]+1]-'0';

int x=0;
while(lc[0]<=la[0]||lc[0]<=lb[0])
{
c[lc[0]][0]=a[lc[0]][0]+b[lc[0]][0]+x;
x=0;
if(c[lc[0]][0]>=10)
{
x=c[lc[0]][0]/10;
c[lc[0]][0]%=10;
}
lc[0]++;
}
c[lc[0]][0]=x;
x=0;
while(!c[lc[0]][0]&&lc[0])
lc[0]--;

lc[1]=min(la[1],lb[1]);
lc[1]--;
while(lc[1]>=0)
{
c[lc[1]][1]=a[lc[1]][1]+b[lc[1]][1]+x;
x=0;
if(c[lc[1]][1]>=10)
{
x=c[lc[1]][1]/10;
c[lc[1]][1]%=10;
}
lc[1]--;
}
c[0][0]+=x;
for(int i=lc[0];i>=0;i--)
cout<<c[i][0];
int l=max(la[1],lb[1]);
cout<<'.';
for(int i=min(la[1],lb[1]);i<l;i++)
if(a[i][1])
c[i][1]=a[i][1];
else
c[i][1]=b[i][1];
while(!c[l][1])
l--;
for(int i=0;i<=l;i++)
cout<<c[i][1];
return 0;
}

特殊日历计算

描述

有一种特殊的日历法,它的一天和我们现在用的日历法的一天是一样长的。它每天有10个小时,每个小时有100分钟,每分钟有100秒。10天算一周,10周算一个月,10个月算一年。现在要你编写一个程序,将我们常用的日历法的日期转换成这种特殊的日历表示法。这种日历法的时、分、秒是从0开始计数的。日、月从1开始计数,年从0开始计数。秒数为整数。假设 0:0:0 1.1.2000 等同于特殊日历法的 0:0:0 1.1.0。

输入

第一行是一个正整数 N ,表明下面有 N 组输入。每组输入有一行,格式如下:hour:minute:second day.month.year 表示常规的日期。日期总是合法的。2000 <= year <= 50000。

输出

每组输入要求输出一行。格式如下:mhour:mmin:msec mday.mmonth.myear 是输入日期的特殊日历表示方法。

样例输入1

7
0:0:0 1.1.2000
10:10:10 1.3.2001
0:12:13 1.3.2400
23:59:59 31.12.2001
0:0:1 20.7.7478
0:20:20 21.7.7478
15:54:44 2.10.20749

样例输出1

0:0:0 1.1.0
4:23:72 26.5.0
0:8:48 58.2.146
9:99:98 31.8.0
0:0:1 100.10.2000
0:14:12 1.1.2001
6:63:0 7.3.6848

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#include<cstdio>
#include<cstring>
int mons[2][13] =
{
{0,31,28,31,30,31,30,31,31,30,31,30,31},
{0,31,29,31,30,31,30,31,31,30,31,30,31}
};
inline int type(int y) //inline避免了频繁调用函数对栈内存重复开辟所带来的消耗
{
if((y % 4 == 0 && y % 100 != 0) || y % 400 == 0)
return 1;
return 0;
}
int years[2] = {365,366};
int main()
{
int n,hour,mute,sec,day,mon,year,mhor,mmin,msec,mday,mmon,myear;
scanf("%d",&n);
while(n--)
{
scanf("%d:%d:%d %d.%d.%d",&hour,&mute,&sec,&day,&mon,&year);
int secs,days = 0;
secs = sec + 60 * mute + 3600 * hour;
for(int y = 2000; y < year; ++y) days += years[type(y)];
for(int m = 1; m < mon; ++m) days += mons[type(year)][m];
days += day - 1;
myear = days / 1000;
days %= 1000;
mmon = days / 100 + 1;
days %= 100;
mday = days + 1;
secs = secs * 125 / 108;
mhor = secs / 10000;
secs %= 10000;
mmin = secs / 100;
msec = secs % 100;
printf("%d:%d:%d %d.%d.%d\n",mhor,mmin,msec,mday,mmon,myear);
}
return 0;
}

奖学金

描述

某小学最近得到了一笔赞助,打算拿出其中一部分为学习成绩优秀的前5名学生发奖学金。期末,每个学生都有3门课的成绩:语文、数学、英语。先按总分从高到低排序,如果两个同学总分相同,再按语文成绩从高到低排序,如果两个同学总分和语文成绩都相同,那么规定学号小的同学排在前面,这样,每个学生的排序是唯一确定的。

任务:先根据输入的3门课的成绩计算总分,然后按上述规则排序,最后按排名顺序输出前五名名学生的学号和总分。注意,在前5名同学中,每个人的奖学金都不相同,因此,你必须严格按上述规则排序。例如,在某个正确答案中,如果前两行的输出数据(每行输出两个数:学号、总分) 是:

7 279

5 279

这两行数据的含义是:总分最高的两个同学的学号依次是7号、5号。这两名同学的总分都是 279 (总分等于输入的语文、数学、英语三科成绩之和) ,但学号为7的学生语文成绩更高一些。如果你的前两名的输出数据是:

5 279

7 279

则按输出错误处理,不能得分。

输入

包含n+1行: 第1行为一个正整数n(6<=n<=300),表示该校参加评选的学生人数。 第2到n+1行,每行有3个用空格隔开的数字,每个数字都在0到100之间。第j行的3个数字依次表示学号为 j-1 的学生的语文、数学、英语的成绩。每个学生的学号按照输入顺序编号为1~n (恰好是输入数据的行号减1)。 所给的数据都是正确的,不必检验。

输出

共有5行,每行是两个用空格隔开的正整数,依次表示前5名学生的学号和总分。

样例输入1

6
90 67 80
87 66 91
78 89 91
88 99 77
67 89 64
78 89 98

样例输出1

6 265
4 264
3 258
2 244
1 237

样例输入2

8
80 89 89
88 98 78
90 67 80
87 66 91
78 89 91
88 99 77
67 89 64
78 89 98

样例输出2

8 265
2 264
6 264
1 258
5 258

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#include<bits/stdc++.h>
using namespace std;
struct students
{
int all; //总分
int yw; //语文
int ss; //数学
int yy; //英语
int id; //学号
}s[305]; //储存以上信息的数组

int judge(students a,students b) //判断函数
{
if(a.all==b.all) //如果总分相等
{
//按语文成绩高低排序
if(a.yw==b.yw)
return a.id<b.id;
return a.yw>b.yw;
}
return a.all>b.all;
}
int main()
{
int n; //学生总人数
cin>>n;
for(int i=1;i<=n;i++)
{
cin>>s[i].yw>>s[i].ss>>s[i].yy;
s[i].all=s[i].ss+s[i].yw+s[i].yy;
s[i].id=i;
}
sort(s+1,s+n+1,judge); //排序总分
for(int i=1;i<=5;i++) //按题目要求顺序输出
{
cout<<s[i].id<<' '<<s[i].all<<endl; //要记得换行 没换行没输出
}
}

多项式输出

描述

一元 n 次多项式可用如下的表达式表示:

f(x)=anx^n+an−1x^n-1+…+a1x+a0,an≠0

其中,aix^i称为i次项,ai称为i次项的系数。给出一个一元多项式各项的次数和系数,请按照如下规定的格式要求输出该多项式:

  1. 多项式中自变量为x,从左到右按照次数递减顺序给出多项式。

  2. 多项式中只包含系数不为0的项。

  3. 如果多项式n次项系数为正,则多项式开头不出现“+”号,如果多项式n次项系数为负,则多项式以“-”号开头。

  4. 对于不是最高次的项,以“+”号或者“-”号连接此项与前一项,分别表示此项系数为正或者系数为负。紧跟一个正整数,表示此项系数的绝对值(如果一个高于0次的项,其系数的绝对值为1,则无需输出1)。如果x的指数大于1,则接下来紧跟的指数部分的形式为“x^b”,其中b为x的指数;如果x的指数为1,则接下来紧跟的指数部分形式为“x”; 如果x的指数为0,则仅需输出系数即可。

  5. 多项式中,多项式的开头、结尾不含多余的空格。

输入

共有2 行: 第一行 1 个整数 n,表示一元多项式的次数。 第二行有 n+1 个整数,其中第 i 个整数表示第 n-i+1 次项的系数,每两个整数之间用空格隔开。 1 ≤ n ≤ 100,多项式各次项系数的绝对值均不超过100。

输出

共1行,按题目所述格式输出多项式。

样例输入1

5
100 -1 1 -3 0 10

样例输出1

100x^5-x^4+x^3-3x^2+10

样例输入2

3
-50 0 0 1

样例输出2

-50x^3+1

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include<cstdio>
#include<cmath>
using namespace std;
int main()
{
int n,i,j,k;
char c;
scanf("%d",&n);
for(i=1;i<=n;i++)
{
scanf("%d",&k);
if(k==0) continue;
c=(k>0)?'+':'-'; //根据k正负判断加减号
if(i>1 || (i==1 && k<0))
printf("%c",c); /。如果非首项或首项为负则输出符号
k=abs(k); //去除负号影响
if(k!=1)
printf("%d",k);
if(i<n)
printf("x^%d",n-i+1);
else
printf("x");
}
scanf("%d",&k);
if(k!=0)
printf("%+d",k);
printf("\n");
return 0;
}

金银岛

描述

某天KID利用飞行器飞到了一个金银岛上,上面有许多珍贵的金属,KID虽然更喜欢各种宝石的艺术品,可是也不拒绝这样珍贵的金属。但是他只带着一个口袋,口袋至多只能装重量为w的物品。岛上金属有s个种类, 每种金属重量不同,分别为n1,n2 ,… , ns,同时每个种类的金属总的价值也不同,分别为v1,v2,…, vs。KID想一次带走价值尽可能多的金属,问他最多能带走价值多少的金属。注意到金属是可以被任意分割的,并且金属的价值和其重量成正比。

输入

第1行是测试数据的组数k,后面跟着k组输入。 每组测试数据占3行,第1行是一个正整数w (1 <= w <= 10000),表示口袋承重上限。第2行是一个正整数s (1 <= s <=100),表示金属种类。第3行有2s个正整数,分别为n1, v1, n2, v2, … , ns, vs分别为第一种,第二种,…,第s种金属的总重量和总价值(1 <= ni <= 10000, 1 <= vi <= 10000)。

输出

输出k行,每行输出对应一个输入。输出应精确到小数点后2位。

样例输入

2
50
4
10 100 50 30 7 34 87 100
10000
5
1 43 43 323 35 45 43 54 87 43

样例输出

171.93
508.00

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
struct Gold
{
double n,v;
bool operator < (const Gold & other)const
{
return v * other.n > n * other.v;
}
}g[105];

int main()
{
int k,s;
double w,ans;
scanf("%d",&k);
while(k--)
{
ans = 0;
scanf("%lf%d",&w,&s);
for(int i = 0; i < s; ++i)
{
scanf("%lf%lf",&g[i].n,&g[i].v);
}
sort(g,g+s);
for(int i = 0; i < s; ++i)
{
if(w >= g[i].n)
{
ans += g[i].v;
w -= g[i].n;
}
else
{
ans += g[i].v * w / g[i].n;
w = 0;
}
if(w == 0) break;
}
printf("%.02lf\n",ans);
}
return 0;
}