PAT乙級測試題及JAVA參考例程
PAT就是浙江大學程式設計能力考試，網址為http://www.patest.cn。考試分為乙級、甲級和Top。這裡分享一下乙級測試題和我實現的一些解法，如果有不同的解法或者更好的實現方式，歡迎在文章下面回覆。主要是在提交的時候，需要注意編譯器裡為Main.class 所以主類的命名要為Main。
刷到第11題以後，java的劣勢體現出來了，題庫的時間限制都是針對c的，java讀入資料的時間就可能會超過時間限制，所以後來我就沒有繼續刷題了，現在在牛客網刷PAT和其他線上測試，後續還會在更新其他題目。
1001. 害死人不償命的(3n+1)猜想 (15)
卡拉茲(Callatz)猜想：
對任何一個自然數n，如果它是偶數，那麼把它砍掉一半；如果它是奇數，那麼把(3n+1)砍掉一半。這樣一直反覆砍下去，最後一定在某一步得到n=1。卡拉茲在1950年的世界數學家大會上公佈了這個猜想，傳說當時耶魯大學師生齊動員，拼命想證明這個貌似很傻很天真的命題，結果鬧得學生們無心學業，一心只證(3n+1)，以至於有人說這是一個陰謀，卡拉茲是在蓄意延緩美國數學界教學與科研的進展……
我們今天的題目不是證明卡拉茲猜想，而是對給定的任一不超過1000的正整數n，簡單地數一下，需要多少步（砍幾下）才能得到n=1？
輸入格式：每個測試輸入包含1個測試用例，即給出自然數n的值。
輸出格式：輸出從n計算到1需要的步數。
輸入樣例：
3
輸出樣例：
5
這裡第1題沒有什麼好說的，按照題目要求給出次數就好，程式碼如下。
import java.util.Scanner; /** * * @author zjb */ public class Main { public static void main(String[] args){ Scanner sc = new Scanner(System.in); int num = Integer.parseInt(sc.nextLine()); int step=0; while(num >1){ if(num%2 == 0){ num = num/2; step++; } else{ num = (3*num+1)/2; step++; } } System.out.println(step); } }
1002. 寫出這個數 (20)
讀入一個自然數n，計算其各位數字之和，用漢語拼音寫出和的每一位數字。
輸入格式：每個測試輸入包含1個測試用例，即給出自然數n的值。這裡保證n小於10100。
輸出格式：在一行內輸出n的各位數字之和的每一位，拼音數字間有1 空格，但一行中最後一個拼音數字後沒有空格。
輸入樣例：
1234567890987654321123456789
輸出樣例：
yi san wu
這個題一般也不會遇到什麼問題，各個數位求和，然後求出和的每一位數，並且用switch語句和0到9的拼音匹配就好。程式碼如下：
import java.util.Scanner; import java.util.Stack; /** * * @author zjb */ public class Main { public static void main(String[] args){ Scanner sc = new Scanner(System.in); String numString = sc.next(); int num = 0; int sum = 0; for(int i=0; i<numString.length(); i++){ num = Integer.parseInt(numString.substring(i,i+1)); sum += num; } changenum(sum); } public static void changenum(int num){ //System.out.println(num); Stack<Integer> stack = new Stack(); String output = new String(); String outtemp = new String(); int temp; int flag = 0; if(num ==0) output += "ling"; while(num>0){ stack.push(num%10); num = num/10; } while(!stack.empty()){ temp = stack.pop(); switch(temp){ case 0: outtemp = "ling"; break; case 1: outtemp = "yi"; break; case 2: outtemp = "er"; break; case 3: outtemp = "san"; break; case 4: outtemp = "si"; break; case 5: outtemp = "wu"; break; case 6: outtemp = "liu"; break; case 7: outtemp = "qi"; break; case 8: outtemp = "ba"; break; case 9: outtemp = "jiu"; break; } if(flag ==0){ output += outtemp; flag = 1; } else{ output =output+ " " +outtemp; } } System.out.println(output); } }
1003. 我要通過！(20)
“答案正確”是自動判題系統給出的最令人歡喜的回覆。本題屬於PAT的“答案正確”大派送—— 只要讀入的字串滿足下列條件，系統就輸出“答案正確”，否則輸出“答案錯誤”。
得到“答案正確”的條件是：
1. 字串中必須僅有P, A, T這三種字元，不可以包含其它字元；
2. 任意形如 xPATx 的字串都可以獲得“答案正確”，其中 x 或者是空字串，或者是僅由字母 A 組成的字串；
3. 如果 aPbTc 是正確的，那麼aPbATca 也是正確的，其中 a, b, c 均或者是空字串，或者是僅由字母 A 組成的字串。
現在就請你為PAT寫一個自動裁判程式，判定哪些字串是可以獲得“答案正確”的。
輸入格式：每個測試輸入包含1個測試用例。第1行給出一個自然數n (<10)，是需要檢測的字串個數。接下來每個字串佔一行，字串長度不超過100，且不包含空格。
輸出格式：每個字串的檢測結果佔一行，如果該字串可以獲得“答案正確”，則輸出YES，否則輸出NO
。
輸入樣例：
8
PAT
PAAT
AAPATAA
AAPAATAAAA
xPATx
PT
Whatever
APAAATAA
輸出樣例：
YES
YES
YES
YES
NO
NO
NO
NO
這個題目會存在一些小小的問題，主要是對於題目的理解不是很到位引起的。
首先我們看題目的意思，1和2兩點沒有問題，主要是第3點，其實第3點是對第2點的推廣。理解了這一點之後，就可以發現規律了。其實從2我們可以發現，在1 2的約束下，滿足條件的只有兩種形式PAT和APATA，那麼3中滿足條件的必然是從2推匯出來的。
1.如果初始的是PAT那麼接下來就是PAAT，再接下來就是PAAAT，以此類推。
2.如果初始狀態是aPATa的話，那麼接下來就是aPAATaa，在接下來就是aPAAATaaa,其中a為A的字串，我們發現num(P前面a)*num(A)=num(T後面a)，上面的形式也滿足這個條件，所以我們可以利用這個約束來判斷。下面是程式碼部分：
import java.util.Scanner;
/**
*
* @author zjb
*/
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
for(int i=0; i<num; i++){
int numa = 0;
int nump = 0;
int numt = 0;
boolean flag = false;
String str = sc.next();
for(int j=0; j<str.length(); j++){
char ch = str.charAt(j);
if(ch == 'A')
numa++;
else if(ch == 'P')
nump++;
else if(ch == 'T')
numt++;
else{
flag = false;
break;
}
}
if(numa>=1 && nump==1 && numt==1){
//System.out.println(str.indexOf('P'));
//System.out.println(str.indexOf('T'));
if(str.indexOf('P')*(str.indexOf('T')-str.indexOf('P')-1) == str.length() - str.indexOf('T')-1)
flag = true;
else
flag = false;
//str.indexOf('P')*(str.indexOf('T')-str.indexOf('P'));
//int numAbeforeP = str.indexOf('P');
}
if(flag)
System.out.println("YES");
else
System.out.println("NO");
}
}
}
1004. 成績排名 (20)
讀入n名學生的姓名、學號、成績，分別輸出成績最高和成績最低學生的姓名和學號。
輸入格式：每個測試輸入包含1個測試用例，格式為
第1行：正整數n
第2行：第1個學生的姓名 學號 成績
第3行：第2個學生的姓名 學號 成績
...... ...
第n+1行：第n個學生的姓名 學號 成績
其中姓名和學號均為不超過10個字元的字串，成績為0到100之間的一個整數，這裡保證在一組測試用例中沒有兩個學生的成績是相同的。
輸出格式：對每個測試用例輸出2行，第1行是成績最高學生的姓名和學號，第2行是成績最低學生的姓名和學號，字串間有1空格。
輸入樣例：
3
Joe Math990112 89
Mike CS991301 100
Mary EE990830 95
輸出樣例：
Mike CS991301
Joe Math990112
這一題有幾個注意點需要注意：
1.當n=1的時候需要處理，此時應該輸出兩行一樣的姓名和學號
2. 由於提交的jdk版本是jdk1.6 不支援，自己實現Comparator介面，覆蓋compare方法的sort，所以我這裡使用了Collections.sort()進行排序，程式碼如下
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.Scanner;
/**
*
* @author zjb
*/
public class Main{
public static void main(String args[]){
Scanner sc = new Scanner(System.in);
int rp = sc.nextInt();
String studentInfo = new String();
studentInfo = sc.nextLine();
List<String> studentList = new ArrayList();
List<Integer> studentscore = new ArrayList();
for(int i=0; i<rp; i++){
studentInfo = sc.nextLine();
studentList.add(studentInfo);
//System.out.println(studentInfo);
}
if(rp == 1){
String[] output = studentList.get(0).split(" ");
System.out.println(output[0]+" "+output[1]);
System.out.println(output[0]+" "+output[1]);
}
else{
for(int i=0; i<studentList.size(); i++){
String[] arr = studentList.get(i).split(" ");
studentscore.add(Integer.parseInt(arr[2]));
}
Collections.sort(studentscore);
Integer min = studentscore.get(0);
Integer max = studentscore.get(studentscore.size()-1);
String[] minString = new String[2];
String[] maxString = new String[2];
for(int i=0; i<studentList.size(); i++){
String[] arr = studentList.get(i).split(" ");
if(min.equals(Integer.parseInt(arr[2]))){
minString[0] = arr[0];
minString[1] = arr[1];
}
if(max.equals(Integer.parseInt(arr[2]))){
maxString[0] = arr[0];
maxString[1] = arr[1];
}
}
//String[] arr = maxString.split(" ");
System.out.println(maxString[0]+" "+maxString[1]);
//arr = minString.split(" ");
System.out.println(minString[0]+" "+minString[1]);
}
}
}
1005. 繼續(3n+1)猜想 (25)
卡拉茲(Callatz)猜想已經在1001中給出了描述。在這個題目裡，情況稍微有些複雜。
當我們驗證卡拉茲猜想的時候，為了避免重複計算，可以記錄下遞推過程中遇到的每一個數。例如對n=3進行驗證的時候，我們需要計算3、5、8、4、2、1，則當我們對n=5、8、4、2進行驗證的時候，就可以直接判定卡拉茲猜想的真偽，而不需要重複計算，因為這4個數已經在驗證3的時候遇到過了，我們稱5、8、4、2是被3“覆蓋”的數。我們稱一個數列中的某個數n為“關鍵數”，如果n不能被數列中的其他數字所覆蓋。
現在給定一系列待驗證的數字，我們只需要驗證其中的幾個關鍵數，就可以不必再重複驗證餘下的數字。你的任務就是找出這些關鍵數字，並按從大到小的順序輸出它們。
輸入格式：每個測試輸入包含1個測試用例，第1行給出一個正整數K(<100)，第2行給出K個互不相同的待驗證的正整數n(1<n<=100)的值，數字間用空格隔開。
輸出格式：每個測試用例的輸出佔一行，按從大到小的順序輸出關鍵數字。數字間用1個空格隔開，但一行中最後一個數字後沒有空格。
輸入樣例：
6
3 5 6 7 8 11
輸出樣例：
7 6
這個題就是1001的延續，這裡對每一個輸入的數字，都遍歷一邊整個輸入的驗證過程，這種方式比較消耗記憶體，可以看到我在這裡使用了3個ArrayList，
還有一種方法就是對每一個輸入做一次卡拉茨驗證，然後設立一個標記陣列，由於輸入不超過1000，所以可以設定標記陣列flag[3001],在迴圈驗證輸入的時候，比如驗證了2那麼就對flag[2]++,這樣只要進行一次遍歷驗證，那麼就可以得到flag，查詢flag中大於1的項就是重複驗證的項，這樣就只需要開銷一個list和一個數組，這種方法在輸入比較多的時候比較快速。
三個List的程式碼如下：
import java.util.*;
/**
*
* @author zjb
*/
public class Main {
public static void main(String args[]){
Scanner sc = new Scanner(System.in);
int rp = sc.nextInt();
int numin;
int num;
List<Integer> list = new ArrayList();
List<Integer> copylist = new ArrayList();
List<Integer> specillist = new ArrayList();
for(int i=0; i<rp; i++){
numin = sc.nextInt();
list.add(numin);
copylist.add(numin);
}
//copylist = list;
Iterator it = list.iterator();
while(it.hasNext()){
num = (Integer)it.next();
// System.out.println(num+"++");
if(!ifSpecil(copylist,num)){
specillist.add(num);
// System.out.println(num);
}
}
// B1005CMP cmp = new B1005CMP();
Collections.sort(specillist);
for(int i=specillist.size()-1; i>=0; i--){
if(i == specillist.size()-1)
System.out.print(specillist.get(i));
else
System.out.print(" "+specillist.get(i));
}
}
public static boolean ifSpecil(List copylist, int num){
boolean flag = false;
Integer testnum;
for(int i=0; i<copylist.size(); i++){
testnum = (Integer)copylist.get(i);
//System.out.println(testnum);
while(testnum>1&&!(testnum.equals(num))){
if(testnum%2 == 0){
testnum = testnum/2;
if(testnum == num)
flag = true;
}
else{
testnum = (3*testnum+1)/2;
if(testnum == num){
flag = true;
}
}
}
}
return flag;
}
}
1006. 換個格式輸出整數 (15)
讓我們用字母B來表示“百”、字母S表示“十”，用“12...n”來表示個位數字n（<10），換個格式來輸出任一個不超過3位的正整數。例如234應該被輸出為BBSSS1234，因為它有2個“百”、3個“十”、以及個位的4。
輸入格式：每個測試輸入包含1個測試用例，給出正整數n（<1000）。
輸出格式：每個測試用例的輸出佔一行，用規定的格式輸出n。
輸入樣例1：
234
輸出樣例1：
BBSSS1234
輸入樣例2：
23
輸出樣例2：
SS123
這道題比較簡單，程式碼如下
import java.util.*;
/**
*
* @author zjb
*/
public class Main {
public static void main(String args[]){
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
int numb = num/100;
num = num%100;
int nums = num/10;
int numg = num%10;
String output = new String();
while(numb > 0){
output += "B";
numb--;
}
while(nums > 0){
output += "S";
nums--;
}
for(int i=1; i<numg+1; i++){
output += i;
}
System.out.println(output);
}
}
1007. 素數對猜想 (20)
讓我們定義 dn 為：dn = pn+1 - pn，其中 pi 是第i個素數。顯然有 d1=1 且對於n>1有 dn 是偶數。“素數對猜想”認為“存在無窮多對相鄰且差為2的素數”。
現給定任意正整數N (< 105)，請計算不超過N的滿足猜想的素數對的個數。
輸入格式：每個測試輸入包含1個測試用例，給出正整數N。
輸出格式：每個測試用例的輸出佔一行，不超過N的滿足猜想的素數對的個數。
輸入樣例：
20
輸出樣例：
4
這個題目需要注意的是
1.不超過N的素數對，那麼對於N是偶數和基數就要分開處理了
2.判斷素數的時候for(int i=2;i<Math.sqrt(num)+1; i++)只要整除num的開放加1就可以判斷是不是素數，如果從2到nun-1的話，很可能超時間。
程式碼如下：
import java.util.*;
/**
*
* @author zjb
*/
public class Main {
public static void main(String args[]){
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
int pairnum = 0;
int up = (num%2 == 1)? num/2:num/2-1;
for(int i=1; i<=up; i++){
if(isPrime(2*i-1)&&isPrime(2*i+1))
pairnum++;
}
System.out.println(pairnum);
}
public static boolean isPrime(int num){
if(num <= 2)
return false;
for(int i=2; i<Math.sqrt(num)+1; i++){
if(num%i == 0)
return false;
}
return true;
}
}
1008. 陣列元素迴圈右移問題 (20)
一個數組A中存有N（N>0）個整數，在不允許使用另外陣列的前提下，將每個整數迴圈向右移M（M>=0）個位置，即將A中的資料由（A0A1……AN-1）變換為（AN-M …… AN-1 A0 A1……AN-M-1）（最後M個數迴圈移至最前面的M個位置）。如果需要考慮程式移動資料的次數儘量少，要如何設計移動的方法？
輸入格式：每個輸入包含一個測試用例，第1行輸入N ( 1<=N<=100)、M（M>=0）；第2行輸入N個整數，之間用空格分隔。
輸出格式：在一行中輸出迴圈右移M位以後的整數序列，之間用空格分隔，序列結尾不能有多餘空格。
輸入樣例：
6 2
1 2 3 4 5 6
輸出樣例：
5 6 1 2 3 4
這個題目說是不允許使用另外陣列的前提下，當然如果使用另外的陣列當然可以通過提交，因為測試用例測試不出來你是否使用了另外的陣列，當然作為練習階段當然還是不適用另外的陣列比較好，其實實現起來也比較容易，因為N<=100，所以只要宣告一個200的陣列就，就可以把陣列先整體後移動，再把後面的移上來就好了。程式碼如下所示：
import java.util.*;
/**
*
* @author zjb
*/
public class Main {
private int[] a;
private int N;
private int M;
public Main(int[]a, int N, int M){
this.a = a;
this.N = N;
this.M = M;
}
public void cycleMove(){
for(int i=N-1; i>=0; i--){
a[i+M] = a[i];
}
for(int i=0; i<M; i++){
a[i] = a[N+i];
}
}
public void display(){
for(int i=0; i<N; i++){
// System.out.println("+++++++++");
if(i == 0)
System.out.print(a[i]);
else
System.out.print(" "+a[i]);
}
}
public static void main(String args[]){
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
int M = sc.nextInt();
M = M%N;
int[] a = new int[200];
for(int i=0; i<N; i++){
a[i] = sc.nextInt();
}
// System.out.println("+++++++++");
Main my = new Main(a,N,M);
// my.display();
my.cycleMove();
my.display();
}
}
1009. 說反話 (20)
給定一句英語，要求你編寫程式，將句中所有單詞的順序顛倒輸出。
輸入格式：測試輸入包含一個測試用例，在一行內給出總長度不超過80的字串。字串由若干單詞和若干空格組成，其中單詞是由英文字母（大小寫有區分）組成的字串，單詞之間用1個空格分開，輸入保證句子末尾沒有多餘的空格。
輸出格式：每個測試用例的輸出佔一行，輸出倒序後的句子。
輸入樣例：
Hello World Here I Come
輸出樣例：
Come I Here World Hello
這個題目很簡單沒什麼好說的，實現方法也很多，程式碼如下：
import java.util.*;
/**
*
* @author zjb
*/
public class Main {
public static void main(String args[]){
Scanner sc = new Scanner(System.in);
String str = sc.nextLine();
String[] strarr = str.split(" ");
for(int i=strarr.length-1; i>=0; i--){
if(i==strarr.length-1)
System.out.print(strarr[i]);
else
System.out.print(" "+strarr[i]);
}
}
}
1010. 一元多項式求導 (25)
設計函式求一元多項式的導數。（注：xn（n為整數）的一階導數為n*xn-1。）
輸入格式：以指數遞降方式輸入多項式非零項係數和指數（絕對值均為不超過1000的整數）。數字間以空格分隔。
輸出格式：以與輸入相同的格式輸出導數多項式非零項的係數和指數。數字間以空格分隔，但結尾不能有多餘空格。注意“零多項式”的指數和係數都是0，但是表示為“0 0”。
輸入樣例：
3 4 -5 2 6 1 -2 0
輸出樣例：
12 3 -10 1 6 0
這個題目很奇怪，因為其實題目已經給你規定好輸入格式了非零項的係數和指數。如果n為洗漱，e為指數的話，保證了a大於0，只要考慮e大於零輸出就好了，很奇怪的時候最後輸入"0 0"的語句，理論上是永遠達不到的，可能測試樣對於0多項式的測試，採用了終止Scanner的方式，這樣必須在後面加個判斷，這個也是我網上找的處理方式，其實一開始我自己寫的也一直過不了測試點，程式碼如下：
import java.util.*;
/**
*
* @author zjb
*/
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int a,b;
boolean flag = false;
while(sc.hasNext()){
a = sc.nextInt();
b = sc.nextInt();
if(b>0)
if(!flag){
System.out.print(a*b+" "+(b-1));
flag = true;
}
else{
System.out.print(" "+a*b+" "+(b-1));
}
}
if(!flag)
System.out.print("0 0");
}
}
1011. A+B和C (15)
給定區間[-231, 231]內的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
這個題目需要注意的是int型別的長度，java中int為32位所以會存在越界的現象，換成Long型別就沒有問題了，程式碼如下：
import java.util.*;
/**
*
* @author zjb
*/
public class Main {
public static void main(String[] args){
//System.out.print(Integer.SIZE);
Scanner sc = new Scanner(System.in);
int T = sc.nextInt();
sc.nextLine();
List<String> list = new ArrayList();
for(int i=0; i<T; i++){
list.add(sc.nextLine());
}
for(int i=0; i<T; i++){
String[] strarr = list.get(i).split(" ");
long A = Long.parseLong(strarr[0]);
long B = Long.parseLong(strarr[1]);
long C = Long.parseLong(strarr[2]);
//System.out.print(A+" "+B+" "+C+" ");
if(A+B > C)
System.out.println("Case #"+(i+1)+": true");
else
System.out.println("Case #"+(i+1)+": false");
}
}
}
相關推薦
PAT乙級測試題及JAVA參考例程
PAT就是浙江大學程式設計能力考試，網址為http://www.patest.cn。考試分為乙級、甲級和Top。這裡分享一下乙級測試題和我實現的一些解法，如果有不同的解法或者更好的實現方式，歡迎在文章下面回覆。主要是在提交的時候，需要注意編譯器裡為Main.class 所
Kinect.dll檔案、驅動及LabVIEW開發例程問題
轉載請註明出處 Kinect是微軟公司開發的一款體感感測器（具體內容可以百度，這裡只講部分個人遇到的問題）。 環境：Windows7，Kinect 1.8 SDK，LabVIEW15.0； 問題：（1）找不到 Microsoft.Kinect.dll 動態連結庫；（2）找不到LabVIEW對K
1025. 反轉連結串列 (25)-浙大PAT乙級真題java實現
個人部落格：開啟連結 1025. 反轉連結串列 (25) 給定一個常數K以及一個單鏈表L，請編寫程式將L中每K個結點反轉。例如：給定L為1→2→3→4→5→6，K為3，則輸出應該為3→2→1→6→5
1049. 數列的片段和(20)-浙大PAT乙級真題java實現
個人部落格：開啟連結 1049. 數列的片段和(20) 給定一個正數數列，我們可以從中擷取任意的連續的幾個數，稱為片段。例如，給定數列{0.1, 0.2, 0.3, 0.4}，我們有(0.1) (0
C語言及程式設計初步例程-26 利用switch語句解決問題
應用：計算運費每公里每噸貨物的基本運費為p(price)，貨物重為w(weight)，距離為s，折扣為d(discount)，則總運費f(freight)的計算公式為 freight=price*wei
VS2010下的多執行緒程式設計入門參考例程
/* * File : main.c * De
1071.小賭怡情(15)--PAT乙級真題java實現
個人部落格：小景哥哥 1071.小賭怡情(15)–PAT乙級真題java實現 常言道“小賭怡情”。這是一個很簡單的小遊戲：首先由計算機給出第一個整數；然後玩家下注賭第二個整數將會比第一個數大還是小；玩家下注t個籌碼後，計算機給出第二個數。若玩家猜對了，則
1003. 我要通過！(20)-浙大PAT乙級真題Java實現
1003. 我要通過！(20)“答案正確”是自動判題系統給出的最令人歡喜的回覆。本題屬於PAT的“答案正確”大派送 —— 只要讀入的字串滿足下列條件，系統就輸出“答案正確”，否則輸出“答案錯誤”。
1040. 有幾個PAT（25）-浙大PAT乙級真題java實現
個人部落格：開啟連結 1040. 有幾個PAT（25） 字串APPAPT中包含了兩個單詞“PAT”，其中第一個PAT是第2位(P),第4位(A),第6位(T)； 第二個PAT是第3位(P),第4位
C語言及程式設計初步例程-42 將資料輸出到文字檔案
檔案的操作步驟#include <stdio.h> #include <stdlib.h> int main() { FILE *fp; int i, d;
1072. 開學寄語(20)--PAT乙級真題java實現
個人部落格：小景哥哥 1072. 開學寄語(20)–PAT乙級真題java實現 下圖是上海某校的新學期開學寄語：天將降大任於斯人也，必先刪其微博，卸其QQ，封其電腦，奪其手機，收其ipad，斷其wifi，使其百無聊賴，然後，淨面、理髮、整衣，然後思過、讀書、
C語言及程式設計初步例程-25 用switch語句實現多分支結構
例：這是星期幾?#include <stdio.h> int main() { int week; scanf("%d", &week); switch(we
牛客網PAT乙級真題及java實現樣例（真題1-14）
由於之前在PAT官網的練習場有時間限制，而且限制是針對c的基本上100ms到400ms，由於java需要虛擬機器才能執行，因此有些題實在不是因為演算法的原因才超時，牛客網的時間限制為1s，而且給我感覺後臺伺服器也比PAT官網跑的快，一樣的程式PAT官網要80ms，牛客網只要
java 多線程中的鎖的類別及使用
ron 靜態方法 log 代碼 targe 對象實例 javase 依賴 監視器 目前在Java中存在兩種鎖機制： synchronized Lock Lock接口及其實現類是JDK5增加的內容，其作者是大名鼎鼎的並發專家Doug Lea。 數據同步需要依賴鎖，那鎖的
JAVA多線程及補充
線程死鎖 面向 封裝 摘要 long build random類 比較 current 進程 運行中的應用程序叫進程，每個進程運行時，都有自已的地址空間（內存空間）如IE瀏覽器在任務管器中可以看到操作系統都是支持多進程的 線程
Java 多線程系列2——多線程的生命周期及生產消費者模型
wait 重要 strong clas 經典 關於 running 結束 準備 一、線程的生命周期及五種基本狀態 關於Java中線程的生命周期，首先看一下下面這張較為經典的圖： 上圖中基本上囊括了Java中多線程各重要知識點。掌握了上圖中的各知識點，Java中的多
PAT乙級-1036.跟奧巴馬一起編程(15)
alt space span pat content pac ima com 分享 題解 題解： 註意“行數是列數的50%（四舍五入）” 1 #include<iostream> 2 using namespace std; 3 int main()
java-多線程下的單例模式
餓漢式 return ret div 解決 有一個 必須 懶漢式 修改 /* 多線程下的單例-懶漢式會有多線程問題 餓漢式不會有多線程問題 */ //餓漢式 class Single { private static final Single s = new
Java 多線程下的單例模式
處理方式 復雜 數據庫 使用 read 對象實例 訪問 -s pac 單例對象（Singleton）是一種常用的設計模式。在Java應用中，單例對象能保證在一個JVM中，該對象只有一個實例存在。正是由於這個特 點，單例對象通常作為程序中的存放配置信息的載體，因為它能保證其他
Java多線程下單例
不能 pla init 能夠 餓漢 技術 安全性 ron 解決 /* 多線程下的單例 */ //餓漢式 class Single { private static final Single s = new Single(); pri