网站 › 『编程语言讨论求助区』 › 易语言语法的25个练习题

OVVO 发表于 2022-10-4 02:40

易语言语法的25个练习题

本帖最后由 OVVO 于 2022-10-4 02:42 编辑

题目来源：
Python语法的25个练习题
https://www.52pojie.cn/thread-1689186-1-1.html

> 第12、15、24题为作业，请留在评论区，不调用任何模块的方式实现。

## 题目1：水仙花数
```
.版本 2
.支持库 spec

.子程序 题目1_水仙花数
.局部变量 start, 整数型
.局部变量 stop, 整数型
.局部变量 i, 整数型, , , 100~999
.局部变量 i1, 整数型
.局部变量 i2, 整数型
.局部变量 i3, 整数型

start ＝ 100
stop ＝ 1000
.变量循环首 (start, stop － 1, 1, i)
    ' i ＝ 123' 假设
    i1 ＝ i ＼ 100' 取百位数字 123//100=1
    i2 ＝ i ＼ 10 ％ 10' 取十位数字 123//10=1212%10=2
    i3 ＝ i ％ 10' 取个位数字 123%10=3
    .如果真 (到整数 (求次方 (i1, 3)) ＋ 到整数 (求次方 (i2, 3)) ＋ 到整数 (求次方 (i3, 3)) ＝ i)
      调试输出 (到文本 (i) ＋ “是水仙花数”)
      ' 153是水仙花数
      ' 370是水仙花数
      ' 371是水仙花数
      ' 407是水仙花数
    .如果真结束

.变量循环尾 ()

```

## 题目2：四叶玫瑰数
```
.版本 2
.支持库 spec

.子程序 题目2_四叶玫瑰数
.局部变量 start, 整数型
.局部变量 stop, 整数型
.局部变量 i, 整数型, , , 1000~9999
.局部变量 i1, 整数型
.局部变量 i2, 整数型
.局部变量 i3, 整数型
.局部变量 i4, 整数型

start ＝ 1000
stop ＝ 10000
.变量循环首 (start, stop － 1, 1, i)
    ' i ＝ 1234' 假设
    i1 ＝ i ＼ 1000' 取千位数字 1234//1000=1
    i2 ＝ i ＼ 100 ％ 10' 取百位数字 1234//100=1212%10=2
    i3 ＝ i ＼ 10 ％ 10' 取十位数字 1234//10=123123%10=3
    i4 ＝ i ％ 10' 取个位数字 1234%10=4
    .如果真 (到整数 (求次方 (i1, 4)) ＋ 到整数 (求次方 (i2, 4)) ＋ 到整数 (求次方 (i3, 4)) ＋ 到整数 (求次方 (i4, 4)) ＝ i)
      调试输出 (到文本 (i) ＋ “是四叶玫瑰数”)
      ' 1634是四叶玫瑰数
      ' 8208是四叶玫瑰数
      ' 9474是四叶玫瑰数
    .如果真结束

.变量循环尾 ()

```
## 题目3：逆序输出字符串
```
.版本 2
.支持库 spec

.子程序 题目3_逆序输出字符串
.局部变量 str, 文本型, , , 只允许数字或字母
.局部变量 len, 整数型, , , 不考虑中文，需特殊处理（1个汉字占2字节）
.局部变量 i, 整数型
.局部变量 ret, 文本型

标准输出 (#标准输出设备, “请输入字符串” ＋ #换行符)
str ＝ 标准输入 ()
' str ＝ “123456”
' str ＝ “abcdefghijklmnopqrstuvwxyz”
' str ＝ “52pojie_OVVO”
len ＝ 取文本长度 (str)
.变量循环首 (len, 1, -1, i)
    ret ＝ ret ＋ 取文本中间 (str, i, 1)
.变量循环尾 ()
调试输出 (ret)

```
## 题目4：猜数字小游戏
```
.版本 2
.支持库 spec

.子程序 题目4_猜数字小游戏
.局部变量 number, 整数型, , , 0~100都有可能
.局部变量 i, 整数型
.局部变量 choice, 整数型
.局部变量 ok, 逻辑型

置随机数种子 ()
number ＝ 取随机数 (0, 100)
调试输出 (“嘘~这是随机数：” ＋ 到文本 (number))
.计次循环首 (10, i)
    标准输出 (#标准输出设备, “请输入你要猜测的数字：” ＋ #换行符)
    choice ＝ 到整数 (标准输入 ())
    .如果 (choice ＞ number)
      调试输出 (“你猜大了”)
    .否则
      .如果 (choice ＜ number)
            调试输出 (“你猜小了”)
      .否则
            ok ＝ 真
            调试输出 (“你猜对了，真棒！”)
            调试输出 (“你一共用了” ＋ 到文本 (i) ＋ “次机会”)
            跳出循环 ()
      .如果结束

    .如果结束
    调试输出 (“还剩” ＋ 到文本 (10 － i) ＋ “次机会”)
.计次循环尾 ()
.如果真 (ok ＝ 假)
    调试输出 (“游戏结束，你没有猜到”)

```
## 题目5：百鸡百钱
```
.版本 2
.支持库 spec

.子程序 题目5_百鸡百钱
.局部变量 count, 整数型
.局部变量 x, 整数型
.局部变量 y, 整数型
.局部变量 z, 整数型

count ＝ 0
.变量循环首 (1, 20 － 1, 1, x)
    .变量循环首 (1, 33 － 1, 1, y)
      z ＝ 100 － x － y
      .如果真 (z ＞ 0 且 5 × x ＋ 3 × y ＋ z ÷ 3 ＝ 100)
            count ＝ count ＋ 1
            调试输出 (取重复文本 (60, “=”))
            调试输出 (“第” ＋ 到文本 (count) ＋ “种买法，公鸡买了” ＋ 到文本 (x) ＋ “只，母鸡买了” ＋ 到文本 (y) ＋ “只，小鸡买了” ＋ 到文本 (z) ＋ “只”)
            ' ============================================================
            ' 第1种买法，公鸡买了4只，母鸡买了18只，小鸡买了78只
            ' ============================================================
            ' 第2种买法，公鸡买了8只，母鸡买了11只，小鸡买了81只
            ' ============================================================
            ' 第3种买法，公鸡买了12只，母鸡买了4只，小鸡买了84只
      .如果真结束

    .变量循环尾 ()
.变量循环尾 ()

```
## 题目6：闰年问题升级版
```
.版本 2
.支持库 spec

.子程序 题目6_闰年问题升级版
.局部变量 year, 整数型
.局部变量 month, 整数型
.局部变量 day, 整数型
.局部变量 date_list, 整数型, , "0"
.局部变量 count_day, 整数型
.局部变量 i, 整数型

标准输出 (#标准输出设备, “请输入年份” ＋ #换行符)
year ＝ 到整数 (标准输入 ())
标准输出 (#标准输出设备, “请输入月份” ＋ #换行符)
month ＝ 到整数 (标准输入 ())
标准输出 (#标准输出设备, “请输入日期” ＋ #换行符)
day ＝ 到整数 (标准输入 ())

' year ＝ 2022
' month ＝ 10
' day ＝ 3

date_list ＝ { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
count_day ＝ day
.如果 (year ％ 4 ＝ 0 且 year ％ 100 ≠ 0 或 year ％ 400 ＝ 0)
    调试输出 (到文本 (year) ＋ “年是闰年”)
    date_list ＝ 29
.否则
    调试输出 (到文本 (year) ＋ “年是平年”)
    date_list ＝ 28
.如果结束

.计次循环首 (month － 1, i)
    count_day ＝ count_day ＋ date_list
.计次循环尾 ()
调试输出 (到文本 (year) ＋ “年” ＋ 到文本 (month) ＋ “月” ＋ 到文本 (day) ＋ “日是当年的第” ＋ 到文本 (count_day) ＋ “天”)

' 2022年是平年
' 2022年10月3日是当年的第276天

```
## 题目7：猴子吃桃问题
```
.版本 2
.支持库 spec

.子程序 题目7_猴子吃桃问题
.局部变量 p, 整数型
.局部变量 i, 整数型

p ＝ 1
调试输出 (“第10天还剩下” ＋ 到文本 (p) ＋ “个桃子”)
.变量循环首 (9, 1, -1, i)
    p ＝ (p ＋ 1) × 2
    调试输出 (“第” ＋ 到文本 (i) ＋ “天还剩下” ＋ 到文本 (p) ＋ “个桃子”)
.变量循环尾 ()
调试输出 (“第一天一共摘了” ＋ 到文本 (p) ＋ “个桃子”)

' 第10天还剩下1个桃子
' 第9天还剩下4个桃子
' 第8天还剩下10个桃子
' 第7天还剩下22个桃子
' 第6天还剩下46个桃子
' 第5天还剩下94个桃子
' 第4天还剩下190个桃子
' 第3天还剩下382个桃子
' 第2天还剩下766个桃子
' 第1天还剩下1534个桃子
' 第一天一共摘了1534个桃子

```
## 题目8：冒泡排序
```
.版本 2
.支持库 spec

.子程序 题目8_冒泡排序
.局部变量 pop_list, 整数型, , "0"
.局部变量 count, 整数型
.局部变量 i, 整数型
.局部变量 j, 整数型

' pop_list ＝ { 82, 15, 15, 41, 37, 31 }
pop_list ＝ { 29, 12, 19, 37, 14 }
count ＝ 取数组成员数 (pop_list)
调试输出 (“没排序之前的列表”, pop_list)
.计次循环首 (count, i)
    .计次循环首 (count － i, j)
      .如果真 (pop_list ＞ pop_list )
            交换变量 (pop_list , pop_list )
      .如果真结束

    .计次循环尾 ()

.计次循环尾 ()
调试输出 (“排好序的列表为”, pop_list)

' {15, 15, 31, 37, 41, 82}
' {12, 14, 19, 29, 37}

```
## 题目9：二分查找法

> 第一种 纯算法的方式

```
.版本 2
.支持库 spec

.子程序 题目9_二分查找法_纯算法
.局部变量 arr_list, 整数型, , "0"
.局部变量 number, 整数型
.局部变量 count, 整数型
.局部变量 left, 整数型
.局部变量 right, 整数型
.局部变量 middle, 整数型
.局部变量 ok, 逻辑型

arr_list ＝ { 5, 7, 11, 22, 27, 33, 39, 52, 58 }
number ＝ 11
count ＝ 0
left ＝ 0
right ＝ 取数组成员数 (arr_list) － 1

.判断循环首 (left ≤ right)
    middle ＝ (left ＋ right) ＼ 2
    count ＝ count ＋ 1
    .如果 (number ＞ arr_list )
      left ＝ middle ＋ 1
    .否则
      .如果 (number ＜ arr_list )
            right ＝ middle － 1
      .否则
            ok ＝ 真
            调试输出 (“数字” ＋ 到文本 (number) ＋ “已找到，索引值为” ＋ 到文本 (middle))
            跳出循环 ()
      .如果结束

    .如果结束

.判断循环尾 ()
.如果 (ok ＝ 假)
    调试输出 (“数字” ＋ 到文本 (number) ＋ “没有找到”)
.否则
    调试输出 (“一共用了” ＋ 到文本 (count) ＋ “次查找”)
.如果结束

' 数字11已找到，索引值为2
' 一共用了3次查找

```

> 第二种 递归函数的方式

```
.版本 2
.支持库 spec

.子程序 binary_search, 整数型, 公开
.参数 arr_list, 整数型, 参考 数组
.参数 number, 整数型
.参数 left, 整数型
.参数 right, 整数型
.局部变量 middle, 整数型

.如果 (left ≤ right)
    middle ＝ (left ＋ right) ＼ 2
    .如果 (number ＜ arr_list )
      right ＝ middle － 1
    .否则
      .如果 (number ＞ arr_list )
            left ＝ middle ＋ 1
      .否则
            返回 (middle)
      .如果结束

    .如果结束
    返回 (binary_search (arr_list, number, left, right))
.否则
    返回 (-1)
.如果结束
返回 (0)

.子程序 题目9_二分查找法_递归函数的方式
.局部变量 arr_list, 整数型, , "0"

arr_list ＝ { 5, 7, 11, 22, 27, 33, 39, 52, 58 }
调试输出 (binary_search (arr_list, 11, 0, 取数组成员数 (arr_list) － 1))' 3

```
## 题目10：选择排序
```
.版本 2
.支持库 spec

.子程序 题目10_选择排序
.局部变量 sec_list, 整数型, , "0"
.局部变量 length, 整数型
.局部变量 i, 整数型
.局部变量 min_index, 整数型
.局部变量 j, 整数型

sec_list ＝ { 91, 30, 93, 98, 26, 98, 20, 90 }
length ＝ 取数组成员数 (sec_list)
调试输出 (“未排序的列表为：”, sec_list)
.计次循环首 (length, i)
    min_index ＝ i
    .变量循环首 (i, length, 1, j)
      .如果真 (sec_list ＞ sec_list )
            min_index ＝ j
      .如果真结束

    .变量循环尾 ()
    交换变量 (sec_list , sec_list )
    调试输出 (“第” ＋ 到文本 (i) ＋ “轮排好序是：”, sec_list)
.计次循环尾 ()
调试输出 (“最终排好序的列表为：”, sec_list)

' 数组:8{20,26,30,90,91,93,98,98}

```
## 题目11：剪刀石头布
```
.版本 2
.支持库 spec

.子程序 题目11_剪刀石头布
.局部变量 game_info, 文本型, , "0"
.局部变量 score, 整数型
.局部变量 是否跳出, 逻辑型
.局部变量 robots_choice, 整数型
.局部变量 user_choice, 整数型

调试输出 (取重复文本 (60, “=”))
调试输出 (取重复文本 (20, “ ”), “剪刀石头布游戏”)
调试输出 (“1代表剪刀 2代表石头 3代表布”)

加入成员 (game_info, “剪刀”)
加入成员 (game_info, “石头”)
加入成员 (game_info, “布”)

score ＝ 100

置随机数种子 ()
是否跳出 ＝ 假
.判断循环首 (是否跳出 ＝ 假)
    robots_choice ＝ 取随机数 (1, 3)
    标准输出 (#标准输出设备, “请出拳” ＋ #换行符)
    user_choice ＝ 到整数 (标准输入 ())
    .如果真 (寻找文本 (到文本 (user_choice), “1”, , 假) ＝ -1 且 寻找文本 (到文本 (user_choice), “2”, , 假) ＝ -1 且 寻找文本 (到文本 (user_choice), “3”, , 假) ＝ -1)
      调试输出 (“出拳错误，请重新出拳”)
      到循环尾 ()
    .如果真结束

    调试输出 (取重复文本 (60, “*”))
    调试输出 (“电脑出” ＋ game_info )
    调试输出 (“你出” ＋ game_info )
    调试输出 (取重复文本 (60, “*”))

    .如果 (user_choice ＝ 1 且 robots_choice ＝ 3 或 user_choice ＝ 2 且 robots_choice ＝ 1 或 user_choice ＝ 3 且 robots_choice ＝ 2)
      score ＝ score ＋ 10
      调试输出 (“你赢得本轮游戏，当前分数为” ＋ 到文本 (score))
    .否则
      .如果 (user_choice ＝ robots_choice)
            调试输出 (“本轮游戏平局，当前分数为” ＋ 到文本 (score))
      .否则
            score ＝ score － 10
            调试输出 (“你输了本轮游戏，当前分数” ＋ 到文本 (score))
      .如果结束

    .如果结束

    .如果 (score ≥ 200)
      调试输出 (“游戏结束，你赢得比赛”)
      跳出循环 ()
    .否则
      .如果 (score ≤ 0)
            调试输出 (“游戏结束，你输了”)
            跳出循环 ()
      .否则

      .如果结束

    .如果结束

.判断循环尾 ()

```
## 题目12：快乐数
```
调试输出 ("请完善")
```
## 题目13：猜年龄（一）
```
.版本 2
.支持库 spec

.子程序 题目13_猜年龄_一
.局部变量 i, 整数型
.局部变量 j, 整数型

.变量循环首 (1, 100 － 1, 1, i)
    .变量循环首 (1, i － 1, 1, j)
      .如果真 (i × j ＝ 6 × (i ＋ j) 且 i － j ＜ 8)
            调试输出 (i, j)
            ' 15 | 10
      .如果真结束

    .变量循环尾 ()
.变量循环尾 ()

```
## 题目14：猜年龄(二)
```
.版本 2
.支持库 spec

.子程序 数组_去重复_整数型, 整数型, 公开, 返回剩余不重复数组的成员数量
.参数 整数数组, 整数型, 参考 数组, 要去重复的 整数数组
.局部变量 成员数, 整数型
.局部变量 i, 长整数型
.局部变量 a, 整数型

数组排序 (整数数组, 真)
成员数 ＝ 取数组成员数 (整数数组)
i ＝ 0
a ＝ 1
.判断循环首 (a ≤ 成员数)
    i ＝ i ＋ 1
    整数数组 ＝ 整数数组
    .循环判断首 ()
      a ＝ a ＋ 1
      .如果真 (a ＞ 成员数)
            跳出循环 ()
      .如果真结束

    .循环判断尾 (整数数组 ＝ 整数数组 )
.判断循环尾 ()
重定义数组 (整数数组, 真, i)
返回 (i)

.子程序 题目14_猜年龄_二
.局部变量 i, 整数型
.局部变量 i3, 文本型
.局部变量 i4, 文本型
.局部变量 arr, 整数型, , "0"
.局部变量 a, 整数型

.变量循环首 (10, 30 － 1, 1, i)
    i3 ＝ 到文本 (到整数 (求次方 (i, 3)))
    i4 ＝ 到文本 (到整数 (求次方 (i, 4)))
    .如果真 (取文本长度 (i3) ＝ 4 且 取文本长度 (i4) ＝ 6)
      清除数组 (arr)
      .计次循环首 (取文本长度 (i3), a)
            加入成员 (arr, 到整数 (取文本中间 (i3, a, 1)))
      .计次循环尾 ()
      .计次循环首 (取文本长度 (i4), a)
            加入成员 (arr, 到整数 (取文本中间 (i4, a, 1)))
      .计次循环尾 ()
      数组_去重复_整数型 (arr)
      .如果真 (取数组成员数 (arr) ＝ 10)
            调试输出 (i)' 18
            调试输出 (i3 ＋ i4)' 5832104976

      .如果真结束

    .如果真结束

.变量循环尾 ()

```
## 题目15：split算法实现
```
调试输出 ("请完善")
```
## 题目16：大衍数列
```
.版本 2
.支持库 spec

.子程序 题目16_大衍数列
.局部变量 x, 整数型
.局部变量 a, 整数型

.变量循环首 (1, 101 － 1, 1, x)
    .如果 (x ％ 2 ＝ 0)' 偶数
      a ＝ 到整数 (求次方 (x, 2) ＼ 2)
    .否则
      a ＝ 到整数 ((求次方 (x, 2) － 1) ＼ 2)
    .如果结束
    调试输出 (a)
    ' 0
    ' 2
    ' 4
    ' 8
    ' 12
    ' 18
    ' 24
    ' 32
    ' 40
    ' 50
    ' ...
.变量循环尾 ()

```
## 题目17：单词分析
```
.版本 2
.支持库 e2ee
.支持库 spec

.子程序 analyse_words, , , 需要E2EE支持库
.参数 words, 文本型
.局部变量 len, 整数型
.局部变量 i, 整数型
.局部变量 arr, 文本型, , "0"
.局部变量 key, 文本型
.局部变量 json, 存取键值表
.局部变量 value, 整数型
.局部变量 最大值的_key, 文本型
.局部变量 最大值的_value, 整数型

len ＝ 取文本长度 (words)
.计次循环首 (len, i)
    加入成员 (arr, 取文本中间 (words, i, 1))
.计次循环尾 ()
' 数组:10{“h”,“e”,“l”,“l”,“o”,“w”,“o”,“r”,“l”,“d”}

.计次循环首 (取数组成员数 (arr), i)
    key ＝ arr
    json.置整数 (key, json.取整数 (key) ＋ 1)
.计次循环尾 ()
' {"h":1,"e":1,"d":1,"l":3,"w":1,"o":2,"r":1}

arr ＝ json.取键数组 ()
.计次循环首 (取数组成员数 (arr), i)
    key ＝ arr
    value ＝ json.取整数 (key)
    .如果 (i ＝ 1)
      最大值的_key ＝ key
      最大值的_value ＝ value
    .否则
      .如果真 (value ≥ 最大值的_value)
            最大值的_key ＝ key
            最大值的_value ＝ value
      .如果真结束

    .如果结束

.计次循环尾 ()
调试输出 (最大值的_key)' l
调试输出 (最大值的_value)' 3

.子程序 题目17_单词分析

analyse_words (“helloworld”)

```
## 题目18：利用栈打印菱形
```
.版本 2
.支持库 spec

.子程序 diamond
.参数 n, 整数型
.局部变量 stack, 文本型, , "0"
.局部变量 i, 整数型
.局部变量 p_str, 文本型

' stack ＝ {}
.计次循环首 (2 × n － 1, i)
    .如果 (i ≤ n)
      p_str ＝ 取重复文本 (n － i, “ ”) ＋ 取重复文本 (2 × i － 1, “*”)
      .如果真 (i ≠ n)
            加入成员 (stack, p_str)
      .如果真结束
      调试输出 (p_str)
    .否则
      调试输出 (stack [取数组成员数 (stack)])
      删除成员 (stack, 取数组成员数 (stack), 1)
    .如果结束

.计次循环尾 ()
' ....*
' ...***
' ..*****
' .*******
' *********
' .*******
' ..*****
' ...***
' ....*

.子程序 题目18_利用栈打印菱形

diamond (5)

```
## 题目19：深入理解递归函数
```
.版本 2
.支持库 spec

.子程序 p
.参数 n, 整数型

.如果真 (n ＝ 0)
    返回 ()
.如果真结束
调试输出 (“递归前->”, n)
p (n － 1)
调试输出 (“递归后->”, n)

.子程序 题目19_深入理解递归函数

p (5)
' “递归前->” | 5
' “递归前->” | 4
' “递归前->” | 3
' “递归前->” | 2
' “递归前->” | 1
' “递归后->” | 1
' “递归后->” | 2
' “递归后->” | 3
' “递归后->” | 4
' “递归后->” | 5

```
## 题目20：斐波那契递归函数
```
.版本 2
.支持库 spec

.子程序 fib, 整数型
.参数 n, 整数型

.如果真 (n ≤ 2)
    返回 (1)
.如果真结束
返回 (fib (n － 1) ＋ fib (n － 2))

.子程序 题目20_斐波那契递归函数

调试输出 (fib (10))' 55
调试输出 (fib (2))' 1

```
## 题目21：三个数取最大数
```
.版本 2
.支持库 spec

.子程序 题目21_三个数取最大数
.局部变量 a, 整数型
.局部变量 b, 整数型
.局部变量 c, 整数型
.局部变量 max_num, 整数型

a ＝ 10
b ＝ 6
c ＝ 18
.如果 (a ＞ b)
    max_num ＝ a
.否则
    max_num ＝ b
.如果结束

.如果真 (max_num ＜ c)
    max_num ＝ c
.如果真结束
调试输出 (max_num)' 18

```
## 题目22：因子之和“完数”
```
.版本 2
.支持库 spec

.子程序 factor_sum, 整数型
.参数 n, 整数型
.局部变量 s_sum, 整数型
.局部变量 i, 整数型

s_sum ＝ 0
.变量循环首 (1, n － 1, 1, i)
    .如果真 (n ％ i ＝ 0)
      s_sum ＝ s_sum ＋ i
    .如果真结束

.变量循环尾 ()
返回 (s_sum)

.子程序 题目22_因子之和_完数
.局部变量 j, 整数型

.变量循环首 (1, 1000 － 1, 1, j)
    .如果真 (j ＝ factor_sum (j))
      调试输出 (j)
      ' 6
      ' 28
      ' 496
    .如果真结束

.变量循环尾 ()

```
## 题目23：递归阶乘求和
```
.版本 2
.支持库 spec

.子程序 factor, 整数型
.参数 n, 整数型

.如果真 (n ＜ 2)
    返回 (1)
.如果真结束
返回 (n × factor (n － 1))

.子程序 题目23_递归阶乘求和
.局部变量 s_sum, 整数型
.局部变量 i, 整数型

s_sum ＝ 0
.变量循环首 (1, 11 － 1, 1, i)
    s_sum ＝ s_sum ＋ factor (i)
.变量循环尾 ()
调试输出 (s_sum)' 4037913

```
## 题目24：有效的括号
```
调试输出 ("请完善")
```
## 题目25：回文数的两种解法

>解法一：通过逆转字符串进行比对


```
.版本 2
.支持库 spec

.子程序 is_palindrome_1, 逻辑型
.参数 x, 整数型
.局部变量 str_x, 文本型
.局部变量 len, 整数型
.局部变量 i, 整数型
.局部变量 ret, 文本型

.如果真 (x ＜ 0 或 x ＞ 0 且 x ％ 10 ＝ 0)
    返回 (假)
.如果真结束

str_x ＝ 到文本 (x)
len ＝ 取文本长度 (str_x)
.变量循环首 (len, 1, -1, i)
    ret ＝ ret ＋ 取文本中间 (str_x, i, 1)
.变量循环尾 ()
返回 (str_x ＝ ret)

.子程序 题目25_回文数的两种解法_一

调试输出 (is_palindrome_1 (121))' 真
调试输出 (is_palindrome_1 (120))' 假

```


>解法二：反转一半数字和前半部分的数字进行比较


```
.版本 2
.支持库 spec

.子程序 is_palindrome_2, 逻辑型
.参数 x, 整数型
.局部变量 reverted, 整数型

.如果真 (x ＜ 0 或 x ＞ 0 且 x ％ 10 ＝ 0)
    返回 (假)
.如果真结束

reverted ＝ 0
.判断循环首 (x ＞ reverted)
    reverted ＝ reverted × 10 ＋ x ％ 10
    x ＝ x ＼ 10
.判断循环尾 ()
返回 (x ＝ reverted 或 x ＝ reverted ＼ 10)

.子程序 题目25_回文数的两种解法_二

调试输出 (is_palindrome_2 (1221))' 真
调试输出 (is_palindrome_2 (1223))' 假
调试输出 (is_palindrome_2 (123321))' 真

```

OVVO 发表于 2022-10-4 03:07

长图版

wxf2589 发表于 2022-10-4 06:14

博爵 发表于 2022-10-4 07:01

感谢分享，厉害了

xcz668 发表于 2022-10-4 07:42

感谢分享，厉害了

孤狼微博 发表于 2022-10-4 09:53

很棒研究算法是很快乐的事

funny123 发表于 2022-10-4 10:01

6啊{:1_921:}6啊{:1_921:}

NINE09 发表于 2022-10-4 10:14

感谢分享，厉害了

晓儿 发表于 2022-10-4 10:23

{:1_893:}看看详细的内容

sw7057 发表于 2022-10-4 11:08

收藏学习，谢谢楼主分享。

查看完整版本: 易语言语法的25个练习题