JavaScript基础[150道练习题及解法]

练习网站：https://www.w3resource.com/

 

 

 

1.编写一个 JavaScript 程序，以下列格式显示当前日期和时间。
示例输出：今天是：星期二。
当前时间是 : 10 PM : 30 : 38

复制代码
var today = new Date();

    var day = today.getDay();
    var daylist = ["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"];
    console.log("Today is:"+daylist[day]+".")
    var hour = today.getHours()
    var minute = today.getMinutes()
    var second = today.getSeconds()
    var prepand =(hour>=12)?"PM":"AM"
    hour = (hour>=12)? hour-12 : hour


    if(hour===0 && prepand==='PM'){
        if(minute ===0 && second===0){
            hour=12;
            prepand='Noon'
    
        }else{
            hour=12;
            prepand='PM'
        }
    }

    if(hour===0 && prepand==='AM'){
        if(minute===0 && second===0){
            hour=12;
            prepand="Midnight"
        }else{
            hour=12;
            prepand='AM'
        }
    }

    console.log("CUrrent Time:"+hour+prepand+":"+minute+":"+second);
    



    //  console.log(prepand)
复制代码

 

2.编写一个 JavaScript 程序来打印当前窗口的内容。

复制代码
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link rel="stylesheet" href="./style.css">
    <title>Document</title>
</head>
<body>

    <p>Click the button to print the current page</p>
    <button onclick="print_current_page()">Print this page</button>

    <script src="./script.js"></script>
</body>
</html>
复制代码

 

function print_current_page(){
    window.print()
}

 

3.编写一个 JavaScript 程序来获取当前日期。

Expected Output :
mm-dd-yyyy, mm/dd/yyyy or dd-mm-yyyy, dd/mm/yyyy

复制代码
var today = new Date()
var dd = today.getDate()

var mm = today.getMonth()+1;
var  yyyy = today.getFullYear();

if(dd<10){
    dd= '0'+dd;
}
if(mm<10){
    mm='0'+mm;
}

today = mm + '-' + dd + '-' + yyyy;
console.log(today)

today = mm + '/' + dd + '/' + yyyy;
console.log(today)

today = mm + '-' + dd + '-' + yyyy;
console.log(today)
复制代码

 

4.编写一个JavaScript程序，找出三角形三边长分别为5、6、7的面积。

const sidel = 5;
const side2 = 6;
const side3 = 7;
const perimeter = (side3+side2+sidel)/2;
const area = Math.sqrt(perimeter*((perimeter-side3)*(perimeter-side2)*(perimeter-sidel)));
console.log(area)

 

5.编写一个 JavaScript 程序，通过周期性地从字符串末尾删除一个字母并将其附加到前面，将字符串 'w3resource' 向右旋转。

复制代码
function animate_string(id){
    var element = document.getElementById(id);
    var textNode = element.childNodes[0];
    var text = textNode.data;
    setInterval(function(){
        // text[text.length-1] 是先获取字符中最后一个补在这个text的前面，
        //text.substring(0,text.length - 1) 是截取前面的，不要最后一个
        text = text[text.length-1] + text.substring(0,text.length - 1);
        // console.log(text[text.length-1])
        textNode.data = text;
        // console.log(textNode.data)
    },1000)
}
复制代码

 

6. 编写一个 JavaScript 程序来确定给定年份是否是公历中的闰年。

能被 4 整除的每一年都是闰年，但能被 100 整除的年份除外，但如果这些百年年份能被 400 整除，则它们就是闰年。例如，1700 年、1800 年和 1900 年是不是闰年，而是2000年。

复制代码
function leapear(year){
    return (year %100 === 0) ? year % 400 === 0 : year % 4 === 0 ;
}

console.log(leapear(2016))
console.log(leapear(2000))
console.log(leapear(1700))
console.log(leapear(1800))
console.log(leapear(100))
复制代码

 

7.编写一个 JavaScript 程序，发现 1 月 1 日是 2014 年到 2050 年之间的一个星期日。

复制代码
console.log('-------------------')

for(var year =2014;year <=2050 ;year++){
    //构造函数,Date的月份下边从0开始，天数从1开始
    var d= new Date(year,0,1);
    if(d.getDay()===0){
        console.log("1st Jabuary is being a Sunday："+year)
    }
}




console.log('---------------------')
复制代码

 

8.编写一个 JavaScript 程序，程序取一个 1 到 10 之间的随机整数，然后提示用户输入一个猜测数字。如果用户输入与猜测数匹配，程序将显示消息“Good Work”，否则显示消息“Not match”。

const num = Math.ceil(Math.random()*10);
console.log(num);
const gnum = prompt('Guess the number between 1 and 10 inclusive')
if(gnum==num){
    console.log('Matched');
}else{
    console.log('Not matched,the number was:'+gnum)
}

 

 

9.编写一个 JavaScript 程序来计算距离下一个圣诞节还剩多少天。

 如果你有一个以秒为单位的数字，当然，你必须将它乘以 1000。getTime()函数有毫秒的

复制代码
var today = new Date();
var cmas = new Date(today.getFullYear(),11,25);
if(today.getMonth()==11 && today.getDate()>25){
    cmas.setFullYear(cmas.getFullYear()+1);
}

var one_day = 1000*60*60*24;
console.log(
    Math.ceil((cmas.getTime()-today.getTime())/(one_day))+"  days left untill Chrismas!")
复制代码

 

 

10.编写一个 JavaScript 程序来计算两个数字的乘除（用户输入）

复制代码
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link rel="stylesheet" href="./style.css">
    <title>Document</title>
    <style>
        body{
            margin: 30px;
        }
    </style>
</head>
<body>

    <form action="#">
        1st Number : <input type="text" id="firstNumber"><br>
        2nd Number : <input type="text" id="secondNumber"><br>
        <input type="button" onClick="multiplyBy()" value="Multiply">
        <input type="button" onClick="divideBy()" value="Divide">
    </form>
    <p>The Result is :</p>

    <span id="result"></span>


   

    <script src="./script.js"></script>
</body>
</html>
复制代码
复制代码
function multiplyBy(){
    num1 = document.getElementById("firstNumber").value;
    num2 = document.getElementById("secondNumber").value;
    document.getElementById("result").innerHTML=num1*num2;
}

function divideBy(){
    num1 = document.getElementById("firstNumber").value;
    num2 = document.getElementById("secondNumber").value;
    document.getElementById("result").innerHTML=num1/num2;
}
复制代码

 

 

11.编写一个 JavaScript 程序来将温度与摄氏、华氏进行转换。

[公式：c/5 = (f-32)/9 [其中 c = 摄氏温度，f = 华氏温度]
预期输出：
60°C 是 140°F
45°F 是 7.222222222222222°C

复制代码
function cTof(celsius){
    var cTemp = celsius;
    // var cToFachr = ((cTemp * 9)+(32*5))/5 ;
    var cToFachr = cTemp * 9 / 5 +32 ;
    var message = cTemp + '\xB0C is '+ cToFachr + ' \xB0F .'
    console.log(message);
}


function fToC(fahrenHeit){
    var fTemp = fahrenHeit;
    var fToCel = (fTemp-32)*5/9;
    var message =  fTemp+'\xB0F is ' + fToCel + '\xB0C.';
    console.log(message);
}

cTof(60)
fToC(45)
复制代码

 

 

12.编写一个JavaScript程序来获取网站URL（加载页面）

console.log(document.URL)

 

 

13.编写一个 JavaScript 练习以使用用户定义的名称创建一个变量。

var var_name = 'abcd'
var n = 120;
this[var_name] = n;
console.log(this[var_name])

 

 

14.编写一个 JavaScript 练习来获取文件名的扩展名.

fliename = "system.php"
console.log(fliename.split('.').pop());
fliename = "abc.js";
console.log( fliename.split('.').pop());

 

 

15.编写一个 JavaScript 程序来获取给定数字与 13 之间的差，如果该数字大于 13，则返回绝对差的两倍

复制代码
function diffeerence(n){
    if(n < 13){
        return 13-n;
    }else{
        return (n-13) *2
    }
}
console.log(diffeerence(32))
console.log(diffeerence(11))
复制代码

 

 

16.编写一个 JavaScript 程序来计算两个给定整数的和。如果两个值相同，则返回三倍的总和。

复制代码
function sumTriple(x,y){
    if(x==y){
        return 3*(x+y)
    }else{
        return (x+y)
    }
}

console.log(sumTriple(10,20))
console.log(sumTriple(10,10))
复制代码

 

 

17.编写一个JavaScript程序来计算指定数字和19之间的绝对差。如果指定的数字大于19，则返回它们绝对差的三倍。

复制代码
function diff_num(n){
    if(n<=19){
        return (19-n);
    }else{
        return (n-19)*3
    }
}

console.log(diff_num(12));
console.log(diff_num(19));
console.log(diff_num(22));
复制代码

 

 

18.编写一个 JavaScript 程序来检查两个给定的数字，如果其中一个是 50 或它们的总和是 50，则返回 true。

function test50(x,y){
    return ((x==50||y==50)||(x+y==50));
}

console.log(test50(50,50))
console.log(test50(20,50))
console.log(test50(20,20))
console.log(test50(20,30))

 

 

19.编写一个JavaScript程序来检查给定的整数是否在100或400的20以内

复制代码
function testhubdred(x){
    return ((Math.abs(100-x)<=20)||(Math.abs(400-x)<=20))
}

console.log(testhubdred(10))
console.log(testhubdred(90))
console.log(testhubdred(99))
console.log(testhubdred(199))
console.log(testhubdred(399))
复制代码

 

 

20.编写一个 JavaScript 程序来检查两个给定的整数，一个是正数，另一个是负数。

复制代码
function positive_negative(x,y){
    if( (x < 0 && y >0 ) || x>0 && y<0){
        return true;
    }else{
        return false;
    }
}

console.log(positive_negative(2,2))
console.log(positive_negative(-2,2))
console.log(positive_negative(2,-2))
console.log(positive_negative(-2,-2))
复制代码

 

 

21.编写一个 JavaScript 程序来创建一个在给定字符串前面添加“Py”的新字符串。如果给定字符串以“Py”开头，则返回原始字符串。

复制代码
function string_check(str1){
    if(str1 === null || str1 === undefined || str1.substring(0,2) === 'Py'){
        return str1;
    }

    return "Py"+str1;
}

console.log(string_check("Python"));
console.log(string_check("thon"));
复制代码

 

 

22.编写一个 JavaScript 程序，在给定字符串的指定位置删除一个字符并返回新字符串。

复制代码
function remove_character(str,char_pos){
    part1 = str.substring(0,char_pos);
    part2 = str.substring(char_pos+1,str.length);
    return (part1+part2);
}

console.log(remove_character("Python",0));
console.log(remove_character("Python",3));
console.log(remove_character("Python",5));
复制代码

 

 

23.编写一个 JavaScript 程序，从给定的字符串创建一个新字符串，改变第一个和最后一个字符的位置。字符串长度必须大于等于1 。

复制代码
function first_last(str1){
    if(str1.length<=1){
        return str1;
    }

    mid_char = str1.substring(1,str1.length-1);

    return (str1.charAt(str1.length-1) + mid_char + str1.charAt(0) )
}


console.log(first_last('a'));
console.log(first_last('ab'));
console.log(first_last('abc'));
复制代码

 

 

24.编写一个 JavaScript 程序，从给定字符串创建一个新字符串，并在前后添加给定字符串的第一个字符。

function front_back(str){
    first = str.substring(0,1);
    return first + str + first;
}

console.log(front_back('a'));
console.log(front_back('ab'));
console.log(front_back('abc'));

 

 

25.编写一个JavaScript程序，检查给定的正数是3的倍数还是7的倍数。

复制代码
function test37(x){
    if(x % 3 == 0 || x % 7 == 0){
        return true;
    }
    else{
        return false;
    }
} 

console.log(test37(12));
console.log(test37(14));
console.log(test37(10));
console.log(test37(11));
复制代码

 

 

26.编写一个 JavaScript 程序，从给定字符串中创建一个新字符串，该字符串取最后 3 个字符并添加到前面和后面。字符串长度必须为 3 或更多。

复制代码
function front_back3(str){
    if(str.length>=3){
        str_len = 3;

        back = str.substring(str.length-3);
        return back + str + back ;
    }
    else{
        return false;
    }

}

console.log(front_back3("abc"));
console.log(front_back3("ab"));
console.log(front_back3("abcd"));
复制代码

 

 

27.编写一个 JavaScript 程序来检查一个字符串是否以 'Java' 开头，否则为 false。

复制代码
function start_spec_str(str){
    if(str.length < 4){
        return false;
    }
    front = str.substring(0,4);

    if(front == 'Java'){
        return true;
    }else{
        return false
    }
}

console.log(start_spec_str("JavaScript"));
console.log(start_spec_str("Java"));
console.log(start_spec_str("Python"));
复制代码

 

 

28.编写一个 JavaScript 程序来检查两个给定的整数值是否在 50..99（含）范围内。如果其中任何一个在所述范围内，则返回 true。

复制代码
function check_numbers(x,y){
    if((x >= 50 && x <= 99 )|| (y >= 50 && y<=99 ) ){
        return true;
    }
    else{
        return false;
    }
}

console.log(check_numbers(12,101));
console.log(check_numbers(52,80));
console.log(check_numbers(15,99));
复制代码

 

 

29.编写一个 JavaScript 程序来检查三个给定的整数值是否在 50..99（包括）范围内。如果其中一个或多个在所述范围内，则返回 true。

function check_three_nums(x,y,z){
    return (x >=50 && x<=99) || (y >= 50 && y<=99) || (z>=50 && z<=99);
}

console.log(check_three_nums(50,90,99));
console.log(check_three_nums(5,9,199));
console.log(check_three_nums(65,59,199));
console.log(check_three_nums(65,9,199));

 

 

30.编写一个JavaScript程序来检查字符串“Script”是否出现在给定字符串的第5（索引4）位置，如果“Script”出现在字符串中，则返回没有“Script”的字符串，否则返回原始字符串。

复制代码
function check_script(str){
    if(str.length < 6){
        return str;
    }
    let result_str =str;
    // console.log(str.substring(10,4))
    if(str.substring(10,4)=='Script'){
        result_str = str.substring(0,4) + str.substring(10,str.length);
    }
    return result_str;
}

console.log(check_script('JavaScript'))
console.log(check_script('CoffeeScript'))
复制代码

 

 

31.编写一个 JavaScript 程序来找出三个给定整数中最大的一个。

复制代码
function max_of_three(x,y,z){
    max_val =0;
    if(x>y){
        max_val =x;
    }else{
        max_val=y;
    }
    if(z>max_val){
        max_val =z;
    }
    return max_val;
}

console.log(max_of_three(1,0,1));
console.log(max_of_three(0,-10,-20));
console.log(max_of_three(1000,510,440));
复制代码

 

 

32.编写一个 JavaScript 程序，从两个不同的给定整数值中找出最接近 100 的值。

复制代码
function near_100(x,y){
    if(x!=y){
        x1 = Math.abs(x-100);
        y1 = Math.abs(y-100);

        if(x1<y1){
            return x;
        }
        else if(y1 < x1){
            return y;
        }

        return 0;
    }else{
       return false; 
    }
}


console.log(near_100(90,89));
console.log(near_100(-90,-89));
console.log(near_100(90,90));
复制代码

 

 

33.编写一个 JavaScript 程序来检查两个数字是在 40..60 范围内还是在 70..100 范围内。

复制代码
function numbers_ranges(x,y){
    if((x>=40 && x<=60 &&y>=40&&y<=60)||(x>=70&&x<=100&&y>=70&&y<=100)){
        return true
    }else{
        return false;
    }
}


console.log(numbers_ranges(44,56));
console.log(numbers_ranges(70,95));
console.log(numbers_ranges(50,89));
复制代码

 

 

34.编写一个 JavaScript 程序，从给定的两个正整数中找出较大的数，这两个数在 40..60 范围内。

复制代码
function max_townums_range(x,y){
    if((x>=40)&&(x<=60)&&(y>=40&&y<=60)){
        if(x===y){
            return "Numbers are the same"
        }else if(x>y){
            return x;
        }else{
           return y;
        }
    }
    else{
        return "Numbers don't fit in range"
    }

    
    
}

console.log(max_townums_range(45,60));
console.log(max_townums_range(25,60));
console.log(max_townums_range(45,80));
复制代码

 

 

35.编写一个程序，检查给定字符串的第 2 到第 4 个位置是否存在指定字符。

复制代码
function check_char(str1,char){
    ctr = 0;
    for(let i =0; i< str1.length; i++){
        if((str1.charAt(i) == char) && (i>=1 && i<=3)){
            ctr = 1;
            break;
        }
    }
    if(ctr ==1 ){
        return true;
    }else{
        return false
    }
}


console.log(check_char("Python","y"));
console.log(check_char("JavaScript","a"));
console.log(check_char("Console","o"));
console.log(check_char("Console","C"));
console.log(check_char("Console","e"));
复制代码

 

 

36.编写一个 JavaScript 程序来检查三个给定正整数的最后一位是否相同。

复制代码
function last_digit(x,y,z){
    if( (x>0) && y > 0 && z > 0 ){
        return (x % 10 == y %10 && y%10 ==z%10 && x%10 == z%10)
    }else{
        return false;
    }
}


console.log(last_digit(20,30,400));
console.log(last_digit(-20,30,400));
console.log(last_digit(20,-30,400));
console.log(last_digit(20,30,-400));
复制代码

 

 

37.编写一个 JavaScript 程序来创建新字符串，其中前 3 个字符是给定字符串的小写字母。如果字符串长度小于 3，则将所有字符转换为大写。

复制代码
function upper_lower(str){
    if(str.length < 3){
        return str.toUpperCase();
    }
    front_part = (str.substring(0,3).toLowerCase());
    back_part = str.substring(3,str.length);
    return front_part+back_part;
}

console.log(upper_lower("Python"));
console.log(upper_lower("Py"));
console.log(upper_lower("JAVAScript"));
复制代码

 

 

38.编写一个 JavaScript 程序来检查一个学生在各种考试中的总分。如果考试是“期末考试”，如果总分在 89..100 范围内，学生将获得 A+ 成绩。学生将获得 A+ 成绩，总分必须大于或等于 90。如果学生获得 A+ 成绩，则返回 true，否则返回 false。

复制代码
function exam_status(totmarks,is_exam){
    if(is_exam){
        return totmarks >= 90;
    }
    return (totmarks>=89 && totmarks<=100)
}

console.log(exam_status("78",""))
console.log(exam_status("89","true"))
console.log(exam_status("99","true"))
复制代码

 

 

39.编写一个 JavaScript 程序来计算两个给定整数的和，如果和在 50..80 范围内，则返回 65，否则返回 80

复制代码
function sortaSum(x,y){
    const sum_nums = x+y;
    if(sum_nums >=50 && sum_nums <=80){
        return 65;
    }
    return 80;
}



console.log(sortaSum(30,20))
console.log(sortaSum(90,80))
复制代码

 

 

40.编写一个 JavaScript 程序，从两个给定的整数中检查其中一个是 8 还是它们的和或差是 8。 

复制代码
    function check8(x,y){
        if(x==8 || y==8){
            return true;
        }
        if( x+y==8 || Math.abs(x-y) ==8){
            return true;
        }
        return false;
    }


    console.log(check8(7, 8));
    console.log(check8(16, 8));
    console.log(check8(24, 32));
    console.log(check8(17, 18));
复制代码

 

 

41.编写一个JavaScript程序来检查三个给定的数字，如果三个数字相同返回30，否则返回20，如果两个数字相同返回40。

复制代码
function three_number(x,y,z){
    if(x==y && y==z){
        return 30;
    }
    else if(x==y || y==z || z==x){
        return 40;
    }
    else{
        return 20;
    }
}


console.log(three_number(8,8,8));
console.log(three_number(8,8,18));
console.log(three_number(8,7,18));
复制代码

 

 

42.编写一个 JavaScript 程序来检查三个给定的数字是在严格模式还是在软模式下增加。

复制代码
function number_order(x,y,z){
    if(y>x && z>y){
        return "strict mode";
    }
    else if(z > y){
        return "Soft mode";
    }
    else{
        return "Undefnded"
    }
}


console.log(number_order(10,15,31));
console.log(three_number(24,22,31));
console.log(three_number(50,21,15));
复制代码

 

 

43.编写一个 JavaScript 程序来检查三个给定数字（非负整数）中的两个或所有数字是否具有相同的最右边数字。

function same_last_digit(p,q,r){
    return(p%10 === q%10) || (p%10 === r%10) || (q%10 === r%10);
}


console.log(same_last_digit(22,32,42));
console.log(same_last_digit(102,302,2));
console.log(same_last_digit(20,22,45));

 

 

44.编写一个 JavaScript 程序，从三个给定的整数中检查一个数是否大于或等于 20 并且小于其他一个数。

function lessby20_others(x,y,z){
    return (x>=20 && (x<y || x<z)) || (y>=20 && (y<x || y<z)) || (z >20 && (z<y || z<x))
}

console.log(lessby20_others(23,45,10))
console.log(lessby20_others(23,23,10))
console.log(lessby20_others(21,66,75))

 

 

 

 45.编写一个 JavaScript 程序来检查两个给定的整数值，如果其中一个是 15 或者它们的和或差是 15，则返回 true

复制代码
function test_number(x,y){
    return (x === 15 || y===15 || x+y===15 || Math.abs(x-y)===15);
}




console.log(test_number(15,9))
console.log(test_number(25,15))
console.log(test_number(7,8))
console.log(test_number(10,25))
console.log(test_number(5,9))
console.log(test_number(7,9))
console.log(test_number(9,25))
复制代码

 

 

46.编写一个 JavaScript 程序来检查两个给定的非负整数，其中一个（不是两个）是否是 7 或 11 的倍数。

复制代码
function valCheck(a,b){
    if(!((a%7 ==0 || a%11==0) && (b%7==0 || b%11 ==0))){
        return ((a%7 == 0 || a%11 ==0) || (b%7 ==0 || b%11 == 0));
    }
    else{
        return false;
    }
}

console.log(valCheck(14,21));
console.log(valCheck(14,20));
console.log(valCheck(16,20));
复制代码

 

 

47.编写一个 JavaScript 程序来检查给定的数字是否存在于 40..10000 范围内

例如40和4000中的40个礼物

复制代码
function test_diggit(x,y,n){
    if(n<40 || n>10000){
        return false;
    }
    else if(n>=x && n<=y){
        return true
    }
    else{
        return false
    }
}

console.log(test_diggit(40,4000,45))
console.log(test_diggit(80,320,79))
console.log(test_diggit(89,4000,30))
复制代码

 

 

48.编写一个 JavaScript 程序来反转给定的字符串。

function string_reverse(str){
    return str.split("").reverse().join("")
}

console.log(string_reverse('w3resource'))
console.log(string_reverse('www'))
console.log(string_reverse('JavaScript'))

 

 

49.编写一个 JavaScript 程序，将给定字符串中的每个字符替换为字母表中紧随其后的字符。

复制代码
function string_reverse(str){
    return str.split("").reverse().join("")
}


function LetterChanges(text){
    var s=text.split('');
    for(var i =0;i<s.length;i++){
        switch(s[i]){
            case ' ':
            break;
            case 'z':
            s[i] = 'a';
            break;
            case 'Z':
            s[i] = 'A';
            break;
            default:
            s[i] =String.fromCharCode(1+s[i].charCodeAt(0));
        }

        switch(s[i]){
            case 'a':
            case 'e':
            case 'i':
            case 'o':
            case 'u':
            s[i] = s[i].toUpperCase();
        }
    }

    return s.join('');
}

console.log(LetterChanges('PYTHON'))
console.log(LetterChanges('W3R'))
console.log(LetterChanges('php'))
复制代码

 

 

50.编写一个 JavaScript 程序，将给定字符串中每个单词的首字母大写。

复制代码
function capital_letter(str){
    str = str.split(" ");

    for(var i=0, x=str.length; i<x; i++){
        str[i] = str[i][0].toUpperCase() + str[i].substr(1);
    }

    return str.join(" ");
}



console.log(capital_letter("Write a JavaScript program to capitalize the first letter of each word of a given string."))
复制代码

 

 

 51.编写一个 JavaScript 程序将给定的数字转换为小时和分钟。

复制代码
function time_convert(num){
    var hours = Math.floor(num/60);
    var minuter = num % 60;
    return hours+":"+minuter;
}

console.log(time_convert(71))
console.log(time_convert(450))
console.log(time_convert(1441))
复制代码

 

 

52.编写一个 JavaScript 程序以按字母顺序转换给定字符串的字母。

function alphabet_Soup(str){
    return str.split("").sort().join("");
}

console.log(alphabet_Soup("Python"));
console.log(alphabet_Soup("Exercises"));

 

 

53.编写一个 JavaScript 程序来检查字符 a 和 b 是否在给定字符串中的任何位置（至少一次）恰好被 3 个位置分开。

function ab_Check(str){
    return (/a...b/).test(str) || (/b...a/).test(str);
}

console.log(ab_Check("Chainsbreak"));
console.log(ab_Check("pane borrowed"));
console.log(ab_Check("abCheck"));

 

 54.编写一个 JavaScript 程序来计算给定字符串中元音的数量。

function vowel_count(str){
    return str.replace(/[^aeiou]/g,'').length;
}
 

console.log(vowel_count("Python"));
console.log(vowel_count("w3resource.com"));

 

 

 55.编写一个 JavaScript 程序来检查给定的字符串是否包含相等数量的 p 和 t。

复制代码
function equal_pt(str){
    var str_p = str.replace(/[^p]/g,"");
    var str_t = str.replace(/[^t]/g,"");
    var p_num = str_p.length;
    var s_num = str_t.length;
    return p_num === s_num;
}

console.log(equal_pt("paatps"));
console.log(equal_pt("paatps"));
复制代码

 

 

56.编写一个 JavaScript 程序来划分两个正数并返回一个带有正确格式逗号的字符串。

复制代码
function divison_string(n1,n2){
    n1 =80;
    n2=6;

var div = Math.round(n1 / n2).toString(),result_array =div.split("");

if(div>=1000){
    for(var i = div.length-3; i>0; i-=3){
        result_array.splice(i,0,",")
    }
    result_array;
}

console.log(result_array);


}

divison_string();
复制代码

 

 

57.编写一个 JavaScript 程序来创建一个给定字符串的指定副本（正数）的新字符串。

复制代码
function string_copies(str,n){
    if(n<0)
    return false;
    else
    return str.repeat(n);
}

console.log(string_copies("abc",5));
console.log(string_copies("abc",0));
console.log(string_copies("abc",-2));
复制代码

 

 

58.编写一个 JavaScript 程序来创建一个新字符串，该字符串由给定原始字符串的最后 3 个字符的 4 个副本组成。给定字符串的长度必须为 3 及以上。

复制代码
function newstring(str){
    if(str.length >=3){
        result_str = str.substring(str.length-3);
        return result_str.repeat(4);
    }
}

console.log(newstring("Python 3.0"));
console.log(newstring("JS"));
console.log(newstring("JavaScript"));
复制代码

 

 

59.编写一个 JavaScript 程序来提取偶数长度字符串的前半部分。

复制代码
function first_half(str){
    if(str.length % 2 ==0){
        return str.slice(0,str.length/2);
    }
    return str;
}

console.log(first_half("Python"));
console.log(first_half("first_half"));
console.log(first_half("PHP"));
复制代码

 

 

60.编写一个 JavaScript 程序来创建一个没有给定字符串的第一个和最后一个字符的新字符串。

function without_first_end(str){
    return str.substring(1,str.length -1);
}

console.log(without_first_end("JavaScript"));
console.log(without_first_end("JS"));
console.log(without_first_end("PHP"));

 

 

61.编写一个 JavaScript 程序来连接两个字符串，除了它们的第一个字符。

复制代码
function concatenate(str1,str2){
    str1 = str1.substring(1,str1.length);
    str2 = str2.substring(1,str2.length);
    return str1 + str2;
}

console.log(concatenate("PHP","JS"));
console.log(concatenate("A","B"));
console.log(concatenate("AA","BB"));
复制代码

 

 

62.编写一个 JavaScript 程序，将最后三个字符移动到给定字符串的开头。字符串长度必须大于或等于三。

复制代码
function right_three(str){
    if(str.length>1){
        return str.slice(-3) + str.slice(0,-3);
    }
}

console.log(right_three("Python"));
console.log(right_three("JavaScript"));
console.log(right_three("Hi"));
复制代码

 

 

63.编写一个 JavaScript 程序，使用给定长度奇数字符串的中间三个字符创建一个字符串。字符串长度必须大于或等于三。

复制代码
function middle_three(str){
    if(str.length %2!=0){
        mid =(str.length + 1)/2;
        return str.slice(mid-2,mid+1);
    }
    return str;
}

console.log(middle_three("abcdefg"));
console.log(middle_three("HTML5"));
console.log(middle_three("Python"));
console.log(middle_three("PHP"));
console.log(middle_three("Exercises"));
复制代码

 

 

64.编写一个 JavaScript 程序来连接两个字符串并返回结果。如果字符串的长度不同，则从较长的字符串中删除字符。

function str_con_cat(str1,str2){
    const m = Math.min(str1.length,str2.length);
    return str1.substring(str1.length-m) + str2.substring(str2.length-m);
}

console.log(str_con_cat("Python","JS"));
console.log(str_con_cat("ab","cdef"))

 

 

65.编写一个JavaScript程序来测试一个字符串是否以“Script”结尾。字符串长度必须大于等于6 。

复制代码
function end_script(str){
    if(str.substring(str.length-6,str.length)==="Script"){
        return true
    }else{
        return false;
    }
}

console.log(end_script("JavaScript"));
console.log(end_script("Java Script"));
console.log(end_script("Java Scripts"))
复制代码

 

 

66.如果字符串以“Los”或“New”开头，则编写一个 JavaScript 程序来显示城市名称，否则返回空白。

复制代码
function city_name(str){
    if(str.length >=3 && ((str.substring(0,3)=="Los")||(str.substring(0,3)=="New"))){
        return str;
    }else{
        return "";
    }
}

console.log(city_name("New Your"));
console.log(city_name("Los Angeles"));
console.log(city_name("London"))
复制代码

 

 

67.编写一个 JavaScript 程序，从给定字符串创建一个新字符串，如果第一个或最后一个字符是“P”，则删除字符串的第一个和最后一个字符。如果条件不满足，则返回原始字符串。

复制代码
function nop(str){
    let start_pos = 0;
    let end_pos = str.length;

    if(str.length > 0 && str.charAt(0)=='P'){
        start_pos = 1;
    }

    if(str.length >1 && str.charAt(str.length -1) == 'P'){
        end_pos --;
    }


    return str.substring(start_pos,end_pos);
}

console.log(nop("PythonP"));
console.log(nop("Python"));
console.log(nop("JavaScript"));
复制代码

 

 

68.编写一个 JavaScript 程序，使用给定字符串的第一个和最后 n 个字符创建一个新字符串。字符串长度必须大于或等于 n。

function two_string(str,n){
    first_part = str.substring(0,n);
    last_part = str.substring(str.length - n);
    return first_part + last_part;
}

console.log(two_string("javascript",2));
console.log(two_string("javascript",3));

 

 

69.编写一个 JavaScript 程序来计算给定长度为 3 的整数数组的三个元素的总和。

function sum_three(nums){
    return nums[0] + nums[1] + nums[2];
}

console.log(sum_three([10,32,20]));
console.log(sum_three([5,7,9]));
console.log(sum_three([0,8,-11]));

 

 

70.编写一个 JavaScript 程序，旋转给定长度为 3 的整数数组左侧的元素 3. 

复制代码
<!DOCTYPE html>
<html lang="zh">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title></title>
</head>
<body>
    
    
    
    <script type="text/javascript">
        function rotate_elements_left(array){
            return [array[1],array[2],array[0]];
        }
        
        console.log(rotate_elements_left([3,4,5]))
        console.log(rotate_elements_left([0,-1,2]))
        console.log(rotate_elements_left([7,6,5]))
    </script>
</body>
</html>
复制代码

 

 

 

71.编写一个 JavaScript 程序来检查 1 是否出现在给定整数数组的第一个或最后一个位置。数组长度必须大于等于1 。

function first_last_1(nums){
    var end_pos = nums.length - 1;
    return nums[0] ==1 || nums[end_pos]==1; 
}

console.log(first_last_1([1,3,5]))
console.log(first_last_1([1,3,5,1]))
console.log(first_last_1([2,4,6]))

 

 

72.编写一个 JavaScript 程序来检查第一个和最后一个元素是否等于给定的整数数组长度 3. 

复制代码
function first_last_same(nums){
    var end = nums.length - 1;
    if(nums.length >=1){
        return nums[0] == nums[end]
    }else{
        return false;
    }
}

console.log(first_last_same([1,3,5]))
console.log(first_last_same([10,3,5,10]))
console.log(first_last_same([20,4,20]))
复制代码

 

 

73.编写一个 JavaScript 程序来反转给定长度的整数数组的元素 3. 

 

function reverse3(array){
    return array.map((element,idx,arr)=>arr[(arr.length -1)-2]);
}

console.log(reverse3([5,4,3]));
console.log(reverse3([1,0,-1]));
console.log(reverse3([2,3,1]));

 

 

74.编写一个 JavaScript 程序来查找第一个或最后一个之间较大的值，并将所有其他元素设置为该值。显示新数组。

复制代码
function all_max(nums){
    var max_val = nums[0] > nums[2] ? nums[0] :nums[2];

    nums[0] = max_val;
    nums[1] = max_val;
    nums[2] = max_val;

    return nums;
}

console.log(all_max([20,30,40]))
console.log(all_max([-7,-9,0]))
console.log(all_max([12,10,3]))
复制代码

 

 

75.编写一个 JavaScript 程序来创建一个新数组，取两个整数数组的中间元素和每个长度 3. 

复制代码
function middle_elements(a,b){
    var new_array = []
    new_array.push(a[1],b[1]);

    return new_array;
}

console.log(middle_elements([1,2,3],[1,5,6]));
console.log(middle_elements([3,3,3],[2,8,0]));
console.log(middle_elements([4,2,7],[2,4,5]));
复制代码

 

 

76.编写一个JavaScript程序来创建一个新数组，从给定的整数数组中获取第一个和最后一个元素，长度必须大于或等于1。

复制代码
function started(nums){
            var array1 = [];
            array1.push([nums[0],nums[nums.length-1]]);
            
            return array1;
        }
        
        console.log(started([20,20,30]));
        console.log(started([5,2,7,8]));
        console.log(started([17,12,34,78]));
复制代码

 

 

77.编写一个JavaScript程序来测试一个长度为2的整数数组是否包含1或3。

复制代码
function contains13(nums){
            if(nums.indexOf(1) != -1 || nums.indexOf(3) != -1){
                return true;
            }else{
                return false;
            }
        }
        
        
        console.log(contains13([1,5]))
        console.log(contains13([2,3]))
        console.log(contains13([7,5]))
复制代码

 

 

78.编写一个JavaScript程序，测试一个长度为2的整数数组是否不包含1或3。

复制代码
function is13(nums){
            if(nums.indexOf(1) ==1 && nums.indexOf(3)== -1){
                return true
            }
            else{
                return false
            }
        }
        
        
        console.log(is13([7,8]))
    console.log(is13([3,2]))
    console.log(is13([0,1]))
复制代码

 

 

79.编写一个 JavaScript 程序来测试给定的整数数组是否包含两次 30 和 40。数组长度应为0、1或2。

复制代码
function twice3040(arra1){
            let a =arra1[0],b=arra1[1];
            
            return (a === 30 && b === 30) || (a === 40 && b ===0);
        }
        
        console.log(twice3040([30,30]))
        console.log(twice3040([40,40]))
        console.log(twice3040([20,20]))
        console.log(twice3040([30]))
复制代码

 

 

80.编写一个 JavaScript 程序来交换给定整数数组的第一个和最后一个元素。数组长度至少应为1。

复制代码
function swap(arra){
            [arra[0],arra[arra.length-1]] = [arra[arra.length-1],arra[0]]
            
            return arra;
        }
        
        console.log(swap([1,2,3,4]))
        console.log(swap([0,2,1]))
        console.log(swap([3]))
复制代码

 

 

81.编写一个 JavaScript 程序，将长度为 2 的给定正整数的两位数相加。

    function add_two_digits(n){
        return n % 10 + Math.floor(n/10);
    }

console.log(add_two_digits(25))
console.log(add_two_digits(50))

 

 

82.编写一个 JavaScript 来添加两个不带进位的正整数。

复制代码
    function add_two_without_carrying(n1,n2){
        var result = 0,x = 1;

        while(n1 > 0 && n2 > 0){
            result += x* ((n1 + n2) % 10);
            n1 = Math.floor(n1 / 10)
            n2 = Math.floor(n2 / 10);
            x *= 10;
        }

        return result;
    }

console.log(add_two_without_carrying(222,911))
console.log(add_two_without_carrying(200,900))
复制代码

 

 

83.编写一个 JavaScript 从给定的字符串数组中找到最长的字符串。

复制代码
    function longest_string(str_ara){
        var max = str_ara[0].length;
        console.log(max)
        str_ara.map(v=>max=Math.max(max,v.length));
        // result = str_ara.filter(v=>v.length==max);
        result = str_ara.filter(function(v){
            return v.length==max;
        });
        return result;
    }


console.log(longest_string(['a','aa','aaa','aaaa','aaaaa']))
复制代码

 

 

84.编写一个 JavaScript 将给定字符串的每个字符替换为英文字母表中的下一个字符。
注意：“a”将被“b”替换或“z”将被“a”替换。

复制代码
 function alphabet_char_Shift(str){
    var all_chars = str.split("");
    for(var i = 0; i< all_chars.length; i++){
        var n = all_chars[i].charCodeAt() - 'a'.charCodeAt();
        n=(n+1)%26;
        all_chars[i] = String.fromCharCode(n+'a'.charCodeAt());
    }
    return all_chars.join("");
 }

console.log(alphabet_char_Shift("abcdxyz"))
复制代码

 

 

85.编写一段 JavaScript 代码，将给定的正整数数组分成两部分。第一个元素进入第一部分，第二个元素进入第二部分，第三个元素进入第一部分，依此类推。现在计算两个部分的总和并存储到一个大小为 2 的数组中。

复制代码
    function alternate_Sums(arr){
        var result = [0,0];
        for(var i =0; i<arr.length; i++){
            if(i % 2){
                result[1]+=arr[i];
            }else{
                result[0] +=arr[i];
            }
        }
        return result;
    }

    console.log(alternate_Sums([1,3,6,2,5,10]))
复制代码

 

 

86.编写一个 JavaScript 程序来查找给定角度的类型。

角度类型：

  • 锐角：0 到 90 度之间的角度。
  • 直角：90度角。
  • 钝角：介于 90 度和 180 度之间的角度。
  • 直角：180度角。
复制代码
  function angle_Type(angle){
      if(angle <90){
          return "Acute angle."
      }
      if(angle === 90){
          return "Right angle."
      }
      if(angle<180){
          return "Obtuse angle."
      }
      return "Straight angle."
  }

console.log(angle_Type(47))
console.log(angle_Type(90))
console.log(angle_Type(145))
console.log(angle_Type(180))
复制代码

 

 

87.编写一个 JavaScript 程序来检查两个相同长度的整数数组是否相似。如果一个数组可以通过最多交换一对元素从另一个数组中获得，那么这些数组将是相似的。

复制代码
 function array_checking(arra1,arra2){
     for(var i =0; i<arra1.length; i++){
        for(var j = i; j<arra1.length; j++){
            var result = true;
            temp = arra1[i];
            // console.log(temp = arra1[i])
            arra1[i] = arra1[j];
            // console.log(arra1[i] = arra1[j])
            arra1[j] = temp;
            // console.log(arra1[j] = temp)
            for(var k = 0; k<arra1.length; k++){
                if(arra1[k]!==arra2[k]){
                    result = false;
                    break;
                }
            }
            if(result){
                return true;
            }
            arra1[j] = arra1[i];
            arra1[i] = temp;
        }
     }
     return false;
 }

 console.log(array_checking([10,20,30],[10,20,30]))
 console.log(array_checking([10,20,30],[30,10,20]))
 console.log(array_checking([10,20,30,40],[10,20,30,40]))
复制代码

 

 

88.编写一个 JavaScript 程序来检查两个给定的整数是否相似，如果一个给定的除数除以两个整数并且它都不除。

复制代码
  function checking_numbers(x,y,divisor){
      if(x%divisor === 0 && y%divisor ===0 || x%divisor !==0 && y%divisor !== 0){
        return true;
      }
      return false;
  }

  console.log(checking_numbers(10,25,5));
  console.log(checking_numbers(10,20,5));
  console.log(checking_numbers(10,20,4));
复制代码

 

 

89.编写一个 JavaScript 程序，检查是否可以将给定表达式 x $ y = z 中的 $ 替换为 +、-、* 或 / 四个符号之一，以获得正确的表达式。

比如x = 10, y = 30 and z = 300，我们可以把$换成多重运算符(*)得到x * y = z

复制代码
  function checj_arithmetic_Expression(x,y,z){
      return x+y==z || x*y ==z || x/y == z || x-y == z;
  }

  console.log(checj_arithmetic_Expression(10,25,35))
  console.log(checj_arithmetic_Expression(10,25,250))
  console.log(checj_arithmetic_Expression(30,25,5))
  console.log(checj_arithmetic_Expression(100,25,4.0))
  console.log(checj_arithmetic_Expression(100,25,25))
复制代码

 

 

90.编写一个 JavaScript 程序来查找给定整数数组的第 k 个最大元素。

复制代码
 function Kth_greatest_in_array(arr,k){
     for(var i = 0; i<k; i++){
         var max_index = i;
         tmp = arr[i];

         for(var j = i+1 ; j<arr.length; j++){
             if(arr[j] > arr[max_index]){
                 max_index = j;
             }
         }
         arr[i] = arr[max_index];
         arr[max_index]=tmp;
     }

     return arr[k-1];
 }

 console.log(Kth_greatest_in_array([1,2,6,4,5],3))
 console.log(Kth_greatest_in_array([-10,-25,-47,-36,0],1))
复制代码

 

 

91.编写一个 JavaScript 程序，找出给定正整数数组的 k 个连续数字（按顺序相互跟随的数字）的最大可能和。

复制代码
 function Kth_greatest_in_array(arr,k){
     for(var i = 0; i<k; i++){
         var max_index = i;
         tmp = arr[i];
        //  console.log(typeof tmp)

         for(var j = i+1 ; j<arr.length; j++){
             if(arr[j] > arr[max_index]){
                 max_index = j;
             }
         }
         arr[i] = arr[max_index];
         arr[max_index]=tmp;
     }
     return arr[k-1];
 }

 console.log(Kth_greatest_in_array([1,2,6,4,5],3))
 console.log(Kth_greatest_in_array([-10,-25,-47,-36,0],1))
复制代码

 

 

92.编写一个 JavaScript 程序，找出给定整数数组中任意两个相邻元素之间的最大差值。

复制代码
 function max_difference(arr){
     var max = -1;
     var temp;
     for(var i =0; i<arr.length-1; i++){
         temp = Math.abs(arr[i]-arr[i+1]);
         max = Math.max(max,temp);
     }
     return max;
 }

 console.log(max_difference([1,2,3,8,9]));
 console.log(max_difference([1,2,3,18,9]));
 console.log(max_difference([13,2,3,8,9]));
复制代码

 

 

93.编写一个 JavaScript 程序，找出给定整数数组的所有可能对之间的最大差值。

复制代码
function array_max_diff(arr){
    var max_result = 0;
    for(var i=1; i<arr.length; i++){
        for(var k=0; k!=i && k<arr.length; k++){
            var diff = Math.abs(arr[i]-arr[k])
            max_result = Math.max(max_result,diff)
        }
    }
    return max_result;
}

console.log(array_max_diff([1,2,3,8,9]))
console.log(array_max_diff([1,2,3,18,9]))
console.log(array_max_diff([13,2,3,8,9]))
复制代码

 

 

94.编写一个 JavaScript 程序，找出给定整数数组中出现次数最多的数字。

复制代码
function array_element_mode(arr){
    var ctr = [],ans=0;

    for(var i =0; i<10; i++){
        ctr.push(0);
    }

    for(var i = 0; i<arr.length; i++){
        ctr[arr[i]-1]++;
        if(ctr[arr[i]-1] > ctr[ans]){
            ans = arr[i] -1;
        }
    }
    return ans+1;

}

console.log(array_element_mode([1,2,3,2,2,8,1,9]))
复制代码

 

 

95.编写一个 JavaScript 程序，用给定整数数组的指定数量替换所有数字。

复制代码
function array_element_replace(arr,old_val,new_vule){
    for(var i =0; i<arr.length; i++){
        if(arr[i]===old_val){
            arr[i]=new_vule;
        }
    }
    return arr;
}

var num =[1,2,3,2,2,8,1,9];
console.log("Orignal Array"+num);
console.log(array_element_replace(num,2,5))
复制代码

 

 

96.编写一个 JavaScript 程序来计算给定整数数组的连续数的绝对差之和。

复制代码
function sum_adjacent_difference(arr){
            var result = 0;
            for(var i =1; i<arr.length; i++){
                result +=Math.abs(arr[i] - arr[i-1]);
            }
            return result;
        }
        
        console.log(sum_adjacent_difference([1,2,3,2,-5]))
复制代码

 

 

97.编写一个 JavaScript 程序来找到可能的最短字符串，该程序可以创建一个字符串，通过在其末尾添加字符使其成为回文。

复制代码
function build_Palindrome(new_str){
            var flag;
            for(var i= new_str.length;;i++){
                flag = true;
                for(var j=0;j<i-j-1;j++){
                    if(i-j-1<new_str.length && new_str[j]!=new_str[i-j-1]){
                        flag = false;
                        break;
                    }
                }
                if(flag){
                    for(var j=new_str.length;j<i;j++){
                        new_str += new_str[i-j-1];
                    }
                    return new_str;
                }
            }
        }
        
        console.log(build_Palindrome("abcddc"))
        console.log(build_Palindrome("122"))
复制代码

 

 

98.编写一个 JavaScript 程序来切换最小可能字母数的大小写，以使给定的字符串以大写或小写形式写入。

Fox 示例 “Write” 将是 write 而“PHp” 将是 “PHP”

复制代码
function change_case(new_str){
            var x=0;
            var y=0;
            // console.log(typeof /[A-Z]/)
            for(var i =0; i<new_str.length; i++){
                if(/[A-Z]/.test(new_str[i])){
                    x++;
                }else{
                    y++;
                }
            }
            
            if(y>x){
                return new_str.toLowerCase();
            }else{
                return new_str.toUpperCase();
            }
        }
        
        console.log(change_case("Write"))
        console.log(change_case("PHp"))
复制代码

 

 

99.编写一个 JavaScript 程序来检查是否可以重新排列给定字符串的字符，使其与另一个给定字符串相等。

复制代码
    function rearrangement_characters(str1,str2){
            var first_set = str1.split(''),
            second_set = str2.split(''),
            result = true;
            
            first_set.sort();
            second_set.sort();
            
            for(var i=0; i<Math.max(first_set.length,second_set.length);i++){
                if(first_set[i] !== second_set[i]){
                    result=false;
                }
            }
            
            return result;
        }
        
        console.log(rearrangement_characters("xyz","zyx"))
        console.log(rearrangement_characters("xyz","zyp"))
复制代码

 

 

100.编写一个 JavaScript 程序来检查是否有至少一个元素出现在两个给定的整数排序数组中。

复制代码
function check_common_element(arra1,arra2){
            for(var i = 0; i<arra1.length; i++){
                if(arra2.indexOf(arra1[i]!= -1)){
                    return true;
                }
            }
            return false;
        }
        
        console.log(check_common_element([1,2,3],[3,4,5]))
        console.log(check_common_element([1,2,3],[5,6,7]))
复制代码

 

 

 

101.编写一个 JavaScript 程序来检查给定的字符串是否只包含拉丁字母并且没有两个大写字母和两个小写字母在相邻的位置。

复制代码
function test_string(input_str){

    var is_lower_case = function(symbol){
        if('a' <= symbol && symbol <='z'){
            return true
        }
        else{
            return false;
        }
    }

    var is_upper_case = function(symbol){
        if('A'<= symbol && symbol <= 'Z'){
            return true;
        }else{
            return false;
        }
    }


    var is_first_char_lower = is_lower_case(input_str[0]);
    var is_first_char_upper = is_upper_case(input_str[0]);

    if(!(is_first_char_lower || is_first_char_upper)){
        return false;
    }

    for(var i =1; i<input_str.length; i++){
        if(i%2){
            if(is_lower_case(input_str[i]) === is_first_char_lower ||is_upper_case(input_str[i]) === is_first_char_upper){
                return false;
            }
        }
        else{
            if(is_lower_case(input_str[i]!== is_first_char_lower) || is_upper_case(input_str[i])!== is_first_char_upper){
                return false;
            }
        }
    }
    return true;
}


    console.log(test_string('xYr'));
    console.log(test_string('XXyx'));
复制代码

 

 

102.编写一个 JavaScript 程序来查找给定整数数组的反转次数。
注意：如果 a[i] > a[j] 且 i < j，则存储在位置 i 和 j 的数组 a 的两个元素形成反转。

复制代码
    function number_of_InversionsNaive(arr){
        var ctr = 0;
        for(var i = 0; i<arr.length; i++){
            for(var j=i+1; j<arr.length; j++){
                if(arr[i] > arr[j]){
                    ctr++;
                }
            }
        }
        return ctr;
    }

    console.log(number_of_InversionsNaive([0,3,2,5,9]))
    console.log(number_of_InversionsNaive([1,5,4,3]))
    console.log(number_of_InversionsNaive([10,30,20,-10]))
复制代码

 

 

103.编写一个 JavaScript 程序，通过删除给定数字的一个数字，从给定的正整数中找到最大的数字。

复制代码
    function digit_delete(num){
        var result = 0,
        num_digits = [];
        while(num){
            num_digits.push(num%10);
            num=Math.floor(num/10);
        }
        for(var index_num=0; index_num < num_digits.length;index_num++){
            var n=0;
            for(var i = num_digits.length-1; i>=0; i--){
                if(i!==index_num){
                    n=n*10+num_digits[i];
                }
            }
            result = Math.max(n,result);
        }
        return result;
    }

    console.log(digit_delete(100));
    console.log(digit_delete(10));
    console.log(digit_delete(1245));
复制代码

 

 

104.编写一个 JavaScript 程序来找到数组的两个元素，使得它们的绝对差不大于给定的整数，但尽可能接近所述整数。

复制代码
    function different_values(ara,n){
        var max_val = -1;
        for(var i =0; i<ara.length; i++){
            for(var j =i+1; j<ara.length;j++){
                var x=Math.abs(ara[i]-ara[j]);
                if(x<=n){
                    max_val=Math.max(max_val,x)
                }
            }
        }

        return max_val;
    }

    console.log(different_values([12,10,33,34],10))
    console.log(different_values([12,10,33,34],24))
    console.log(different_values([12,10,33,44],40))
复制代码

 

 

105.编写一个 JavaScript 程序，找出用数字之和替换给定数字的次数，直到它转换为单个数字。

复制代码
function digit_to_one(num){
    var digitSum = function(num){
        var digit_sum =0;
        while(num){
            digit_sum +=num%10;
            num = Math.floor(num / 10);
        }
        return digit_sum;
    }

    var result = 0;

    while(num>=10){
        result += 1 ;
        num = digitSum(num);
    }

    return result;
}

console.log(digit_to_one(123))
console.log(digit_to_one(156))
复制代码

 

 

106、编写一个JavaScript程序，只要结果是整数，就可以将一个整数除以另一个整数，并返回结果。

复制代码
    function fivide_digit(num,d){
        if(d==1){
            return num;
        }
        else{
            while(num%d ===0){
                num /=d;
                // console.log( num /=d)
            }
            return num;
        }
    }

    console.log(fivide_digit(-12,2))
    console.log(fivide_digit(13,2))
    console.log(fivide_digit(13,1))
复制代码

 

 

107.编写一个 JavaScript 程序来查找由给定整数数组中的元素组成的排序对的数量，使得对中的一个元素可以被另一个整除。
例如 - [1, 3, 2] ->2 - (1,3), (1,2) 的输出。
[2, 4, 6] 的输出 -> 2 - (2,4), (2,6)
[2, 4, 16] 的输出 -> 3 - (2,4), (2,16) , (4,16)

复制代码
    function arr_pairs(arr){
        var result=0;
        for(var i =0; i<arr.length; i++){
           for(var j=i+1; j<arr.length; j++){
            if(arr[i]% arr[j]===0 || arr[j]%arr[i]===0){
                result++;
            }
           }
        }
        return result;
    }


    console.log(arr_pairs([1,2,3]))
    console.log(arr_pairs([2,4,6]))
    console.log(arr_pairs([2,4,16]))
复制代码

 

 

108.编写一个 JavaScript 程序来创建两个给定 3D 向量的点积。

注：点积是两个数字序列的相应条目的乘积之和。

复制代码
    function dot_product(vector1,vector2){
        var result =0;
        for(var i =0; i<3; i++){
            result +=vector1[i] * vector2[i];
        }
        return result;
    }

    console.log(dot_product([1,2,3],[1,2,3]))
    console.log(dot_product([2,4,6],[2,4,6]))
    console.log(dot_product([1,1,1],[0,1,-1]))
复制代码

 

 

109.编写一个 JavaScript 程序，对一个包含 1 到给定整数之间的所有素数的数组进行排序。

复制代码
function sort_prime(num){
    var prime_num1 = [],
    prime_num2 = [];
    for(var i =0; i<=num; i++){
        prime_num2.push(true);
    }
    for(var i =2; i<=num; i++){
        if(prime_num2[i]){
            prime_num1.push(i);
            for(var j=1; i*j <=num; j++){
                prime_num2[i*j] = false;
            }
        }
    }
    return prime_num1;
}

console.log(sort_prime(5))
console.log(sort_prime(11))
console.log(sort_prime(19))
复制代码

 

 

 

110.编写一个 JavaScript 程序，在给定数字第一次出现之前依次查找偶数个数

复制代码
    function find_numbers(arr_num,num){
        var result = 0;
        for(var i = 0; i<arr_num.length; i++){
            if(arr_num[i] % 2 === 0 && arr_num[i] !==num){
                result++;
            }
            if(arr_num[i] === num){
                return result;
            }
        }
        return -1;
    }

    console.log(find_numbers([1,2,3,4,5,6,7,8],5))
    console.log(find_numbers([1,3,5,6,7,8],6))
复制代码

 

 

111.编写一个 JavaScript 程序来检查三个给定数字中的一个数字，其中两个数字相等，找到第三个。

复制代码
    function find_third_number(x,y,z){
        if((x!==y) && (x!==z) && (y!==z))
            return "Three numbers are unequal.";
            if(x==y){
                return z;
            }
            if(x==z){
                return y;
            }
            return x;
    }

    console.log(find_third_number(1,2,2))
    console.log(find_third_number(1,1,2))
    console.log(find_third_number(1,2,3))
复制代码

 

 

 

112.编写一个 JavaScript 程序来查找给定数字的阶乘的十进制表示中尾随零的数量

复制代码
 function trailing_zeros_factorial(n){
     var result = 0;
     for(var i =5; i<=n; i+=5){
        var num = i;
        while(num%5=== 0){
            num/=5;
            result++;
        }
     }
     return result;
 }

 console.log(trailing_zeros_factorial(8));
 console.log(trailing_zeros_factorial(9))
 console.log(trailing_zeros_factorial(10))
复制代码

 

 

 

113.编写一个 JavaScript 程序来计算 n + n/2 + n/4 + n/8 + .... 其中 n 是一个正整数，所有除法都是整数。

复制代码
  function int_sum(num){
      var s_sum = 0;
      while(num > 0){
          s_sum +=num;
          num = Math.floor(num/2);
      }
      return s_sum;
  }

  console.log(int_sum(8));
  console.log(int_sum(9));
  console.log(int_sum(26));
复制代码

 

 

114.编写一个 JavaScript 程序来检查给定的字符串是否代表正确的句子。如果一个字符串以大写字母开头并以句号 (.) 结尾，则该字符串被认为是正确的句子

复制代码
    function is_correct_Sentence(input_str){
        var first_char = input_str[0];
        var last_char = input_str[input_str.length -1];
        return /[A-Z]/.test(first_char) && last_char =="."
    }

    console.log(is_correct_Sentence("This tool will help you write better English and efficiently corrects texts."));
    console.log(is_correct_Sentence("This tool will help you write better English and efficiently corrects texts"));
    console.log(is_correct_Sentence("this tool will help you write better English and efficiently corrects texts."));
复制代码

 

 

115.编写一个 JavaScript 程序来检查一个矩阵是否是对角矩阵。在线性代数中，对角矩阵是一个矩阵，其中主对角线之外的项都为零（从左上角到右下角的对角线）。

复制代码
function is_diagoal_matrix(user_matrix){
    for(var i=0; i<user_matrix.length;i++){
        for(var j=0; j<user_matrix.length; j++){
            // console.log( user_matrix[i][j])
            if(i!==j && user_matrix[i][j]!==0){
                return false
            }
        }
        // console.log(i+'j')
    }
    return true;
}

console.log(is_diagoal_matrix([[1,0,0],[0,2,0],[0,0,3]]))
console.log(is_diagoal_matrix([[1,0,0],[0,2,3],[0,0,3]]))
复制代码

 

 

 

116.编写一个 JavaScript 程序，找出所有可能的选项，将字符串中的散列（由数字和一个散列 (#) 组成）替换为一个数字，以生成可被 3 整除的整数。

字符串“2 *0"，输出应该是：["210", "240", "270"]

复制代码
<!DOCTYPE html>
<html lang="zh">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title></title>
</head>
<body>
    
    
    
    <script type="text/javascript">
        function is_divisible_by3(mask_str){
            
            var digitSum = 0,
            left = '0'.charCodeAt(),
            right='9'.charCodeAt(),
            result = [],
            mask_data = mask_str.split(''),
            hash_pos = -1;
            
            for(var i=0; i<mask_data.length;i++){
                if(left<=mask_data[i].charCodeAt()&&mask_data[i].charCodeAt()<=right){
                    digitSum +=mask_data[i].charCodeAt() - left;
                }else{
                    hash_pos=i;
                }
            }
            
            for(var i =0; i<10; i++){
                if((digitSum +i)%3 ===0){
                    mask_data[hash_pos]=String.fromCharCode(left+i);
                    result.push(mask_data.join(''));
                }
            }
            return result;
        }
        
        console.log(is_divisible_by3("2#0"))
        console.log(is_divisible_by3("4#2"))
    </script>
</body>
</html>
复制代码

 

 

117.编写一个 JavaScript 程序来检查给定的矩阵是否是单位矩阵。
注意：在线性代数中，单位矩阵，或者有时被模糊地称为单位矩阵，大小为 n 是 n ? n 方阵，主对角线上为 1，其他地方为 0

复制代码
function is_identity_Matrix(matrix_data){
    // 给定的矩阵是否为方阵
    for(var i=0; i<matrix_data.length; i++){
        rows = matrix_data.length;
        cols = matrix_data[i].length;
        if(rows !=cols){
            console.log("Matrix should be a square matrix");
            return false;
        }
    }

    for(var i =0; i<matrix_data.length; i++){
        for(var j=0; j<matrix_data.length; j++){
            // console.log(matrix_data[i][j])
            if(matrix_data[i][j]!==1 && i===j || matrix_data[i][j] && i!==j){
                return false;
            }
        }
    }
    return true;
}

console.log(is_identity_Matrix([[1,0,0,2],[0,1,0],[0,0,1]]))
console.log(is_identity_Matrix([[1,0,0],[0,1,0],[0,0,1]]))
console.log(is_identity_Matrix([[1,0,1],[0,1,0],[0,0,1]]))
复制代码

 

 

118.编写一个 JavaScript 程序来检查给定的数字是否在给定的范围内

function is_inrange(x,y,z){
    return y>=x && y<=z
}

console.log(is_inrange(1,2,3));
console.log(is_inrange(1,2,-3));
console.log(is_inrange(1.1,1.2,1.3));

 

 

119.编写一个 JavaScript 程序来检查给定的整数是否具有递增的数字序列。

复制代码
function is_increasing_digits_sequence(num){
    var arr_num=(''+num).split('');
    // console.log(typeof arr_num)

    for(var i =0; i<arr_num.length-1;i++){
        // console.log(typeof parseInt(arr_num[i]))
        // console.log(arr_num[i])
        // console.log(arr_num[i+1])
        if(parseInt(arr_num[i]) >= parseInt(arr_num[i+1])){
            return false;
        }
    }
    return true;
    
}


console.log(is_increasing_digits_sequence(123)); 
console.log(is_increasing_digits_sequence(1223));
console.log(is_increasing_digits_sequence(45677))
复制代码

 

120.编写一个 JavaScript 程序来检查一个点是否严格位于给定的圆内。

输入：
圆心(x,y)
圆半径：r
圆内点(a,b)

复制代码
  
  function check_a_point(a,b,x,y,r){
      var dist_points = (a-x)*(a-x)+(b-y)*(b-y);
      r*=r;

      if(dist_points < r){
        return true;
      }

      return false;
  }

  console.log(check_a_point(0,0,2,4,6))
  console.log(check_a_point(0,0,6,8,6))
复制代码

 

 

121.编写一个 JavaScript 程序来检查给定的矩阵是否是下三角矩阵。
注意：如果主对角线以上的所有项都为零，则方矩阵称为下三角矩阵。

复制代码
    function lower_triangular_matrix(user_matrix){
            for(var i=0; i<user_matrix.length; i++){
                for(var j = 0; j<user_matrix[0].length; j++){
                    if(j>i && user_matrix[i][j] !==0){
                        return false;
                    }
                }
            }
            return true;
        }
        
        console.log(lower_triangular_matrix([[1,0,0],[2,0,0],[0,3,3]]))
        console.log(lower_triangular_matrix([[1,0,1],[2,0,0],[0,3,3]]))
复制代码

 

 

 

122.编写一个 JavaScript 程序来检查给定的整数数组是表示严格递增的还是严格递减的序列。

复制代码
function is_monotonous(num){
            if(num.length===1){
                return true;
            }
            
            var num_direction = num[1] -num[0];
            // console.log(num_direction)
            for(var i=0; i<num.length-1; i++){
                // console.log(num_direction *(num[i+1]-num[i]))
                if(num_direction * (num[i+1]-num[i]) <=0){
                    return false;
                }
            }
            return true;
        }
        
        console.log(is_monotonous([1,2,3]));
        console.log(is_monotonous([1,2,2]));
        console.log(is_monotonous([-3,-2,-1]));
复制代码

 

 

123.编写一个 JavaScript 程序来查找给定整数数组的成员是否是从 1 到给定整数的数字排列。

复制代码
    function is_permutation(input_arr,n){
      for(var i = 0; i<n; i++){
        if(input_arr.indexOf(i+1)<0){
          return false;
        }
      }
      return true;
    }

    console.log(is_permutation([1,2,3,4,5],5))
    console.log(is_permutation([1,2,3,5],5))
复制代码

 

 

124.编写一个 JavaScript 程序来创建两个给定布尔值的 NOR 值。
注意：在布尔逻辑中，逻辑或或联合否定是一个真值函数运算符，它产生的结果是逻辑或的否定。也就是说，当 p 和 q 都不为真时，形式为 (p NOR q) 的句子为真——即当 p 和 q 都为假时
示例：
对于 x = true 和 y = false，输出应该是logical_Nor (x, y) = 假；对于 x = false 和 y = false，输出应该是logical_Nor(x, y) = true。

    function test_logical_Nor(a,b){
      return (!a && !b)
    }

    console.log(test_logical_Nor(true,false));
    console.log(test_logical_Nor(false,false));
    console.log(test_logical_Nor(true,true));

 

 

125.编写一个 JavaScript 程序，从给定的数组中找出最长的字符串。

复制代码
  function longest_str_in_array(arra){
      var max_str = arra[0].length;
      var ans = arra[0];
      for(var i=1; i<arra.length; i++){
        if(maxi > max_str){
          ans = arra[i];
          max_str=maxi;
        }
      }
      return ans;
  }

  console.log(longest_str_in_array(["ab","a","abcd"]));
  console.log(longest_str_in_array(["ab","ab","ab"]));
复制代码

 

 

126.编写一个 JavaScript 程序，从整数数组中获取最大的偶数。

复制代码
    function max_enev(arra){
      arra.sort((x,y)=>y-x);
      for(var i =0; i<arra.length; i++){
        if(arra[i]%2 == 0){
          return arra[i];
      }
    }
  }

  console.log(max_enev([20,40,200]))
  console.log(max_enev([20,40,200,301]))
复制代码

 

 

127.编写一个 JavaScript 程序来反转给定整数中位的顺序。
56 -> 111000 反转后 7 -> 111
234 -> 11101010 反转后 87 -> 1010111

  function mirror_bits(n){
    return parseInt(n.toString(2).split("").reverse().join(""),2)
  }

  console.log(mirror_bits(56))
  console.log(mirror_bits(234))

 

 

 

128.编写一个 JavaScript 程序，找出不小于给定值的最小整数。
注意：整数被非正式地认为是一个以一个或多个零结尾的整数。 [3] 所以，590比592更圆，但590比600小。

复制代码
  function nearest_round_number(num){
    while(num % 10){
      num++;
    }
    return num;
  }

  console.log(nearest_round_number(56))
  console.log(nearest_round_number(592))
复制代码

 

 

129.编写一个 JavaScript 程序来找到严格大于给定数的最小素数。

复制代码
  function next_Prime_num(num){
    for(var i=num+1; ; i++){
      var isPrime = true;
      for(var d=2; d*d <=i; d++){
        if(i%d===0){
          isPrime = false;
          break;
        }
      }
      if(isPrime){
        return i;
      }
    }
  }

  console.log(next_Prime_num(3))
  console.log(next_Prime_num(17))
复制代码

 

 

130.编写一个 JavaScript 程序来找出给定整数中偶数的个数。

复制代码
  function even_digits(num){
    var ctr=0;
    while(num){
      ctr +=num%2 ===0;
      num = Math.floor(num / 10);
    }
    return ctr;
  }

  console.log(even_digits(123));
  console.log(even_digits(1020));
  console.log(even_digits(102));
复制代码

 

 

131.编写一个 JavaScript 程序来创建一个给定数组的前缀和数组。
在计算机科学中，数字序列 x0、x1、x2、...的前缀和、累积和、包含扫描或简单扫描是数字 y0、y1、y2、...的第二个序列，输入序列的前缀之和：
y0 = x0
y1 = x0 + x1
y2 = x0 + x1+ x2

复制代码
  function prefix_sums(arr){
    var new_arr = [];
    for(var i =0; i<arr.length; i++){
      new_arr[i] = 0;
      for(var j =0; j<i+1; j++){
        new_arr[i] += arr[j];
      }
    }
    return new_arr;
  }


  console.log(prefix_sums([1,2,3,4,5]));
  console.log(prefix_sums([1,2,-3,4,5]))
复制代码

 

 

132.编写一个 JavaScript 程序来查找给定整数的所有不同质因数。

复制代码
function prime_factors(num) {
  function is_prime(num) {
    for (let i = 2; i <= Math.sqrt(num); i++)
    {
      if (num % i === 0) return false;
    }
    return true;
  }
  const result = [];
  for (let i = 2; i <= num; i++)
  {
    while (is_prime(i) && num % i === 0) 
    {
      if (!result.includes(i)) result.push(i);
      num /= i;
    }
  }
  return result;
}




 console.log(prime_factors(100))
 console.log(prime_factors(101))
 console.log(prime_factors(103))
 console.log(prime_factors(104))
 console.log(prime_factors(105))
复制代码

 

 

 

 133.编写一个 JavaScript 程序来检查给定分数是否正确。
注意：有两种类型的常见分数，正确的或不正确的。当分子和分母都为正时，如果分子小于分母，则称分数为真，否则为不正确。

复制代码
  function proper_improper_test(num){
    return Math.abs(num[0] / num[1])< 1 ? "Proper fraction." : 'Improper fraction'
  }

  console.log(proper_improper_test([12,300]))
  console.log(proper_improper_test([2,4]))
  console.log(proper_improper_test([103,3]))
  console.log(proper_improper_test([104,2]))
  console.log(proper_improper_test([5,40]))
复制代码

 

 

 

134.编写一个JavaScript程序来改变字符串中的字符（小写），其中a变成z，b变成y，c变成x，...，n变成m，m变成n，... , z 变成 a。

复制代码
  function change_char(str1){
    var result = [];
    for(var i=0; i<str1.length; i++){
      var char_order= str1.charCodeAt(i) -'a'.charCodeAt(0),
      change_char = 25-char_order + 'a'.charCodeAt(0);

      result.push(String.fromCharCode(change_char));
    }
    return result.join("");
  }

  console.log(change_char("abcxyz"));
  console.log(change_char("python"));
复制代码

 

 

 

135.编写一个 JavaScript 程序来删除给定字符串中出现多次的所有字符。

复制代码
    function remove_duplicate_cchars(str){
      var arr_char = str.split("");
      var result_arr = [];

      for(var i=0; i<arr_char.length; i++){
        if(str.indexOf(arr_char[i]) === str.lastIndexOf(arr_char[i]) ){
          result_arr.push(arr_char[i]);
        }
      }
      return result_arr.join("");
    }

    console.log(remove_duplicate_cchars("abcdabc"));
    console.log(remove_duplicate_cchars("python"));
    console.log(remove_duplicate_cchars("abcabc"));
    console.log(remove_duplicate_cchars("1365451"))
复制代码

 

 

136.编写一个 JavaScript 程序，用 $ 字符替换字符串中的第一个数字（应该至少包含一个数字）。

  function replace_first_digit(input_str){
    return input_str.replace(/[0-9]/,'$');
  }

  console.log(replace_first_digit("abc1dabc"))
  console.log(replace_first_digit("p3ython"))
  console.log(replace_first_digit("ab1cabc"))

 

 

137.编写JavaScript程序测试给定整数是否大于15返回给定数，否则返回15.

复制代码
  function test_fifteen(num){
    while(num<15){
      num++
    }
    return num;
  }

  console.log(test_fifteen("123"))
  console.log(test_fifteen("10"))
  console.log(test_fifteen("5"))
复制代码

 

 

138.编写一个 JavaScript 程序来反转给定的 16 位无符号短整数的位。

复制代码
  function sixteen_bits_reverse(num){
    var result =0;
    for(var i=0; i<16; i++){
      result = result*2+(num%2)
      num = Math.floor(num/2);
    }
    return result;
  }

  console.log(sixteen_bits_reverse(12345));
  console.log(sixteen_bits_reverse(10));
  console.log(sixteen_bits_reverse(5));
复制代码

 

 

139.编写一个 JavaScript 程序来查找整数数组中最右边的整数的位置。如果没有整数，则返回 0。 
注意：整数被非正式地认为是一个以一个或多个零结尾的整数。

复制代码
    function find_rightmost_round_number(input_arr){
      var result = 0;
      for(var i=0; i<input_arr.length; i++){
        if(input_arr[i] % 10 ===0){
          result = i;
        }
      }
      return result;
    }

    console.log(find_rightmost_round_number([1,22,30,54,56]));
    console.log(find_rightmost_round_number([1,22,32,54,56]));
    console.log(find_rightmost_round_number([1,22,32,54,50]));
复制代码

 

 

140.编写一个 JavaScript 程序来检查给定数字中的所有数字是否相同。

复制代码
  function test_same_digit(num){
    var first = num % 10;
    // console.log(first)
    while(num){
      // console.log(num)
      if(num % 10 !== first){
        return false;
      }
      num = Math.floor(num/10);
    }
    return true;
  }

  console.log(test_same_digit(1234));
  console.log(test_same_digit(1111));
  console.log(test_same_digit(222222222));
复制代码

 

 

141.编写一个 JavaScript 程序来查找两个给定数组中出现的元素的数量。 

复制代码
  function test_same_elements_both_arrays(arra1,arra2){
    var result = 0;
    for(var i =0; i<arra1.length; i++){
      for(var j = 0; j< arra2.length; j++){
        // console.log(arra1[j]+"j")
        // console.log(arra1[i]+"i")
        if(arra1[i]===arra2[j]){
          result ++;
        }
      }
    }
    return result;
  }

  console.log(test_same_elements_both_arrays([1,2,3,4],[1,2,3,4]))
  console.log(test_same_elements_both_arrays([1,2,3,4],[1,2,3,5]))
  console.log(test_same_elements_both_arrays([1,2,3,4],[11,22,33,44]))
复制代码

 

 142.编写一个 JavaScript 程序来简化 Unix 风格文件的给定绝对路径。

复制代码
function simplify_path(main_path) {
  var parts = main_path.split('/'),
      new_path = [],
      length = 0;
  for (var i = 0; i < parts.length; i++) {
    var part = parts[i];
    if (part === '.' || part === '' || part === '..') {
      if (part === '..' && length > 0) {
        length--;
      }
      continue;
    }
    new_path[length++] = part;
  }

  if (length === 0) {
    return '/';
  }

  var result = '';
  for (var i = 0; i < length; i++) {
    result +=  '/'+new_path[i] ;
  }

  return result;
}
console.log(simplify_path("/home/var/./www/../html//sql/"));
复制代码

 

 

143.编写一个 JavaScript 程序，按长度递增的顺序对给定字符串数组中的字符串进行排序。 
注意：如果两个字符串的长度相同，请不要更改顺序。

复制代码
function sort_by_string_length(arra){
  for(var i =0; i<arra.length; i++){
    for(var j =i+1; j<arra.length; j++){
      if(arra[i].length > arra[j].length){
        var m = arra[i];
        arra[i] = arra[j];
        arra[j]=m;
      }
    }
  }
  return arra;
}

var arra =["xyz","acd","aa","bb","zzz","", "a","b"];
console.log("Original array:"+arra+"\n");
console.log(sort_by_string_length(["xyz","acd","aa","bb","zzz","", "a","b"]))
复制代码

 

 

 

144.编写一个 JavaScript 程序来分解一个 url 的地址并将它的一部分放入一个数组中。
注意：url结构：://.org[/]，地址中可能没有部分。

复制代码
  function break_address(url_add){
    var data = url_add.split("://")
    var protocol = data[0];
    data = data[1].split(".com");
    var domain = data[0];
    data = data[1].split("/");

    if(data[1]){
      return [protocol,domain,data[1]]
    }
    return [protocol,domain]
  }

  var url_add = "https://www.w3resource.com/javascript-exercises/"
  console.log("Original address:"+url_add)
  console.log(break_address(url_add))
复制代码

 

 

145.编写一个 JavaScript 程序来找到最大整数 n，使得 1 + 2 + ... + n <= 给定整数。

复制代码
 function sumn(val){
    var sn = 0;
    var i =0;
    while(sn <= val){
      sn += i++;
    }
    return i-2;
  }

  console.log(sumn(11))
  console.log(sumn(15))
复制代码

 

 

146.编写一个 JavaScript 程序来计算从 1 到给定整数的所有整数的立方和。

复制代码
  function sum_Of_Cubes(n){
    var sumn =0;
    for(var i=1; i<=n; i++){
      sumn +=Math.pow(i,3)
    }
    return sumn;
  }

  console.log(sum_Of_Cubes(3))
  console.log(sum_Of_Cubes(4))
复制代码

 

 

147.编写一个 JavaScript 程序来计算给定字符串中出现的所有数字的总和。

复制代码
  function sum_digits_from_string(dstr){
    var dsum = 0;
    for(var i =0; i<dstr.length; i++){
      if(/[0-9]/.test(dstr[i])){
        dsum +=parseInt(dstr[i])
      }
    }
    return dsum;
  }

  console.log(sum_digits_from_string("abcd12efg9"))
  console.log(sum_digits_from_string("w3resource"))
复制代码

 

 

148.编写一个 JavaScript 程序来交换给定的偶数长度整数数组的两半。

复制代码
  function halv_array_swap(iarra){
    if(((iarra.length)%2)!=0){
      return false;
    }

    for(var i =0; i<iarra.length / 2; i++){
      var tmp = iarra[i];
      iarra[i] = iarra[i+iarra.length/2];
      iarra[i+iarra.length/2]=tmp;
    }

    return iarra;

  }

  console.log(halv_array_swap([1,2,3,4,5,6]))
  console.log(halv_array_swap([1,2,3,4,5,6,7]))
复制代码

 

 

149.编写一个 JavaScript 程序来改变给定字符串中所有字母的大小写。

复制代码
 function change_case(txt){
    var str1 = '';
    for(var i=0; i<txt.length; i++){
      if(/[A-Z]/.test(txt[i])){
        str1+=txt[i].toLowerCase();
      }else{
        str1 +=txt[i].toUpperCase();
      }
    }

    return str1;
  }

  console.log(change_case("w3resource"))
  console.log(change_case("Germany"))
复制代码

 

 

150.编写一个 JavaScript 程序来交换给定偶数长度整数的相邻数字对。

复制代码
  function swap_adjacent_digits(n){
    if(n.toString().length%2!=0){
      return false;
    }

    var result = 0,x=1;
    while(n!=0){
      var dg1 = n%10,
      dg2=((n-dg1)/10)%10;

      result +=x*(10*dg1+dg2);
      n=Math.floor(n/100);
      x*=100;
    }
      return result;
  }

  console.log(swap_adjacent_digits(15))
  console.log(swap_adjacent_digits(1234))
  console.log(swap_adjacent_digits(123456))
  console.log(swap_adjacent_digits(12345))
复制代码

 

posted @   漫漫长路</>  阅读(2003)  评论(0)  编辑  收藏  举报
相关博文：
·  JavaScript示例
·  JavaScript DOM [13 个练习和解决方案]
·  JavaScript基础 看这一篇就够了
·  JavaScript基础学习
·  78JavaScript基础
阅读排行：
· 分享一个免费、快速、无限量使用的满血 DeepSeek R1 模型，支持深度思考和联网搜索！
· 基于 Docker 搭建 FRP 内网穿透开源项目（很简单哒）
· ollama系列01：轻松3步本地部署deepseek，普通电脑可用
· 25岁的心里话
· 按钮权限的设计及实现
点击右上角即可分享
微信分享提示
AI IDE Trae