我的笔记—编程面试题大全

编程题：

1、提示用户输入一个三位数，若不是三位数，则提示用户输入有误；若是三位数，则判断该数能否被13整除

    let numbers = +prompt("请输入三位数字");
    if(isNaN(numbers) || numbers > 999 || numbers < 100){
        console.log("输入有误，请输入三位有效数字");
    }else{
        if(numbers % 13 == 0){
            console.log("能被13整除");
        }else{
            console.log("不能被13整除");
        }
    }

2、让用户输入一个成绩(1-100)，判断这个成绩属于哪个范围并输出结果(A:90-100 B:70-89 C:60-69 D:40-59 E:0-39).

let score = +prompt("请输入分数(0~100)之间");

        if(isNaN(score) || score < 0 || score > 100){
            console.log("输入有误");
        }else if(score >= 90){
            console.log("成绩为A");
        }else if(score >= 70){
            console.log("成绩为B");
        }else if(score >= 60){
            console.log("成绩为C");
        }else if(score >= 40){
            console.log("成绩为D");
        }else{
            console.log("成绩为E");
        }

3、根据世界卫生组织推荐的计算方法，

男性的标准体重计算方法为(身高cm - 80) * 70%;
女性的标准体重计算方法为(身高cm - 70) * 60%;
标准体重正负10%为正常体重，低于标准体重的10%为偏瘦，高于标准体重的10%为偏胖;
编写程序，让用户输入性别，身高，体重，判断用户的健康状况。

let height = +prompt("请输入身高(cm)");
    let weight = +prompt("请输入体重(kg)");
    let gender = prompt("请输入性别(男/女)");
    let standardWeight;

    if(isNaN(height) || isNaN(weight) || gender !== "男" && gender !== "女"){
        console.log("输入有误");
    }else{  //标准体重计算方法
        if(gender == "男"){
            standardWeight = (height - 80) * 0.7;
        }else{
            standardWeight = (height - 70) * 0.6;
        }

        if(weight < standardWeight * 0.9){
            console.log("你的体重偏瘦，多吃点");
        }else if(weight > standardWeight * 1.1){
            console.log("您的体重偏胖，少吃点吧");
        }else{
            console.log("您的体重正常");
        }
    }

4、某理财公司推出一种理财服务，服务规则如下：

若用户的理财金额在50万元以下，则每年的收益按照4%计算
若用户的理财金额在50万元以上(包括50万)，则每年的收益按照4.5%计算
若用户的理财金额超过200万元，除了理财收益以外，还要额外给予用户收益金额的10%
编写程序，让用户输入理财金额和理财年限，计算到期后的收益。

let money = prompt("请输入理财金额");
    let year = prompt("请输入理财年限");
    if (isNaN(money) || isNaN(year) || money < 0 || year < 0) {
        console.log("输入有误");
    } else {
        let rate = 0.04;
        if (money >= 500000) {
            rate = 0.045;
        }
        var earnings = money * year * rate;
        if (money >= 2000000) {
            
            earnings += earnings * 0.01;
        }

        console.log(`总收益为${earnings}`)
    }

5、编写一个用户和计算机猜拳的游戏，用户输入剪刀、石头、布与计算机的出拳进行比较，并判断胜负

let fist = prompt("请输入(剪刀、石头、布)");
    if (fist !== "剪刀" && fist != "石头" && fist != "布") {
        console.log("输入有误");
    } else {  //给计算机定义随机出拳
        let reg = Math.random();
        let PcFist;
        if (reg < 0.333) {
            PcFist = "剪刀";
        } else if (reg < 0.666) {
            PcFist = "石头";
        } else {
            PcFist = "布";
        }
        //判断胜负
        if (fist == "剪刀" && PcFist == "布" || fist == "石头" && PcFist == "剪刀" || fist == "布" && PcFist == "石头") {
            console.log(`你的出拳:${fist},电脑出拳：${PcFist}`);
            console.log("恭喜你 你赢了！");
        }else if(fist == PcFist){
            console.log(`你的出拳${fist},电脑出拳${PcFist}`);
            console.log("平局");
        }else{
            console.log(`你的出拳${fist},电脑出拳${PcFist}`);
            console.log("很遗憾，你输了！");
        }
    }

判断是不是一个质数 //条件：只能被1和自身整除 如2是质数 4不是质数

思路：从1循环到这个数，记录有多少个数能整除它，当数字为2的时候，判断为质数/素数

1、输入一个数字判断是否为质数

let num = +prompt("请输入一个数字");
    if(isNaN(num) || num < 0){
        console.log("输入错误");
    }else{
        let record = 0;   //记录整除数量
        for(let i = 0; i <= num; i++){
            if(num % i === 0){
                record++;
            }
        }
        if(record === 2){
            console.log("是质数");
        }else{
            console.log("不是质数");
        }
    }

2、打印从1-100之间的所有质数

for (let i = 1; i <= 100; i++) {
        let isFind = false;
        for (let j = 2; j < i - 1; j++) {
            if (i % j === 0) {
                isFind = true;
                break;
            }
        }
        if (i > 1 && !isFind) {  //isFind去掉1和它本身只计算中间的，来判断
        // isFind = true的时候打印的是非质数，取反表示打印的是质数
            console.log(i);
        }
    }

3、让用户输入星星的数量，然后输出对应数量的*

let num = +prompt("请输入一个数字");
    if(isNaN(num) || num < 0){
        console.log("输入错误");
    }else{
        for(let i = 0;i < num; i++){
            console.log("*");
        }
    }

4、输出一个3行5列的*;

for(let i = 1; i <= 3; i++){
        let str = "";
        for(let j = 1; j <= 5; j++){
            str += "*";
        }
        console.log(str);
    }

5、用*输出一个5行的直角三角形

let str = "";
    for(let i = 0; i < 5; i++){
        str += "*";
        console.log(str);
    }

6、用*输出一个5行的等腰三角形

let r = 5;
    for(let i = 1; i <= 5; i++){
        let str = "";
        for(let j = 1; j <= r - i; j++){
            str += " ";
        }
        for(let j = 1; j <= 2*i - 1; j++){
            str += "*";
        }
        console.log(str);
    }

7、输出99乘法表

for(let i = 1; i <= 9; i++){
    let str = "";
    for(let j = 1; j <= i; j++){
        str += `${j}*${i}=${j*i}\t`;
    }
    console.log(str);
}

8、斐波拉契数列：

//第一种:  缺点：当n较大时很快产生栈溢出，引发原因是“调用帧”过多
function Fibo(n){
        if(n == 1 || n == 2){
            return 1
        }
        return Fibo(n - 1) + Fibo(n - 2);
    }
    console.log(Fibo(9));

9、创建一个斐波拉契的迭代器

function createFeiboiterator(){
        let prev1,
            prev2,
            n = 1;
        return {
            next(){
                let value;
                if(n <= 2){
                    value = 1;
                }else{
                    value = prev1 + prev2;
                }
                let result={
                    value,
                    done:false,
                }
                prev1 = prev2;
                prev2 = result.value;
                n++;
                return result;
            }
        }
    }
    const iter = createFeiboiterator();

10、数组去重

const arr = [1,2,3,78,45,2,89,45,67,89,2,2,3];
const s = new Set(arr);
const result = [...s];  //es7展开运算符
console.log(result);

11、字符串去重

const str = "skefahesifisdaehrfsasdfasdfqwfjs23r23rswer";
const s = new Set(str);
const result = [...s].join("");
console.log(result);

12、两个数组的并集、交集、差集 (不能出现重复项) 得到的结果是一个新数组

const arr1 = [11,22,4,5,521,3,22,11,78];
const arr2 = [11,33,55,11,78,4,34,55];
const s = new Set(arr1.concat(arr2));
const result = [...s];
console.log("并集",result);

//还可用var nums = [...arr1,...arr2];合并两个数组

13、写一个方法，求一个字符串的长度，(提示：字符串有一个方法charCodeAt(),一个中文占两个字节，一个英文占一个字节。)

​ 定义和用法：

​ charCodeAt()方法可以返回，指定位置的字符的Unicode编码。返回值是0-65535之间的整数。(当返回值是

​ <=255时，为英文，当返回值 > 255 时，为中文)

​ 语法：stringObject.charCodeAt(index);

//第一种方法：常规方法
var str = "fhwsioe广东省fie";
function getStrLength(str){
    let count = 0;
    for(let i = 0; i < str.length; i++){
        if(str.charCodeAt(i) > 255){
            count += 2;
        }else{
            count ++;
        }
    }
    return count;
}
getStrLength(str);

//第二种：简写：
function getStrLength(target){
    var count = str.length;
    for(var i = 0; i < str.length; i++){
        if(str.charCodeAt(i) > 255){
            count++;
        }
    }
    return count;
}
getStrLength(str);

14、获取一个指定长度的随机数组成的数组

function getRandomNumbers(length){
      var arr = [];
      for(var i = 1; i <= length; i ++){
          arr.push(Math.random());
      }
      return arr;
 }

15、混合对象

const obj = {  //ES6方法
            name:"a",
            age:18,
            sex:"男"
        }
        const obj1 = {
            name:"b",
            address:"中国"
        }
        const obj2 = {
            ...obj,
            ...obj1
        }
        console.log(obj2); 

console.log(Object.assign(obj,obj1)); //ES7的方法 但是它会改变原数组obj
console.log(Object.assign({},obj,obj1));//前面传一个空对象，就不会改变obj

数组去重：1、将数组中的每一位当做对象的属性名

16、Object.assign(obj1,obj2) //混合两个对象

Object.assign({},obj1,obj2) //在前面加上一个对象，就不会改变原数组

17、找出元素 item 在给定数组 arr 中的位置

输出描述:

如果数组中存在 item，则返回元素在数组中的位置，否则返回 -1

function indexOf(arr,item){
    if(Array.prototype.indexOf){
        return arr.indexOf(item);
    }else{
        for(let i = 0; i < arr.length; i++){
            if(arr[i] === item){
                return i;
            }
        }
    }
    return -1;
}

18、利用解构的方法将两个数组的值进行交换

var arr = [1,2,3,3,5];
var arr1 = ["a","b","c","d"];
[arr,arr1] = [arr1,arr];
console.log(arr,arr1);

19、两种实现流式布局的方法

1、流式布局就是float

用align-content模拟流式布局 利用弹性盒子代替浮动产生流式布局

最理想的就是用弹性盒子写流式布局

2、利用float浮动，但是会产生浮动流，对后面元素产生影响

20、圣杯布局

圣杯布局：属于特殊的三栏布局，有header部分、footer部分、left部分、right部分，它们都有固定占有的百分比的，中间自适应

<div class="wrap">
        <div class="header"></div>
        <div class="contain">
            <div class="left"></div>
            <div class="content"></div>
            <div class="right"></div>
        </div>
        <div class="footer"></div>
    </div>

<style>
        .wrap{
            width:300px;
            height:300px;
            border:1px solid green;
            display:flex;
            flex-direction:column;
            resize:both;
            overflow:hidden;
        }
        .header, .footer{
            flex:0 0 20%;
            border:1px solid green;
        }
        .contain{
            flex:1 1 auto;
            display:flex;
        }
        .left, .right{
            flex:0 0 20%;
            border:1px solid green;
        }
        .content{
            flex:1 1 auto;
        }
    </style>

21、字符串取反

var str = 'abc123';
console.log(str.split("").reverse().join(''));	

22、判断是否为质数

function isPrime(n){
     if(n < 2){
         return false;
     }
     //判断从2到它本身减1之间有没有可以整除自身的，有的话就为false，没有则为true
     for(var i = 2; i < n - 1; i ++){
         if(n % i == 0 ){
             return false;
         }
     }
     return true;
 }

23、得到一个区间的随机整数

function getRandom(min,max){
    return Math.floor(Math.random() *(max - min + 1) + min);
}
getRandom(1,40);
-------------------------------
var arr = [1,2,3,4,5,6,7,8];
console.log(getRandom(0,arr.length));  //从数组中随机取一个

24、获取指定长度的随机数组成的数组

function getRandomNumbers(length){
   const arr = [];
   for(var i = 0; i < length; i++){
       arr.push(Math.random());
   }
   return arr;
}

25、提示用户输入数组的长度，以及数组每一项的值，然后输出该数组；

var len = +prompt("请输入数组的长度");
if(isNaN(len) || len < 0){
    console.log("输入错误");
}else{

    var arr = new Array(len);
    for(var i = 0; i<len; i++){
        arr[i] = prompt("请输入第"+(i + 1)+"项的值");
    }
    console.log(arr);
}

26、判断输入的年份是否是闰年

// 闰年：4年一闰，百年不闰，400年一闰
function isLeap(year){
	return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
}

谢谢您的访问！

更新中…