Java每日一练(20230420) 罗马数字转整数、电话号码的字母组合、排列序列

简介: Java每日一练(20230420) 罗马数字转整数、电话号码的字母组合、排列序列

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 。

通常情况下,罗马数字中小的数字在大的数字的右边。但也存在特例,例如 4 不写做 IIII,而是 IV。数字 1 在数字 5 的左边,所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地,数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况:

  • I 可以放在 V (5) 和 X (10) 的左边,来表示 4 和 9。
  • X 可以放在 L (50) 和 C (100) 的左边,来表示 40 和 90。
  • C 可以放在 D (500) 和 M (1000) 的左边,来表示 400 和 900。

给你一个罗马数字,将其转为整数。

示例 1:

输入: num = "III"

输出: 3

示例 2:

输入: num = "IV"

输出: 4

示例 3:

输入: num = "IX"

输出: 9

示例 4:

输入: num = "LVIII"

输出: 58

解释: L = 50, V = 5, III = 3.


示例 5:

输入: num = "MCMXCIV"

输出: 1994

解释: M = 1000, CM = 900, XC = 90, IV = 4.


提示:

  • 1 <= num <= 3999

出处:

https://edu.csdn.net/practice/26046518

代码:

import java.util.*;
public class romanToInt {
    public static class Solution {
        public int romanToInt(String s) {
            int n = 0;
            for (int i = 0; i < s.length();) {
                char c = s.charAt(i);
                if (c == 'I') {
                    if (i + 1 < s.length()) {
                        if (s.charAt(i + 1) == 'V') {
                            n += 4;
                            i += 2;
                        } else if (s.charAt(i + 1) == 'X') {
                            n += 9;
                            i += 2;
                        } else {
                            n += 1;
                            i++;
                        }
                    } else {
                        n += 1;
                        i++;
                    }
                } else if (c == 'X') {
                    if (i + 1 < s.length()) {
                        if (s.charAt(i + 1) == 'L') {
                            n += 40;
                            i += 2;
                        } else if (s.charAt(i + 1) == 'C') {
                            n += 90;
                            i += 2;
                        } else {
                            n += 10;
                            i++;
                        }
                    } else {
                        n += 10;
                        i++;
                    }
                } else if (c == 'C') {
                    if (i + 1 < s.length()) {
                        if (s.charAt(i + 1) == 'D') {
                            n += 400;
                            i += 2;
                        } else if (s.charAt(i + 1) == 'M') {
                            n += 900;
                            i += 2;
                        } else {
                            n += 100;
                            i++;
                        }
                    } else {
                        n += 100;
                        i++;
                    }
                } else if (c == 'V') {
                    n += 5;
                    i++;
                } else if (c == 'L') {
                    n += 50;
                    i++;
                } else if (c == 'D') {
                    n += 500;
                    i++;
                } else if (c == 'M') {
                    n += 1000;
                    i++;
                }
            }
            return n;
        }
    }
    public static void main(String[] args) {
        Solution s = new Solution();
        String str = "III";
        System.out.println(s.romanToInt(str));
        str = "IV";
        System.out.println(s.romanToInt(str));
        str = "IX";
        System.out.println(s.romanToInt(str));
        str = "LVIII";
        System.out.println(s.romanToInt(str));
        str = "MCMXCIV";
        System.out.println(s.romanToInt(str));
    }
}

输出:

3

4

9

58

1994


2. 电话号码的字母组合

给定一个仅包含数字 2-9 的字符串,返回所有它能表示的字母组合。答案可以按 任意顺序 返回。

给出数字到字母的映射如下(与电话按键相同)。注意 1 不对应任何字母。

示例 1:

输入:digits = "23"

输出:["ad","ae","af","bd","be","bf","cd","ce","cf"]

示例 2:

输入:digits = ""

输出:[]

示例 3:

输入:digits = "2"

输出:["a","b","c"]


提示:

  • 0 <= digits.length <= 4
  • digits[i] 是范围 ['2', '9'] 的一个数字。

出处:

https://edu.csdn.net/practice/26046519

代码:

import java.util.*;
public class romanToInt {
    public static class Solution {
        public List<String> letterCombinations(String digits) {
            Character[][] letters = { {}, {}, { 'a', 'b', 'c' }, { 'd', 'e', 'f' }, { 'g', 'h', 'i' }, { 'j', 'k', 'l' },
                    { 'm', 'n', 'o' }, { 'p', 'q', 'r', 's' }, { 't', 'u', 'v' }, { 'w', 'x', 'y', 'z' }, };
            List<List<Character>> combinations = new ArrayList<>();
            for (int i = 0; i < digits.length(); i++) {
                Character d = digits.charAt(i);
                int index = Character.getNumericValue(d);
                Character[] letter = letters[index];
                //System.out.println(d);
                if (i == 0) {
                    for (int j = 0; j < letter.length; j++) {
                        List<Character> c = new ArrayList<>();
                        c.add(letter[j]);
                        combinations.add(c);
                    }
                } else {
                    List<List<Character>> added = new ArrayList<>();
                    for (int j = 0; j < combinations.size(); j++) {
                        List<Character> c = combinations.get(j);
                        List<Character> origin_c = new ArrayList<>(c);
                        for (int k = 0; k < letter.length; k++) {
                            Character l = letter[k];
                            if (k == 0) {
                                c.add(l);
                            } else {
                                List<Character> new_c = new ArrayList<>(origin_c);
                                new_c.add(l);
                                added.add(new_c);
                            }
                        }
                    }
                    combinations.addAll(added);
                }
            }
            List<String> output = new ArrayList<>();
            for (int i = 0; i < combinations.size(); i++) {
                List<Character> c = combinations.get(i);
                StringBuilder sb = new StringBuilder();
                for (Character l : c) {
                    sb.append(l);
                }
                output.add(sb.toString());
            }
            return output;
        }
    }
    public static void main(String[] args) {
        Solution s = new Solution();
        String str = "23";
        System.out.println(s.letterCombinations(str));
        str = "";
        System.out.println(s.letterCombinations(str));
        str = "2";
        System.out.println(s.letterCombinations(str));
    }
}

输出:

[ad, bd, cd, ae, af, be, bf, ce, cf]

[]

[a, b, c]


3. 排列序列

给出集合 [1,2,3,...,n],其所有元素共有 n! 种排列。

按大小顺序列出所有排列情况,并一一标记,当 n = 3 时, 所有排列如下:

  1. "123"
  2. "132"
  3. "213"
  4. "231"
  5. "312"
  6. "321"

给定 n 和 k,返回第 k 个排列。

示例 1:

输入:n = 3, k = 3

输出:"213"

示例 2:

输入:n = 4, k = 9

输出:"2314"

示例 3:

输入:n = 3, k = 1

输出:"123"


提示:

  • 1 <= n <= 9
  • 1 <= k <= n!

以下程序实现了这一功能,请你填补空白处内容:

```Java
class Solution {
    public String getPermutation(int n, int k) {
        StringBuilder sb = new StringBuilder();
        List candidates = new ArrayList<>();
        int[] factorials = new int[n + 1];
        factorials[0] = 1;
        int fact = 1;
        for (int i = 1; i <= n; ++i) {
            candidates.add(i);
            fact *= i;
            factorials[i] = fact;
        }
        k -= 1;
        ____________________;
        return sb.toString();
    }
}
```

出处:

https://edu.csdn.net/practice/26046520

代码:

import java.util.*;
public class getPermutation {
    public static class Solution {
        public String getPermutation(int n, int k) {
            StringBuilder sb = new StringBuilder();
            List<Integer> candidates = new ArrayList<>();
            int[] factorials = new int[n + 1];
            factorials[0] = 1;
            int fact = 1;
            for (int i = 1; i <= n; ++i) {
                candidates.add(i);
                fact *= i;
                factorials[i] = fact;
            }
            k -= 1;
    for (int i = n - 1; i >= 0; --i) {
        int index = k / factorials[i];
        sb.append(candidates.remove(index));
        k -= index * factorials[i];
    }
            return sb.toString();
        }
    }
    public static void main(String[] args) {
        Solution s = new Solution();
        System.out.println(s.getPermutation(3,3));
        System.out.println(s.getPermutation(4,9));
        System.out.println(s.getPermutation(3,1));
    }
}

输出:

213

2314

123


🌟 每日一练刷题专栏 🌟

✨持续,努力奋斗做强刷题搬运工!

👍 点赞,你的认可是我坚持的动力!

🌟 收藏,你的青睐是我努力的方向!

✎ 评论,你的意见是我进步的财富!  

☸ 主页:https://hannyang.blog.csdn.net/


目录
相关文章
|
算法 Java
LeetCode初级算法题:环形链表+排列硬币+合并两个有序数组java解法
LeetCode初级算法题:环形链表+排列硬币+合并两个有序数组java解法
336 0
|
安全 Java C++
2023-3-25 java选择题每日一练
2023-3-25 java选择题每日一练
252 1
CSDN每日一练(Java)--小艺的英文名
CSDN每日一练(Java)--小艺的英文名
|
算法 Java
[Java·算法·简单] LeetCode 13. 罗马数字转整数 详细解读
[Java·算法·简单] LeetCode 13. 罗马数字转整数 详细解读
331 0
|
Java
LeetCode-整数转罗马数字=Java
整数转罗马数字=Java题解
148 0
|
Java 测试技术
java字符串练习题5、罗马数字转整数
java字符串练习题5、罗马数字转整数
215 0
|
JSON 网络协议 安全
【Java】(10)进程与线程的关系、Tread类;讲解基本线程安全、网络编程内容;JSON序列化与反序列化
几乎所有的操作系统都支持进程的概念,进程是处于运行过程中的程序,并且具有一定的独立功能,进程是系统进行资源分配和调度的一个独立单位一般而言,进程包含如下三个特征。独立性动态性并发性。
640 1
|
JSON 网络协议 安全
【Java基础】(1)进程与线程的关系、Tread类;讲解基本线程安全、网络编程内容;JSON序列化与反序列化
几乎所有的操作系统都支持进程的概念,进程是处于运行过程中的程序,并且具有一定的独立功能,进程是系统进行资源分配和调度的一个独立单位一般而言,进程包含如下三个特征。独立性动态性并发性。
568 1
|
数据采集 存储 弹性计算
高并发Java爬虫的瓶颈分析与动态线程优化方案
高并发Java爬虫的瓶颈分析与动态线程优化方案
Java 数据库 Spring
535 0