你可不可以
成为我的main函数
做我此生必须有
且只能有一个的入口
——————————
我愿为自己加上private
在你的class中只有
你能调用
——————————————代 码 如 诗 。
据说所有程序员学习的第一个程序都是在屏幕上输出一句“Hello World”，跟这个世界打个招呼。作为天梯赛中的程序员，你写的程序得高级一点，要能跟任意指定的星球打招呼。
输入格式：
输入在第一行给出一个星球的名字S，是一个由不超过7个英文字母组成的单词，以回车结束。
输出格式：
在一行中输出“Hello S”，跟输入的S星球打个招呼。
输入样例：
Mars
输出样例：
Hello Mars
|
1 2 3 4 5 6 7 8 |
#include <iostream> using namespace std; int main() { string s; cin >> s; cout << "Hello " << s; return 0; } |
大家应该都会玩“锤子剪刀布”的游戏：两人同时给出手势，胜负规则如图所示：
现要求你编写一个稳赢不输的程序，根据对方的出招，给出对应的赢招。但是！为了不让对方输得太惨，你需要每隔K次就让一个平局。
输入格式：
输入首先在第一行给出正整数K（<=10），即平局间隔的次数。随后每行给出对方的一次出招：“ChuiZi”代表“锤子”、“JianDao”代表“剪刀”、“Bu”代表“布”。“End”代表输入结束，这一行不要作为出招处理。
输出格式：
对每一个输入的出招，按要求输出稳赢或平局的招式。每招占一行。
输入样例：
2
ChuiZi
JianDao
Bu
JianDao
Bu
ChuiZi
ChuiZi
End
输出样例：
Bu
ChuiZi
Bu
ChuiZi
JianDao
ChuiZi
Bu
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
#include <iostream> #include <map> using namespace std; int main() { map<string,string> m; m["Bu"] = "JianDao"; m["JianDao"] = "ChuiZi"; m["ChuiZi"] = "Bu"; int k, cnt = 0; string s; cin >> k; while(cin >> s) { if(s == "End") return 0; cnt++; if(cnt % (k + 1) == 0) cout << s << endl; else cout << m[s] << endl; } return 0; } |
天梯图书阅览室请你编写一个简单的图书借阅统计程序。当读者借书时，管理员输入书号并按下S键，程序开始计时；当读者还书时，管理员输入书号并按下E键，程序结束计时。书号为不超过1000的正整数。当管理员将0作为书号输入时，表示一天工作结束，你的程序应输出当天的读者借书次数和平均阅读时间。
注意：由于线路偶尔会有故障，可能出现不完整的纪录，即只有S没有E，或者只有E没有S的纪录，系统应能自动忽略这种无效纪录。另外，题目保证书号是书的唯一标识，同一本书在任何时间区间内只可能被一位读者借阅。
输入格式：
输入在第一行给出一个正整数N（<= 10），随后给出N天的纪录。每天的纪录由若干次借阅操作组成，每次操作占一行，格式为：
书号（[1, 1000]内的整数） 键值（“S”或“E”） 发生时间（hh:mm，其中hh是[0,23]内的整数，mm是[0, 59]内整数）
每一天的纪录保证按时间递增的顺序给出。
输出格式：
对每天的纪录，在一行中输出当天的读者借书次数和平均阅读时间（以分钟为单位的精确到个位的整数时间）。
输入样例：
3
1 S 08:10
2 S 08:35
1 E 10:00
2 E 13:16
0 S 17:00
0 S 17:00
3 E 08:10
1 S 08:20
2 S 09:00
1 E 09:20
0 E 17:00
输出样例：
2 196
0 0
1 60
分析：模拟借书还书，输出当天借书次数和平均借书时间，四舍五入可以用加 0.5 然后强转成int，用isborrow数组标记书是否背借走
注意：如果出现连续两次借书，以第二次为成功借阅为成功借阅，（个人理解应该是第一次借书成功，第二次为非法借书，可题目只有按照第二次为借书成功计算）如果连续两次还书，以第一次还书为成功
|
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 <iostream> #include <cstring> using namespace std; int main() { int n; cin >> n; int id, h, m, cnt = 0, sum = 0, isborr[1010] = {0}, time[1010] = {0}; char type, temp; for(int day = 0; day < n; ) { cin >> id >> type >> h >> temp >> m; if(id == 0) { if(cnt == 0) printf("0 0\n"); else printf("%d %d\n", cnt, (int)(1.0 * sum / cnt + 0.5)); day++; cnt = sum = 0; memset(isborr, 0, sizeof(isborr)); }else if(type == 'S') { isborr[id] = 1; time[id] = h * 60 + m; }else if(type == 'E' && isborr[id] == 1) { isborr[id] = 0; sum += h * 60 + m - time[id]; cnt++; } } return 0; } |
世界上不同国家有不同的写日期的习惯。比如美国人习惯写成“月-日-年”，而中国人习惯写成“年-月-日”。下面请你写个程序，自动把读入的美国格式的日期改写成中国习惯的日期。
输入格式：
输入在一行中按照“mm-dd-yyyy”的格式给出月、日、年。题目保证给出的日期是1900年元旦至今合法的日期。
输出格式：
在一行中按照“yyyy-mm-dd”的格式给出年、月、日。
输入样例：
03-15-2017
输出样例：
2017-03-15
|
1 2 3 4 5 6 7 8 9 |
#include <iostream> using namespace std; int main() { int a, b, c; char ch; cin >> a >> ch >> b >> ch >> c; printf("%d-%02d-%02d",c ,a, b); return 0; } |
对方不想和你说话，并向你扔了一串数…… 而你必须从这一串数字中找到“250”这个高大上的感人数字。
输入格式：
输入在一行中给出不知道多少个绝对值不超过1000的整数，其中保证至少存在一个“250”。
输出格式：
在一行中输出第一次出现的“250”是对方扔过来的第几个数字（计数从1开始）。题目保证输出的数字在整型范围内。
输入样例：
888 666 123 -233 250 13 250 -222
输出样例：
5
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
#include <iostream> using namespace std; int main() { int num, cnt = 0; while(cin >> num) { cnt++; if(num == 250) { cout << cnt; break; } } return 0; } |
1030. Travel Plan (30)
A traveler’s map gives the distances between cities along the highways, together with the cost of each highway. Now you are supposed to write a program to help a traveler to decide the shortest path between his/her starting city and the destination. If such a shortest path is not unique, you are supposed to output the one with the minimum cost, which is guaranteed to be unique.
Input Specification:
Each input file contains one test case. Each case starts with a line containing 4 positive integers N, M, S, and D, where N (<=500) is the number of cities (and hence the cities are numbered from 0 to N-1); M is the number of highways; S and D are the starting and the destination cities, respectively. Then M lines follow, each provides the information of a highway, in the format:
City1 City2 Distance Cost
where the numbers are all integers no more than 500, and are separated by a space.
Output Specification:
For each test case, print in one line the cities along the shortest path from the starting point to the destination, followed by the total distance and the total cost of the path. The numbers must be separated by a space and there must be no extra space at the end of output.
Sample Input
4 5 0 3
0 1 1 20
1 3 2 30
0 3 4 10
0 2 2 20
2 3 1 20
Sample Output
0 2 3 3 40
题目大意：求起点到终点的最短路径最短距离和花费，要求首先路径最短，其次花费最少，要输出完整路径
PS：感谢github用户@fs19910227提供的pull request～
|
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 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 |
import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.util.LinkedList; import java.util.PriorityQueue; public class Main { static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in)); static class Info { int distance, cost; Info(int distance, int cost) { this.distance = distance; this.cost = cost; } } static class Graph { private final int vertex, edges, end, start; private final Info[][] tables; Graph() throws IOException { String[] split = reader.readLine().split(" "); this.vertex = Integer.valueOf(split[0]); this.edges = Integer.valueOf(split[1]); this.start = Integer.valueOf(split[2]); this.end = Integer.valueOf(split[3]); tables = new Info[vertex][vertex]; for (int i = 0; i < edges; i++) { String[] lineInfo = reader.readLine().split(" "); int s = Integer.valueOf(lineInfo[0]); int e = Integer.valueOf(lineInfo[1]); int distance = Integer.valueOf(lineInfo[2]); int cost = Integer.valueOf(lineInfo[3]); tables[s][e] = new Info(distance, cost); tables[e][s] = new Info(distance, cost); } } Node bfs() { Node node = new Node(start); boolean[] checkTable = new boolean[vertex]; PriorityQueue<Node> queue = new PriorityQueue<>(); queue.add(node); while (!queue.isEmpty()) { Node poll = queue.poll(); if (poll.id == end) { return poll; } checkTable[poll.id] = true; for (int i = 0; i < vertex; i++) { Info info = tables[poll.id][i]; if (info != null && !checkTable[i]) { Node newNode = new Node(i); newNode.previous = poll; newNode.distance = poll.distance + info.distance; newNode.cost = poll.cost + info.cost; queue.offer(newNode); } } } return null; } } static class Node implements Comparable<Node> { int id, distance, cost; Node previous; Node(int id) { this.id = id; } @Override public int compareTo(Node o) { int compare = distance - o.distance; if (compare == 0) { compare = id - o.id; } return compare == 0 ? cost - o.cost : compare; } } public static void main(String[] args) throws IOException { Graph graph = new Graph(); Node bfs = graph.bfs(); LinkedList<String> list = new LinkedList<>(); list.addFirst(String.valueOf(bfs.cost)); list.addFirst(String.valueOf(bfs.distance)); while (bfs != null) { list.addFirst(String.valueOf(bfs.id)); bfs = bfs.previous; } int last = list.size() - 1; int start = 0; for (String o : list) { System.out.printf("%s%s", o, start == last ? "\n" : " "); start++; } } } |