522是什么意思杭电acm题目水题英文题目、翻译及ac源代码

2021年1月20日发(作者：缓解压力英语)
1040 As Easy As A+B
Time Limit: 2000/1000 MS (Java/Others)



Memory Limit: 65536/32768 K (Java/Others)

Total Submission(s): 26015



Accepted Submission(s): 11054

Problem Description
These days, I am thinking about a question, how can I get a problem as easy as A+B? It is fairly
difficulty to do such a thing. Of course, I got it after many waking nights.
Give you some integers, your task is to sort these number ascending (
升序
).
You should know how easy the problem is now!
Good luck!
Input
Input contains multiple test cases. The first line of the input is a single integer T which is the
number of test cases. T test cases follow. Each test case contains an integer N (1<=N<=1000 the
number of integers to be sorted) and then N integers follow in the same line.

It is guarantied that all integers are in the range of 32-int.
Output
For each case, print the sorting result, and one line one case.
问题描述

这些天来，我在思考一个问题，我怎样才能得到一个简单的问题，因为
A + B
？这是相当困
难做这样的事情。当然，我得到了它之后，许多清醒的夜晚，

给你一些整数，你的任务就是这些数字升序（升序）排序。

你应该知道，现在的问题是多么容易！

祝你好运

输入

输入包含多个测试案例。
输入的第一行是一个整数
T
，
它是多的测试 用例。
T
检验的情况下，
遵循。
每个测试案例都包含一个整数
N（
1 <= N <= 1000
的整数的个数进行排序）
，
然后在同< br>一行
N
个整数。

消费
“
，所有的整数都在
32
整数的范围。

产量

对于每一种情况下，打印的排序结果，一行一个案例。





2
3 2 1 3
9 1 4 7 2 5 8 3 6 9



样本输出

1 2 3
1 2 3 4 5 6 7 8 9
最后一个数字后面没有空格的！

#include
int main()
{
int a,b,d,n,m,i,j,t,k;
int c[2000];
scanf(
for(n=0;n {
scanf(
for(m=0;m {
scanf(
c[m]=d;
}
for(i=1;i {
for(j=1;j<=(b-i);j++)
{
if(c[j-1]>c[j])
{
t=c[j];
c[j]=c[j-1];
c[j-1]=t;
}
else
continue;
}
}
for(k=0;k {
if(k==(b-1))
printf(
else
printf(
}
}
return 0;
}
1032 The 3n + 1 problem
Time Limit: 2000/1000 MS (Java/Others)



Memory Limit: 65536/32768 K (Java/Others)

Total Submission(s): 15157



Accepted Submission(s): 5577



Problem Description
Problems in Computer Science are often classified as belonging to a certain class of problems (e.g.,
NP, Unsolvable, Recursive). In this problem you will be analyzing a property of an algorithm
whose classification is not known for all possible inputs.

Consider the following algorithm:







1.





input n





2.





print n





3.





if n = 1 then STOP





4.










if n is odd then n <- 3n + 1





5.










else n <- n / 2





6.





GOTO 2


Given the input 22, the following sequence of numbers will be printed 22 11 34 17 52 26 13 40 20
10 5 16 8 4 2 1


It is conjectured that the algorithm above will terminate (when a 1 is printed) for any integral input
value. Despite the simplicity of the algorithm, it is unknown whether this conjecture is true. It has
been verified, however, for all integers n such that 0 < n < 1,000,000 (and, in fact, for many more
numbers than this.)


Given an input n, it is possible to determine the number of numbers printed (including the 1). For
a given n this is called the cycle-length of n. In the example above, the cycle length of 22 is 16.


For any two numbers i and j you are to determine the maximum cycle length over all numbers
between i and j.





Input
The input will consist of a series of pairs of integers i and j, one pair of integers per line. All
integers will be less than 1,000,000 and greater than 0.


You should process all pairs of integers and for each pair determine the maximum cycle length
over all integers between and including i and j.


You can assume that no opperation overflows a 32-bit integer.




Output
For each pair of input integers i and j you should output i, j, and the maximum cycle length for
integers between and including i and j. These three numbers should be separated by at least one
space with all three numbers on one line and with one line of output for each line of input. The
integers i and j must appear in the output in the same order in which they appeared in the input and
should be followed by the maximum cycle length (on the same line).


这个题很水，主要是题意。还这个题涉及到了
3*n+1
问题：

3n+1
问题是一个简单有趣而又没有解决的数学问题。这个问题是由
L.
Collatz
在
1937
年提出的。克拉
兹问题（
Collatz problem
）也被叫做
hailstone
问题、
3n+1
问题 、
Hasse
算法问题、
Kakutani
算法问题、
Thwait es
猜想或者
Ulam
问题。




问题如下：




（
1
）输入一个正整数
n
；




（
2
）如果
n=1
则结束；




（
3
）如果
n
是奇数，则
n
变为
3n+1
，否则
n
变为
n/2
；




（
4
）转入第（
2
）步。




克拉兹问题的特殊之处在于：尽管很容易将这个问题讲清楚，但直到今天仍不能保 证这个问题的算法
对所有可能的输入都有效
——
即至今没有人证明对所有的正整数该过 程都终止。

题意
:
题的大意是输入两个数
(
注意
,
这里没有说第一个数一定要小与第二个数
),
然后对这两个数之间的所有整
数包括端点的数
,
进行一种规律运算
,
并求出运算的次数
,
比较所有的数规律运算次数
,
输出最大的
.
#include

int main(int argc, char *argv[])
{
int a,b;
while (scanf (
{

int i,j,flag=0,len=0,max = 0;
if (a>b)
{
i=a;
a=b;
b=i;
flag=1;

}
for (i=a;i<=b;i++)
{
for (j=i,len=1;j!=1;)
{
if (j%2!=0)
j = 3*j+1;
else
j = j/2;
len++;
}
if (len>max)
max = len;
}
if (flag == 1)
{
i = a;
a = b;
b = i;
}
printf (
}
return 0;
}


Sample Input
1 10
100 200
201 210
900 1000


Sample Output
1 10 20
100 200 125
201 210 89
900 1000 174
``````

1048 The Hardest Problem Ever
Time Limit: 2000/1000 MS (Java/Others)



Memory Limit: 65536/32768 K (Java/Others)

Total Submission(s): 11647



Accepted Submission(s): 5273



Problem Description
Julius Caesar lived in a time of danger and intrigue. The hardest situation Caesar ever faced was
keeping himself alive. In order for him to survive, he decided to create one of the first ciphers.
This cipher was so incredibly sound, that no one could figure it out without knowing how it
worked.

You are a sub captain of Caesar's army. It is your job to decipher the messages sent by Caesar and
provide to your general. The code is simple. For each letter in a plaintext message, you shift it five
places to the right to create the secure message (i.e., if the letter is 'A', the cipher text would be 'F').
Since you are creating plain text out of Caesar's messages, you will do the opposite:


Cipher text
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

Plain text
V W X Y Z A B C D E F G H I J K L M N O P Q R S T U


Only letters are shifted in this cipher. Any non-alphabetical character should remain the same, and
all alphabetical characters will be upper case.


朱利叶斯< br>·
凯撒生活在危险和阴谋的时间。
恺撒以往任何时候都面临着最困难的情况下保持
自己活着。
为了他的生存，
他决定创建的第一个密码。
此密码是如此的令人难以置信 的声音，
没有人能弄清楚，不知道它是如何工作的。

你是一个分队长，恺撒的军队。
这是你的工作，这些消息进行解密发送的凯撒，并提供您的
一般。
代码很简单。
对于一个明文消息中的每个字母，你将它转移五个地方的权利，以创建
安全的消息（即，如果这封信是
'A'
，密文将
'F'
）
。由于您要创建纯文本凯撒的消息，你会做
相反的：在这个加密密文的一个
BCDEFGHIJKLMNOPQRSTUV WXYZ
纯文本
V
WXYZABCDEFGHIJKLMNOPQ RSTU
只有字母被转移。任何非字母字符保持不变，所有
字母字符将是大写字

输入

输入到这个问题，将包括一个（非空）系列高达
100
的数据 集。每个数据集将被格式化，根
据下面的描述中，将不会有空白行分离数据集。所有字符都将是大写的。 一个数据集有
3
个
部分组成：起始线
-
一个单一的线，
“< br>开始
”
加密消息
- A
一行包含
200
个字符，包 括从凯撒端
线，
包括一个单一的消息
-
单行线，
“END”
的最终数据集将是一个单一的，
“ENDOFINPUT”
。


产量

为每个数据集，将是完全有一行输出。这是凯撒的原始消息。

//

Input
Input to this problem will consist of a (non-empty) series of up to 100 data sets. Each data set will
be formatted according to the following description, and there will be no blank lines separating
data sets. All characters will be uppercase.


A single data set has 3 components:


Start line - A single line,


Cipher message - A single line containing from one to two hundred characters, inclusive,
comprising a single message from Caesar


End line - A single line,


Following the final data set will be a single line,




Output
For each data set, there will be exactly one line of output. This is the original message by Caesar.




Sample Input
START NS BFW, JAJSYX TK NRUTWYFSHJ FWJ YMJ WJXZQY TK YWNANFQ HFZXJX
END START N BTZQI WFYMJW GJ KNWXY NS F QNYYQJ NGJWNFS ANQQFLJ YMFS
XJHTSI NS WTRJ END START IFSLJW PSTBX KZQQ BJQQ YMFY HFJXFW NX RTWJ
IFSLJWTZX YMFS MJ END ENDOFINPUT



Sample Output
IN
WAR,
EVENTS
OF
IMPORTANCE
ARE
THE
RESULT
OF
TRIVIAL
CAUSES
I
WOULD
RATHER
BE
FIRST
IN
A
LITTLE
IBERIAN
VILLAGE
THAN
SECOND
IN
ROME
DANGER
KNOWS FULL WELL THAT CAESAR IS MORE DANGEROUS THAN HE
scanf
（）改
gets
（）就过了！

#include
#include
int main()
{
int i,n;
char s[500];
while(gets(s))
{
if(strcmp(s,
continue;
if(strcmp(s,
continue;
if(strcmp(s,
break;
n=strlen(s);
for(i=0;i {
if(s[i]>='F')
s[i]-=5;
else if(s[i]>='A'&&s[i]<'F')
s[i]+=21;
else
s[i]=s[i];
printf(
}
printf(
}
return 0;
}

1076 An Easy Task
Time Limit: 2000/1000 MS (Java/Others)



Memory Limit: 65536/32768 K (Java/Others)

Total Submission(s): 10297



Accepted Submission(s): 6421



Problem Description
Ignatius was born in a leap year, so he want to know when he could hold his birthday party. Can
you tell him?

Given a positive integers Y which indicate the start year, and a positive integer N, your task is to
tell the Nth leap year from year Y
.

Note: if year Y is a leap year, then the 1st leap year is year Y
.




Input
The input contains several test cases. The first line of the input is a single integer T which is the
number of test cases. T test cases follow.
Each test case contains two positive integers Y and N(1<=N<=10000).




Output
For each test case, you should output the Nth leap year from year Y
.




Sample Input
3 2005 25 1855 12 2004 10000



Sample Output
2108 1904 43236
Hint

We call year Y a leap year only if (Y%4==0 && Y%100!=0) or Y%400==0.
#include
int main()
{
int a,y,c,i,j,s;
scanf (
for (j=0;j{
scanf(
s=0;
for (i=y;i>0;i++)
{
if((i%4==0&&i%100!=0)||(i%400==0))
s++;
if(s==c) break;
}
printf (
}
return 0;
}