javaSE-基本语法-练习题

求二个二进制的和

• 编程1：求二个二进制的和： 给你两个二进制字符串 a 和 b ，以二进制字符串的形式返回它们的和。

  /*
   * 注意：a 和 b 仅由字符 '0' 或 '1' 组成
   *  
   * 示例 1：
   * 		输入:a = "11", b = "1"
   * 		输出："100"
   * 示例 2：
   * 		输入：a = "1010", b = "1011"
   * 		输出："10101"
   */
  public String addBinary(String a, String b) {
  
  }
  

• 方式1：老师讲的版本

  package com.czxy;
  
  /**
   * @author 桐叔
   * @email [email protected]
   * @description
   */
  public class Test02_addBinary {
  
      public static void main(String[] args) {
          testStringBuilder();
          System.out.println(addBinary("11","1"));            //100
          System.out.println(addBinary("1010","1011"));       //10101
          System.out.println(addBinary("111011","1010"));     //1000101
      }
  
      /*
       * 注意：a 和 b 仅由字符 '0' 或 '1' 组成
       *
       * 示例 1：
       * 		输入:a = "11", b = "1"
       * 		输出："100"
       * 示例 2：
       * 		输入：a = "1010", b = "1011"
       * 		输出："10101"
       */
      public static String addBinary(String a, String b) {
          // 定义变量、记录所有计算结果
          StringBuilder sb = new StringBuilder();
  
          // 定义i和j分别记录两个字符串的高位
          int i = a.length() - 1;
          int j = b.length() - 1;
          // 保存进位
          int c = 0;
          // 循环处理，从右往左进行计算
          while(i >= 0 || j >= 0 || c != 0) {
              // 依次获取i和j位置的数字
              int ii = (i >= 0) ? a.charAt(i--) - '0' : 0;
              int jj = (j >= 0) ? b.charAt(j--) - '0' : 0;
              // 记录当前位的和
              c = ii + jj + c;
              // 记录结果：c=1 -->1  , c=0 --> 0   c==2 --> 0 （进位）
              sb.append(c % 2);
              // 是否进位 c=2 -->1(进位)  c=1 -->0 （不进位）  c=0 --> 0 (不进位)
              c /=2;
          }
          //sb记录的数为倒序，需要反转
          return sb.reverse().toString();
      }
  
      public static void testStringBuilder() {
          // StringBuilder 用于拼凑字符串 工具类
          StringBuilder sb = new StringBuilder();
          sb.append("a");
          sb.append('a');
          sb.append(98);
  
          // 其他功能：反转
          sb.reverse();
  
          // 将所有内容 转换成 字符串
          String str = sb.toString();
          System.out.println(str);
      }
  }
  
  

• 方式2：胡锦宁的版本

  //编程1：求二个二进制的和： 给你两个二进制字符串 `a` 和 `b` ，以二进制字符串的形式返回它们的和。
  public static String binarySystem (String a,String b) {
     return Integer.toBinaryString(Integer.parseInt(a, 2) + Integer.parseInt(b, 2));
  }
  

罗马数字转换成整数

• 编程2：将罗马数字转换成整数

  /**
  示例 1:
      输入: s = "III"
      输出: 3
      
  示例 2:
      输入: s = "IV"
      输出: 4
      
  示例 3:
      输入: s = "IX"
      输出: 9
      
  示例 4:
      输入: s = "LVIII"
      输出: 58
  	解释: L = 50, V= 5, III = 3.
  	
  示例 5:
      输入: s = "MCMXCIV"
      输出: 1994
      解释: M = 1000, CM = 900, XC = 90, IV = 4.
   */
  public int romanToInt(String s) {
  
  }
  

  /*规则
  1 基本对应关系：罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。
          字符          数值
          I             1
          V             5
          X             10
          L             50
          C             100
          D             500
          M             1000
     例如，
     		罗马数字2写做II，即为两个并列的1。
     		12 写做 XII ，即为 X + II 。 
     		27 写做  XXVII, 即为 XX + V + II 。
  2 特例：特殊的规则只适用于以下六种情况
  	I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
  	X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。 
  	C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。
  	例如：
  		数字4不写做IIII，而是IV。数字1在数字5的左边，表示大数5减小数1得到的数值4。
  */
  

  package com.czxy;
  
  /**
   * 在线罗马数转换器：
   *  https://miniwebtool.com/zh-cn/roman-numerals-converter/?number=4999#google_vignette
   * @author 桐叔
   * @email [email protected]
   * @description
   */
  public class Test03_romanToInt {
      public static void main(String[] args) {
          System.out.println(romanToInt("III"));      //3
          System.out.println(romanToInt("IV"));       //4
          System.out.println(romanToInt("IX"));       //9
          System.out.println(romanToInt("LVIII"));    //58
          System.out.println(romanToInt("MCMXCIV"));  //1994
          System.out.println(romanToInt("MMMMCMXCIX"));  //4999
      }
  
      /**
       示例 1:
       输入: s = "III"
       输出: 3
  
       示例 2:
       输入: s = "IV"
       输出: 4
  
       示例 3:
       输入: s = "IX"
       输出: 9
  
       示例 4:
       输入: s = "LVIII"
       输出: 58
       解释: L = 50, V= 5, III = 3.
  
       示例 5:
       输入: s = "MCMXCIV"
       输出: 1994
       解释: M = 1000, CM = 900, XC = 90, IV = 4.
       */
      public static int romanToInt(String s) {
          /* 提前使用preNum变量存放一个数据，用于与后面的数据进行比较
           如果小于后面的数据，将进行的-操作
           如果大于等于后面的数据，将进行的+操作
           使用perNum进行所有数据的累加/减操作
           */
          //1 累加/减操作变量
          int sum = 0;
          //2 定义preNum，用于存放第一个字符
          int preNum = getValue(s.charAt(0));
          //3 从索引号1开始(第二字符)，依次与preNum进行比较
          for(int i = 1 ; i < s.length() ; i ++) {
              // 3.1 获得字符对应的水珠
              int num = getValue(s.charAt(i));
              // 3.2 比较
              if(preNum < num) {
                  sum -= preNum;
              } else {
                  sum += preNum;
              }
              // 3.3 数据依次下移，将preNum存放num
              preNum = num;
          }
          //4 累加最后一个值
          sum += preNum;
          // 5 返回
          return sum;
      }
  
      public static int getValue(char ch){
          switch(ch) {
              case 'I':  return 1;
              case 'V':  return 5;
              case 'X':  return 10;
              case 'L':  return 50;
              case 'C':  return 100;
              case 'D':  return 500;
              case 'M':  return 1000;
              default: return 0;
          }
      }
  }
  
  

• 方式2：胡锦宁的版本

  //    编程2：将罗马数字转换成整数
      public static int romanToInt(String s) {
  //        创建一个Map集合，用于存储数据
          Map<Character, Integer> map = new HashMap<>();
          map.put('I',1);
          map.put('V',5);
          map.put('X',10);
          map.put('L',50);
          map.put('C',100);
          map.put('D',500);
          map.put('M',1000);
          int sum = 0;
          for(int i = 0; i < s.length();i ++){
              //无论什么符号都先加
              sum += map.get(s.charAt(i));
              if(map.get(s.charAt((i - 1)< 0 ? i : i-1)) < map.get(s.charAt(i))){
                  //需要减的符号减2次（1次之前加了，1次自己需要减）
                  sum =sum - map.get(s.charAt(i-1)) * 2;
              }
          }
          return sum;
      }