2020-06-30 15:47:42

5cf7954b · wizardforcel · 30d61d8e · 5cf7954b · 5cf7954b · 5cf7954b
28 changed file
--- a/docs/kotlin/11.md
+++ b/docs/kotlin/11.md
@@ -156,7 +156,7 @@ fun main(args: Array<String>) {

 ```

-该程序检查`数字`是正数，负数还是零。
+该程序检查`num`是正数，负数还是零。

 * * *


--- a/docs/kotlin/123.md
+++ b/docs/kotlin/123.md
@@ -33,11 +33,11 @@ fun main(args: Array<String>) {
 12345s15 is not a number
 ```

-在上面的程序中，我们有一个名为`字符串`的`String`，其中包含要检查的字符串。 我们还有一个布尔值`数字`，它存储最终结果是否为数字。
+在上面的程序中，我们有一个名为`字符串`的`String`，其中包含要检查的字符串。 我们还有一个布尔值`num`，它存储最终结果是否为数字。

 要检查`字符串`是否仅包含数字，在 try 块中，我们使用`Double`的`parseDouble()`方法将字符串转换为`Double`。

-如果抛出错误（即`NumberFormatException`错误），则表示`字符串`不是数字，并且`数字`设置为`false`。 否则，这是一个数字。
+如果抛出错误（即`NumberFormatException`错误），则表示`字符串`不是数字，并且`num`设置为`false`。 否则，这是一个数字。

 但是，如果要检查是否有一定数量的字符串，则需要将其更改为函数。 而且，逻辑基于抛出异常，这可能会非常昂贵。


--- a/docs/kotlin/20.md
+++ b/docs/kotlin/20.md
@@ -22,7 +22,7 @@

 函数`foo()`具有两个参数。 参数提供有默认值。 但是，通过在上述程序中传递两个参数来调用`foo()`。 因此，不使用默认参数。

-在`foo()`函数内，`字母`和`数字`的值分别为`'x'`和`2`。
+在`foo()`函数内，`字母`和`num`的值分别为`'x'`和`2`。

 **情况 II：未传递所有参数**

@@ -32,7 +32,7 @@

 在此，仅一个（第一个）参数传递给`foo()`函数。 因此，第一个参数使用传递给函数的值。 但是，第二个参数`num`将采用默认值，因为在函数调用期间未传递第二个参数。

-在`foo()`函数内，`字母`和`数字`的值分别为`'y'`和`15`。
+在`foo()`函数内，`字母`和`num`的值分别为`'y'`和`15`。

 **情况 III：不传递任何参数**

@@ -42,7 +42,7 @@

 在此，不传递任何参数就调用`foo()`函数。 因此，两个参数都使用其默认值。

-在`foo()`函数内，`字母`和`数字`的值分别为`'a'`和`15`。
+在`foo()`函数内，`字母`和`num`的值分别为`'a'`和`15`。

 * * *


--- a/docs/kotlin/46.md
+++ b/docs/kotlin/46.md
@@ -37,7 +37,7 @@ Remainder = 1

 同样，要找到余数，我们使用`%`运算符。 因此，`25/4`的其余部分，即`1`存储在`Int`变量`剩余部分`中。

-最后，使用`println()`函数在屏幕上打印`商`和`余数`。
+最后，使用`println()`函数在屏幕上打印`商`和`remainder`。

 * * *


--- a/docs/kotlin/5.md
+++ b/docs/kotlin/5.md
@@ -14,7 +14,8 @@

 以下是 Kotlin 中的算术运算符列表：

-<caption>Kotlin Arithmetic Operators</caption>
+Kotlin Arithmetic Operators
+
 | 操作员 | 含义 |
 | --- | --- |
 | + | 加法（也用于字符串连接） |

--- a/docs/kotlin/59.md
+++ b/docs/kotlin/59.md
@@ -22,14 +22,14 @@ fun main(args: Array<String>) {
        ++i
    }

-    println("G.C.D of $n1 and $n2 is $gcd")
+    println("GCD of $n1 and $n2 is $gcd")
 }
 ```

 运行该程序时，输出为：

 ```kt
-G.C.D of 81 and 153 is 9
+GCD of 81 and 153 is 9
 ```

 这里，将要找到其 GCD 的两个数字分别存储在`n1`和`n2`中。
@@ -58,14 +58,14 @@ fun main(args: Array<String>) {
            n2 -= n1
    }

-    println("G.C.D = $n1")
+    println("GCD = $n1")
 }
 ```

 When you run the program, the output will be:

 ```kt
-G.C.D = 9
+GCD = 9
 ```

 这是查找 GCD 的更好方法。 在此方法中，从较大的整数中减去较小的整数，然后将结果分配给保存较大整数的变量。 继续该过程，直到`n1`和`n2`相等为止。
@@ -92,12 +92,12 @@ fun main(args: Array<String>) {
            n2 -= n1
    }

-    println("G.C.D = $n1")
+    println("GCD = $n1")
 }
 ```

 When you run the program, the output will be:

 ```kt
-G.C.D = 9
+GCD = 9
 ```
\ No newline at end of file
--- a/docs/kotlin/60.md
+++ b/docs/kotlin/60.md
@@ -2,11 +2,11 @@

 > 原文： [https://www.programiz.com/kotlin-programming/examples/lcm](https://www.programiz.com/kotlin-programming/examples/lcm)

-#### 在此程序中，您将学习使用 GCD 而不是 GCD 查找两个数字的 lcm。 这是通过 Kotlin 中的 while 循环完成的。
+#### 在此程序中，您将学习使用 GCD 而不是 GCD 查找两个数字的 lcm。 这是通过 Kotlin 中的`while`循环完成的。

 两个整数的 LCM 是可以被两个数字完全除（没有余数）的最小正整数。

-## 示例 1：Kotlin 程序使用 while 循环和 if 语句计算 LCM
+## 示例 1：Kotlin 程序使用`while`循环和`if`语句计算 LCM

 ```kt
 fun main(args: Array<String>) {
@@ -38,13 +38,13 @@ The LCM of 72 and 120 is 360.

 然后，我们最初将`lcm`设置为两个数字中的最大值。 这是因为 LCM 不能小于最大数量。

-与 Java 类似，在无限 while 循环（`while(true)`）中，我们检查`lcm`是否完美地划分了`n1`和`n2`。
+与 Java 类似，在无限`while`循环（`while(true)`）中，我们检查`lcm`是否完美地划分了`n1`和`n2`。

-如果是这样，我们已经找到 LCM。 我们打印 LCM 并使用`break`语句退出 while 循环。
+如果是这样，我们已经找到 LCM。 我们打印 LCM 并使用`break`语句退出`while`循环。

 否则，我们将`lcm`加 1，然后重新测试除数条件。

-这是等效的 Java 代码：[查找两个数字](/java-programming/examples/lcm "How to find LCM of two numbers in Java?")的 LCM 的 Java 程序。
+这是等效的 Java 代码：[查找两个数字的 LCM 的 Java 程序](/java-programming/examples/lcm "How to find LCM of two numbers in Java?")。

 * * *

@@ -79,4 +79,4 @@ fun main(args: Array<String>) {

 该程序的输出与示例 1 相同。

-在这里，在 while 循环内，我们计算了两个数字的 GCD- `n1`和`n2`。 计算后，我们使用上面的公式来计算 LCM。
\ No newline at end of file
+在这里，在`while`循环内，我们计算了两个数字的 GCD - `n1`和`n2`。 计算后，我们使用上面的公式来计算 LCM。
\ No newline at end of file
--- a/docs/kotlin/61.md
+++ b/docs/kotlin/61.md
@@ -2,7 +2,7 @@

 > 原文： [https://www.programiz.com/kotlin-programming/examples/display-alphabets](https://www.programiz.com/kotlin-programming/examples/display-alphabets)

-#### 在此程序中，您将学习在 Kotlin 中使用 while 循环打印英文字母。 您还将学习学会仅打印大写和小写字母。
+#### 在此程序中，您将学习在 Kotlin 中使用`while`循环打印英文字母。 您还将学习学会仅打印大写和小写字母。

 ## 示例 1：显示大写的 A 到 Z

@@ -24,7 +24,7 @@ fun main(args: Array<String>) {
 A B C D E F G H I J K L M N O P Q R S T U V W X Y Z 
 ```

-与 Java 一样，您可以使用 for 循环从 A 到 Z 循环，因为它们以 ASCII 字符存储在 Kotlin 中。
+与 Java 一样，您可以使用`for`循环从 A 到 Z 循环，因为它们以 ASCII 字符存储在 Kotlin 中。

 因此，在内部，您可以在 65 到 90 之间循环打印英文字母。

@@ -54,4 +54,4 @@ When you run the program, the output will be:
 a b c d e f g h i j k l m n o p q r s t u v w x y z 
 ```

-您只需将“ A”替换为“ a”，将“ Z”替换为“ z”以显示小写字母。 在这种情况下，您会在内部循环通过 97 到 122。
\ No newline at end of file
+您只需将“`A`”替换为“`a`”，将“`Z`”替换为“`z`”以显示小写字母。 在这种情况下，您会在内部循环通过 97 到 122。
\ No newline at end of file
--- a/docs/kotlin/62.md
+++ b/docs/kotlin/62.md
@@ -2,7 +2,7 @@

 > 原文： [https://www.programiz.com/kotlin-programming/examples/digits-count](https://www.programiz.com/kotlin-programming/examples/digits-count)

-#### 在此程序中，您将学习在 Kotlin 中使用 while 循环来计算位数。
+#### 在此程序中，您将学习在 Kotlin 中使用`while`循环来计算位数。

 ## 示例 1：计算整数中的位数

@@ -26,12 +26,12 @@ fun main(args: Array<String>) {
 Number of digits: 7
 ```

-在此程序中，将循环 while 循环，直到测试表达式`num != 0`的值为 0（假）。
+在此程序中，将循环`while`循环，直到测试表达式`num != 0`的值为 0（假）。

-*   第一次迭代后，`num`将除以 10，其值将为 345。然后，`计数`增至 1。
-*   在第二次迭代后，`n` um 的值将为 34，并且`计数`递增为 2。
-*   在第三次迭代后，`num`的值将为 3，并且`计数`增至 3。
-*   第四次迭代后，`num`的值将为 0，并且`计数`增至 4。
-*   然后将测试表达式求值为 false 并终止循环。
+*   第一次迭代后，`num`将除以 10，其值将为 345。然后，`count`增至 1。
+*   在第二次迭代后，`n` um 的值将为 34，并且`count`递增为 2。
+*   在第三次迭代后，`num`的值将为 3，并且`count`增至 3。
+*   第四次迭代后，`num`的值将为 0，并且`count`增至 4。
+*   然后将测试表达式求值为`false`并终止循环。

-以下是等效的 Java 代码： [Java 程序：对整数](/java-programming/examples/digits-count "Java Program to Count Number of Digits in an Integer")中的位数进行计数
\ No newline at end of file
+以下是等效的 Java 代码： [Java 程序：对整数中的位数进行计数](/java-programming/examples/digits-count "Java Program to Count Number of Digits in an Integer")
\ No newline at end of file
--- a/docs/kotlin/63.md
+++ b/docs/kotlin/63.md
-# Kotlin 逆转数字程序
+# Kotlin 反转数字程序

 > 原文： [https://www.programiz.com/kotlin-programming/examples/reverse-number](https://www.programiz.com/kotlin-programming/examples/reverse-number)

-#### 在此程序中，您将学习在 Kotlin 中使用 while 循环反转数字。
+#### 在此程序中，您将学习在 Kotlin 中使用`while`循环反转数字。

-## 示例：倒转 Kotlin 中的数字
+## 示例：反转 Kotlin 中的数字

 ```kt
 fun main(args: Array<String>) {
@@ -27,14 +27,13 @@ fun main(args: Array<String>) {
 Reversed Number: 4321
 ```

-在此程序中，while 循环用于按以下步骤反转数字：
+在此程序中，`while`循环用于按以下步骤反转数字：

-*   首先，将`num`除以 10 的余数存储在变量`数字`中。 现在，`数字`包含`数字`的最后一位，即 4。
-    `数字`然后将其乘以 10 后乘以反向。 10 在倒序数字中添加一个新位置。 十分之一乘以 10 可得到第十位，十分之一则可得到百分数，依此类推。 在这种情况下，将`反转为`包含 0 * 10 + 4 =4。然后
+*   首先，将`num`除以 10 的余数存储在变量`digit`中。 现在，`digit`包含`num`的最后一位，即 4。然后将`reversed`乘以 10 后加上`digit`。 乘 10 在倒序数字中添加一个新位置。 个位乘以 10 可得到十位，十位则可得到百位，依此类推。 在这种情况下，`reversed`包含`0 * 10 + 4 = 4`。然后
    `num`除以 10，因此现在它仅包含前三个数字：123。
-*   在第二次迭代后，`数字`等于 3，`反转了`等于 4 * 10 + 3 = 43，并且`num` = 12
-*   在第三次迭代后，`数字`等于 2，`反转了`等于 43 * 10 + 2 = 432，并且`num` = 1
-*   在第四次迭代后，`数字`等于 1，`反转了`等于 432 * 10 +1 = 4321，并且`num` = 0
-*   现在`num` = 0，因此测试表达式`num != 0`失败并且 while 循环退出。 颠倒的``已经包含颠倒的数字 4321。
+*   在第二次迭代后，`digit`等于 3，`reversed`等于`4 * 10 + 3 = 43`，并且`num = 12` 
+*   在第三次迭代后，`digit`等于 2，`reversed`等于`43 * 10 + 2 = 432`，并且`num = 1`
+*   在第四次迭代后，`digit`等于 1，`reversed`等于`432 * 10 +1 = 4321`，并且`num = 0`
+*   现在`num = 0`，因此测试表达式`num != 0`失败并且`while`循环退出。 `reversed`已经包含颠倒的数字 4321。

 以下是等效的 Java 代码：[反转数字的 Java 程序](/java-programming/examples/reverse-number "Java Program to reverse a number")
\ No newline at end of file
--- a/docs/kotlin/64.md
+++ b/docs/kotlin/64.md
@@ -2,9 +2,9 @@

 > 原文： [https://www.programiz.com/kotlin-programming/examples/power-number](https://www.programiz.com/kotlin-programming/examples/power-number)

-#### 在此程序中，您将学习使用和不使用 pow（）函数来计算数字的幂。
+#### 在此程序中，您将学习使用和不使用`pow()`函数来计算数字的幂。

-## 示例 1：不使用 pow（）计算数字的幂
+## 示例 1：不使用`pow()`计算数字的幂

 ```kt
 fun main(args: Array<String>) {
@@ -27,19 +27,19 @@ fun main(args: Array<String>) {
 Answer = 81
 ```

-在此程序中，`基`和`指数`分别分配了值 3 和 4。
+在此程序中，`base`和`exponent`分别分配了值 3 和 4。

-使用 while 循环，我们继续将`result`与`基数`相乘，直到`指数`变为零。
+使用`while`循环，我们继续将`result`与`base`相乘，直到`exponent`变为零。

-在这种情况下，我们将`result`乘以基数总共四次，因此`result` = 1 * 3 * 3 * 3 * 3 =81。我们还需要强制转换`基数`到`Long`，因为`result`仅接受`Long`，而 Kotlin 专注于类型安全。
+在这种情况下，我们将`result`乘以基数总共四次，因此`result = 1 * 3 * 3 * 3 * 3 = 81` 。我们还需要强制转换`base`到`Long`，因为`result`仅接受`Long`，而 Kotlin 专注于类型安全。

-但是，与 Java 中一样，如果指数为负，则以上代码将不起作用。 为此，您需要在 Kotlin 中使用 pow（）函数
+但是，与 Java 中一样，如果指数为负，则以上代码将不起作用。 为此，您需要在 Kotlin 中使用`pow()`函数

 以下是等效的 Java 代码：[计算数字幂的 Java 程序](/java-programming/examples/power-number "Java Program to calculate power of a number")

 * * *

-## 示例 2：使用 pow（）计算数字的幂
+## 示例 2：使用`pow()`计算数字的幂

 ```kt
 fun main(args: Array<String>) {
@@ -57,6 +57,6 @@ When you run the program, the output will be:
 Answer = 0.012345679012345678
 ```

-在此程序中，我们使用标准库函数 Math.pow（）来计算基数的幂。
+在此程序中，我们使用标准库函数`Math.pow()`来计算基数的幂。

-我们还需要将`基`和`指数`转换为`Double`，因为 pow 仅接受`Double`参数。
\ No newline at end of file
+我们还需要将`base`和`exponent`转换为`Double`，因为`pow`仅接受`Double`参数。
\ No newline at end of file
--- a/docs/kotlin/65.md
+++ b/docs/kotlin/65.md
@@ -36,29 +36,30 @@ fun main(args: Array<String>) {
 121 is a palindrome.
 ```

-**注意**：可以将 num 的值更改为 11221，并且在运行程序时，输出为：
+**注意**：可以将`num`的值更改为 11221，并且在运行程序时，输出为：

 ```kt
 11221 is not a palindrome.
 ```

-以下是等效的 Java 代码：[用于检查回文数](/java-programming/examples/palindrome-number "Java Program to Check Whether a Number is Palindrome or Not")的 Java 程序
+以下是等效的 Java 代码：[用于检查回文数的 Java 程序](/java-programming/examples/palindrome-number "Java Program to Check Whether a Number is Palindrome or Not")

 在这个程序中

-*   首先，给定数字（`num`）的值存储在另一个整数变量 <samp>originalInteger</samp> 中。 这是因为，我们需要在最后比较反向编号和原始编号的值。
-*   然后，使用 while 循环循环遍历 num，直到等于 0。
-    *   在每次迭代中，`num`的最后一位存储在`余数`中。
-    *   然后，将`余数`添加到`reversedInteger`，以便将其添加到下一个位置值（乘以 10）。
+*   首先，给定数字（`num`）的值存储在另一个整数变量`originalInteger`中。 这是因为，我们需要在最后比较反向编号和原始编号的值。
+*   然后，使用`while`循环循环遍历`num`，直到等于 0。
+    *   在每次迭代中，`num`的最后一位存储在`remainder`中。
+    *   然后，将`remainder`添加到`reversedInteger`，以便将其添加到下一个位置值（乘以 10）。
    *   然后，除以 10 后，从`num`中删除最后一位数字。
 *   最后，比较`reversedInteger`和`originalInteger`。 如果相等，则为回文数。 如果不是，则不是。

 以下是执行的步骤：

-<caption>Palindrome execution steps</caption>
-| 在一个 | num！= 0 | 余 | reversedInteger |
+Palindrome execution steps
+
+| `num` | `num != 0` | `remainder` | `reversedInteger` |
 | --- | --- | --- | --- |
-| 121 | 真正 | 1 | 0 * 10 + 1 = 1 |
-| 12 | true | 2 | 1 * 10 + 2 = 12 |
-| 1 | true | 1 | 12 * 10 + 1 = 121 |
-| 0 | 假 | - | 121 |
\ No newline at end of file
+| 121 | `true` | 1 | `0 * 10 + 1 = 1` |
+| 12 | `true` | 2 | `1 * 10 + 2 = 12` |
+| 1 | `true` | 1 | `12 * 10 + 1 = 121` |
+| 0 | `false` | - | 121 |
\ No newline at end of file
--- a/docs/kotlin/66.md
+++ b/docs/kotlin/66.md
@@ -2,9 +2,9 @@

 > 原文： [https://www.programiz.com/kotlin-programming/examples/prime-number](https://www.programiz.com/kotlin-programming/examples/prime-number)

-#### 在本文中，您将学习检查数字是否为质数。 这是通过 Kotlin 中的 for-in 循环完成的。
+#### 在本文中，您将学习检查数字是否为质数。 这是通过 Kotlin 中的`for-in`循环完成的。

-## 示例 1：使用 for-in 循环检查素数的程序
+## 示例 1：使用`for-in`循环检查质数的程序

 ```kt
 fun main(args: Array<String>) {
@@ -31,17 +31,17 @@ fun main(args: Array<String>) {
 29 is a prime number.
 ```

-与 Java 一样，在上述程序中，for 循环用于确定给定数字`num`是否为素数。 我们只需要遍历`num`的 2 到一半，因为没有数字可被其一半以上的整数整除。
+与 Java 一样，在上述程序中，`for`循环用于确定给定数字`num`是否为质数。 我们只需要遍历`num`的 2 到一半，因为没有数字可被其一半以上的整数整除。

-在 for 循环内，我们检查该数字是否可被给定范围`(2..num/2)`中的任何数字整除。 如果是，则将`标志`设置为`true`，我们就跳出了循环。 这确定`num`不是素数。
+在`for`循环内，我们检查该数字是否可被给定范围`(2..num/2)`中的任何数字整除。 如果是，则将`标志`设置为`true`，我们就跳出了循环。 这确定`num`不是质数。

-如果`num`不能被任何数整除，则`标志`为 false，而`num`为质数。
+如果`num`不能被任何数整除，则`标志`为`false`，而`num`为质数。

-以下是等效的 Java 代码：[用于检查素数](/java-programming/examples/prime-number "Java Program to Check Whether a Number is Prime or Not")的 Java 程序
+以下是等效的 Java 代码：[用于检查质数的 Java 程序](/java-programming/examples/prime-number "Java Program to Check Whether a Number is Prime or Not")

 * * *

-## 示例 2：使用 while 循环检查素数的程序
+## 示例 2：使用`while`循环检查质数的程序

 ```kt
 fun main(args: Array<String>) {
@@ -70,6 +70,6 @@ When you run the program, the output will be:
 33 is not a prime number.
 ```

-在上面的程序中，使用 while 循环代替 for 循环。 循环一直运行到`i <= num/2`为止。 在每次迭代中，检查`num`是否除以`i`，并将`i`的值增加 1。
+在上面的程序中，使用`while`循环代替`for`循环。 循环一直运行到`i <= num/2`为止。 在每次迭代中，检查`num`是否除以`i`，并将`i`的值增加 1。

-访问此页面以了解如何[显示两个时间间隔](/kotlin-programming/examples/prime-number-interval "Display all prime numbers between two intervals ")之间的所有素数。
\ No newline at end of file
+访问此页面以了解如何[显示两个时间间隔](/kotlin-programming/examples/prime-number-interval "Display all prime numbers between two intervals ")之间的所有质数。
\ No newline at end of file
--- a/docs/kotlin/67.md
+++ b/docs/kotlin/67.md
@@ -2,7 +2,7 @@

 > 原文： [https://www.programiz.com/kotlin-programming/examples/prime-number-interval](https://www.programiz.com/kotlin-programming/examples/prime-number-interval)

-#### 在此程序中，您将学习显示两个给定间隔（低和高）之间的质数。 您将在 Kotlin 中使用一会儿和 for 循环学习如何做到这一点。
+#### 在此程序中，您将学习显示两个给定间隔（低和高）之间的质数。 您将在 Kotlin 中使用`while`和`for`循环学习如何做到这一点。

 ## 示例：显示两个间隔之间的质数

@@ -36,8 +36,8 @@ fun main(args: Array<String>) {
 23 29 31 37 41 43 47 
 ```

-在此程序中，将测试介于低和高之间的每个数字的质数。 内部的 for 循环检查数字是否为质数。
+在此程序中，将测试介于低和高之间的每个数字的质数。 内部的`for`循环检查数字是否为质数。

-您可以检查： [Kotlin 程序来检查素数](/kotlin-programming/examples/prime-number "Kotlin Program to Check Prime Number")，以获取更多说明。
+您可以检查： [Kotlin 程序：检查质数](/kotlin-programming/examples/prime-number "Kotlin Program to Check Prime Number")，以获取更多说明。

-检查单个质数和一个间隔之间的区别是，您需要在 while 循环的每次迭代中重置`flag = false`的值。
\ No newline at end of file
+检查单个质数和一个间隔之间的区别是，您需要在`while`循环的每次迭代中重置`flag = false`的值。
\ No newline at end of file
--- a/docs/kotlin/68.md
+++ b/docs/kotlin/68.md
-# Kotlin 程序：检查阿姆斯特朗号
+# Kotlin 程序：检查阿姆斯特朗数

 > 原文： [https://www.programiz.com/kotlin-programming/examples/armstrong-number](https://www.programiz.com/kotlin-programming/examples/armstrong-number)

-#### 在此程序中，您将学习检查给定的数字是否为阿姆斯壮数字。 您将通过在 Kotlin 中使用 while 循环学习如何做到这一点。
+#### 在此程序中，您将学习检查给定的数字是否为阿姆斯特朗数字。 您将通过在 Kotlin 中使用`while`循环学习如何做到这一点。

 一个正整数称为阿姆斯特朗数`n`，如果

@@ -17,7 +17,7 @@ abcd... = an + bn + cn + dn + ...

 ```

-## 示例 1：检查阿姆斯壮编号为 3 位数字
+## 示例 1：检查 3 位数字的阿姆斯特朗数 

 ```kt
 fun main(args: Array<String>) {
@@ -47,19 +47,19 @@ fun main(args: Array<String>) {
 371 is an Armstrong number.
 ```

-*   首先，给定数字（`数字`）的值存储在另一个整数变量`originalNumber`中。 这是因为，我们需要在最后比较最终编号和原始编号的值。
-*   然后，使用 while 循环循环遍历`originalNumber`，直到等于 0。
-    *   在每次迭代中，`num`的最后一位存储在`余数`中。
-    *   然后，使用`Math.pow()`函数将`余数`乘以 3（数字位数），并将其添加到`result`中。
+*   首先，给定数字（`num`）的值存储在另一个整数变量`originalNumber`中。 这是因为，我们需要在最后比较最终编号和原始编号的值。
+*   然后，使用`while`循环循环遍历`originalNumber`，直到等于 0。
+    *   在每次迭代中，`num`的最后一位存储在`remainder`中。
+    *   然后，使用`Math.pow()`函数将`remainder`乘以 3（数字位数），并将其添加到`result`中。
        此处，`余下的`被转换为`Double`，因为`pow`仅接受`Double`参数，并且其值再次转换回`Int`
    *   然后，除以 10 后，从`originalNumber`中删除最后一位数字。
-*   最后，比较`result`和`num`。 如果相等，则为阿姆斯壮数。 如果不是，则不是。
+*   最后，比较`result`和`num`。 如果相等，则为阿姆斯特朗数。 如果不是，则不是。

-以下是等效的 Java 代码：[用于检查 Armstrong 编号](/java-programming/examples/armstrong-number "Java Program to Check Armstrong Number")的 Java 程序
+以下是等效的 Java 代码：[用于检查阿姆斯特朗数的 Java 程序](/java-programming/examples/armstrong-number "Java Program to Check Armstrong Number")

 * * *

-## 示例 2：检查 Armstrong 号为 n 位数字
+## 示例 2：检查 n 位数字的阿姆斯特朗数

 ```kt
 fun main(args: Array<string>) {
@@ -91,10 +91,10 @@ fun main(args: Array<string>) {
 }</string>
 ```

-在此程序中，我们使用了两个 while 循环。 第一个 while 循环用于计算`数字`中的位数。
+在此程序中，我们使用了两个`while`循环。 第一个`while`循环用于计算`num`中的位数。

-然后，将`originalNumber`恢复为给定的`数字`。
+然后，将`originalNumber`恢复为给定的`num`。

-然后，第二个 while 循环检查数字是否为 armstrong。
+然后，第二个`while`循环检查数字是否为阿姆斯特朗数。

-访问此页面了解如何[显示两个时间间隔](/kotlin-programming/examples/armstrong-number-interval "Display all armstrong numbers between two intervals")之间的所有阿姆斯壮数字。
\ No newline at end of file
+访问此页面了解如何[显示两个间隔之间的所有阿姆斯特朗数](/kotlin-programming/examples/armstrong-number-interval "Display all armstrong numbers between two intervals")。
\ No newline at end of file
--- a/docs/kotlin/69.md
+++ b/docs/kotlin/69.md
-# Kotlin 程序：在两个间隔之间显示阿姆斯壮数
+# Kotlin 程序：显示两个间隔之间的阿姆斯特朗数

 > 原文： [https://www.programiz.com/kotlin-programming/examples/armstrong-number-interval](https://www.programiz.com/kotlin-programming/examples/armstrong-number-interval)

-#### 在此程序中，您将学习在 Kotlin 中显示两个给定间隔（低和高）之间的所有阿姆斯壮数字。
+#### 在此程序中，您将学习在 Kotlin 中显示两个给定间隔（低和高）之间的所有阿姆斯特朗数字。

 一个正整数称为阿姆斯特朗数`n`，如果

@@ -17,9 +17,9 @@ abcd... = an + bn + cn + dn + ...

 ```

-该程序基于[的概念，该方法如何检查整数是否为 Armstrong 数字](/kotlin-programming/examples/armstrong-number "Check Armstrong Number in Kotlin")。
+该程序基于[的概念，该方法如何检查整数是否为阿姆斯特朗数](/kotlin-programming/examples/armstrong-number "Check Armstrong Number in Kotlin")。

-## 示例：两个整数之间的阿姆斯壮数
+## 示例：两个整数之间的阿姆斯特朗数

 ```kt
 fun main(args: Array<String>) {
@@ -60,4 +60,4 @@ fun main(args: Array<String>) {

 在上述程序中，检查了给定间隔高和低之间的每个数字。

-每次检查后，`位`的位数和总和`result`被恢复为 0。
\ No newline at end of file
+每次检查后，`digits`的位数和总和`result`被恢复为 0。
\ No newline at end of file
--- a/docs/kotlin/70.md
+++ b/docs/kotlin/70.md
@@ -2,7 +2,7 @@

 > 原文： [https://www.programiz.com/kotlin-programming/examples/prime-number-function](https://www.programiz.com/kotlin-programming/examples/prime-number-function)

-#### 在此程序中，您将学习使用 Kotlin 中的函数显示给定时间间隔之间的所有素数。
+#### 在此程序中，您将学习使用 Kotlin 中的函数显示给定时间间隔之间的所有质数。

 为了找到两个整数之间的所有质数，创建了`checkPrimeNumber()`函数。 此功能[检查数字是否为质数](/kotlin-programming/examples/prime-number "Check prime number in Kotlin")。

@@ -44,8 +44,8 @@ fun checkPrimeNumber(num: Int): Boolean {

 在上面的程序中，我们创建了一个名为`checkPrimeNumber()`的函数，该函数采用参数`num`并返回布尔值。

-如果数字是素数，则返回`true`。 如果不是，则返回`false`。
+如果数字是质数，则返回`true`。 如果不是，则返回`false`。

 根据返回值，在`main()`函数内的屏幕上打印数字。

-以下是等效的 Java 代码：[使用函数](/java-programming/examples/prime-number-function "Java Program to Check Prime Number using Function")检查素数的 Java 程序
\ No newline at end of file
+以下是等效的 Java 代码：[使用函数检查质数的 Java 程序](/java-programming/examples/prime-number-function "Java Program to Check Prime Number using Function")
\ No newline at end of file
--- a/docs/kotlin/71.md
+++ b/docs/kotlin/71.md
-# Kotlin 程序：使用函数显示间隔之间的阿姆斯壮数
+# Kotlin 程序：使用函数显示间隔之间的阿姆斯特朗数

 > 原文： [https://www.programiz.com/kotlin-programming/examples/armstrong-number-function](https://www.programiz.com/kotlin-programming/examples/armstrong-number-function)

-#### 在此程序中，您将学习使用 Kotlin 中的函数显示两个给定间隔（低和高）之间的所有阿姆斯壮数字。
+#### 在此程序中，您将学习使用 Kotlin 中的函数显示两个给定间隔（低和高）之间的所有阿姆斯特朗数字。

-为了找到两个整数之间的所有阿姆斯壮数，创建了`checkArmstrong()`函数。 此功能[检查号码是否为阿姆斯壮](/kotlin-programming/examples/armstrong-number "Check armstrong number in Kotlin")。
+为了找到两个整数之间的所有阿姆斯特朗数，创建了`checkArmstrong()`函数。 此功能[检查号码是否为阿姆斯特朗](/kotlin-programming/examples/armstrong-number "Check armstrong number in Kotlin")。

-## 示例：两个整数之间的阿姆斯壮数
+## 示例：两个整数之间的阿姆斯特朗数

 ```kt
 fun main(args: Array<String>) {
@@ -54,8 +54,8 @@ fun checkArmstrong(num: Int): Boolean {

 在上面的程序中，我们创建了一个名为`checkArmstrong()`的函数，该函数采用参数`num`并返回布尔值。

-如果数字是 armstrong，则返回`true`。 如果不是，则返回`false`。
+如果数字是阿姆斯特朗数，则返回`true`。 如果不是，则返回`false`。

 根据返回值，在`main()`函数内的屏幕上打印数字。

-下面是等效的 Java 代码：[使用功能检查 Armstrong 编号的 Java 程序。](/java-programming/examples/armstrong-number-function "Java Program to Check Armstrong Number using Function")
\ No newline at end of file
+下面是等效的 Java 代码：[使用功能检查阿姆斯特朗数的 Java 程序](/java-programming/examples/armstrong-number-function "Java Program to Check Armstrong Number using Function")。
\ No newline at end of file
--- a/docs/kotlin/72.md
+++ b/docs/kotlin/72.md
@@ -2,7 +2,7 @@

 > 原文： [https://www.programiz.com/kotlin-programming/examples/factors-number](https://www.programiz.com/kotlin-programming/examples/factors-number)

-#### 在此程序中，您将学习在 Kotlin 中使用 for 循环显示给定数字的所有因子。
+#### 在此程序中，您将学习在 Kotlin 中使用`for`循环显示给定数字的所有因子。

 ## 示例：正整数的因子

@@ -27,6 +27,6 @@ Factors of 60 are: 1 2 3 4 5 6 10 12 15 20 30 60

 在上述程序中，要查找其因素的编号存储在变量`num`中（60）。

-`for`循环从 1 迭代到`数字`。 在每次迭代中，检查`num`是否可被`i`完全整除（`i`是`数字`的因数）和`i`的值增加 1。
+`for`循环从 1 迭代到`num`。 在每次迭代中，检查`num`是否可被`i`完全整除（`i`是`num`的因数）和`i`的值增加 1。

 以下是等效的 Java 代码：[显示数字因子的 Java 程序](/java-programming/examples/factors-number "Java Program to Display Factors of a Number")
\ No newline at end of file
--- a/docs/kotlin/73.md
+++ b/docs/kotlin/73.md
-# Kotlin 程序：使用 switch ... case 制作一个简单的计算器
+# Kotlin 程序：使用`switch...case`制作一个简单的计算器

 > 原文： [https://www.programiz.com/kotlin-programming/examples/calculator-when](https://www.programiz.com/kotlin-programming/examples/calculator-when)

-#### 在此程序中，您将学习使用 Kotlin 中的 when 表达式制作一个简单的计算器。 该计算器将能够对两个数字进行加，减，乘和除运算。
+#### 在此程序中，您将学习使用 Kotlin 中的`when`表达式制作一个简单的计算器。 该计算器将能够对两个数字进行加，减，乘和除运算。

-## 示例：使用 switch 语句的简单计算器
+## 示例：使用`switch`语句的简单计算器

 ```kt
 import java.util.*

--- a/docs/kotlin/74.md
+++ b/docs/kotlin/74.md
@@ -2,11 +2,11 @@

 > 原文： [https://www.programiz.com/kotlin-programming/examples/sum-prime-numbers](https://www.programiz.com/kotlin-programming/examples/sum-prime-numbers)

-#### 在该程序中，您将学习检查给定的数字是否可以表示为两个质数之和。 这是通过 Kotlin 中的循环和 break 语句完成的。
+#### 在该程序中，您将学习检查给定的数字是否可以表示为两个质数之和。 这是通过 Kotlin 中的循环和`break`语句完成的。

 为了完成此任务，创建了`checkPrime()`函数。

-如果传递给函数的数字是[素数](/kotlin-programming/examples/prime-number "Check prime number in Kotlin programming")，则`checkPrime()`返回 1。
+如果传递给函数的数字是[质数](/kotlin-programming/examples/prime-number "Check prime number in Kotlin programming")，则`checkPrime()`返回 1。

 ## 示例：整数作为两个质数之和

@@ -59,4 +59,4 @@ fun checkPrime(num: Int): Boolean {

 ```

-以下是等效的 Java 代码： [Java 程序：将一个数字表示为两个数字的总和。](/java-programming/examples/sum-prime-numbers "Java Program to Check Whether a Number can be expressed as a sum of two numbers")
\ No newline at end of file
+以下是等效的 Java 代码： [Java 程序：将一个数字表示为两个数字的总和](/java-programming/examples/sum-prime-numbers "Java Program to Check Whether a Number can be expressed as a sum of two numbers")。
\ No newline at end of file
--- a/docs/kotlin/75.md
+++ b/docs/kotlin/75.md
@@ -4,7 +4,7 @@

 #### 在此程序中，您将学习在 Kotlin 中使用递归查找自然数之和。 这是在递归函数的帮助下完成的。

-正数 1、2、3 ...称为自然数。 下面的程序从用户处获取一个正整数，然后计算得出给定数字的总和。
+正数 1、2、3... 称为自然数。 下面的程序从用户处获取一个正整数，然后计算得出给定数字的总和。

 您也可以使用循环[查找自然数的总和。 但是，您将在此处学习使用递归解决此问题。](/kotlin-programming/examples/sum-natural-numbers "Natural number sum using loops in Kotlin")

@@ -31,7 +31,7 @@ fun addNumbers(num: Int): Int {
 Sum = 210
 ```

-将求和的数字存储在变量`数字`中。
+将求和的数字存储在变量`num`中。

 最初，从`main()`函数调用`addNumbers()`，并将 20 作为参数传递。


--- a/docs/kotlin/76.md
+++ b/docs/kotlin/76.md
@@ -41,7 +41,7 @@ Factorial of 6 = 720

 由于 6 大于或等于 1，因此将 6 与`multiplyNumbers()`的结果相乘，其中传递了 5（数字-1）。 由于是从同一函数调用的，因此它是递归调用。

-在每个递归调用中，参数`n` um 的值减小 1，直到`num`小于 1。
+在每个递归调用中，参数`num`的值减小 1，直到`num`小于 1。

 当`num`的值小于 1 时，将没有递归调用。


--- a/docs/kotlin/77.md
+++ b/docs/kotlin/77.md
-# Kotlin 程序：使用递归查找 G.C.D
+# Kotlin 程序：使用递归查找 GCD

 > 原文： [https://www.programiz.com/kotlin-programming/examples/gcd-hcf-recursion](https://www.programiz.com/kotlin-programming/examples/gcd-hcf-recursion)

@@ -16,7 +16,7 @@ fun main(args: Array<String>) {
    val n2 = 60
    val hcf = hcf(n1, n2)

-    println("G.C.D of $n1 and $n2 is $hcf.")
+    println("GCD of $n1 and $n2 is $hcf.")
 }

 fun hcf(n1: Int, n2: Int): Int {
@@ -30,16 +30,17 @@ fun hcf(n1: Int, n2: Int): Int {
 运行该程序时，输出为：

 ```kt
-G.C.D of 366 and 60 is 6.
+GCD of 366 and 60 is 6.
 ```

-在上面的程序中，递归函数被调用直到 n2 为 0。最后，n1 的值是给定两个数字的 GCD 或 HCF。
+在上面的程序中，递归函数被调用直到`n2`为 0。最后，`n1`的值是给定两个数字的 GCD 或 HCF。

-<caption>Execution Steps</caption>
-| 没有。 | 递归调用 | n1 | n2 | n1% n2 |
+Execution Steps
+
+| 序号 | 递归调用 | `n1` | `n2` | `n1 % n2` |
 | --- | --- | --- | --- | --- |
-| 1 | hcf（366，60） | 366 | 60 | 6 |
-| 2 | hcf（60，6） | 60 | 6 | 0 |
-| 最后 | hcf（6，0） | 6 | 0 | - |
+| 1 | `hcf(366, 60)` | 366 | 60 | 6 |
+| 2 | `hcf(60, 6)` | 60 | 6 | 0 |
+| 最后 | `hcf(6, 0)` | 6 | 0 | - |

-这是等效的 Java 代码：[查找 G.C.D.的 Java 程序。 使用递归](/java-programming/examples/gcd-hcf-recursion "Java Program to Find GCD using recursive function")
\ No newline at end of file
+这是等效的 Java 代码：[使用递归查找 GCD 的 Java 程序](/java-programming/examples/gcd-hcf-recursion "Java Program to Find GCD using recursive function")。 
\ No newline at end of file
--- a/docs/kotlin/81.md
+++ b/docs/kotlin/81.md
@@ -35,7 +35,8 @@ The reversed sentence is: krow oG

 最后，我们以空的`句子`和`reverse()`返回相反的句子结束。

-<caption>Execution steps</caption>
+Execution steps
+
 | 迭代 | 逆转（） | substring（） | reversedString |
 | --- | --- | --- | --- |
 | 1 | 反向（“开始工作”） | “工作” | 结果+“ G” |

--- a/docs/kotlin/82.md
+++ b/docs/kotlin/82.md
@@ -37,7 +37,8 @@ fun power(base: Int, powerRaised: Int): Int {
 3 * 3 * 3 * 3 = 81
 ```

-<caption>Execution steps</caption>
+Execution steps
+
 | 迭代 | 功率（） | powerRaised | 结果 |
 | --- | --- | --- | --- |
 | 1 | 功率（3，4） | 4 | 3 *结果 <sub>2</sub> |

--- a/docs/kotlin/84.md
+++ b/docs/kotlin/84.md
@@ -28,7 +28,7 @@ Largest element = 55.50

 在上面的程序中，我们将数组的第一个元素存储在最大的变量`中。`

-然后，使用`最大的`比较数组中的其他元素。 如果任何数字大于`最大`，则将最大`最大`分配给`数字`。
+然后，使用`最大的`比较数组中的其他元素。 如果任何数字大于`最大`，则将最大`最大`分配给`num`。

 这样，打印时最大的编号存储在最大的`中。`


--- a/docs/kotlin/92.md
+++ b/docs/kotlin/92.md
@@ -46,7 +46,8 @@ Ruby

 如果 compareTo（）的返回值大于 0，则必须在位置上进行交换，即 word [i]在 word [j]之后。 因此，在每次迭代中，单词[i]包含最早的单词。

-<caption>Execution Steps</caption>
+Execution Steps
+
 | 迭代 | 初始词 | 一世 | Ĵ | 话[] |
 | --- | --- | --- | --- | --- |
 | 1 | `{ "Ruby", "C", "Python", "Java" }` | 0 | 1 | `{ "C", "Ruby", "Python", "Java" }` |