该练习题旨在学习Go和回忆Python用法，所以只实现核心功能，不再冗余进行异常处理

NO.1

编写一个程序，查找所有此类数字，它们可以被7整除，但不能是5的倍数（在2000和3200之间（均包括在内））。获得的数字应以逗号分隔的顺序打印在一行上

• Python代码实现

'''
编写一个程序，查找所有此类数字，它们可以被7整除，
但不能是5的倍数（在2000和3200之间（均包括在内））。获得的数字应以逗号分隔的顺序打印在一行上
'''
arr = []
for num in range(2000, 3201):
    if num % 7 == 0 and num % 5 != 0:
        arr.append(str(num))
print(','.join(arr))

• Go代码实现

package main

import (
    "fmt"
    "strconv"
    "strings"
)

//编写一个程序，查找所有此类数字，它们可以被7整除，
//但不能是5的倍数（在2000和3200之间（均包括在内））。获得的数字应以逗号分隔的顺序打印在一行上
func main() {
    var numbers []string
    for i := 2000; i <= 3200; i++ {
        if i%5 != 0 && i%7 == 0 {
            numbers = append(numbers, strconv.Itoa(i))
        }
        
    }
    tr1 := strings.Join(numbers, ",")
    fmt.Println(tr1)
}

• 结果

2002,2009,2016,2023,2037,2044,2051,2058,2072,2079,2086,2093,2107,2114,2121,2128,2142,2149,2156,2163,2177,2184,2191,2198,2212,2219,2226,2233,2247,2254,2261,2268,2282,2289,2296,2303,2317,2324,2331,2338,2352,2359,2366,2373,2387,2394,2401,2408,2422,2429,2436,2443,2457,2464,2471,2478,2492,2499,2506,2513,2527,2534,2541,2548,2562,2569,2576,2583,2597,2604,2611,2618,2632,2639,2646,2653,2667,2674,2681,2688,2702,2709,2716,2723,2737,2744,2751,2758,2772,2779,2786,2793,2807,2814,2821,2828,2842,2849,2856,2863,2877,2884,2891,2898,2912,2919,2926,2933,2947,2954,2961,2968,2982,2989,2996,3003,3017,3024,3031,3038,3052,3059,3066,3073,3087,3094,3101,3108,3122,3129,3136,3143,3157,3164,3171,3178,3192,3199

No.2

编写一个程序，可以计算给定数字的阶乘，结果应以逗号分隔的顺序打印在一行上，假设向程序提供了以下输入：8然后，输出应为：40320

• Python 代码实现

'''
编写一个程序，可以计算给定整数数字的阶乘，结果应以逗号分隔的顺序打印在一行上，假设向程序提供了以下输入：8然后，输出应为：40320
'''
number_int = input("请输入整型数字:")
try:
    # 先检查输入的内容是否可以转成float，之后再判定有没有带小数点
    num = float(number_int)
    if num.is_integer() and str(number_int).count('.') == 0:
        for i in range(1, int(num)):
            num = i * num
        print(num)
    else:
        print('非整型')
except:
    print('非数字')

结果

请输入整型数字:8
40320.0

• Go 代码实现

package main

import (
    "fmt"
)

//编写一个程序，可以计算给定整数数字的阶乘，结果应以逗号分隔的顺序打印在一行上，
//假设向程序提供了以下输入：8然后，输出应为：40320

func main() {
    var num int
    var count int
    // 终端接收一个整型数值
    fmt.Printf("请输入一个整型数值")
    fmt.Scanln(&num)
    count = num
    for i := 1; i < num; i++ {
        count *= i
    }
    fmt.Printf("阶乘结果:%d", count)
}

• 结果

请输入一个整型数值8
阶乘结果:40320

No.3

使用给定的整数n，编写程序以生成包含（i，ixi）的字典，该字典为1到n之间的整数（都包括在内）。然后程序应打印字典。假设向程序提供了以下输入：8然后，输出应为：{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64}

• Python 实现

number_int = input("请输入整型数字:")
num = float(number_int)
num_dict = {}
if num.is_integer() and str(number_int).count('.') == 0:
    for i in range(1, int(num)+1):
        num_dict.update({i:i*i})
    print(num_dict)

• Go 实现

package main

import "fmt"

func main() {
    var num int
    fmt.Printf("请输入一个整型数值")
    fmt.Scanln(&num)
    num_map := make(map[int]int)
    for i := 1; i<= num; i++ {
        num_map[i] = i * i
    }
    fmt.Println(num_map)
}

• 输出

# python
{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64}
# go
map[1:1 2:4 3:9 4:16 5:25 6:36 7:49 8:64]

No.4

1、求最大公约数和最小公倍数
两个数的最大公约数是两个数的公共因子中最大的那个数；最大公约数=两数同时被一个最大的数除尽
两个数的最小公倍数则是能够同时被两个数整除的最小的那个数。最小公倍数=两数相乘÷两数的最大公约数
输入：（120和60是通过键盘输入的）
x = 120
y = 60
输出：
60和120的最大公约数60
60和120的最小公倍数是120

• Python 实现

x = int(input('x = '))
y = int(input('y = '))
# 计算最小公倍数，找出两个数最小的那个。
if x > y:
    k = y
else:
    k = x
for i in range(k, 0, -1):
    if x % i == 0 and y % i == 0:
        print("%d和%d的最大公约数是%d" % (x, y, i))
        print("%d和%d的最小公倍数数是%d" % (x, y, x * y / i))
        break

• Go 实现

package main

import "fmt"

func main() {
    var x int
    var y int
    fmt.Printf("请输入一个整型数值x:")
    fmt.Scanln(&x)
    fmt.Printf("请输入一个整型数值y:")
    fmt.Scanln(&y)
    if x > y {
        // 运用Go语言的变量多重赋值，实现变量交换
        x, y = y, x
    }
    for i := x; i > 0; i-- {
        if x%i == 0 && y%i == 0 {
            fmt.Printf("%d和%d的最大公约数是%d", x, y, i)
            fmt.Println()
            fmt.Printf("%d和%d的最小公倍数是%d", x, y, x*y/i)
            break
        }
    }
}

• 结果

60和120的最大公约数是60
60和120的最小公倍数是120

No.5

斐波那契数列，又称黄金分割数列，指的是这样一个数列：1、1、2、3、5、8、13、21、34
输入:(数字10是通过键盘输入的)
请输入需要打印的斐波那契数列的数据个数（从1开始）：10
输出：（每一个数据项之间用空格）
1 1 2 3 5 8 13 21 34 55

• Python 实现

def fib(n):
    a = 1
    b = 1
    for i in range(n):
        print(a, end=' ')
        temp = a
        a = b
        b = temp+b
num = int(input("请输入需要打印的斐波那契数列的数据个数（从1开始）："))
fib(num)

• Go实现

package main

import "fmt"

func fib(n int) {
    a := 1
    b := 1
    for i := 0; i < n; i++ {
        fmt.Printf("%d ", a)
        temp := a
        a = b
        b = temp + b
    }

}

func main() {
    var num int
    fmt.Printf("请输入需要打印的斐波那契数列的数据个数（从1开始）：")
    fmt.Scanln(&num)
    fib(num)
}

• 结果

请输入需要打印的斐波那契数列的数据个数（从1开始）：10
1 1 2 3 5 8 13 21 34 55 

No.6

求和运算
求 s=a+aa+aaa+aaaa+aa...a的值，其中a是一个数字。
输入 a=4，n=5
输出：
4
44
444
4444
44444
前面5个数的和为:49380

• Python 实现

a = int(input("a = "))
n = int(input("n = "))
Tn = 0
Tn_sum = 0
for i in range(n):
    Tn += a
    Tn_sum += Tn
    a = a*10
    print(Tn)
print("前面5个数的和为: %s" % Tn_sum)

• Go 实现

package main

import "fmt"

func main() {
    var a int
    var n int
    fmt.Printf("a = ")
    fmt.Scanln(&a)
    fmt.Printf("n = ")
    fmt.Scanln(&n)
    Tn := 0
    Tn_sum := 0
    for i := 0; i < n; i++ {
        Tn += a
        Tn_sum += Tn
        a = a * 10
        println(Tn)
    }
    fmt.Println("前面5个数的和为: %s", Tn_sum)
}

• 结果

a = 4
n = 5
4
44
444
4444
44444
前面5个数的和为: 49380

No.7

求前n阶乘的和
比如求1+2！+3！+...+20!的和。
输入：n=20
输出：前20阶乘的和是：2561327494111820313

• Python 实现

n = int(input("n = "))
Tn_sum = 0
for i in range(1,n+1):
    Tn = 1
    for j in range(1,i+1):
        Tn *=j
    Tn_sum +=Tn
print("前%s阶乘的和是：%s" %(n,Tn_sum))

• Go 实现

package main

import "fmt"

func main() {
    var n int
    fmt.Printf("n = ")
    fmt.Scanln(&n)
    Tn_sum := 0
    for i := 1; i <= n; i++ {
        Tn := 1
        for j := 1; j <= i; j++ {
            Tn *= j
        }
        Tn_sum += Tn
    }
    fmt.Printf("前%d阶乘的和是：%d", n, Tn_sum)
}

• 结果

n = 20
前20阶乘的和是：2561327494111820313

No.8

求两个列表中的相同元素和不同元素
给定两个列表，怎么找出他们相同的元素和不同的元素
输入：
list1 = [1,2,3]
list2 = [3,4,5]
输出:
list1 和 list2 的相同元素是: [3]
list1 和 list2 的不同元素是:[1,2,4,5]

• Python

list1 = [1,2,3]
list2 = [3,4,5]
# 去重
set1 = set(list1)
set2 = set(list2)
a = set1 & set2
b = set1 ^ set2
print("list1 和 list2 的相同元素是: ", list(set1))
print("list1 和 list2 的不同元素是:", list(set2))

• Go 实现

package main

import (
    "fmt"
    mapset "github.com/deckarep/golang-set/v2"
)

func main() {
    s1 := mapset.NewSet(1, 2, 3)
    s2 := mapset.NewSet(3, 4, 5)
    // 交集
    fmt.Println("list1 和 list2 的相同元素是: ", s1.Intersect(s2).ToSlice())
    fmt.Println("list1 和 list2 的不同元素是: ", s1.SymmetricDifference(s2).ToSlice())
}

• 结果

list1 和 list2 的相同元素是:  [1, 2, 3]
list1 和 list2 的不同元素是: [3, 4, 5]

No.9

两个列表转合并为一个字典
输入:
m = ['a','b','c']
n = [11,22,33]
输出：
{'a': 11, 'b': 22, 'c': 33}

• Python 实现

m = ['a', 'b', 'c']
n = [11, 22, 33]
dict_mn = {}
for i in range(0, len(m)):
    dict_mn.update({m[i]: n[i]})
print(dict_mn)

• Go 实现

package main

import (
    "fmt"
)

func main() {
    m := []string{"a", "b", "c"}
    n := []int{11, 22, 33}
    map1 := make(map[string]int)
    for i := 0; i < len(m); i++ {
        map1[m[i]] = n[i]

    }
    fmt.Println(map1)
}

• 结果输出

# python
{'a': 11, 'b': 22, 'c': 33}
# go
map[a:11 b:22 c:33]

No.10

倒序输出列表/数组中的数据
输入:
a = ["one","two","three"]
输出：
three
two
one

• Python 实现

a = ["one","two","three"]
for i in a[::-1]:
    print(i)

• Go 实现

package main

import (
    "fmt"
)

func main() {
    m := []string{"one", "two", "three"}
    for i := len(m) - 1; i >= 0; i-- {
        fmt.Println(m[i])
    }
}

• 结果输出

three
two
one