團體程式設計天梯賽-習題集部分題解（大牛勿噴）
阿新 • • 發佈：2019-01-07
Group program design ladder match - practice set.
L1-001. 列印沙漏
時間限制 400 ms 記憶體限制 65536 kB 程式碼長度限制 8000 B
本題要求你寫個程式把給定的符號列印成沙漏的形狀。例如給定17個“*”，要求按下列格式列印
***** *** * *** *****
所謂“沙漏形狀”，是指每行輸出奇數個符號；各行符號中心對齊；相鄰兩行符號數差2；符號數先從大到小順序遞減到1，再從小到大順序遞增；首尾符號數相等。
給定任意N個符號，不一定能正好組成一個沙漏。要求打印出的沙漏能用掉儘可能多的符號。
輸入格式：
輸入在一行給出1個正整數N（<=1000）和一個符號，中間以空格分隔。
輸出格式：
首先打印出由給定符號組成的最大的沙漏形狀，最後在一行中輸出剩下沒用掉的符號數。
輸入樣例：
19 *
輸出樣例：
***** *** * *** ***** 2
程式碼如下：
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner in = new Scanner(System.in); while (in.hasNext()) { int n = in.nextInt(); String ch = in.nextLine(); int rem = 0; for (int i = 1; i <= n; i++) { int Sn = 2 * i * i - 1; rem = n - Sn; if (rem < 4 * i + 2) { break; } } int k = (int) Math.sqrt((n - rem + 1) / 2); for (int i = k; i >= 1; i--) { int p = 1; while (p <= k - i) { System.out.print(" "); p++; } int j = 1; while (j <= 2 * i - 1) { System.out.print(ch.substring(1)); j++; } System.out.println(); } for (int i = 2; i <= k; i++) { int p = 1; while (p <= k - i) { System.out.print(" "); p++; } int j = 1; while (j <= 2 * i - 1) { System.out.print(ch.substring(1)); j++; } System.out.println(); } System.out.println(rem); } in.close(); } }
L1-002. 個位數統計
時間限制 400 ms 記憶體限制 65536 kB 程式碼長度限制 8000 B
給定一個k位整數N = dk-1*10k-1 + ... + d1*101 + d0 (0<=di<=9, i=0,...,k-1, dk-1>0)，請編寫程式統計每種不同的個位數字出現的次數。例如：給定N = 100311，則有2個0，3個1，和1個3。
輸入格式：
每個輸入包含1個測試用例，即一個不超過1000位的正整數N。
輸出格式：
對N中每一種不同的個位數字，以D:M的格式在一行中輸出該位數字D及其在N中出現的次數M。要求按D的升序輸出。
輸入樣例：
100311
輸出樣例：
0:2 1:3 3:1
程式碼如下：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while (in.hasNext()) {
String str = in.nextLine();
int len = str.length();
int[] arr = new int[11];
for (int i = 0; i < len; i++) {
arr[str.charAt(i) - '0']++;
}
for (int i = 0; i < arr.length; i++) {
if (arr[i] != 0)
System.out.println(i + ":" + arr[i]);
}
}
in.close();
}
}
L1-003. 考試座位號
時間限制 200 ms 記憶體限制 65536 kB 程式碼長度限制 8000 B
每個PAT考生在參加考試時都會被分配兩個座位號，一個是試機座位，一個是考試座位。正常情況下，考生在入場時先得到試機座位號碼，入座進入試機狀態後，系統會顯示該考生的考試座位號碼，考試時考生需要換到考試座位就座。但有些考生遲到了，試機已經結束，他們只能拿著領到的試機座位號碼求助於你，從後臺查出他們的考試座位號碼。
輸入格式：
輸入第一行給出一個正整數N（<=1000），隨後N行，每行給出一個考生的資訊：“准考證號 試機座位號 考試座位號”。其中准考證號由14位數字組成，座位從1到N編號。輸入保證每個人的准考證號都不同，並且任何時候都不會把兩個人分配到同一個座位上。
考生資訊之後，給出一個正整數M（<=N），隨後一行中給出M個待查詢的試機座位號碼，以空格分隔。
輸出格式：
對應每個需要查詢的試機座位號碼，在一行中輸出對應考生的准考證號和考試座位號碼，中間用1個空格分隔。
輸入樣例：4 10120150912233 2 4 10120150912119 4 1 10120150912126 1 3 10120150912002 3 2 2 3 4
輸出樣例：
10120150912002 2 10120150912119 1程式碼如下:
import java.util.Scanner;
public class Demo {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while (in.hasNext()) {
long[] idArr = new long[1001];
int[] numArr = new int[1001];
int N = in.nextInt();
for (int i = 0; i < N; i++) {
long id = in.nextLong();
int index = in.nextInt();
int num = in.nextInt();
idArr[index] = id;
numArr[index] = num;
}
int M = in.nextInt();
int[] arr = new int[M];
for (int i = 0; i < M; i++) {
arr[i] = in.nextInt();
System.out.println(idArr[arr[i]] + " " + numArr[arr[i]]);
}
}
in.close();
}
}
L1-004. 念數字
時間限制 400 ms 記憶體限制 65536 kB 程式碼長度限制 8000 B輸入一個整數，輸出每個數字對應的拼音。當整數為負數時，先輸出“fu”字。十個數字對應的拼音如下：
0: ling 1: yi 2: er 3: san 4: si 5: wu 6: liu 7: qi 8: ba 9: jiu
輸入格式：
輸入在一行中給出一個整數，如： 1234 。
提示：整數包括負數、零和正數。
輸出格式：
在一行中輸出這個整數對應的拼音，每個數字的拼音之間用空格分開，行末沒有最後的空格。如 yi er san si。
-600輸出樣例：
fu liu ling ling
程式碼如下：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while (in.hasNext()) {
String str = in.nextLine();
char[] ch = str.toCharArray();
String[] newStr = new String[ch.length];
for (int i = 0; i < ch.length; i++) {
if (ch[i] == '-') {
newStr[i] = "fu";
} else if (ch[i] - '0' == 0) {
newStr[i] = "ling";
} else if (ch[i] - '0' == 1) {
newStr[i] = "yi";
} else if (ch[i] - '0' == 2) {
newStr[i] = "er";
} else if (ch[i] - '0' == 3) {
newStr[i] = "san";
} else if (ch[i] - '0' == 4) {
newStr[i] = "si";
} else if (ch[i] - '0' == 5) {
newStr[i] = "wu";
} else if (ch[i] - '0' == 6) {
newStr[i] = "liu";
} else if (ch[i] - '0' == 7) {
newStr[i] = "qi";
} else if (ch[i] - '0' == 8) {
newStr[i] = "ba";
} else if (ch[i] - '0' == 9) {
newStr[i] = "jiu";
}
}
for (int i = 0; i < newStr.length; i++) {
if (i == newStr.length - 1) {
System.out.println(newStr[i]);
} else {
System.out.print(newStr[i] + " ");
}
}
}
in.close();
}
}
L1-005. 求整數段和
時間限制 400 ms 記憶體限制 65536 kB 程式碼長度限制 8000 B給定兩個整數A和B，輸出從A到B的所有整數以及這些數的和。
輸入格式：
輸入在一行中給出2個整數A和B，其中-100<=A<=B<=100，其間以空格分隔。
輸出格式：
首先順序輸出從A到B的所有整數，每5個數字佔一行，每個數字佔5個字元寬度，向右對齊。最後在一行中輸出全部數字的和。
輸入樣例：-3 8輸出樣例：
-3 -2 -1 0 1
2 3 4 5 6
7 8
Sum = 30程式碼如下：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while (in.hasNext()) {
int beginNum = in.nextInt();
int endNum = in.nextInt();
int sum = 0;
int k = 0;
for (int i = beginNum; i <= endNum; i++) {
sum += i;
System.out.printf("%5d", i);
k++;
if (k % 5 == 0) {
System.out.println();
} else if (i == endNum) {
System.out.println();
}
}
System.out.println("sum = " + sum);
}
in.close();
}
}
L1-006. A-B
時間限制 100 ms 記憶體限制 65536 kB 程式碼長度限制 8000 B本題要求你計算A-B。不過麻煩的是，A和B都是字串 —— 即從字串A中把字串B所包含的字元全刪掉，剩下的字元組成的就是字串A-B。
輸入格式：
輸入在2行中先後給出字串A和B。兩字串的長度都不超過104，並且保證每個字串都是由可見的ASCII碼和空白字元組成，最後以換行符結束。
輸出格式：
在一行中打印出A-B的結果字串。
輸入樣例：I love GPLT! It's a fun game! aeiou輸出樣例：
I lv GPLT! It's fn gm!
程式碼如下：
import java.util.Scanner;
public class Main {
public static void main(String[] args) throws IOException {
Scanner cin = new Scanner(System.in);
BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
while (bf.ready()) {
String s = bf.readLine();
String ss = bf.readLine();
System.out.println(s.replaceAll("[" + ss + "]", ""));
}
cin.close();
}
}
L1-007. 跟奧巴馬一起畫方塊（1）
時間限制 400 ms 記憶體限制 65536 kB 程式碼長度限制 8000 B美國總統奧巴馬不僅呼籲所有人都學習程式設計，甚至以身作則編寫程式碼，成為美國曆史上首位編寫計算機程式碼的總統。2014年底，為慶祝“電腦科學教育周”正式啟動，奧巴馬編寫了很簡單的計算機程式碼：在螢幕上畫一個正方形。現在你也跟他一起畫吧！
輸入格式：
輸入在一行中給出正方形邊長N（3<=N<=21）和組成正方形邊的某種字元C，間隔一個空格。
輸出格式：
輸出由給定字元C畫出的正方形。但是注意到行間距比列間距大，所以為了讓結果看上去更像正方形，我們輸出的行數實際上是列數的50%（四捨五入取整）。
輸入樣例：10 a輸出樣例：
aaaaaaaaaa aaaaaaaaaa aaaaaaaaaa aaaaaaaaaa aaaaaaaaaa程式碼如下：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while (in.hasNext()) {
int n = in.nextInt();
String ch = in.next();
String newStr = "";
for (int i = 0; i < n; i++) {
newStr += ch;
}
for (int i = 0; i < (float) n / (float) 2; i++) {
System.out.println(newStr);
}
}
in.close();
}
}
L1-008. 查驗身份證
時間限制 400 ms 記憶體限制 65536 kB 程式碼長度限制 8000 B一個合法的身份證號碼由17位地區、日期編號和順序編號加1位校驗碼組成。校驗碼的計算規則如下：
首先對前17位數字加權求和，權重分配為：{7，9，10，5，8，4，2，1，6，3，7，9，10，5，8，4，2}；然後將計算的和對11取模得到值Z；最後按照以下關係對應Z值與校驗碼M的值：
Z：0 1 2 3 4 5 6 7 8 9 10
M：1 0 X 9 8 7 6 5 4 3 2
現在給定一些身份證號碼，請你驗證校驗碼的有效性，並輸出有問題的號碼。
輸入格式：
輸入第一行給出正整數N（<= 100）是輸入的身份證號碼的個數。隨後N行，每行給出1個18位身份證號碼。
輸出格式：
按照輸入的順序每行輸出1個有問題的身份證號碼。這裡並不檢驗前17位是否合理，只檢查前17位是否全為數字且最後1位校驗碼計算準確。如果所有號碼都正常，則輸出“All passed”。
輸入樣例1：4 320124198808240056 12010X198901011234 110108196711301866 37070419881216001X輸出樣例1：
12010X198901011234 110108196711301866 37070419881216001X
輸入樣例2：
2 320124198808240056 110108196711301862輸出樣例2：
All passed
程式碼如下：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
// 前17位數的權重
int[] weight = { 7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2 };
// 校驗碼M的值
char[] M = { '1', '0', 'X', '9', '8', '7', '6', '5', '4', '3', '2' };
while (in.hasNext()) {
int N = in.nextInt();
boolean flag = true;
for (int i = 0; i < N; i++) {
String str = in.next();
int sum = 0;
int is_wor = 0;
for (int j = 0; j < 17; j++) {
if (str.charAt(j) - '0' < 0 || str.charAt(j) - '0' > 9) {
System.out.println(str);
flag = false;
is_wor = 1;
break;
}
// 對前17位數字加權求和
sum += ((str.charAt(j) - '0') * weight[j]);
}
// 11取模得到值
int right = sum % 11;
char m = M[right];
// 檢查前17位是否全為數字且最後1位校驗碼計算準確
if (str.charAt(17) != m && is_wor == 0) {
flag = false;
System.out.println(str);
}
}
// 如果所有號碼都正常
if (flag) {
System.out.println("All passed");
}
}
in.close();
}
}
L1-009. 大笨鐘
時間限制 400 ms 記憶體限制 65536 kB 程式碼長度限制 8000 B微博上有個自稱“大笨鐘V”的傢伙，每天敲鐘催促碼農們愛惜身體早點睡覺。不過由於笨鍾自己作息也不是很規律，所以敲鐘並不定時。一般敲鐘的點數是根據敲鐘時間而定的，如果正好在某個整點敲，那麼“當”數就等於那個整點數；如果過了整點，就敲下一個整點數。另外，雖然一天有24小時，鍾卻是隻在後半天敲1~12下。例如在23:00敲鐘，就是“噹噹噹噹噹噹噹噹噹噹噹”，而到了23:01就會是“噹噹噹噹噹噹噹噹噹噹噹噹”。在午夜00:00到中午12:00期間（端點時間包括在內），笨鍾是不敲的。
下面就請你寫個程式，根據當前時間替大笨鐘敲鍾。
輸入格式：
輸入第一行按照“hh:mm”的格式給出當前時間。其中hh是小時，在00到23之間；mm是分鐘，在00到59之間。
輸出格式：
根據當前時間替大笨鐘敲鍾，即在一行中輸出相應數量個“Dang”。如果不是敲鐘期，則輸出：
Only hh:mm. Too early to Dang.
其中“hh:mm”是輸入的時間。
輸入樣例1：19:05輸出樣例1：
DangDangDangDangDangDangDangDang輸入樣例2：
07:05輸出樣例2：
Only 07:05. Too early to Dang.
程式碼如下：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while (in.hasNext()) {
String str = in.next();
int hh = (str.charAt(0) - '0') * 10 + str.charAt(1) - '0';
int mm = (str.charAt(3) - '0') * 10 + str.charAt(4) - '0';
if (hh <= 12 && mm == 0) {
System.out.println("Only " + str + ". Too early to Dang.");
} else {
for (int i = 0; i < hh - 12; i++) {
System.out.print("duang");
}
if (mm > 0) {
System.out.println("duang");
}
}
}
in.close();
}
}
L1-010. 誰先倒
時間限制 400 ms 記憶體限制 65536 kB 程式碼長度限制 8000 B划拳是古老中國酒文化的一個有趣的組成部分。酒桌上兩人划拳的方法為：每人口中喊出一個數字，同時用手比劃出一個數字。如果誰比劃出的數字正好等於兩人喊出的數字之和，誰就輸了，輸家罰一杯酒。兩人同贏或兩人同輸則繼續下一輪，直到唯一的贏家出現。
下面給出甲、乙兩人的酒量（最多能喝多少杯不倒）和划拳記錄，請你判斷兩個人誰先倒。
輸入格式：
輸入第一行先後給出甲、乙兩人的酒量（不超過100的非負整數），以空格分隔。下一行給出一個正整數N（<=100），隨後N行，每行給出一輪划拳的記錄，格式為：
甲喊 甲劃 乙喊 乙劃
其中“喊”是喊出的數字，“劃”是劃出的數字，均為不超過100的正整數（兩隻手一起劃）。
輸出格式：
在第一行中輸出先倒下的那個人：A代表甲，B代表乙。第二行中輸出沒倒的那個人喝了多少杯。題目保證有一個人倒下。注意程式處理到有人倒下就終止，後面的資料不必處理。
輸入樣例：1 1 6 8 10 9 12 5 10 5 10 3 8 5 12 12 18 1 13 4 16 12 15 15 1 1 16輸出樣例：
A 1
程式碼如下：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while (in.hasNext()) {
int Achol = in.nextInt();
int Bchol = in.nextInt();
int jia = Achol, yi = Bchol;
int n = in.nextInt();
for (int i = 0; i < n; i++) {
int Asay = in.nextInt();
int Aaction = in.nextInt();
int Bsay = in.nextInt();
int Baction = in.nextInt();
if (Aaction == Asay + Bsay && Baction != Asay + Bsay) {
Achol--;
}
if (Aaction != Asay + Bsay && Baction == Asay + Bsay) {
Bchol--;
}
if (Achol == -1) {
System.out.println("A\n" + (yi - Bchol));
break;
}
if (Bchol == -1) {
System.out.println("B\n" + (jia - Achol));
break;
}
}
}
in.close();
}
}
L1-011. 帥到沒朋友
時間限制 200 ms 記憶體限制 65536 kB 程式碼長度限制 8000 B當芸芸眾生忙著在朋友圈中發照片的時候，總有一些人因為太帥而沒有朋友。本題就要求你找出那些帥到沒有朋友的人。
輸入格式：
輸入第一行給出一個正整數N（<=100），是已知朋友圈的個數；隨後N行，每行首先給出一個正整數K（<=1000），為朋友圈中的人數，然後列出一個朋友圈內的所有人——為方便起見，每人對應一個ID號，為5位數字（從00000到99999），ID間以空格分隔；之後給出一個正整數M（<=10000），為待查詢的人數；隨後一行中列出M個待查詢的ID，以空格分隔。
注意：沒有朋友的人可以是根本沒安裝“朋友圈”，也可以是隻有自己一個人在朋友圈的人。雖然有個別自戀狂會自己把自己反覆加進朋友圈，但題目保證所有K超過1的朋友圈裡都至少有2個不同的人。
輸出格式：
按輸入的順序輸出那些帥到沒朋友的人。ID間用1個空格分隔，行的首尾不得有多餘空格。如果沒有人太帥，則輸出“No one is handsome”。
注意：同一個人可以被查詢多次，但只輸出一次。
輸入樣例1：3 3 11111 22222 55555 2 33333 44444 4 55555 66666 99999 77777 8 55555 44444 10000 88888 22222 11111 23333 88888輸出樣例1：
10000 88888 23333輸入樣例2：
3 3 11111 22222 55555 2 33333 44444 4 55555 66666 99999 77777 4 55555 44444 22222 11111輸出樣例2：
No one is handsome
程式碼如下：
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while (in.hasNext()) {
Map<Integer, Integer> map = new HashMap<>();
int n = in.nextInt();
int key = 0;
for (int i = 0; i < n; i++) {
int ni = in.nextInt();
for (int j = 0; j < ni; j++) {
key++;
int id = in.nextInt();
map.put(key, id);
}
}
boolean flag = true;
int m = in.nextInt();
ArrayList<Integer> list = new ArrayList<>();
for (int i = 0; i < m; i++) {
int checkId = in.nextInt();
if (!map.containsValue(checkId)) {
flag = false;
if (!list.contains(checkId)) {
list.add(checkId);
}
}
}
for (int i = 0; i < list.size(); i++) {
if (i < list.size() - 1)
System.out.print(list.get(i) + " ");
else
System.out.println(list.get(i));
}
if (flag) {
System.out.println("No one is handsome");
}
}
in.close();
}
}
L1-012. 輸出GPLT
時間限制 150 ms 記憶體限制 65536 kB 程式碼長度限制 8000 B給定一個長度不超過10000的、僅由英文字母構成的字串。請將字元重新調整順序，按“GPLTGPLT....”這樣的順序輸出，並忽略其它字元。當然，四種字元（不區分大小寫）的個數不一定是一樣多的，若某種字元已經輸出完，則餘下的字元仍按GPLT的順序列印，直到所有字元都被輸出。
輸入格式：
輸入在一行中給出一個長度不超過10000的、僅由英文字母構成的非空字串。
輸出格式：
在一行中按題目要求輸出排序後的字串。題目保證輸出非空。
輸入樣例：pcTclnGloRgLrtLhgljkLhGFauPewSKgt輸出樣例：
GPLTGPLTGLTGLGLL程式碼如下：
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
while (bf.ready()) {
String str = bf.readLine();
String newStr = str.toUpperCase();
int GCount = 0, PCount = 0, LCount = 0, TCount = 0;
for (int i = 0; i < newStr.length(); i++) {
if (newStr.charAt(i) == 'G') {
GCount++;
} else if (newStr.charAt(i) == 'P') {
PCount++;
} else if (newStr.charAt(i) == 'L') {
LCount++;
} else if (newStr.charAt(i) == 'T') {
TCount++;
}
}
while (GCount > 0 || PCount > 0 || LCount > 0 || TCount > 0) {
if (GCount > 0) {
System.out.print("G");
GCount--;
}
if (PCount > 0) {
System.out.print("P");
PCount--;
}
if (LCount > 0) {
System.out.print("L");
LCount--;
}
if (TCount > 0) {
System.out.print("T");
TCount--;
}
}
}
bf.close();
}
}
L1-013. A+B和C
時間限制 1000 ms 記憶體限制 32768 KB 程式碼長度限制 100 KB題目描述
給定區間[-2的31次方, 2的31次方]內的3個整數A、B和C，請判斷A+B是否大於C。輸入描述:
輸入第1行給出正整數T(<=10)，是測試用例的個數。隨後給出T組測試用例，每組佔一行，順序給出A、B和C。整數間以空格分隔。輸出描述:
對每組測試用例，在一行中輸出“Case #X: true”如果A+B>C，否則輸出“Case #X: false”，其中X是測試用例的編號（從1開始）。輸入例子:
4 1 2 3 2 3 4 2147483647 0 2147483646 0 -2147483648 -2147483647輸出例子:
Case #1: false Case #2: true Case #3: true Case #4: false
程式碼如下：
import java.math.BigInteger;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while (in.hasNext()) {
int n = in.nextInt();
int[] a = new int[n];
// 輸入n組三個整數
int i = 0;
while (n > 0) {
// 輸入A，B，C
BigInteger A = in.nextBigInteger();
BigInteger B = in.nextBigInteger();
BigInteger C = in.nextBigInteger();
// 判斷A+B==C
if (A.add(B).compareTo(C) > 0) {
a[i] = 1;
} else {
a[i] = 0;
}
i++;
n--;
}
// 輸出結果
for (int j = 0; j < a.length; j++) {
if (a[j] == 1) {
System.out.println("Case #" + (j + 1) + ": true");
} else {
System.out.println("Case #" + (j + 1) + ": false");
}
}
}
in.close();
}
}L1-014. 數字分類
時間限制 1000 ms 記憶體限制 32768 KB 程式碼長度限制 100 KB題目描述
給定一系列正整數，請按要求對數字進行分類，並輸出以下5個數字： A1 = 能被5整除的數字中所有偶數的和； A2 = 將被5除後餘1的數字按給出順序進行交錯求和，即計算n1-n2+n3-n4...； A3 = 被5除後餘2的數字的個數； A4 = 被5除後餘3的數字的平均數，精確到小數點後1位； A5 = 被5除後餘4的數字中最大數字。輸入描述:
每個輸入包含1個測試用例。每個測試用例先給出一個不超過1000的正整數N，隨後給出N個不超過1000的待分類的正整數。數字間以空格分隔。輸出描述:
對給定的N個正整數，按題目要求計算A1~A5並在一行中順序輸出。數字間以空格分隔，但行末不得有多餘空格。 若其中某一類數字不存在，則在相應位置輸出“N”。輸入例子:
13 1 2 3 4 5 6 7 8 9 10 20 16 18輸出例子:
30 11 2 9.7 9程式碼如下：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while (in.hasNext()) {
int N = in.nextInt();
int A1 = 0, A2 = 0, A3 = 0, A4 = 0, A5 = 0;
int count1 = 0, count2 = 0, count3 = 0, count4 = 0, count5 = 0;
for (int i = 1; i <= N; i++) {
int n = in.nextInt();
if (n % 5 == 0 && n % 2 == 0) {
A1 += n;
count1++;
} else if (n % 5 == 1) {
if ((count2 + 2) % 2 == 0) {
A2 += n;
} else {
A2 -= n;
}
count2++;
} else if (n % 5 == 2) {
A3++;
count3++;
} else if (n % 5 == 3) {
A4 += n;
count4++;
} else if (n % 5 == 4) {
if (n > A5)
A5 = n;
count5++;
}
}
float A4Sum = (float) A4 / (float) count4;
String aver = String.format("%.1f", A4Sum);
System.out.print(count1 == 0 ? "N" : A1);
System.out.print(" " + (count2 == 0 ? "N" : A2));
System.out.print(" " + (count3 == 0 ? "N" : A3));
System.out.print(" " + (count4 == 0 ? "N" : aver));
System.out.println(" " + (count5 == 0 ? "N" : A5));
}
in.close();
}
}
L1-015. 數素數
時間限制 1000 ms 記憶體限制 32768 KB 程式碼長度限制 100 KB題目描述
令Pi表示第i個素數。現任給兩個正整數M <= N <= 10000，請輸出PM到PN的所有素數。輸入描述:
輸入在一行中給出M和N，其間以空格分隔。輸出描述:
輸出從PM到PN的所有素數，每10個數字佔1行，其間以空格分隔，但行末不得有多餘空格。輸入例子:
5 27輸出例子:
11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 101 103程式碼如下：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while (in.hasNext()) {
int M = in.nextInt();
int N = in.nextInt();
int[] primeArr = new int[N - M + 1];
int count = 0;
int i = 0;
// 獲得第M到第N個素數
for (int j = 2;; j++) {
if (i == (N - M) + 1) {
break;
} else {
if (prime(j)) {
count++;
if (count >= M) {
primeArr[i] = j;
i++;
}
}
}
}
// 輸出陣列
int k = 1;
for (int j = 0; j < i; j++) {
if (k % 10 == 0) {
System.out.println(primeArr[j]);
} else if (j == i - 1) {
System.out.print(primeArr[j]);
} else {
System.out.print(primeArr[j] + " ");
}
k++;
}
}
in.close();
}
/**
* 功能：判斷是否為素數
*
* @param 需判斷的引數
* @return 返回boolean值
*/
private static boolean prime(int j) {
for (int i = 2; i <= j / 2; i++) {
if (j % i == 0)
return false;
}
return true;
}
}
L1-016. 部分A+B
時間限制 1000 ms 記憶體限制 32768 KB 程式碼長度限制 100 KB題目描述
正整數A的“DA（為1位整數）部分”定義為由A中所有DA組成的新整數PA。例如：給定A = 3862767，DA = 6，則A的“6部分”PA是66，因為A中有2個6。 現給定A、DA、B、DB，請編寫程式計算PA + PB。輸入描述:
輸入在一行中依次給出A、DA、B、DB，中間以空格分隔，其中0 < A, B < 1010。輸出描述:
在一行中輸出PA + PB的值。輸入例子:
3862767 6 13530293 3輸出例子:
399程式碼如下：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner cin = new Scanner(System.in);
int A = cin.nextInt();
int DA = cin.nextInt();
int B = cin.nextInt();
int DB = cin.nextInt();
int count_A = 0;
int count_B = 0;
int res_A = 0;
int res_B = 0;
while (A != 0) {
if (DA == A % 10) {
count_A++;
}
A /= 10;
}
while (B != 0) {
if (DB == B % 10) {
count_B++;
}
B /= 10;
}
for (int i = 0; i < count_A; i++) {
res_A = res_A * 10 + DA;
}
for (int i = 0; i < count_B; i++) {
res_B = res_B * 10 + DB;
}
System.out.println(res_A + res_B);
}
}L1-017. 錘子剪刀布
時間限制 1000 ms 記憶體限制 32768 KB 程式碼長度限制 100 KB題目描述
大家應該都會玩“錘子剪刀布”的遊戲： 現給出兩人的交鋒記錄，請統計雙方的勝、平、負次數，並且給出雙方分別出什麼手勢的勝算最大。輸入描述:
輸入第1行給出正整數N（<=105），即雙方交鋒的次數。隨後N行，每行給出一次交鋒的資訊，即甲、乙雙方同時給出的的手勢。C代表“錘子”、J代表“剪刀”、B代 表“布”，第1個字母代表甲方，第2個代表乙方，中間有1個空格。輸出描述:
輸出第1、2行分別給出甲、乙的勝、平、負次數，數字間以1個空格分隔。第3行給出兩個字母，分別代表甲、乙獲勝次數最多的手勢，中間有1個空格。如果解不唯 一，則輸出按字母序最小的解。輸入例子:
10 C J J B C B B B B C C C C B J B B C J J輸出例子:
5 3 2 2 3 5 B B程式碼如下：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while (in.hasNext()) {
int n = in.nextInt();
int rel = 0;
int AWin = 0, BWin = 0;
int AWinByC = 0, AWinByB = 0, AWinByJ = 0;
int BWinByC = 0, BWinByB = 0, BWinByJ = 0;
for (int i = 0; i < n; i++) {
String AShow = in.next(); // 甲
String BShow = in.next(); // 乙
// 1.雙方打平
if (AShow.equals(BShow)) {
rel++;
}
// 2.甲出錘子時
else if (AShow.equals("C")) {
// 甲勝
if (BShow.equals("J")) {
AWin++;
AWinByC++;
} else {
// 乙勝
BWin++;
BWinByB++;
}
}
// 3.甲出剪刀時
else if (AShow.equals("J")) {
// 甲勝
if (BShow.equals("B")) {
AWin++;
AWinByJ++;
} else {
// 乙勝
BWin++;
BWinByC++;
}
}
// 4.甲出剪刀時
else if (AShow.equals("B")) {
// 甲勝
if (BShow.equals("C")) {
AWin++;
AWinByB++;
} else {
// 乙勝
BWin++;
BWinByJ++;
}
}
}
// 輸出甲乙的戰績分析表
System.out.println(AWin + " " + rel + " " + (n - AWin - rel));
System.out.println(BWin + " " + rel + " " + (n - BWin - rel));
// 排序通過哪個贏的機率
int AWinCountBy = sort(AWinByC, AWinByJ, AWinByB);
int BWinCountBy = sort(BWinByC, BWinByJ, BWinByB);
// 甲贏的絕招
if (AWinCountBy == AWinByB) {
System.out.print("B ");
} else if (AWinCountBy == AWinByC) {
System.out.print("C ");
} else {
System.out.print("J ");
}
// 乙贏的絕招
if (BWinCountBy == BWinByB) {
System.out.println("B");
} else if (BWinCountBy == BWinByC) {
System.out.println("C");
} else {
System.out.println("J");
}
}
in.close();
}
/**
* 獲得三個數的最大值
*
* @param aWinByC
* @param aWinByJ
* @param aWinByB
* @return 返回最大值
*/
private static int sort(int aWinByC, int aWinByJ, int aWinByB) {
int max = 0;
if (aWinByJ > aWinByC)
max = aWinByJ;
else
max = aWinByC;
if (aWinByB > max)
max = aWinByB;
return max;
}
}
L1-018. 月餅
時間限制 1000 ms 記憶體限制 32768 KB 程式碼長度限制 100 KB題目描述
月餅是中國人在中秋佳節時吃的一種傳統食品，不同地區有許多不同風味的月餅。現給定所有種類月餅的庫存量、總售價、以及市場的最大需 求量，請你計算可以獲得的最大收益是多少。 注意：銷售時允許取出一部分庫存。樣例給出的情形是這樣的：假如我們有3種月餅，其庫存量分別為18、15、10萬噸，總售價分別為75、 72、45億元。如果市場的最大需求量只有20萬噸，那麼我們最大收益策略應該是賣出全部15萬噸第2種月餅、以及5萬噸第3種月餅，獲得 72 + 45/2 = 94.5（億元）。輸入描述:
每個輸入包含1個測試用例。每個測試用例先給出一個不超過1000的正整數N表示月餅的種類數、以及不超過500（以萬噸為單位）的正整數 D表示市場最大需求量。隨後一行給出N個正數表示每種月餅的庫存量（以萬噸為單位）；最後一行給出N個正數表示每種月餅的總售價（以億 元為單位）。數字間以空格分隔。輸出描述:
對每組測試用例，在一行中輸出最大收益，以億元為單位並精確到小數點後2位。輸入例子:
3 20 18 15 10 75 72 45輸出例子:
94.50程式碼如下：
import java.util.Arrays;
import java.util.Scanner;
//設定類用於儲存月餅的總價、庫存量，以及計算其單價
class moCake implements Comparable<moCake>{
int totalValue;
int repertories;
double price;
@Override
public int compareTo(moCake m) {
//設定月餅的排序為單價從大到小的順序
return this.price>m.price ? -1:1;
}
}
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
//月餅種類數量，以及需求數量
int num = in.nextInt();
int requirement = in.nextInt();
moCake[] mc = new moCake[num];
for (int i = 0; i < mc.length; i++) {
//對物件操作之前，先將其例項化
mc[i] = new moCake();
mc[i].repertories = in.nextInt();
}
for (int i = 0; i < mc.length; i++) {
mc[i].totalValue = in.nextInt();
}
in.close();
//計算每個月餅的單價
for (int i = 0; i < mc.length; i++) {
mc[i].price = (double) mc[i].totalValue / mc[i].repertories;
}
//對月餅陣列進行排序
Arrays.sort(mc);
double earning = 0.0;
//從月餅單價最大開始遍歷，直接滿足需求
for(int i = 0; i < mc.length; i++) {
if (requirement > mc[i].repertories) {
earning += mc[i].totalValue;
requirement -= mc[i].repertories;
}else {
earning += ((double)requirement/mc[i].repertories) * mc[i].totalValue;
break;
}
}
System.out.printf("%.2f\n",earning);//格式化輸出
}
}L1-019. D進位制的A+B
時間限制 1000 ms 記憶體限制 32768 KB 程式碼長度限制 100 KB題目描述
輸入兩個非負10進位制整數A和B(<=230-1)，輸出A+B的D (1 < D <= 10)進位制數。輸入描述:輸入在一行中依次給出3個整數A、B和D。輸出描述:
輸出A+B的D進位制數。輸入例子:
123 456 8輸出例子:
1103程式碼如下：
import java.math.BigInteger;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while (in.hasNext()) {
BigInteger A = in.nextBigInteger();
BigInteger B = in.nextBigInteger();
BigInteger change = in.nextBigInteger();
BigInteger[] rem = new BigInteger[100];
int i = 0;
BigInteger temp = A.add(B);
while (temp.compareTo(BigInteger.ZERO) > 0) {
i++;
rem[i] = temp.remainder(change);
temp = temp.divide(change);
}
for (int j = i; j > 0; j--) {
System.out.print(rem[j]);
}
}
in.close();
}
}
L1-020. 跟奧巴馬一起程式設計（2）
時間限制 1000 ms 記憶體限制 32768 KB 程式碼長度限制 100 KB題目描述
美國總統奧巴馬不僅呼籲所有人都學習程式設計，甚至以身作則編寫程式碼，成為美國曆史上首位編寫計算機程式碼的總統。2014年底，為慶祝“計算 機科學教育周”正式啟動，奧巴馬編寫了很簡單的計算機程式碼：在螢幕上畫一個正方形。現在你也跟他一起畫吧！輸入描述:
輸入在一行中給出正方形邊長N（3<=N<=20）和組成正方形邊的某種字元C，間隔一個空格。輸出描述:
輸出由給定字元C畫出的正方形。但是注意到行間距比列間距大，所以為了讓結果看上去更像正方形，我們輸出的行數實際上是列數的50% （四捨五入取整）。輸入例子:
10 a輸出例子:
aaaaaaaaaa a a a a a a aaaaaaaaaa程式碼如下：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
String c = in.next();
double m;
double m1 = n / 2.0;
int m2 = n / 2;
if ((m1 - m2) >= 0.5) {
m = m2 + 1;
} else {
m = m2;
}
//
for (int i = 0; i < n; i++) {
System.out.print(c);
}
System.out.println();
for (int i = 0; i < m - 2; i++) {
System.out.print(c);
for (int j = 0; j < n - 2; j++) {
System.out.print(" ");
}
System.out.print(c);
System.out.println();
}
for (int i = 0; i < n; i++) {
System.out.print(c);
}
}
}