Javascript 获取一个数与另一个数相乘的次数，直到达到某个限制

我可以得到一个数与另一个数相乘的次数，直到达到某个极限：

var velocity = -5.706875;
var friction = 0.9925;
var limit = 0
var times = 0;

while (Math.floor(Math.abs(velocity)*10) > limit) {
    velocity *= friction;
    times += 1;
}
// times = 538

有没有一种方法可以不通过循环获得时间？ 尝试了

Math.log（5.706875，0.9925）

，但它给出了另一个结果。

当然，您可以：

times = Math.ceil(Math.log(-0.1/velocity)/Math.log(friction));

编辑：

实际上，考虑到

限额

var，它将是：

times = Math.ceil(Math.log(-(0.1+limit/10)/velocity)/Math.log(friction));

当然可以，给你：

times = Math.ceil(Math.log(-0.1/velocity)/Math.log(friction));

编辑：

实际上，考虑到

限额

var，它将是：

times = Math.ceil(Math.log(-(0.1+limit/10)/velocity)/Math.log(friction));

当然可以，给你：

times = Math.ceil(Math.log(-0.1/velocity)/Math.log(friction));

编辑：

实际上，考虑到

限额

var，它将是：

times = Math.ceil(Math.log(-(0.1+limit/10)/velocity)/Math.log(friction));

当然可以，给你：

times = Math.ceil(Math.log(-0.1/velocity)/Math.log(friction));

编辑：

实际上，考虑到

限额

var，它将是：

times = Math.ceil(Math.log(-(0.1+limit/10)/velocity)/Math.log(friction));

---

@液化石油气提供了正确的答案。要澄清一点：

首先，

Math.floor（Math.abs（velocity）*10）>0

是表示

Math.abs（velocity）>0.1

的一种迂回方式，因为您希望进程在

v*10

小于1（或者换句话说，

v

小于0.1）时立即停止

所以我们可以从这个开始。您的迭代过程不断地将速度确定为

v=vi*f^n

，其中

n

是迭代次数，因此我们有：

abs(v * f ^ n) > abs(0.1)

我们要求出使两边相等的

n

值，使之成为阈值

在这种情况下，我们知道

f^n

是正的，因为

f

是正的，我们知道

v

是负的，所以

abs（v*f^n）

等于

-v*f^n

一步一步，我们可以做到：

- v * f ^ n = 0.1              // start

- f ^ n = 0.1 / v              // divide both sides by v

f ^ n = - 0.1 / v               // negate both sides          

log(f ^ n) = log(-0.1 / v)      // log both sides

n * log(f) = log(-0.1 / v)      // take the exponent out of the log

n = log(-0.1 / v) / log(f)      // divide both sides by log(f)

在这一点上，这只是一个简单的计算，根据需要进行四舍五入以计算最后一次迭代：

var n = Math.ceil(Math.log(-0.1/velocity)/Math.log(friction));

---

@液化石油气提供了正确的答案。要澄清一点：

首先，

Math.floor（Math.abs（velocity）*10）>0

是表示

Math.abs（velocity）>0.1

的一种迂回方式，因为您希望进程在

v*10

小于1（或者换句话说，

v

小于0.1）时立即停止

所以我们可以从这个开始。您的迭代过程不断地将速度确定为

v=vi*f^n

，其中

n

是迭代次数，因此我们有：

abs(v * f ^ n) > abs(0.1)

我们要求出使两边相等的

n

值，使之成为阈值

在这种情况下，我们知道

f^n

是正的，因为

f

是正的，我们知道

v

是负的，所以

abs（v*f^n）

等于

-v*f^n

一步一步，我们可以做到：

- v * f ^ n = 0.1              // start

- f ^ n = 0.1 / v              // divide both sides by v

f ^ n = - 0.1 / v               // negate both sides          

log(f ^ n) = log(-0.1 / v)      // log both sides

n * log(f) = log(-0.1 / v)      // take the exponent out of the log

n = log(-0.1 / v) / log(f)      // divide both sides by log(f)

在这一点上，这只是一个简单的计算，根据需要进行四舍五入以计算最后一次迭代：

var n = Math.ceil(Math.log(-0.1/velocity)/Math.log(friction));

---

@液化石油气提供了正确的答案。要澄清一点：

首先，

Math.floor（Math.abs（velocity）*10）>0

是表示

Math.abs（velocity）>0.1

的一种迂回方式，因为您希望进程在

v*10

小于1（或者换句话说，

v

小于0.1）时立即停止

所以我们可以从这个开始。您的迭代过程不断地将速度确定为

v=vi*f^n

，其中

n

是迭代次数，因此我们有：

abs(v * f ^ n) > abs(0.1)

我们要求出使两边相等的

n

值，使之成为阈值

在这种情况下，我们知道

f^n

是正的，因为

f

是正的，我们知道

v

是负的，所以

abs（v*f^n）

等于

-v*f^n

一步一步，我们可以做到：

- v * f ^ n = 0.1              // start

- f ^ n = 0.1 / v              // divide both sides by v

f ^ n = - 0.1 / v               // negate both sides          

log(f ^ n) = log(-0.1 / v)      // log both sides

n * log(f) = log(-0.1 / v)      // take the exponent out of the log

n = log(-0.1 / v) / log(f)      // divide both sides by log(f)

在这一点上，这只是一个简单的计算，根据需要进行四舍五入以计算最后一次迭代：

var n = Math.ceil(Math.log(-0.1/velocity)/Math.log(friction));

---

@液化石油气提供了正确的答案。要澄清一点：

首先，

Math.floor（Math.abs（velocity）*10）>0

是表示

Math.abs（velocity）>0.1

的一种迂回方式，因为您希望进程在

v*10

小于1（或者换句话说，

v

小于0.1）时立即停止

所以我们可以从这个开始。您的迭代过程不断地将速度确定为

v=vi*f^n

，其中

n

是迭代次数，因此我们有：

abs(v * f ^ n) > abs(0.1)

我们要求出使两边相等的

n

值，使之成为阈值

在这种情况下，我们知道

f^n

是正的，因为

f

是正的，我们知道

v

是负的，所以

abs（v*f^n）

等于

-v*f^n

一步一步，我们可以做到：

- v * f ^ n = 0.1              // start

- f ^ n = 0.1 / v              // divide both sides by v

f ^ n = - 0.1 / v               // negate both sides          

log(f ^ n) = log(-0.1 / v)      // log both sides

n * log(f) = log(-0.1 / v)      // take the exponent out of the log

n = log(-0.1 / v) / log(f)      // divide both sides by log(f)

在这一点上，这只是一个简单的计算，根据需要进行四舍五入以计算最后一次迭代：

var n = Math.ceil(Math.log(-0.1/velocity)/Math.log(friction));

---

我想总是可以做一些递归的事情：@timeJV循环中没有太多变化，但是谢谢。我想总是可以做一些递归的事情：@timeJV循环中没有太多变化，但是谢谢。我想总是可以做一些递归的事情：@timeJV循环中没有太多变化，但是谢谢。我想总是可以做一些递归的事情：@timeJV循环中没有太多变化一个循环，但谢谢。太好了！实际上是538。谢谢你，我太好了！实际上是538。谢谢你，我太好了！实际上是538。谢谢你，我太好了！实际上是538。感谢IpgThanks的澄清。我们将不得不对此进行进一步研究。感谢您的澄清。我们将不得不对此进行进一步研究。感谢您的澄清。我们将不得不对此进行进一步研究。感谢您的澄清。我们必须进一步研究这个问题。