每日JS练习

Star� ??

已于 2024-04-23 21:28:48 修改

阅读量153

点赞数 3

文章标签： javascript 前端 vue.js

于 2024-03-23 16:33:53 首次发布

本文链接：https://blog.csdn.net/weixin_45887481/article/details/136969899

版权

2024.3.23

求两个数的最大公约数（48，36）

function gcd(a, b) {
            if (b == 0) {
                return a
            }
            return gcd(b, a % b)
            // 10 
        }
       const result=gcd(36,48)
       console.log(result);
  // 结果：12

时间格式化

time()
        function time(){
            var data = new Date()
            console.log(data);
            var year=data.getFullYear()
            var month=(data.getMonth()+1).toString().padStart(2,0)
            var day=data.getDate().toString().padStart(2,0)
            var week =(data.getDay()+1).toString().padStart(2,0)
            var h=data.getHours().toString().padStart(2,0)
            var m=data.getMinutes().toString().padStart(2,0)
            var s=data.getSeconds().toString().padStart(2,0)
            // if (condition) {
                
            // }
            console.log(year+"年"+month+"月"+day+"日"+week+"周"+h+"时"+m+"分"+s+"秒");
            console.log(`${year}-${month}-${day}-${week} ${h}:${m}:${s}`);
        }
    // 结果
   // 2024年03月23日07周16时32分00秒
   // 3.23-2.html:25 2024-03-23-07 16:32:00

2024.3.24

求组和偶数

// forEach
        evenNumber()
        function evenNumber() {
            var arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
            var arrs = []
            arr.forEach((item, index) => {
                if (item % 2 == 0) {
                    return arrs.push(item)
                }
            })
            const result = arrs.length
            console.log(result);  // 输出结果 6
        }

        // for
        function evenNumbers(n) {
            var count=0
            for (let i = 0; i <=10; i++) {
                if (i%2==0) {
                    count++
                }
            }
            return count
        }
        const result = evenNumbers(10)
        console.log(result);  // 输出结果 6

实现Json对象的深拷贝

 function deepCopy(obj) {
            var original = {}
            for (var key in obj) {
                if (typeof obj[key] === "object" && obj[key] !== null) {
                    original[key] = deepCopy(obj[key])
                  //  console.log(obj[key], original[key], "11111");
                } else {
                    original[key] = obj[key]
                  //  console.log(obj[key], original[key], "2222");
                }
            }
            return original
        }
        var originalObj = {
            name: 'Alice',
            age: 30,
            address: {
                city: 'New York',
                country: 'USA'
            }
        }
        const result = deepCopy(originalObj)
        console.log(result);
      // 结果：
      // address: {city: 'New York', country: 'USA'}
      //age: 30
      //name: "Alice"

2024.3.25

实现数组扁平化

指将一个多维数组（嵌套数组）转换为一个一维数组

function Flattened(n) {
            var arrs = []
            n.forEach((item, index) => {

                if (Array.isArray(item)) {
                    arrs = arrs.concat(Flattened(item))
                } else {
                    arrs.push(item)
                }
            });
            return arrs
        }
        const arr = [12, 34, [12, 12, [34, 12]], 13, 45, [67]]
        const result = Flattened(arr)
        console.log(result);
        // 结果： [12, 34, 12, 12, 34, 12, 13, 45, 67]

判断给定数组是否符合斐波那契数列的特征

特征：

斐波那契数列是以递归的方式定义的，其前两项为0和1，之后的每一项都是前两项之和。因此，数列的定义可以表示为F(0) = 0, F(1) = 1，对于 n > 1，有 F(n) = F(n-1) + F(n-2)。
增长特性：斐波那契数列的增长非常迅速。随着 n 的增加，数列的增长速度呈现出指数级增长，即数列中的每一项都是前一项的和，因此增长非常迅速。
黄金比例：斐波那契数列展现了黄金比例的特性。当你将相邻两个数相除，随着 n 的增加，这个比值会趋向于黄金比例 φ（约为 1.618033988749895），其中 φ = (1 + √5) / 2。
递归性质：斐波那契数列具有递归性质，因为每一项都依赖于前两项的值。这种递归性质使得斐波那契数列在编程中常常用来演示递归算法的思想。

function Fibonacci(arr) {
            if (arr.length > 2 && arr[0] == 0 && arr[1] == 1) {
                for (let i = 2; i < arr.length; i++) {
                    if (arr[i] == arr[i - 1] + arr[i - 2]) {
                        return true
                    }

                }
            } else {
                return false
            }
        }
        const arr = [12, 34, 12, 12, 34, 12, 13, 45, 67]  // false
        // const arr = [0, 1, 1, 2, 3, 5, 8]    // true
        const result = Fibonacci(arr)
        console.log(result);

2024.3.26

找出字符串中第二大的数字

 function number(num) {
            var arr = []
            for (let i = 0; i < num.length; i++) {
                if (!isNaN(Number(num[i]))) {
                    arr.push(num[i])
                }
            }
            // 从大到小排序
            arr.sort((a, b) => {
                return b - a
            })
            return arr[1]
        }
        const result = number("12bjjhkg7kwh8hkj12")
        console.log(result);
        // 结果： 7

组合数数组

一个数组中包含了各种可能的组合–数列

 function getCombination(arr) {
    const result = [];
    function helper(current, index) {
        console.log(current, index, 1111);  // [],0     [1],1     [1,2],2  [1,2,3],3
        if (current.length > 0) {
            result.push(current);
            console.log(current, 22222222222);    // [1],[1]    [1,2]    [1,2,3]
        }
        for (let i = index; i < arr.length; i++) {
            console.log(current.concat(arr[i]), i + 1, 3333333); // [1],1   [1,2],2 [1,2,3],3
            helper(current.concat(arr[i]), i + 1);
        }
     }
     helper([], 0);
     return result;
    }
     const result = getCombination([1, 2, 3])
    console.log(result);
        /*  结果：[
        		   0: [1]
                   1: [1, 2]
                   2: [1, 2, 3]
                   3: [1, 3]
                   4: [2]
                   5: [2, 3]
                   6: [3] 
                 ]
       */

每步打印结果：

2024.3.27

棋盘放米

棋盘放米问题是一个经典的递归问题，通常被用来演示递归算法的原理。在这个问题中，我们有一个大小为 m x n 的棋盘，我们需要计算有多少种不同的方式可以在棋盘上放置米粒，规则是每个格子最多只能放一粒米粒。

function countWaysToPlaceRice(m, n) {
    // 创建一个二维数组表示棋盘，初始值为 0
    const board = Array.from({ length: m }, () => Array(n).fill(0));
    // 递归函数，用于计算放置米粒的方式
    function placeRice(row, col) {
        // 如果超出了棋盘范围，则返回 0
        if (row >= m || col >= n) {
            return 0;
        }
        
        // 如果到达了棋盘右下角，则表示找到了一种放置米粒的方式
        if (row === m - 1 && col === n - 1) {
            return 1;
        }
        // 如果当前格子已经放了米粒，则直接返回下一个格子的放置方式
        if (board[row][col] !== 0) {
            return board[row][col];
        }
        // 否则，计算当前格子放置米粒的方式数
        const waysToRight = placeRice(row, col + 1);
        const waysToDown = placeRice(row + 1, col);
        // 将当前格子的放置方式数保存起来
        board[row][col] = waysToRight + waysToDown;
        return board[row][col];
    }
    // 调用递归函数并返回结果
    return placeRice(0, 0);
}

// 示例用法
const m = 3; // 棋盘的行数
const n = 3; // 棋盘的列数
const ways = countWaysToPlaceRice(m, n);
console.log("在一个 " + m + " x " + n + " 的棋盘上放置米粒的方式数为: " + ways);

2024.4.8

找出字符串的最长公共前缀

指一组字符串中所有字符串共同拥有的最长的前缀部分

 function strings(string) {
            if (string.length == 0) {
                return ""
            }
            string.sort()   // sort：将字符串按照字母顺序排序
           // console.log(string, 111);
            let firstStr = string[0]
            let lastStr = string[string.length - 1]
           // console.log(firstStr, lastStr);
            let newString = ""
            for (let i = 0; i < firstStr.length; i++) {
                if (firstStr[i] === lastStr[i]) {
                    newString += firstStr[i]
                } else {
                    break
                }
            }
            return newString
        }
        let string = ["logs", "lo12", "l123", "l12"]
        const result = strings(string)
        console.log(result); // 结果：l

2024.4.9

跳跃游戏

 function jumpingGame(arr) {
            let jumpMax = 0
            for (let i = 0; i < arr.length; i++) {
               // console.log(i, jumpMax);
                if (i > jumpMax) {
                    return false
                }
                jumpMax = Math.max(jumpMax, arr[i] + i)
                // console.log(jumpMax);
                if (jumpMax >= arr.length - 1) {
                    return true
                }
            }
            return false
        }
        const arr = [3, 2, 1, 0, 4]
        const result = jumpingGame(arr)
        console.log(result);  // false

在这里插入图片描述

2024.4.11

冒泡排序

1.从列表的第一个元素开始，依次比较相邻的两个元素；2.如果第一个元素比第二个元素大（对于升序排序），则交换这两个元素的位置；3.继续向后遍历列表，重复上述比较和交换步骤，直到达到列表的倒数第二个元素；4.重复以上步骤，每次遍历都会将当前未排序部分的最大元素“冒泡”到未排序部分的末尾；5.重复步骤1-4，直到整个列表排序完成。

 function BubbleSort(arr) {
            if (arr.length == 0) {
                return false
            }
            for (let i = 0; i < arr.length; i++) {
                for (let j = 0; j < arr.length - 1; j++) {
                    if (arr[j] > arr[j + 1]) {
                        var temp = arr[j]
                        arr[j] = arr[j + 1]
                        arr[j + 1] = temp
                    }
                }
            }
            return arr
        }

        const result = BubbleSort([12, 2, 43, 34, 67, 15])
        console.log(result);  // [2, 12, 15, 34, 43, 67]

2024.4.12

选择排序

从未排序的数据中选择最小（或最大）的元素，然后将它与未排序部分的第一个元素交换位置。这样，就将该元素放置在了已排序部分的末尾。然后，再从剩余的未排序数据中选择最小（或最大）的元素，与未排序部分的第一个元素交换位置，以此类推，直到所有元素都被排序完毕。

 function SelectionSort(arr) {
            if (arr.length == 0) {
                return false
            }
            for (let i = 0; i < arr.length; i++) {
                // console.log(arr[i], 111111111111111);
                for (let j = i + 1; j < arr.length; j++) {
                    // console.log(arr[j], 22222222222222);
                    if (arr[j] < arr[i]) {
                        var temp = arr[j]
                        arr[j] = arr[i]
                        arr[i] = temp
                        console.log(arr[i], arr[j]);
                    }
                }
            }
            return arr
        }
        const result = SelectionSort([12, 23, 14, 63, 30])
        console.log(result);  // [12, 14, 23, 30, 63]

2024.4.23

插入排序

插入排序是一种简单直观的排序算法，它的工作方式类似于我们打扑克牌时的方式。具体步骤如下：1.将数组分为已排序部分和未排序部分：初始时，将数组视为两部分，左侧是已排序的部分，右侧是未排序的部分。2. 逐个将未排序部分的元素插入到已排序部分：从未排序部分选取一个元素，将它插入到已排序部分的适当位置，使得已排序部分仍然有序。3. 重复这个过程：不断地选择未排序部分的第一个元素，插入到已排序部分，直到未排序部分为空。这个算法的时间复杂度为O(n^2)，其中n是数组的长度。虽然它的性能不如一些更复杂的排序算法，但对于小型数据集或是部分有序的数据集，插入排序是一个简单而有效的选择。

 function SelectionSort(arr) {
            if (arr.length == 0) {
                return false
            }
            for (let i = 1; i < arr.length; i++) {
                var key = arr[i]
                var j = i - 1
                while (j >= 0 && arr[j] > key) {
                    arr[j + 1] = arr[j];
                    j = j - 1;
                }
                arr[j + 1] = key;

            }
            return arr
        }
        const result = SelectionSort([12, 23, 14, 63, 30])
        console.log(result);
        // 结果：[12, 14, 23, 30, 63]```