使用函数显示区间内阿姆斯特朗数的 Swift 程序

本教程将讨论如何编写 Swift 程序，使用函数显示区间内的阿姆斯特朗数。

如果一个数的每个数字的 n 次幂之和等于该数本身，则这种类型的数称为阿姆斯特朗数。

例如，我们有一个数 407，这里 n = 3

407 = 43 + 03 + 73

407 = 64 + 0 +343

407 = 407

因此 407 是阿姆斯特朗数

例如，我们还有另一个数 2346，这里 n = 4

2346 = 24 + 34 + 44 + 64

2346 = 16 + 81 + 256 + 1296

2346 = 1649

因此 2346 不是阿姆斯特朗数。

以下是相同的演示 -

输入

假设我们的给定输入为 -

LowerLimit = 1
UpperLimit = 200

输出

所需的输出将是 -

Armstrong Numbers are 1, 153

算法

以下是算法 -

  • 步骤 1 - 创建一个函数

  • 步骤 2 - 从下限到上限运行一个 for 循环以迭代每个元素。

  • 步骤 3 - 声明另一个变量来存储总和。

  • 步骤 4 - 声明一个变量来存储给定数字中存在的数字总数。

  • 步骤 5 - 统计给定数字中存在的数字总数 -

while(armNum != 0){
   armNum = armNum/10
   count = count + 1
}

  • 步骤 6 - 计算给定数字的各个数字的幂之和

let rem = armNum % 10
sum = sum + (rem * rem * rem)
armNum = armNum/10

  • 步骤 7 - 将总和与数字本身进行比较。如果总和和数字相等，则该数字是阿姆斯特朗数。否则不是。

  • 步骤 8 - 声明两个变量来存储下限和上限。

  • 步骤 9 - 调用函数并将下限和上限作为参数传递。

  • 步骤 10 - 打印输出。

示例

以下程序演示了如何使用函数显示两个区间之间的阿姆斯特朗数。

import Foundation
import Glibc

// Function to find the Armstrong number
// in between the given intervals
func findArmstrongNumber(interval1: Int, interval2: Int){
   for q in interval1..<interval2{
      var sum = 0
      var armNum = q
      
      // Calculate the sum of 3rd power
      // of individual digit the given number
      while (armNum != 0){
         let rem = armNum % 10
         sum = sum + (rem * rem * rem)
         armNum = armNum/10
      }
      
      // If the sum is equal to the given number
      // Then the number is Armstrong number
      if (sum == q){
         print(q)
      }
   }
}
var lower = 1
var upper = 1000

print("Lower Limit:", lower)
print("Upper Limit:", upper)
print("Armstrong numbers are:")

// Calling function
findArmstrongNumber(interval1: lower, interval2: upper)

输出

Lower Limit: 1
Upper Limit: 1000
Armstrong numbers are:
1
153
370
371
407

在这里，在上面的代码中，我们有两个区间，下限为 1，上限为 600。现在我们创建一个函数来查找 3 位数的阿姆斯特朗数。在这个函数中，使用 for 循环，我们迭代给定范围内的每个数字，并找到该数字的各个数字的总和。计算完总和后，我们通过相互比较来检查总和是否等于给定数字。如果总和等于数字，则该数字为阿姆斯特朗数，并打印输出。因此，上面代码的工作原理是 -

findArmstrongNumber(interval1: 1, interval2: 1000):
1st iteration:
Sum = 0
armNum = 1
while (1 != 0){
   let rem = 1 % 10 = 1
   sum = 0 + (1 * 1 * 1) = 1
   armNum = armNum/10 = 1/10 = 0
}
Sum = 1
if (1 == 1) // Condition true{
   print(1)
}

2nd iteration:
Sum = 1
armNum = 2
while (2 != 0){
   let rem = 2 % 10 = 2
   sum = 0 + (2 * 2 * 2) = 8
   armNum = armNum/10 = 2/10 = 0
}
Sum = 8
if (8 == 2) // Condition False{
   print() // Print nothing
}
….. iterate till 999.

查找 n 位阿姆斯特朗数

示例

以下程序演示了如何使用函数显示两个区间之间的阿姆斯特朗数。

import Foundation
import Glibc

// Function to find armstring number
func FindArmstrong(lower: Int, upper: Int){

   for q in lower..<upper{
      var sum = 0
      var armNum = q
      var count = 0
      
      // Count the total number of digits
      // present in the given number
      while(armNum != 0){
         armNum = armNum/10
         count = count + 1
      }
      armNum = q
      
      // Calculate the sum of nth power
      // of individual digits of the given number
      while (armNum != 0){
         let rem = armNum % 10
         sum = sum + Int(pow(Double(rem), Double(count)))
         armNum = armNum/10
      }
      
      // If the sum is equal to the given number
      // Then the number is Armstrong number
      if (sum == q){
         print(q)
      }
   }
}
var interval1 = 1000
var interval2 = 10000

print("Lower Limit:", interval1)
print("Upper Limit:", interval2)
print("Armstrong numbers are:")
FindArmstrong(lower: interval1, upper: interval2)

输出

Lower Limit: 1000
Upper Limit: 10000
Armstrong numbers are:
1634
8208
9474

在这里，在上面的代码中，我们有两个区间，下限为 1000，上限为 10000。现在我们创建一个函数来查找 n 位阿姆斯特朗数。在这个函数中，使用 for 循环，我们迭代给定范围内的每个数字以检查是否为阿姆斯特朗数。因此，要查找阿姆斯特朗数，我们首先计算数字中存在的数字总数。之后，我们找到数字的各个数字的 n 次幂之和。现在，在计算完总和后，我们通过相互比较来检查总和是否等于给定数字。如果总和等于数字，则该数字为阿姆斯特朗数，并打印输出。因此，1000 到 10000 之间的阿姆斯特朗数为 1634、8208 和 9474。

更新于: 2022年10月20日

291 次查看

开启你的 职业生涯

通过完成课程获得认证

开始学习
广告
© . All rights reserved.