A码的战争挑战

Question

我一直在这样的挑战挣扎，似乎无法找到我在哪里失败：

一些数字有滑稽性。例如：

89 --> 8¹ + 9² = 89 * 1 

695 --> 6² + 9³ + 5⁴= 1390 = 695 * 2 

46288 --> 4³ + 6⁴+ 2⁵ + 8⁶ + 8⁷ = 2360688 = 46288 * 51 

给定一个正整数n写成ABCD ...（A，B，C，d ...暂时位数），我们希望找到一个正整数k为正整数P，若它存在，例如n的数字的总和乘以p的连续幂等于k * n。换句话说：

是否存在整数k，例如：（a^p + b ^（p + 1）+ c ^（p + 2）+ d ^（p + 3）+ ...）= n * k 如果是这种情况，我们将返回k，否则返回-1。

注意：n，p将始终作为严格正整数给出。

digPow(89, 1) should return 1 since 8¹ + 9² = 89 = 89 * 1 
digPow(92, 1) should return -1 since there is no k such as 9¹ + 2² equals 92 * k 
digPow(695, 2) should return 2 since 6² + 9³ + 5⁴= 1390 = 695 * 2 
digPow(46288, 3) should return 51 since 4³ + 6⁴+ 2⁵ + 8⁶ + 8⁷ = 2360688 = 46288 * 51 

我是新来的JavaScript，所以可能有一些东西与我的代码，但我找不到它。我的整个目的是为了正确学习javascript，但现在我想知道我在做什么错了。我试着将给定的整数转换为数字，并用10取模，然后用trunc将其除以10以除去小数部分。我试图用它们各自的权力填充这些数字。但测试结果只是说我只返回在我的代码返回0 0.The唯一的事情是第一部分，但是当我试图注释掉它，我还是回到0

function digPow(n, p){ 
// ... 
var i; 
var sum; 
var myArray= new Array(); 
if(n<0) 
    { 
    return 0; 
    } 
var holder; 
holder=n; 
for(i=n.length-1;i>=0;i--) 
{ 
    if(holder<10) 
    { 
    myArray[i]=holder; 
    break; 
    } 
    myArray[i]=holder%10; 
    holder=math.trunc(holder/10); 
    myArray[i]=math.pow(myArray[i],p+i); 
    sum=myArray[i]+sum; 

} 
if(sum%n==0) 
    { 
    return sum/n; 
    } 
else 
{ 
    return -1; 
}} 

Answer 1

错误

您的代码有几个问题。这是你犯的一些错误。

1. number.length无效。在JS中获取数字长度的最简单方法是将其转换为字符串，如下所示：n.toString().length。 检查这个：Length of Number in JavaScript

2. 数学对象应该被引用为数学，而不是数学。 （注意是大写的M）所以math.pow和math.trunc应Math.pow和Math.trunc。

3. sum在for循环第一次在sum=myArray[i]+sum;中迭代时未定义。使用var sum = 0;而不是var sum;。

固定码

我固定的错误，并更新你的代码。有些部分已被删除 - 例如验证n（该问题表明其严格肯定） - 而其他部分已被重写。我做了一些文体修改，以使代码更具可读性。

function digPow(n, p){ 
 
var sum = 0; 
 
var myArray = []; 
 
var holder = n; 
 

 
for (var i = n.toString().length-1; i >= 0; i--) { 
 
    myArray[i] = holder % 10; 
 
    
 
    holder = Math.trunc(holder/10); 
 
    myArray[i] = Math.pow(myArray[i],p+i); 
 
    sum += myArray[i]; 
 
} 
 

 
    if(sum % n == 0) { 
 
    return sum/n; 
 
    } else { 
 
    return -1; 
 
    } 
 
} 
 

 
console.log(digPow(89, 1)); 
 
console.log(digPow(92, 1)); 
 
console.log(digPow(46288, 3));

我的代码

这是我做过什么回来时，我回答了这个问题。希望这可以帮助。

function digPow(n, p){ 
 
    var digPowSum = 0; 
 
    var temp = n; 
 
    
 
    while (temp > 0) { 
 
    digPowSum += Math.pow(temp % 10, temp.toString().length + p - 1); 
 
    temp = Math.floor(temp/10); 
 
    } 
 
    
 
    return (digPowSum % n === 0) ? digPowSum/n : -1; 
 
} 
 

 
console.log(digPow(89, 1)); 
 
console.log(digPow(92, 1)); 
 
console.log(digPow(46288, 3));

Answer 2

我创建一个完全符合你的要求的代码。在你的代码中的问题已经在评论中解释过了，所以我不会把重点放在这个问题上。

FIDDLE

这里是代码。

function digPow(n, p) { 
    var m = n; 
    var i, sum = 0; 
    var j = 0; 
    var l = n.toString().length; 
    var digits = []; 
    while (n >= 10) { 
    digits.unshift(n % 10); 
    n = Math.floor(n/10); 
    } 
    digits.unshift(n); 
    for (i = p; i < l + p; i++) { 
    sum += Math.pow(digits[j], i); 
    j++; 
    } 
    if (sum % m == 0) { 
    return sum/m; 
    } else 
    return -1; 
} 

alert(digPow(89, 1)) 

Answer 3

您有多个问题：

1. 如果n是一个数字它不会有一个length属性。所以i将是undefined，你的循环永远不会运行，因为undefined是你从来没有初始化sum为0，所以它是undefined，但不大于或等于零

   for(i=n.length-1;i>=0;i--) //could be 
   for(i=(""+n).length;i>=0;i--) //""+n quick way of converting to string 
   

2. 当你添加动力计算的结果综上所述，你会不断地得到NaN

   var sum; //should be 
   var sum=0; 
   

3. 你有if(holder<10)...break你不需要以此为循环将迭代之后到底哪里持有者是小于10。此外你永远做一个输出F或者将其添加到sum。简单地删除，如果一起。

您的最终代码会看起来像：

function digPow(n, p) { 
    var i; 
    var sum=0; 
    var myArray = new Array(); 
    if (n < 0) { 
    return 0; 
    } 
    var holder; 
    holder = n; 
    for (i = (""+n).length - 1; i >= 0; i--) { 
    myArray[i] = holder % 10; 
    holder = Math.trunc(holder/10); 
    myArray[i] = Math.pow(myArray[i], p + i); 
    sum = myArray[i] + sum; 
    } 
    if (sum % n == 0) { 
    return sum/n; 
    } else { 
    return -1; 
    } 
} 

注意你可以苗条下来的东西像

function digPow(n,p){ 
    if(isNaN(n) || (+n)<0 || n%1!=0) return -1; 
    var sum = (""+n).split("").reduce((s,num,index)=>Math.pow(num,p+index)+s,0); 
    return sum%n ? -1 : sum/n; 
} 

• (""+n)简单地转换为字符串
• .split("")分裂将字符串转换为数组（不需要nee d做10％的数学得到每个数字
• .reduce(function,0)通话的阵列的减少功能，这就要求数组中的每一项功能。该功能预计将每次返回一个值，第二个参数是初始值
• (s,num,index)=>Math.pow(num,p+index+1)+s发箭功能只调用Math.pow用正确的参数，然后将它添加到总和s并返回其

Answer 4

只是为了各种你可能在功能上做同样的工作，而无需使用任何字符串操作如下。

function digPow(n,p){ 
 
    var d = ~~Math.log10(n)+1; // number of digits 
 
     r = Array(d).fill() 
 
        .map(function(_,i){ 
 
         var t = Math.pow(10,d-i); 
 
         return Math.pow(~~((n%t)*10/t),p+i); 
 
         }) 
 
        .reduce((p,c) => p+c); 
 
    return r%n ? -1 : r/n; 
 
} 
 

 
var res = digPow(46288,3); 
 
console.log(res);