Javascript 试图在JS中找到一个数字的因子

我刚刚开始学习JS，并且理解了寻找因子的概念。然而，这段代码是我到目前为止所拥有的。我有一个str变量，它只输出第一个因子，即2。我试图将每个（int）作为一个因子列表添加到str中。下面的代码片段有什么错误

function calculate(num) {
    var str = "";
    var int = 2;
    if (num % int == 0) {
        str = str + int;
        int++;
    } else {
        int++;
    }
    alert(str);
}

calculate(232);

函数计算（num）{
var str=“0”；
对于（var i=1；i@Moob的答案是正确的。你必须使用循环。但是，你可以通过确定每个数字是偶数还是奇数来加快这个过程。奇数不需要像偶数那样对照每个数字进行检查。奇数可以对照其他数字进行检查。此外，我们也不需要检查给定数字的一半，因为上面什么都没有一半有效。不包括0，从1开始：


函数计算（num）{
var half=Math.floor（num/2），//确保一个整数
函数factorialize（num）{
var结果=“”；
如果（num==0）{
返回1；
}否则{
var myNum=[]；
对于（i=1；i，作为对@quodesmith's的更有效的补充，一旦你有了一个因子，你就会立即知道它的配对产物是什么：

function getFactors(num) {
  const isEven = num % 2 === 0;
  const max = Math.sqrt(num);
  const inc = isEven ? 1 : 2;
  let factors = [1, num];

  for (let curFactor = isEven ? 2 : 3; curFactor <= max; curFactor += inc) {
    if (num % curFactor !== 0) continue;
    factors.push(curFactor);
    let compliment = num / curFactor;
    if (compliment !== curFactor) factors.push(compliment);
  }

  return factors;
}

函数getFactors（num）{
常量isEven=num%2==0；
const max=Math.sqrt（num）；
const inc=isEven？1:2；
让因子=[1，num]；
对于（让curFactor=isEven？2:3；curFactor更新ES6版本：

正如@gengns在评论中所建议的，生成数组的更简单方法是使用spread运算符和keys方法：


const factors=number=>[…数组（number+1）.keys（）].filter（i=>number%i==0）；
console.log（factors（36））；//[1,2,3,4,6,9,12,18,36]
函数factorialize（num）{
如果（num==0）
返回1；
var-arr=[]；
对于（var i＝1；i＜p＞i），我寻找一个用于此的算法，这意味着我需要同时考虑正负数和因子。
函数getFactors（n）{
如果（n==0）{return“∞";} // 处理0
如果（n%1！==0）{return“输入必须是整数。”；}//处理非整数
//仅检查n绝对值的平方根
//以上所有因素将与以下因素配对
var absval_of_n=数学abs（n），
sqrt_of n=Math.sqrt（absval_of n），
数字到校验=[]；
对于（var i=1；i
函数计算（num）{
var str=“0”//初始化var str的占位符
对于（i=2；i，下面是一个时间复杂度
O（sqrt（N））
的实现：

功能（A）{
var输出=[]；
对于（var i=1；i，这里是一个复杂度为O（sqrt（N））的性能友好型版本。
输出是未使用排序的排序数组

var factors = (num) => {
let fac = [], i = 1, ind = 0;

while (i <= Math.floor(Math.sqrt(num))) {
  //inserting new elements in the middle using splice
  if (num%i === 0) {
    fac.splice(ind,0,i);
    if (i != num/i) {
      fac.splice(-ind,0,num/i);
    }
    ind++;
  }
  i++;
}

//swapping first and last elements
let temp = fac[fac.length - 1];
fac[fac.length - 1] = fac[0];
fac[0] = temp;

// nice sorted array of factors
return fac;
};
console.log(factors(100));

var因子=（num）=>{
设fac=[]，i=1，ind=0；
而（i这里有一个优化的解决方案，使用最佳实践、适当的代码样式/可读性，并以有序数组返回结果


函数getFactors（num）{
常量maxFactorNum=Math.floor（Math.sqrt（num））；
常数factorArr=[]；
let count=0；//找到的因子计数对于（设i=1；i这使我的编码率达到了85%（在上限上失败，超过10亿）

将输入减少一半对大的数字不起作用，因为一半仍然是一个非常大的循环。因此我使用了一个对象来跟踪数字及其一半值，这意味着我们可以将循环减少到四分之一，因为我们同时从两端工作。
N=24变为：（1&24）、（2&12）、（3&8）、（4&6）


函数参数（n）{
设arrPrime=[2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79]；
让除数=2，
除以=n，
arr=[]，
计数=0，out=“”；
while（除数num！=“，”）
//控制台日志（新闻）；
//arr.slice（indexOf（map（“，”），1）
返回arr；
}
放泄=基本系数（86240）；
console.log（注销）；
为了多次运行分解代码，您需要某种循环，对吗？您只是在测试一个值。使用
递归
查找因子。@AshishMishra递归给表带来了什么？通过比较for循环和
i*i我建议不要使用t这里的ErnIn运算符，只使用if语句。您可以考虑< <代码> < < /Cult>循环中的不同条件，以避免每次使用时调用<代码> Maul.Par（）/<代码>。可以使用<代码> const root = Max.QRT（Num）。；
在循环之前，使用
curFactor，我很确定这将为num=1的因子添加两次1，因为存在未选中的
let factors=[1，num]；
。虽然这段代码可以回答这个问题，但提供关于如何和/或为什么解决问题的附加上下文将提高答案的长期价值。问题是询问数字的因子，而不是因子化。如果1是因子，36不也应该是因子吗？那么，
数组（number+1）
？@JonathanRys trueNice，非常优雅，使用[…数组（number+1）.keys（）]而不是数组。从（数组（number+1），（u，i）=>i）如果不需要处理0本身是一个因子的特殊情况，可以移动“+1”“到初始化，而不是分配。这将从1开始搜索，而不是从0开始搜索，但仍保留36作为其本身的一个因子。
。从（数组（数字），（\u，i）=>i+1）
添加一些解释，以便更好地理解。”
function factorialize(num) { 
 if(num === 0)
   return 1; 
 var arr = []; 
 for(var i=1; i<= num; i++){
   arr.push(i);
 } 
 num = arr.reduce(function(preVal, curVal){
   return preVal * curVal;
 });

  return num;
}

factorialize(5);

function getFactors(n) {
  if (n === 0) {return "∞";} // Deal with 0
  if (n % 1 !== 0) {return "The input must be an integer.";} // Deal with non-integers

  // Check only up to the square root of the absolute value of n
  // All factors above that will pair with factors below that
  var absval_of_n = Math.abs(n),
      sqrt_of_n = Math.sqrt(absval_of_n),
      numbers_to_check = [];
  for (var i=1; i <= sqrt_of_n; i++) {
    numbers_to_check.push(i);
  }

  // Create an array of factor pairs
  var factors = [];
  for (var i=0; i <= numbers_to_check.length; i++) {
    if (absval_of_n % i === 0) {
      // Include both positive and negative factors
      if (n>0) {
        factors.push([i, absval_of_n/i]);
        factors.push([-i, -absval_of_n/i]);
      } else {
        factors.push([-i, absval_of_n/i]);
        factors.push([i, -absval_of_n/i]);
      }
    }
  }

  // Test for the console
  console.log("FACTORS OF "+n+":\n"+
              "There are "+factors.length+" factor pairs.");
  for (var i=0; i<factors.length; i++) {
    console.log(factors[i]);
  }

  return factors;
}

getFactors(-26);

function calculate(num){
    var str = "0"   // initializes a place holder for var str
      for(i=2;i<num;i++){     
        var num2 = num%i;
        if(num2 ==0){       
            str = str +i; // this line joins the factors to the var str
        }
    }
    str1 = str.substr(1) //This removes the initial --var str = "0" at line 2
    console.log(str1) 
}
calculate(232);

//Output 2482958116

function(A) {
  var output = [];

  for (var i=1; i <= Math.sqrt(A); i++) {
    if (A % i === 0) {
      output.push(i);

      if (i !== Math.sqrt(A)) output.push(A/i);
    }
  }

  if (output.indexOf(A) === -1) output.push(A);

  return output;
}

var factors = (num) => {
let fac = [], i = 1, ind = 0;

while (i <= Math.floor(Math.sqrt(num))) {
  //inserting new elements in the middle using splice
  if (num%i === 0) {
    fac.splice(ind,0,i);
    if (i != num/i) {
      fac.splice(-ind,0,num/i);
    }
    ind++;
  }
  i++;
}

//swapping first and last elements
let temp = fac[fac.length - 1];
fac[fac.length - 1] = fac[0];
fac[0] = temp;

// nice sorted array of factors
return fac;
};
console.log(factors(100));

function solution(N) {

    const factors = {};

     let num = 1;  
     let finished = false;
     while(!finished)
     {
         if(factors[num] !== undefined)
         {
             finished = true;
         }
         else if(Number.isInteger(N/num))
         {

          factors[num] = 0;
          factors[N/num]= 0;
         }
        num++
     }

    return Object.keys(factors).length;
}