英文文章來源于：https://github.com/Chalarangelo/30-seconds-of-code/blob/master/README.md

Math

數組求和 (arraySum)

返回數字數組的和.

用 Array.reduce() 加每一個value到累加器, 初始值為 0.

const arraySum = arr => arr.reduce((acc, val) => acc + val, 0); // arraySum([1,2,3,4]) -> 10

數組求平均值( arrayAverage)

返回一個數組的平均值.

用 Array.reduce() 加每一個value到累加器, 初始值為 0, 除以數組的 length .

const arrayAverage = arr => arr.reduce((acc, val) => acc + val, 0) / arr.length; // arrayAverage([1,2,3]) -> 2

clampNumber

Clamps num within the inclusive lower and upper bounds.

若 lower > upper, 交換它們.
若 num 在 [lower, upper] 范圍內, 返回 num.
否則, 返回離它最近的邊界數字.

const clampNumber = (num, lower, upper) => {if(lower > upper) upper = [lower, lower = upper][0];return (num>=lower && num<=upper) ? num : ((num < lower) ? lower : upper) } // clampNumber(2, 3, 5) -> 3 // clampNumber(1, -1, -5) -> -1 // clampNumber(3, 2, 4) -> 3

交換兩個數字（自定義）

實現兩個數字的交換

var a = 2, b = 3;b = [a, a = b][0]output: a->3 b->2ES6：[a, b] = [b, a]output: a->3 b->2

collatz

實現 collatz 算法.

如果 n 偶數, 返回 n/2. 否則, 返回 3n+1.

const collatz = n => (n % 2 == 0) ? (n / 2) : (3 * n + 1); // collatz(8) --> 4 // collatz(5) --> 16

digitize

將一個數字轉化為數字數組.

將數字轉化為字符串, 用spread 操作符([...string]) 將字符串轉變為字符串數組.
用 Array.map() 和 parseInt() 將字符串組的元素轉化為數字.

const digitize = n => [...''+n].map(i => parseInt(i)); // digitize(2334) -> [2, 3, 3, 4]

距離(distance)

返回兩點間的距離.

用 Math.hypot() 計算兩點間的幾何距離.

const distance = (x0, y0, x1, y1) => Math.hypot(x1 - x0, y1 - y0); // distance(1,1, 2,3) -> 2.23606797749979

階乘(factorial)

返回一個屬的階乘.

使用遞歸.
如果 n <= 1, 返回 1.
否則, 返回乘以 n - 1 階乘.
如果 n 負數，拋出異常.

const factorial = n =>n < 0 ? (() => { throw new TypeError('Negative numbers are not allowed!') })(): n <= 1 ? 1 : n * factorial(n - 1); // factorial(6) -> 720

斐波那契數列(fibonacci)

生成一個由斐波那契數列數字組成的數組.

創建一個指定長度的空數組, 初始化前兩個元素的值為 (0 , 1).
用 Array.reduce() 向數組中添加數組元素, 從第三個元素開始，每個元素的值為前兩個元素的和.

const fibonacci = n =>Array.from({ length: n}).reduce((acc, val, i) => acc.concat(i > 1 ? acc[i - 1] + acc[i - 2] : i), []); // fibonacci(5) -> [0,1,1,2,3]

fibonacciCountUntilNum

返回[0 , num ]范圍內Fibonacci數目.

使用數學公式計算到 num 的Fibonacci數目.

const fibonacciCountUntilNum = num =>Math.ceil(Math.log(num * Math.sqrt(5) + 1/2) / Math.log((Math.sqrt(5)+1)/2)); // fibonacciCountUntilNum(10) -> 7

fibonacciUntilNum

返回一個到 num 的Fibonacci數組.

創建一個指定長度的數組, 初始化前兩個元素為 (0 , 1).
用 Array.reduce() 向數組中添加數組元素, 從第三個元素開始，每個元素的值為前兩個元素的和.
使用數學公式計算到 num 的Fibonacci數目，該數字即為數組的長度.

const fibonacciUntilNum = num => {let n = Math.ceil(Math.log(num * Math.sqrt(5) + 1/2) / Math.log((Math.sqrt(5)+1)/2));return Array.from({ length: n}).reduce((acc, val, i) => acc.concat(i > 1 ? acc[i - 1] + acc[i - 2] : i), []); } // fibonacciUntilNum(15) -> [0,1,1,2,3,5,8,13]

最大公約數 (gcd)

求兩個數間的最大公約數.

用遞歸.
當 y 等于 0 返回 x.
否則, 返回 gcd(y, x%y).

const gcd = (x, y) => !y ? x : gcd(y, x % y); // gcd (8, 36) -> 4

漢明距離 (hammingDistance)

注：它是使用在數據傳輸差錯控制編碼里面的，在信息論中用到較多。

計算兩個等長字符串的漢明距離。

用異或(XOR)運算符 (^) 去找出兩個數字對應位不同的數量, 用 toString(2) 將字符串轉為二進制.
計算并返回字符串中為1的數量, 用 match(/1/g) 去匹配.

const hammingDistance = (num1, num2) =>((num1 ^ num2).toString(2).match(/1/g) || '').length; // hammingDistance(2,3) -> 1

inRange

判斷一個數字是否在給定的范圍內.

用算術比較來判斷給定的數字是否在指定的方位內.
若第二個參數 end 未被指定，這個范圍將是 [0 , start] .

const inRange = (n, start, end=null) => {if(end && start > end) end = [start, start=end][0];return (end == null) ? (n>=0 && n<start) : (n>=start && n<end); } // inRange(3, 2, 5) -> true // inRange(3, 4) -> true // inRange(2, 3, 5) -> false // inrange(3, 2) -> false

isArmstrongNumber （阿姆斯特朗數的判斷）

判斷一個給定的數字是否是 Armstrong 數字.

所謂Armstrong數，就是n位數的各位數的n次方之和等于該數，如：

153=1^3+5^3+3^3
1634=1^4+6^4+3^4+4^4

將給定的數字轉換為數字數組. 用 Math.pow() 為每個數字取合適的指數，然后求和. 如果總和等于數字本身返回 true，否則，返回 false.

const isArmstrongNumber = digits => ( arr => arr.reduce( ( a, d ) => a + Math.pow( parseInt( d ), arr.length ), 0 ) == digits ? true : false )( ( digits+'' ).split( '' ) ); // isArmstrongNumber(1634) -> true // isArmstrongNumber(371) -> true // isArmstrongNumber(56) -> false

isDivisible

判斷第一個數字參數能否被第二個數字參數整除.

用模操作符 (%) 判斷余數是否為 0.

const isDivisible = (dividend, divisor) => dividend % divisor === 0; // isDivisible(6,3) -> true

isEven

如果被給定的數字是偶數，返回 true ，否則， false.

用模操作符 (%) 判斷一個數字是奇數還是偶數.
是偶數返回 true，是奇數返回 false .

const isEven = num => num % 2 === 0; // isEven(3) -> false

isPrime

判斷給定的數字是否為素數.

判斷從 2 到被給定數的開平方的范圍內.
如果范圍內的任何數字整出被給定的數返回 false, 否則返回 true, 除非給定數字小于 2.

const isPrime = num => {const boundary = Math.floor(Math.sqrt(num));for (var i = 2; i * i <= boundary; i++) if (num % i == 0) return false;return num >= 2; }; // isPrime(11) -> true // isPrime(12) -> false

素數 (primes)

生成到 num 的素數, 用 Sieve of Eratosthenes 算法.

生成一個在 [2, num] 范圍內的素數數組. 用 Array.filter() 過濾出能被 [2, √num] 間任意整數整除的數字.

const primes = num => {let arr = Array.from({length:num-1}).map((x,i)=> i+2), sqroot = Math.floor(Math.sqrt(num)),numsTillSqroot = Array.from({length:sqroot-1}).map((x,i)=> i+2);numsTillSqroot.forEach(x => arr = arr.filter(y => ((y%x)!==0)||(y==x)));return arr; } // primes(10) -> [2,3,5,7]

最小公倍數(lcm)

返回兩個數的最小公倍數.

用最大公約數 (GCD) 運算式和 Math.abs() 來求最小公倍數.
最大公約數 (GCD) 使用遞歸.

const lcm = (x,y) => {const gcd = (x, y) => !y ? x : gcd(y, x % y);return Math.abs(x*y)/(gcd(x,y)); }; // lcm(12,7) -> 84

取中值(median)

返回數字數組中的中間位置數字.

用 Array.sort() 去排序數組，找出中間值.
如果數組的 length 為奇數，返回中間一位數, 否則返回中間兩個數的平局數.

const median = arr => {const mid = Math.floor(arr.length / 2), nums = [...arr].sort((a, b) => a - b);return arr.length % 2 !== 0 ? nums[mid] : (nums[mid - 1] + nums[mid]) / 2; }; // median([5,6,50,1,-5]) -> 5 // median([0,10,-2,7]) -> 3.5

回文字符串(palindrome)

Returns true if the given string is a palindrome, false otherwise.

將字符串轉為小寫 toLowerCase() 并且用 replace() 移除非字母字符.
用 split('') 將字符串分割為字符數組, 緊接著用 reverse() 反轉字符串，用 join('') 拼接字符數組為字符串，然后和原字符串比較.

const palindrome = str => {const s = str.toLowerCase().replace(/[\W_]/g,'');return s === s.split('').reverse().join(''); } // palindrome('taco cat') -> true

百分位(percentile)

公式為 p=100*i/n

用百分位數公式計算給定數組中有多少個數字小于或等于給定值.

用 Array.reduce() 去計算給定數組中有多少個數字小于等于給定的值.

const percentile = (arr, val) =>100 * arr.reduce((acc,v) => acc + (v < val ? 1 : 0) + (v === val ? 0.5 : 0), 0) / arr.length; // percentile([1,2,3,4,5,6,7,8,9,10], 6) -> 55

冪集 (powerset)

返回一個指定數組的冪集.

用 Array.reduce() 結合 Array.map() 迭代所有的元素然后生成一個包含所有元素集合的數組.

const powerset = arr =>arr.reduce((a, v) => a.concat(a.map(r => [v].concat(r))), [[]]); // powerset([1,2]) -> [[], [1], [2], [2,1]]

randomIntegerInRange

返回指定范圍的隨機整數.

用 Math.random() 生成一個隨機數，并將其映射到指定范圍內, 用 Math.floor() 將其轉化為一個整數.

const randomIntegerInRange = (min, max) => Math.floor(Math.random() * (max - min + 1)) + min; // randomIntegerInRange(0, 5) -> 2

randomNumberInRange

返回指定范圍內的隨機數.

用 Math.random() 生成一個隨機數, 使用乘法將其映射到所需的范圍內.

const randomNumberInRange = (min, max) => Math.random() * (max - min) + min; // randomNumberInRange(2,10) -> 6.0211363285087005

四舍五入(round)

數字四舍五入指定位數.

用 Math.round() 和模板字面量四舍五入一個數字指定位數.
如果省略第二個參數, decimals 默認為0.

const round = (n, decimals=0) => Number(`${Math.round(`${n}e${decimals}`)}e-${decimals}`); // round(1.005, 2) -> 1.01

標準差(standardDeviation)

返回一組數字的標準差.

用 Array.reduce() 計算平均值、方差和放長的總和，然后計算標準差.
你可以省略第二個參數來獲得樣本標準差或將其設為true來獲得總體標準差.

const standardDeviation = (arr, usePopulation = false) => {const mean = arr.reduce((acc, val) => acc + val, 0) / arr.length;return Math.sqrt(arr.reduce((acc, val) => acc.concat(Math.pow(val - mean, 2)), []).reduce((acc, val) => acc + val, 0) / (arr.length - (usePopulation ? 0 : 1))); }; // standardDeviation([10,2,38,23,38,23,21]) -> 13.284434142114991 (sample) // standardDeviation([10,2,38,23,38,23,21], true) -> 12.29899614287479 (population)

更多關于30-seconds-code中文翻譯
https://github.com/lvzhenbang/article/blob/master/js/30-seconds-code/index.md

與50位技術專家面對面20年技術見證，附贈技術全景圖

總結

以上是生活随笔為你收集整理的30-seconds-code——math的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。