软工一 Java homework new_practice 2

P1：传入一个数组，返回最大最小值

P2：十六进制转二进制（字符串）（忽略大小写）

忽略大小写(已经排除为数字的情况)：

int margin = (char UpperCase) - 'A' + 10;

int margin = (char LowerCase) - 'a' + 10;

OR

int margin = Character.isUpperCase(char ch)? (char UpperCase) - 'A'+10:(char LowerCase) - 'a'+10;

十进制转换为二进制：（直接用数组）

private static String Dec2Bin(int num){
   String str = "";
   String[] binstr = {"0000", "0001", "0010", "0011",
         "0100", "0101", "0110", "0111",
         "1000", "1001", "1010", "1011",
         "1100", "1101", "1110", "1111"};
   return binstr[num];
}

P3：十六进制转十进制（字符串）（忽略大小写）

拆分为数组同P2

加和部分：

for (int i=Intarr.length-1;i >= 0 ;i --)
   sum += Intarr[i]*Math.pow(16,Intarr.length-i-1);

P4：判断字符串是否为回文串（字母和数字，忽略大小写）

 字符串翻转的小复习

P5：给定一字符串（包含大小写字母、空格' '），返回最后一个单词的长度

String[] arr = s.split(" ");

split()方法：

基础语法：

http://www.cnblogs.com/mingforyou/archive/2013/09/03/3299569.html

http://www.runoob.com/java/java-string-split.html

常见问题&坑：

https://blog.csdn.net/sun5769675/article/details/50204591

https://blog.csdn.net/qq_27093465/article/details/54910323

P6：给定一整型数组，找出主元素（在数组中的出现次数严格大于数组元素个数的二分之一）

HashMap小复习

public class MajorityElement {
   public static int majorityNumber(ArrayList<Integer> nums) {
      Map<Integer,Integer> map = new HashMap<>();
      //注册ArrayList各个元素
      for (Integer i:nums){
         map.put(i,0);
      }
      //统计各个元素出现次数
      for (Integer i:nums){
         map.put(i,map.get(i)==0?1:map.get(i)+1);
      }

      int[] max = {0,0};//[0]-value [1]-key
      for (Integer i:map.keySet()){
         if (max[0]<map.get(i)){
            max[0] = map.get(i);
            max[1] = i;
         }
      }
      return max[1];
   }
}

P7：数字的进制互相转换（二/八/十/十六）

public class NumberConversion {
    public static String toRadix(String in, int inRadix, int outRadix) {
        assert inRadix == 2 || inRadix == 8 || inRadix == 10 || inRadix == 16;
        assert outRadix == 2 || outRadix == 8 || outRadix == 10 || outRadix == 16;
        //TODO
        switch (outRadix){
            case 2:
                return Integer.toBinaryString(Integer.parseInt(in,inRadix));
            case 10:
                return Integer.toString(Integer.parseInt(in,inRadix));
            case 8:
                return Integer.toOctalString(Integer.parseInt(in,inRadix));
            case 16:
                String str = "";
                char[] arr = Integer.toHexString(Integer.parseInt(in,inRadix)).toCharArray();
                for (char a:arr)
                    str += Character.isDigit(a)?a:Character.toUpperCase(a);
                return str;
        }
        return null;
    }
}

Integer内部函数:

toBinaryString()二进制 / toString()十进制 / toOcatalString()八进制 / toHexString()十六进制

parseInt(String s, int radix)字符串转换为整数(radix 为进制)

* <p>Examples:
* <blockquote><pre>
* parseInt("0", 10) returns 0
* parseInt("473", 10) returns 473
* parseInt("+42", 10) returns 42
* parseInt("-0", 10) returns 0
* parseInt("-FF", 16) returns -255
* parseInt("1100110", 2) returns 102
* parseInt("2147483647", 10) returns 2147483647
* parseInt("-2147483648", 10) returns -2147483648
* parseInt("2147483648", 10) throws a NumberFormatException
* parseInt("99", 8) throws a NumberFormatException
* parseInt("Kona", 10) throws a NumberFormatException
* parseInt("Kona", 27) returns 411787

P8：检测回文字符串（大小写不敏感，输入不包含空格）

逐项比较

public boolean checkPalindromicWord(String str){

    for (int i=0;i < str.length()/2;i ++){
        boolean b=true;
        if (Character.toLowerCase(str.charAt(i))
                != Character.toLowerCase(str.charAt(str.length()-i-1)))
            b=false;
        if (!b)
            return false;
    }
    return true;
}

P9：判断输入的正整数为

perfect number（所有除数（除了自己）的和等于这个数） 或 deficient number（所有除数（除了自己）的和小于这个数）

P10：判断一正整数的所有质因数(不包括1和自身)的乘积是否为该正整数

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

public class PrimeFactors {
   public static boolean isProductOfPrimeFactors(int posInt) {
      assert posInt > 0;

      if (posInt==1 || posInt==2 || posInt==3)
         return true;
      Map<Integer,Integer> map = new HashMap<>();

      for (int i=2;i <= Math.pow((double) posInt,0.5);i ++){
         if (posInt%i==0)
            map.put(i,0);
      }

      int n = posInt;
      for (int i=2;i <= Math.pow((double) posInt,0.5);i ++){
         if (n%i==0){
            map.put(i,map.get(i)==0?1:map.get(i)+1);
            n /= i;
            i -= 1;
         }
      }

      for (int i:map.keySet()){
         if (map.get(i)>1)
            return false;
      }

      return true;
   }
}

（待修改）