Alan's blog Alan's blog
首页
思考感悟
技术学习
关于
收藏
  • 分类
  • 标签
  • 归档
GitHub (opens new window)

Alan wu

前端小时
首页
思考感悟
技术学习
关于
收藏
  • 分类
  • 标签
  • 归档
GitHub (opens new window)
  • 前端常考代码

    • 模版字符串
    • 版本比较
    • 洗牌算法
    • 大数相加或相乘
      • 一、相加
      • 二、相乘
        • 方法一
        • 方法二
    • 防抖或节流
    • 并发请求
  • LeetCode Top 100

  • 算法
  • 前端常考代码
alanwu
2023-06-14
目录

大数相加或相乘

# 一、相加

function add(n, m) {
  // 操作数类型判断, 要求为字符串。不满足条件则抛出异常。
  if (typeof n !== 'string' || typeof m !== 'string') {
    throw new Error('数据类型错误, 大数相加操作数为字符串!');
  }

  // 数据反转, 方便后面的遍历求和
  n = n.split('').reverse();
  m = m.split('').reverse();

  // 获取较长的位数, 并作为后面对应位数遍历的最大值
  const maxLength = Math.max(n.length, m.length);

  // 计算过程中, 临时变量
  let tempN = 0; // 临时存储第1个操作数
  let tempM = 0; // 临时存储第2个操作数
  let tempAdd = 0; // 临时存储对应位上的数相加的和
  let extNum = 0; // 满10进1,保存进的值(1 或 0)

  // 计算结果
  const res = []; // 应位上的书相加的和

  // 遍历每一位上的数字,并求和。记录满十进一
  for (let index = 0; index < maxLength; index++) {
    // 缺位补0
    tempN = n[index] || 0;
    tempM = m[index] || 0;

    // 对应位上的数字求和
    tempAdd = Number(tempN) + Number(tempM);

    // 进一(extNum 为进 1)
    if (extNum) {
      tempAdd += extNum;
    }

    // 满十(存储需要进的 1)
    extNum = tempAdd >= 10 ? 1 : 0;

    // 最后一位满十进的一直接保存在当前求得的和中, 非最后一位则取 %10 后的值
    if (index === (maxLength - 1) && extNum) {
      res.push(tempAdd);
    } else {
      res.push(tempAdd % 10);
    }
  }

  // 返回计算后的数时注意翻转
  return res.reverse().join('');
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

# 二、相乘

# 方法一

// 方法一
var multiply = function(num1, num2) {
  if (num1 == "0" || num2 == "0") return "0";
  let l1 = num1.length,
    l2 = num2.length;
  let res = new Array(l1 + l2 - 1).fill(0);
  for (let i = 0; i < l2; i++) {
    for (let j = 0; j < l1; j++) {
      res[i + j] += +num2[i] * +num1[j];
    }
  }
  let len = res.length;
  let str = "",
    num = 0;
  while (len--) {
    num += res[len];
    str = (num % 10) + str;
    num = (num / 10) | 0;
  }
  return num > 0 ? num + str : str;
};

// 方法二
function fn(nums1, nums2){
  let res = new Array(nums1.length + nums2.length).fill(0);
  for(let i = 0; i < nums1.length; i++){
    for(let j = 0; j < nums2.length; j++){
      res[i+j+1] += nums1[i] * nums2[j];
    }
  }
  for(let k = res.length-1; k > 0; k--){
    if(res[k] >= 10){
      res[k-1] += Math.floor(res[k] / 10);
      res[k] = res[k] % 10;
    }
  }
  return res;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

# 方法二

function mut(num1, num2) {
  const numStr1 = num1.toString(),
  numStr2 = num2.toString();
  if (numStr1.indexOf(".") == -1 && numStr2.indexOf(".") == -1)
    return num1 * num2;
  const [a1, a2 = 1] = numStr1.split(".").map((item) => parseInt(item));
  const [b1, b2 = 1] = numStr2.split(".").map((item) => parseInt(item));
  let res1 = a1 * b1;
  let res2 = a2 * b2;
  let res = res1 + "." + res2;
  return parseFloat(res);
}
1
2
3
4
5
6
7
8
9
10
11
12
编辑 (opens new window)
上次更新: 2023/06/15, 08:09:17
洗牌算法
防抖或节流

← 洗牌算法 防抖或节流→

最近更新
01
HTTPS:让数据传输更安全
06-15
02
沙盒:页面和系统之间的隔离墙
06-15
03
CSRF攻击:陌生链接不要随便点
06-15
更多文章>
Theme by Vdoing | Copyright © 2019-2023 Alan Wu | MIT License
  • 跟随系统
  • 浅色模式
  • 深色模式
  • 阅读模式