13
罗马数字包含以下七种字符: 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。
给定一个罗马数字，将其转换成整数。
class Solution {
public int romanToInt(String s) {
int len = s.length();
char [] num = s.toCharArray();//将字符串转换为数组
HashMap <Character,Integer> hashmap = new HashMap<Character,Integer>();
hashmap.put('I',1);//使用哈希表
hashmap.put('V',5);
hashmap.put('X',10);
hashmap.put('L',50);
hashmap.put('C',100);
hashmap.put('D',500);
hashmap.put('M',1000);
int count=0;//若左边的字符代表的数字大于右边则相加否则相减
for(int i=0;i<len-1;i++){
int count1 = hashmap.get(num[i]);
int count2 = hashmap.get(num[i+1]);
if(count1 >= count2){
count +=count1;
}else{
count -=count1;
}
}
count += hashmap.get(num[len-1]);
return count;
}
}12
罗马数字包含以下七种字符： 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。
给你一个整数，将其转为罗马数字。
class Solution {
public String intToRoman(int num) {
int []num1 ={1,4,5,9,10,40,50,90,100,400,500,900,1000};
String []c = {"I","IV","V","IX","X","XL","L","XC","C","CD","D","CM","M"};
StringBuilder str = new StringBuilder("");
while(num!=0){
for(int i= c.length-1;i>=0;i--){
if(num>=num1[i]){
num = num - num1[i];
str.append(c[i]);
break;
}
}
}
String s = new String(str);
return s;
}
}58
给你一个字符串 s，由若干单词组成，单词前后用一些空格字符隔开。返回字符串中 最后一个 单词的长度。
单词 是指仅由字母组成、不包含任何空格字符的最大子字符串。
class Solution {
public int lengthOfLastWord(String s) {
char[] c = s.toCharArray();
int len = c.length;
int count = len;
if (c[len - 1] != ' ') {
for (int i = len - 1; i >= 0; i--) {
if (c[i] == ' ') {
count = len - 1 - i;
break;
}
}
} else {
int flag = -1;
for (int i = len - 1; i > 0; i--) {
if (c[i] == ' ' && c[i - 1] != ' ') {
flag = i;
}
if (c[i] != ' ' && c[i - 1] == ' ') {
count = flag - i;
break;
}
if(i==1&&c[0]!=' '&&flag!=-1){
count = flag;
}
}
}
return count;
}
}14
编写一个函数来查找字符串数组中的最长公共前缀。
如果不存在公共前缀，返回空字符串 ""。
//将第一个元素取出与其他元素比较，取最短的前缀
class Solution {
public String longestCommonPrefix(String[] strs) {
int len = strs.length;
if(len == 0){
return "";
}
String str1 = new String(strs[0]);
char[] c1 = str1.toCharArray();
String pre = strs[0];
for(int i=1;i<len;i++){
StringBuilder str2 = new StringBuilder("");
char [] c2= strs[i].toCharArray();
int j = Math.min(c1.length,c2.length);
for(int k=0;k<j;k++){
if(c1[k]==c2[k]){
str2.append(c1[k]);
}else{
break;
}
}
String str = new String(str2);
if(str.length()<pre.length()){
pre = str;
}
}
return pre;
}
}151
给你一个字符串 s ，请你反转字符串中 单词 的顺序。
单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。
返回 单词 顺序颠倒且 单词 之间用单个空格连接的结果字符串。
注意：输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。
class Solution {
public String reverseWords(String s) {
int len = s.length();
if (len == 0) {
return "";
}
if(len == 1){
return s;
}
char[] c = s.toCharArray();
StringBuilder str1 = new StringBuilder("");
for (int i = len - 1; i > 0; i--) {
int flag = -1;
if (c[i] != ' ' && c[i - 1] == ' ') {
flag = i;
while (flag < len && c[flag] != ' ') {
str1.append(c[flag]);
flag++;
}
for (int j = 0; j < i; j++) {
if (c[j] != ' ') {
str1.append(" ");
break;
}
}
}
if (i == 1 && c[0] != ' ') {
int j = 0;
while (j < len && c[j] != ' ') {
str1.append(c[j]);
j++;
}
}
}
String str = str1.toString();
return str;
}
}6
将一个给定字符串 s 根据给定的行数 numRows ，以从上往下、从左到右进行 Z 字形排列。
比如输入字符串为 "PAYPALISHIRING" 行数为 3 时，排列如下：
P A H N A P L S I I G Y I R
之后，你的输出需要从左往右逐行读取，产生出一个新的字符串，比如："PAHNAPLSIIGYIR"。
请你实现这个将字符串进行指定行数变换的函数：
//实际上可将Z字看做N，则先考虑垂直再考虑斜着，连续的N就看做一组连续的垂直加斜着
//一个while就是一个连续，i记录目前到达的次序，与此外对应的是由j控制
//将对应数组定义为StringBuilder类型，每一个元素都是StringBuilder类型，每次增加在每个对应的字符串后面加，最后再合起来
class Solution {
public String convert(String s, int numRows) {
int len = s.length();
if (numRows == 1) {
return s;
}
char[] c = s.toCharArray();
StringBuilder []ch = new StringBuilder[numRows];
for(int i=0;i<numRows;i++){
ch[i] = new StringBuilder("");
}
int k = 0;
int i = 0;
while(i<len){
for(int j = 0;j<numRows&&i<len;j++){
ch[j].append(c[i++]);
}
for(int j=numRows-2;j>0&&i<len;j--){
ch[j].append(c[i++]);
}
}
StringBuilder ph = new StringBuilder("");
for(int j=0;j<numRows;j++){
ph.append(ch[j]);
}
String str = new String(ph);
return str;
}
}28
给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串的第一个匹配项的下标（下标从 0 开始）。如果 needle 不是 haystack 的一部分，则返回 -1 。
class Solution {
public int strStr(String haystack, String needle) {
int len1 = haystack.length();
int len2 = needle.length();
if(len1<len2){
return -1;
}
if(!haystack.contains(needle)){
return -1;
}
return haystack.indexOf(needle);
}
}68
给定一个单词数组 words 和一个长度 maxWidth ，重新排版单词，使其成为每行恰好有 maxWidth 个字符，且左右两端对齐的文本。
你应该使用 “贪心算法” 来放置给定的单词；也就是说，尽可能多地往每行中放置单词。必要时可用空格 ' ' 填充，使得每行恰好有 maxWidth 个字符。
要求尽可能均匀分配单词间的空格数量。如果某一行单词间的空格不能均匀分配，则左侧放置的空格数要多于右侧的空格数。
文本的最后一行应为左对齐，且单词之间不插入额外的空格。
注意:
- 单词是指由非空格字符组成的字符序列。
- 每个单词的长度大于 0，小于等于 maxWidth。
- 输入单词数组
words至少包含一个单词。
class Solution {
public List<String> fullJustify(String[] words, int maxWidth) {
List<String> list = new ArrayList<String>();
int len = words.length;
int i = 0;
while (i < len) {
int start = i;
int length = 0;
List<String> lineWords = new ArrayList<>();
// 计算一行能容纳的单词
while (i < len && length + words[i].length() + i - start <= maxWidth) {
length += words[i].length();
lineWords.add(words[i]);
i++;
}
// 处理一行的单词
StringBuilder line = new StringBuilder();
if (i == len || lineWords.size() == 1) { // 处理最后一行或者只有一个单词的情况
for (int j = 0; j < lineWords.size(); j++) {
line.append(lineWords.get(j));
if (j < lineWords.size() - 1) {
line.append(" ");
}
}
for (int j = line.length(); j < maxWidth; j++) {
line.append(" ");
}
} else {
int totalSpaces = maxWidth - length; // 总共的空格数
int gaps = lineWords.size() - 1; // 单词之间的间隔数
int spacePerGap = totalSpaces / gaps; // 平均每个间隔应分配的空格数
int extraSpaces = totalSpaces % gaps; // 不能均分的多余空格数
for (int j = 0; j < lineWords.size(); j++) {
line.append(lineWords.get(j));
if (j < gaps) {
for (int k = 0; k < spacePerGap + (j < extraSpaces ? 1 : 0); k++) {//计算当前间隔应分配的空格数。如果j小于extraSpaces，则当前间隔需要额外多分配一个空格，否则只分配平均空格数。
line.append(" ");
}
}
}
}
list.add(line.toString());
}
return list;
}
}
扫一扫
565
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
