Javascript 用小数除数

我怎样才能把数字（钱）平均地除以x 数字可以有一个或两个小数点，也可以没有小数点

例如

1000

或

100.2

或

112.34

我想把这个数平均地分成x部分，但是如果不是奇数，就把多余的数加到最后一个

比如说

3856 / 3
1285.33
1285.33
1285.34

函数除法（分子、除数）{
var结果=[]；
var股息=（数学下限（分子/除数*100）/100）.toFixed（2）；//小数点后2位的股息
对于（var i=0；i<除数-1；i++）{
results.push（股息）；//在结果中放入n-1份股息副本
}
results.push（分子-（除数-1）*被除数）；//将余数添加到结果中
返回结果；
}

听起来像是一个非常简单的循环/递归

试试看
函数myFunction（数字、除法）{
var货币=数字/除法；
money=Math.ceil（money*100）/100；
警惕（金钱）；/1285.34
}

---

回顾其他答案

在重新检查这里提供的解决方案之后，我注意到它们产生了一些奇怪的结果

@GeorgeMauler的

dividecurrency

似乎与原始问题中提供的输入一致。但是如果你稍微改变一下，就会产生一个非常奇怪的结果

// it appears to work
divideCurrencyEvenly(10,3)
=> [ '3.33', '3.33', '3.34' ]

// wups ...
divideCurrencyEvenly(10,6)
=> [ '1.67', '1.67', '1.67', '1.67', '3.32' ]

// hmm this one works ...
divideCurrencyEvenly(18,5)
=> [ '3.60', '3.60', '3.60', '3.60', '3.60' ]

// wups ...
divideCurrencyEvenly(100,7)
=> [ '14.29', '14.29', '14.29', '14.29', '14.29', '28.55' ]

---

虽然@Barmar的解决方案似乎表现得更好一点……好一点

像

3.599999999996

这样的数字大部分是可以原谅的，因为在JavaScript中

但是，关于

divide

我发现最令人不安的是它给出了一个混合类型数组（字符串和浮点）。由于输出中的数字没有四舍五入（精确到正确的精度），如果你在纸上加上结果，你就不会回到原来的

分子

输入——也就是说，除非你对结果进行四舍五入

---

我们仍在为平等而战……

对于上述两种解决方案，我最后的不满也是存在的。结果并不代表尽可能接近相等的分布

如果你以2的精度将100除以7，@Barmar的解决方案（修好了舍入问题）将给出

[ '14.28', '14.28', '14.28', '14.28', '14.28', '14.28', 14.32 ]

如果这些人是人，而数字代表金钱，1人不应再支付4便士。相反，4个人应该多付1便士

[ 14.29, 14.29, 14.29, 14.29, 14.28, 14.28, 14.28 ]

这是尽可能接近相等的

---

回到原点

我对解决方案不满意，所以我自己做了一个，

distribute

它有3个参数：精度

p

、除数

d

、分子

n

• 它返回一个同质数组-总是一个数字数组
• 如果你把它们加起来，你会得到一个和你原来的分子完全相等的值

它缩放分子并查找最大整数

q

，其中

q*d
数组（n）.填充（x）
const concat=（xs，ys）=>
xs.concat（ys）
常数quotrem=（n，d）=>
[数学楼层（n/d）
，数学楼层（n%d）
]
常数分布=（p，d，n）=>
{const e=
数学战俘（10，p）
常数[q，r]=
quotrem（n*e，d）
返回海螺
（填充（r，（q+1）/e）
，填充（d-r，q/e）
)
}
控制台日志
（分配（2、3、10）
// [ 3.34, 3.33, 3.33 ]
，分发（2,6,10）
// [ 1.67, 1.67, 1.67, 1.67, 1.66, 1.66 ]
，分发（2,5,18）
// [ 3.6, 3.6, 3.6, 3.6, 3.6 ]
，分发（2,7100）
// [ 14.29, 14.29, 14.29, 14.29, 14.28, 14.28, 14.28 ]
)

因为我们谈论的是钱，通常只要总数加起来正确，几美分的差别并不重要。因此，如果你不介意一次付款可能比其他付款多出几美分，这里有一个非常简单的分期付款解决方案

函数计算安装（总计、分期）{
//计算分期付款
var pennies=总计*100；
剩余风险值=分期付款的便士百分比；
var其他付款=（便士-剩余）/分期付款；
var firstPayment=其他付款+余额；
对于（变量i=0；i<分期付款；i++）{
如果（i==0）{
console.log（“first payment=”，firstPayment/100）；
}否则{
console.log（“next payment=”，otherPayments/100）；
}
}
}

在@user633183的

分发上有一个问题，但只有当除法器小于3时才会发生

distribute(2, 2, 560.3)
// [ '280.15' , '280.14']

distribute(2, 1, 74.10)
// [ '74.09' ]

distribute(2, 1, 74.60)
// [ '74.59' ]

我将答案改写成javascript

常数分布=（精度、除法器、分子）=>{
常数arr=[]；
而（除法器>0）{
设数量=数学四舍五入（（分子/除法器）*数学功率（10，精度））/数学功率（10，精度）；
arr.push（金额）；
分子-=数量；
分隔器--；
}
返回arr.sort（（a，b）=>b-a）；
};

以下是结果

请检查下面的代码

function Dividently(Amount, Quantity) {
        var m = Amount* 100,
            n = m % Quantity,
            v = Math.floor(m / Quantity) / 100,
            w = Math.floor(m / Quantity+ 1) / 100;

        for (var i = 0, out = new Array(Quantity); i < Quantity; ++i) {
            out[i] = i < n ? w : v;
        }
        return out;
    }    

 var arr = Dividently(3856, 3);    

功能划分（金额、数量）{
var m=金额*100，
n=m%数量，
v=数学地板（m/数量）/100，
w=数学楼层（m/数量+1）/100；
对于（变量i=0，out=新数组（数量）；i

Math.floor（）-如果有人在寻找随机分布的vanilla JS解决方案，请将数字向下舍入到最接近的整数
，这里是我的：

function fairDivision(resolution, numerator, denominator) {
    // preserves numerator(n) integrity when dividing into denominator(d) bins
    // remainders are randomly distributed into sequential bins 
    // resolution is number of significant digits after decimal
    // (-'ve resolution for insignificant digits before decimal).
    const n = numerator * Math.pow(10, resolution);
    const remainder = n % denominator;
    const base = (n - remainder) / denominator;  
    const offset = Math.floor(Math.random()*denominator); // index of first 'round-up' bin

    let arr = []
    let low= (offset + remainder) % denominator;

    let a; let b; let c = (low < offset); //logical units
    for (let i=0; i < denominator; i++) {
        a = (i < low);
        b = (i >= offset);
        if ((a && b) || (a && c) || (b && c)) {
            arr.push(base +1)
        } else{
            arr.push(base)
        }
        arr[i] = arr[i] / Math.pow(10, resolution);
    }
    return arr;
}

函数fairDivision（分辨率、分子、分母）{
//在划分为分母（d）箱时保留分子（n）的完整性
//剩余部分随机分配到顺序存储箱中
//分辨率是小数点后的有效位数
//（-小数点前不重要数字的分辨率）。
常数n=分子*数学功率（1）
[ '14.28', '14.28', '14.28', '14.28', '14.28', '14.28', 14.32 ]

[ 14.29, 14.29, 14.29, 14.29, 14.28, 14.28, 14.28 ]

distribute(2, 2, 560.3)
// [ '280.15' , '280.14']

distribute(2, 1, 74.10)
// [ '74.09' ]

distribute(2, 1, 74.60)
// [ '74.59' ]

distribute(0, 7, 100)
=> [ 15, 15, 14, 14, 14, 14, 14 ]

distribute(1, 7, 100)
=> [ 14.3, 14.3, 14.3, 14.3, 14.3, 14.3, 14.2 ]

distribute(2, 7, 100)
=> [ 14.29, 14.29, 14.29, 14.29, 14.28, 14.28, 14.28 ]

distribute(3, 7, 100)
=> [ 14.286, 14.286, 14.286, 14.286, 14.286, 14.285, 14.285 ]

distribute(4, 7, 100)
=> [ 14.2858, 14.2857, 14.2857, 14.2857, 14.2857, 14.2857, 14.2857 ]

// and of course

distribute(2, 2, 560.3)
=> [ 280.15, 280.15 ]

distribute(2, 1, 74.10)
=> [ 74.1 ]

distribute(2, 1, 74.60)
=> [ 74.6 ]

function Dividently(Amount, Quantity) {
        var m = Amount* 100,
            n = m % Quantity,
            v = Math.floor(m / Quantity) / 100,
            w = Math.floor(m / Quantity+ 1) / 100;

        for (var i = 0, out = new Array(Quantity); i < Quantity; ++i) {
            out[i] = i < n ? w : v;
        }
        return out;
    }    

 var arr = Dividently(3856, 3);    

function fairDivision(resolution, numerator, denominator) {
    // preserves numerator(n) integrity when dividing into denominator(d) bins
    // remainders are randomly distributed into sequential bins 
    // resolution is number of significant digits after decimal
    // (-'ve resolution for insignificant digits before decimal).
    const n = numerator * Math.pow(10, resolution);
    const remainder = n % denominator;
    const base = (n - remainder) / denominator;  
    const offset = Math.floor(Math.random()*denominator); // index of first 'round-up' bin

    let arr = []
    let low= (offset + remainder) % denominator;

    let a; let b; let c = (low < offset); //logical units
    for (let i=0; i < denominator; i++) {
        a = (i < low);
        b = (i >= offset);
        if ((a && b) || (a && c) || (b && c)) {
            arr.push(base +1)
        } else{
            arr.push(base)
        }
        arr[i] = arr[i] / Math.pow(10, resolution);
    }
    return arr;
}

//n=how many groups, lot = total units
function makeTeams2(n,lot){
  var div = lot/n;
  var portion = Math.floor(div);
  var remains = Math.round(n*((div) % 1));
  var arr = [];
  for(var i=0; i<n; i++) arr.push(portion);
  for(var i=0; i<remains; i++) arr[i] = arr[i] + 1;
  return arr;
}

// >> makeTeams2(7,100);
// >> [15,15,14,14,14,14,14]