HJ1 字符串最后一个单词的长度
描述
计算字符串最后一个单词的长度，单词以空格隔开，字符串长度小于5000。（注：字符串末尾不以空格为结尾）
输入描述：输入一行，代表要计算的字符串，非空，长度小于5000。
输出描述：输出一个整数，表示输入字符串最后一个单词的长度。
示例1
输入：
hello nowcoder
输出：
8
说明：最后一个单词为nowcoder，长度为8
//计算字符串最后一个单词的长度，单词以空格隔开，字符串长度小于5000。（注：字符串末尾不以空格为结尾）let line = readline();function getLastWord(str){let i = str.length - 1let j = 0while(str[i] !== ' ' && i >= 0) {i -= 1j += 1}return j}console.log(getLastWord(line));
HJ2 计算某字符出现次数
描述
写出一个程序，接受一个由字母、数字和空格组成的字符串，和一个字符，然后输出输入字符串中该字符的出现次数。（不区分大小写字母）
数据范围： 1≤n≤1000
输入描述：
第一行输入一个由字母和数字以及空格组成的字符串，第二行输入一个字符。
输出描述：
输出输入字符串中含有该字符的个数。（不区分大小写字母）
示例1
输入：ABCabc A
输出：2
const str = readline();const key = readline();var num = 0;const arr = str.split('');arr.forEach(item=>{if(item.toLowerCase()===key.toLowerCase()){num ++;}})console.log(num)
HJ4 字符串分隔
描述
•输入一个字符串，请按长度为8拆分每个输入字符串并进行输出；
•长度不是8整数倍的字符串请在后面补数字0，空字符串不处理。
输入描述：
连续输入字符串(每个字符串长度小于等于100)
输出描述：
依次输出所有分割后的长度为8的新字符串
示例1
输入：
abc
输出：
abc00000
var lines = ''while(line = readline()){var str = line +'00000000';for(let i = 8; i < str.length; i += 8) {console.log(str.substring(i - 8, i));}}
HJ5 进制转换
描述
写出一个程序，接受一个十六进制的数，输出该数值的十进制表示。
数据范围：保证结果在 1≤n≤231−1
输入描述：
输入一个十六进制的数值字符串。
输出描述：
输出该数值的十进制字符串。不同组的测试用例用\n隔开。
示例1
输入：0xAA
输出：170
let str = readline();let newstr = parseInt(str,16);console.log(newstr);
输出int型转二进制含1的个数
题目描述
输入一个int型的正整数，计算出该int型数据在内存中存储时1的个数。
输入描述:
输入一个整数（int类型）
输出描述:
这个数转换成2进制后，输出1的个数
示例1
输入
5
输出
2
let num = parseInt(readline()); // 需要将输入的转为int型数字let bit = num.toString(2).split(''); // 转为2进制字符，再转为字符数组let count = 0; // 统计1的个数for(let i = 0; i < bit.length; i++) {if( bit[i] == '1') {count++;}}console.log(count);
数字颠倒
题目描述
描述：
输入一个整数，将这个整数以字符串的形式逆序输出
程序不考虑负数的情况，若数字含有0，则逆序形式也含有0，如输入为100，则输出为001
输入描述:
输入一个int整数
输出描述:
将这个整数以字符串的形式逆序输出
示例1<br /> 输入<br /> 1516000<br /> 输出<br /> 0006151
let num = readline();
let str = num.split('').reverse(); // 转为字符数组
console.log(str.toString().replace(/,/g,''));
字符串反转
题目描述
写出一个程序，接受一个字符串，然后输出该字符串反转后的字符串。（字符串长度不超过1000）
输入描述:
输入N个字符
输出描述:
输出该字符串反转后的字符串
示例1
输入
abcd
输出
dcba
let str = readline();
let strRev = str.split('').reverse();
console.log(strRev.toString().replace(/,/g,'')); //还是要先转成字符串的形式
句子逆序
题目描述
将一个英文语句以单词为单位逆序排放。例如“I am a boy”，逆序排放后为“boy a am I”
所有单词之间用一个空格隔开，语句中除了英文字母外，不再包含其他字符
输入描述:
将一个英文语句以单词为单位逆序排放。
输出描述:
得到逆序的句子
示例1
输入
I am a boy
输出
boy a am I
let str = readline();
let sentence = str.split(' '); //通过空格分割字符
let res = [];
for(let i = sentence.length-1; i >= 0; i--) {
res.push(sentence[i]); //将句子内容按照单词逆序存入res
}
// res = ["boy","a","am","I"];
// res.toString() = [boy,a,am,I]
// 最后用正则表达式将 逗号换成 空格
console.log(res.toString().replace(/,/g,' '));
n个字符串按照字典序排列。
题目描述
给定n个字符串，请对n个字符串按照字典序排列。
输入描述:
输入第一行为一个正整数n(1≤n≤1000),下面n行为n个字符串(字符串长度≤100),字符串中只含有大小写字母。
输出描述:
数据输出n行，输出结果为按照字典序排列的字符串。
示例1<br /> 输入<br /> 3<br /> cap<br /> to<br /> cat<br /> 输出<br /> cap<br /> cat<br /> to
let num = readline();
let str = [];
for(let i = 0; i < num; i++) {
str.push(readline());
}
res = str.sort(); //直接利用 sort 可以对字符串按照字典序排序
for(let j = 0; j < res.length; j++){
console.log(res[j]);
}
质数因子
功能:输入一个正整数，按照从小到大的顺序输出它的所有质因子（如180的质因子为2 2 3 3 5 ）
最后一个数后面也要有空格
详细描述：
函数接口说明：
public String getResult(long ulDataInput)
输入参数：
long ulDataInput：输入的正整数
返回值：
String
输入描述:
输入一个long型整数
输出描述:
按照从小到大的顺序输出它的所有质数的因子，以空格隔开。最后一个数后面也要有空格。
示例1
输入
180
输出
2 2 3 3 5
// 质因数=质数+因数，即是质数，也要能被输入的数整除，我们可以从小开始查找
// 180 = 2x2x3x3x5
let num = readline();
let res = [];
for(let i = 2; i <= num; i++ ) {
if( num%i == 0 ) {
res.push(i); //将该质因数保存起来
num = num/i;
i = 1; //累加后等于2，又从2开始遍历
}
}
let res_sort = res.sort(function(a,b){
return a-b;
}).join(' ')+' '; //返回字符串，并在两个之间加空格，最后也要加空格
console.log(res_sort);
取近似值
题目描述
写出一个程序，接受一个正浮点数值，输出该数值的近似整数值。如果小数点后数值大于等于5,向上取整；小于5，则向下取整。
输入描述:
输入一个正浮点数值
输出描述:
输出该数值的近似整数值
示例1
输入
5.5
输出
6
let num = readline();
let nums = num.toString().split('.'); //将数字先转成字符串，然后按小数点分成两部分，右边为要判断的数
if(nums[1]>=5) {
nums[0]++;
console.log(nums[0]);
} else {
console.log(nums[0]);
}
提取不重复的整数
题目描述
输入一个int型整数，按照从右向左的阅读顺序，返回一个不含重复数字的新的整数。
输入描述:
输入一个int型整数
输出描述:
按照从右向左的阅读顺序，返回一个不含重复数字的新的整数
示例1
输入
9876673
输出
37689
let num_str = readline();
//调用split得到字符数组，再直接调用翻转函数
let num_rev = num_str.split('').reverse(); //reverse用于数组,num-rev为逆转后的字符数组
let res = [];
for(let i = 0; i < num_rev.length; i++) {
if( res.indexOf(num_rev[i]) == -1)
res.push(num_rev[i]);
}
// res为包含逗号的反转后的字符串，join用于数组放入一个字符串中，默认逗号连接
console.log(res.toString().replace(/,/g,''));
字符个数统计
题目描述
编写一个函数，计算字符串中含有的不同字符的个数。字符在ACSII码范围内(0~127)，换行表示结束符，不算在字符里。不在范围内的不作统计。
输入描述:
输入N个字符，字符在ACSII码范围内。
输出描述:
输出范围在(0~127)字符的个数。
示例1<br /> 输入<br /> abc<br /> 输出<br /> 3
// charCodeAt() //将字符转为 ascall 码
// formCharCode //将 ascall转为字符，单个转
let str = readline();
let strArr = str.split(''); //需要将连续字符转为字符去重
let strSet = [];
let count = 0;
for(let i = 0; i < strArr.length; i++) { // 循环遍历，去重
if( strSet.indexOf(strArr[i]) == -1) {
strSet.push(strArr[i]);
}
}
for(let i =0; i < strSet.length; i++) { // 遍历去重后的数组，判断转换后的 ascall 是否小于 127
if (strSet[i].charCodeAt() <= 127)
count++;
}
console.log(count);
求字符串分组后，每组的和为水仙花数
（注：水仙花数是一个三位数 其个位、十位、百位的立次方 的和等于自身 如 371 = 3^3 + 7^3 + 1^1 ）
(1) 如果无法找到该分组 ，返回0 ；
(2) 找到该分组，切分组不唯一 ，返回 -1；
(3）分组唯一 ，则返回分组的组数 ；
给定两个字符串A、B 两个字符串长度相等，A字符串中有一段连续字符，在B字符串中也有一段长度相同位置相同的连续字符串
要求| [A [ i ] -B [ i ] ] | 小于等于给定数值V 。
输入要求：
第一行 字符串A
第二行 字符串B
第三行 给定数字 V
停车位：给定一个类似”10000100101”的字符串，1代表有车停着，0代表空车位，求在停车位停车与最近的车之间的最大距离
括号的最大嵌套深度
输入一个仅由 “()[]{}” 组成的字符串，计算出有效的括号最大嵌套深度
输入：([]{()})
输出：3
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String s = sc.nextLine();
int res = 0;
int temp = 0;
Stack<Character> stack = new Stack<>();
for(int i=0;i<s.length();i++){
Character c = s.charAt(i);
if(c=='(') {
stack.push(')');
temp++;
res = Math.max(res,temp);
}else if(c=='[') {
stack.push(']');
temp++;
res = Math.max(res,temp);
}else if (c=='{') {
stack.push('}');
temp++;
res = Math.max(res,temp);
}else {
if((c==')'||c==']'||c=='}')&&stack.size()>0){
Character pop = stack.pop();
if (pop==c){
temp--;
}
}
}
}
if(temp!=0)res = 0;
System.out.println(res);
}
第一行输入一个非负整数字符串，第二行输入一个整数n
输出从该字符串中取出n个字符后剩下的字符组成的最小的数（不改变字符顺序）
输入 ：
2615371
4
输出：131
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String num = sc.nextLine();
int n = sc.nextInt();
StringBuilder num1 = new StringBuilder(num);
int start = 0;
int m = num1.length()-n;
StringBuilder sb = new StringBuilder();
for(int i=1;i<=m;i++){
if(num1.substring(start,n+i).contains("0")){
sb.append(0);
start = num1.indexOf("0")+1;
for(int j=1;j<=start;j++){
num1 = num1.replace(j-1,j,"h");
}
}else if(num1.substring(start,n+i).contains("1")){
sb.append(1);
start = num1.indexOf("1")+1;
for(int j=1;j<=start;j++){
num1 = num1.replace(j-1,j,"h");
}
}else if(num1.substring(start,n+i).contains("2")){
sb.append(2);
start = num1.indexOf("2")+1;
for(int j=1;j<=start;j++){
num1 = num1.replace(j-1,j,"h");
}
}
else if(num1.substring(start,n+i).contains("3")){
sb.append(3);
start = num1.indexOf("3")+1;
for(int j=1;j<=start;j++){
num1 = num1.replace(j-1,j,"h");
}
}
else if(num1.substring(start,n+i).contains("4")){
sb.append(4);
start = num1.indexOf("4")+1;
for(int j=1;j<=start;j++){
num1 = num1.replace(j-1,j,"h");
}
}
else if(num1.substring(start,n+i).contains("5")){
sb.append(5);
start = num1.indexOf("5")+1;
for(int j=1;j<=start;j++){
num1 = num1.replace(j-1,j,"h");
}
}
else if(num1.substring(start,n+i).contains("6")){
sb.append(6);
start = num1.indexOf("6")+1;
for(int j=1;j<=start;j++){
num1 = num1.replace(j-1,j,"h");
}
}
else if(num1.substring(start,n+i).contains("7")){
sb.append(7);
start = num1.indexOf("7")+1;
for(int j=1;j<=start;j++){
num1 = num1.replace(j-1,j,"h");
}
}
else if(num1.substring(start,n+i).contains("8")){
sb.append(8);
start = num1.indexOf("8")+1;
for(int j=1;j<=start;j++){
num1 = num1.replace(j-1,j,"h");
}
}
else if(num1.substring(start,n+i).contains("9")){
sb.append(9);
start = num1.indexOf("9")+1;
for(int j=1;j<=start;j++){
num1 = num1.replace(j-1,j,"h");
}
}
}
if(sb.length()<=0){
System.out.println(0);
}else{
System.out.println(Long.valueOf(sb.toString()));
}
}
若有收获，就点个赞吧
0 人点赞
