常見機試題分析Java版

時間 2019-11-06

標籤見機試題分析 java 欄目 Java 简体版

原文原文鏈接

1. 操做系統任務分爲系統任務和用戶任務兩種。其中，系統任務的優先級<50，用戶任務的優先級>=50且<=255.優先級大於255的爲非法任務，應予以剔除。現有一任務隊列task[]，長度爲n，task中的元素值表示任務的優先級，數值越小，優先級越高。函數scheduler實現以下功能，將task[]種的任務按照系統任務、用戶任務依次存放到system_task[]數組和user_task[]數組中，數組中元素的值是任務在task[]數組中的下標，而且優先級高的任務排在前面，優先級相同的任務按照入隊順序排列，數組元素爲-1表示結束。例如：task[]={0,30,155,1,80,300,170,40,99} system_task[]=}0,3,1,7,-1} user_task[]={4,8,2,6,-1}。函數接口爲void scheduler(int task[],int n,int system_task[],int user_task[])。java

思路分析：數組

（1）先看給定的函數接口，參數爲任務隊列數組、任務數、系統任務數組和用戶隊列數組，也就是說在main函數中調用該函數時，這些參數是已經初始化了的。這裏系統任務數組和用戶隊列數組就要注意了，題目中說數組元素爲-1表示結束，即數組中並非全部元素都是任務下標，輸出時用一個while循環判斷一下不是-1就成。那就好辦了，先按照任務數組的長度初始化系統任務數組和用戶隊列數組，Java會自動爲它們賦初值爲0，這樣就能夠傳參了。函數

（2）題目的核心是根據數組元素值的大小排列其下標，艾瑪這不就是爲HashMap量身定製的麼。能夠遍歷任務隊列，將系統任務和用戶任務及其下標分別存入HashMap，而後對這兩個HashMap分別按照值排序，再取出其鍵分別存入系統任務數組和用戶任務數組，最後兩個數組都添個-1就搞定了。spa

代碼以下：操作系統

package cn.edu.xidian.crytoll;

import java.util.*;

import java.util.Map.*;

public class Scheduler {

   public static void scheduler(int task[],int n,int system_task[],int user_task[]){

   Map<Integer,Integer> inputsystem = new HashMap<Integer,Integer>();

   Map<Integer,Integer> inputuser = new HashMap<Integer,Integer>();

   for(int i=0;i<n;i++){

   if(task[i]>=0&&task[i]<50) inputsystem.put(i,task[i]);

   else if(task[i]>=50&&task[i]<=255) inputuser.put(i,task[i]);

   }

   Map<Integer, Integer> outputsystem = sortByValue(inputsystem);

   Map<Integer, Integer> outputuser = sortByValue(inputuser);

   Set<Integer> systemset = outputsystem.keySet();

   Set<Integer> userset = outputuser.keySet(); 

   int systemn=0;

   int usern=0;

   for (Integer s:systemset) {

       system_task[systemn]=s;

       systemn++;

   } 

   for (Integer s:userset) {

       user_task[usern]=s;

       usern++;

   }

   system_task[systemn]=-1;

   user_task[usern]=-1;

   int i=0;

   while(system_task[i]!=-1){

   System.out.println(system_task[i]);

   ++i;

   }

   int j=0;

   while(user_task[j]!=-1){

   System.out.println(user_task[j]);

   ++j;

   }

   }

   public static <K, V extends Comparable<V>> Map<K, V> sortByValue(

           Map<K, V> map) {

       List<Entry<K, V>> list = new LinkedList<Entry<K, V>>(map.entrySet());

       Collections.sort(list, new Comparator<Entry<K, V>>() {

           public int compare(Entry<K, V> o1, Entry<K, V> o2) {

               Comparable<V> v1 = o1.getValue();

               V v2 = o2.getValue();

               if (v1 == null) {

                   if (v2 == null) {

                       return 0;

                   } else {

                       return -1;

                   }

               } else {

                   if (v2 == null) {

                       return 1;

                   } else {

                       return v1.compareTo(v2);

                   }

               }

           }

       });

       Map<K, V> result = new LinkedHashMap<K, V>();

       Iterator<Entry<K, V>> it = list.iterator();

       while (it.hasNext()) {

           Entry<K, V> entry = it.next();

           result.put(entry.getKey(), entry.getValue());

       }

       return result;

   }

   public static void main(String[] args){

   int task[]={0,30,155,1,80,300,170,40,99};

   int n=task.length;        

   int system_task[]=new int[n];

   int user_task[]=new int[n];

   scheduler(task,n,system_task,user_task);

   }

}

2. 輸入一個表達式，沒有括號，數字小於0-9之間，輸出計算結果，全部的中間結果化爲整形。例如: 輸入：3+8×2/9-2。輸出：2 code

思路分析：blog

（1）輸入的表達式是個字符串類型，要獲取它的每一個運算數和運算符須要用到charAt()方法。而後挨個字符地存入ArrayList，再使用get()方法遍歷字符串。排序

（2）四則表達式的運算符分兩種優先級，需遍歷兩次，第一次處理乘法和除法，第二次處理加法和減法。遇到運算符後將其先後兩個數的運算結果求出，而後使用add()方法將運算結果插入到前運算數的位置，再連續使用remove()方法將參與這次運算的運算符和兩個運算數移除。最後ArrayList中只剩一個元素，即爲該表達式的值。使用parseInt()方法將其格式化後返回。接口

代碼以下：隊列

package cn.edu.xidian.crytoll;

import java.util.ArrayList;
import java.util.List;

public class getMyRet {
    public int getMyRet(String str){
        int len=str.length(); 
        List<String> list=new ArrayList<String>(); 
        for(int i=0;i<len;i++) 
            list.add(str.charAt(i)+"");
        for(int j=0;j<list.size();j++){                
            if(list.get(j).equals("×")){                    
                int ji=Integer.parseInt(list.get(j-1))*Integer.parseInt(list.get(j+1)); 
                list.add(j-1,ji+""); 
                list.remove(j); 
                list.remove(j); 
                list.remove(j);                
                j--; 
             } 
             else if(list.get(j).equals("/")){ 
                 int shang=Integer.parseInt(list.get(j-1))/Integer.parseInt(list.get(j+1)); 
                 list.add(j-1,shang+"");  
                 list.remove(j);  
                 list.remove(j);  
                 list.remove(j);  
                 j--; 
             } 
         }            
         for(int k=0;k<list.size();k++){ 
             if(list.get(k).equals("+")){ 
                 int he=Integer.parseInt(list.get(k-1))+Integer.parseInt(list.get(k+1)); 
                 list.add(k-1,he+"");  
                 list.remove(k);  
                 list.remove(k);  
                 list.remove(k);
                 k--;  
             } 
             if(list.get(k).equals("-")){ 
                 int cha=Integer.parseInt(list.get(k-1))-Integer.parseInt(list.get(k+1)); 
                 list.add(k-1,cha+"");  
                 list.remove(k);  
                 list.remove(k);  
                 list.remove(k);  
                 k--; 
             } 
         } 
         int sum=Integer.parseInt(list.get(0)); 
         return sum;
    }
    public static void main(String[] args){
        String input="3+8×2/9-2";
        getMyRet getmyret=new getMyRet();
        System.out.println(getmyret.getMyRet(input));
    }
}

3. 將一個十進制（byte型）轉換爲二進制，將二進制數先後顛倒，再算出顛倒後對應的十進制數。

思路分析：進制互轉的話Java有現成的方法能夠調用。十進制轉二進制用Integer類的toBinaryString()方法，二進制轉十進制用Integer類的valueOf()方法。

代碼以下：

package cn.edu.xidian.crytoll;

public class UpperToLower {
    //遍歷字符串中的每一個字符，若是是小寫則直接添加進結果字符串
    //如果A-U的大寫字母，將其轉換成小寫字母后加5，添加進結果字符串
    //如果V-Z的大寫字母，將其轉換成小寫字母后減21，添加進結果字符串
    public String uptolow(String input){
        String output="";
        int len=input.length();
        for(int i=0;i<len;i++){
            if((input.charAt(i)+"").matches("[a-z]")) output=output+input.charAt(i);
            if((input.charAt(i)+"").matches("[A-U]")) output=output+((char)(input.charAt(i)+5)+"").toLowerCase();
            if((input.charAt(i)+"").matches("[V-Z]")) output=output+((char)(input.charAt(i)-21)+"").toLowerCase();
        }
        return output;
    }
    public static void main(String[] args){
        String input="AbCdEfGhIjKlMnOpQrStUvWxYz";
        System.out.println(new UpperToLower().uptolow(input));
    }
}

4. 輸入一串數字，將第一個數字做爲容量大小，從其它的數字中挑選出之和正好等於第一個數字的數字組合，若存在這樣的數字組合其和等於第一個數字的大小，則輸出1，不然輸出0。

輸入：10，5，3，4，2（大致上是這種形式的）輸出：1

思路分析：

（1）先將輸入格式化，第一個數字拿出來做爲目標和，其他數字存入數組並升序排序

（2）創建兩個鏈表，一個用於存儲備選數字，一個用於存儲當前歸入選擇的數字

（3）將備選數字存入鏈表，爲其設置迭代器，由於是雙層循環，故需建立一個迭代器副本

（4）設置已選數字的和並初始化爲0，從第一個備選數字開始，清空已有和，比較當前數字數字與其餘每一個數字的和的狀況

（5）若第一個備選數字和目標和相等，則返回1；若第一個備選數字大於目標和，則返回0；若當前備選數字小於目標和，判斷當前備選數字和已有和相加是否等於目標和，若等於則直接返回1；若當前備選數字和已有和相加小於目標和，將當前備選數字填入已選列表，更新當前和；若當前備選數字和已有和相加大於目標和，若減去以前插入已選列表的數字正好等於目標和，則返回1；若減去以後小於目標和，則更新當前和及已選列表，跳出循環和下一個數相比；若減去以後還大於目標和，就得不斷從已選列表中剔除最新插入的數字並更新當前和，直到當前和小於或等於目標和爲止

代碼以下：

package cn.edu.xidian.crytoll;

import java.util.Arrays;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

public class IsEqual {
    public int isequal(String input){
        //將輸入存入字符串型數組
        String[] all=input.split(",");
        //獲取第一個數字做爲目標和
        int needsum=Integer.parseInt(all[0]);
        //將備選數字存入整型數組
        int[] member=new int[all.length-1];
        for(int i=0;i<member.length;i++) member[i]=Integer.parseInt(all[i+1]);
        //對備選數字數組排序
        Arrays.sort(member);
        //創建兩個鏈表，一個存儲備選數字，一個存儲當前歸入選擇的數字
        List<Integer> list=new LinkedList<Integer>();
        List<Integer> content=new LinkedList<Integer>();
        //將備選數字存入鏈表，爲其設置迭代器，由於是雙層循環，故需建立一個迭代器副本
        for(int i=0;i<member.length;i++) list.add(member[i]);
        Iterator it=list.iterator();
        Iterator it0=it;
        //設置已選數字的和並初始化爲0
        int sum=0;
        //從第一個備選數字開始，比較每個數字與其餘每一個數字的和的狀況
        while(it.hasNext()){
            it0=it;
            sum=0;
            while(it0.hasNext()){
                int temp=(int)it0.next();
                //若第一個備選數字和目標和相等，則返回1
                if(temp==needsum) return 1;
                //若第一個備選數字大於目標和，則返回0
                    if(temp>needsum) return 0;
                    //若當前備選數字小於目標和
                    if(temp<needsum){
                        //判斷當前備選數字和已有和相加是否等於目標和，若等於則直接返回1
                        if(temp+sum==needsum) return 1;
                        //若當前備選數字和已有和相加小於目標和，將當前備選數字填入已選列表，更新當前和
                        if(temp+sum<needsum){
                            content.add(temp);
                            sum=sum+temp;
                        }
                        //若當前備選數字和已有和相加大於目標和，
                        else if(temp+sum>needsum){
                            while(content.size()>1){
                                //若減去以前插入已選列表的數字正好等於目標和，則返回1
                                if(temp+sum-content.get(content.size()-1)==needsum) return 1;
                                //若減去以後小於目標和，則更新當前和，已選列表，跳出循環和下一個數相比
                                if(temp+sum-content.get(content.size()-1)<needsum){
                                    sum=sum-content.get(content.size()-1)+temp;
                                    content.remove(content.size()-1);
                                    content.add(temp);
                                    break;
                                }
                                //若減去以後還大於目標和，就得不斷從已選列表中剔除最新插入的數字並更新當前和，直到當前和小於或等於目標和爲止
                                else if(temp+sum-content.get(content.size()-1)>needsum){
                                    sum=sum-content.get(content.size()-1);
                                    content.remove(content.size()-1);
                                }
                            }
                        }
                    }
            }
        }
        return 0;
    }
    public static void main(String[] args){
        String input="10,5,3,4,2";
        System.out.println(new IsEqual().isequal(input));
    }
}

5. 在給定字符串中找出單詞（「單詞」由大寫字母和小寫字母字符構成，其餘非字母字符視爲單詞的間隔，如空格、問號、數字等等；另外單個字母不算單詞）；找到單詞後，按照長度進行降序排序，（排序時若是長度相同，則按出現的順序進行排列），而後輸出到一個新的字符串中；若是某個單詞重複出現屢次，則只輸出一次；若是整個輸入的字符串中沒有找到單詞，請輸出空串。輸出的單詞之間使用一個「空格」隔開，最後一個單詞後不加空格。

思路分析：

（1）將單詞門存入字符串型數組

（2）對inputs進行穩定的冒泡降序排序

（3）將長度大於一的單詞加入結果字符串

代碼以下：

package cn.edu.xidian.crytoll;

import java.util.HashMap;
import java.util.Map;

public class MyWord {
    public String myword(String input,String output){
        int len=input.length();
        String temp="";
        //將單詞門存入字符串型數組
        for(int i=0;i<len;i++){
            if((input.charAt(i)+"").matches("[a-zA-Z]")) temp=temp+input.charAt(i);
            if(!(input.charAt(i)+"").matches("[a-zA-Z]")) temp=temp+" ";
        }
        String[] inputs=temp.split("\\s+");
        //對inputs進行穩定的冒泡降序排序
        for(int i=0;i<inputs.length-1;i++){
            for(int j=0;j<inputs.length-i-1;j++){
                if(inputs[j].length()<inputs[j+1].length()){
                    String tempstr=inputs[j];
                    inputs[j]=inputs[j+1];
                    inputs[j+1]=tempstr;
                }
            }
        }
        //將長度大於一的單詞加入結果字符串
        for(int i=0;i<inputs.length;i++){
            if(inputs[i].length()>1&&output.indexOf(inputs[i])<0) output=output+inputs[i]+" ";
        }
        return output;
    }
    public static void main(String[] args){
        String input="DING Zhongli, academician of the Chinese Academy of Sciences (CAS) and a test";
        String output="";
        System.out.println(new MyWord().myword(input, output));
    }
}