for循环语句
# 一、程序的流程结构
程序的流程控制结构一共有三种：顺序结构、选择结构、循环结构.
顺序结构：代码从上向下逐行的执行
选择结构：条件满足,某些代码才会被执行.0-1次
if语句,switch语句
循环结构：条件满足,某些代码会被反复的多次执行.0-n次
for语句
# 二、循环语句
- 循环语句表示条件满足,可以反复的执行某段代码.
- for是唯一的循环语句.(Go没有while循环)
# 2.1 For语句
语法结构：
for init; condition; post { }
1
初始化语句只执行一次.在初始化循环之后,将检查该条件.如果条件计算为
true,那么{}中的循环体将被执行,然后是post语句.post语句将在循环的每次成功迭代之后执行.在执行post语句之后,该条件将被重新检查.如果它是正确的,循环将继续执行,否则循环终止.
示例代码：
package main
import "fmt"
func main() {
/*
for循环: 某些代码会被多次的执行
语法:
for 表达式1; 表达式2; 表达式3{
循环体
}
*/
/* fmt.Println("hello world...")
fmt.Println("hello world...")
fmt.Println("hello world...")
fmt.Println("hello world...")*/
for i := 1; i <= 5; i++ {
fmt.Println("Hello World...")
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
在
for循环中声明的变量仅在循环范围内可用.因此,i不能在外部访问循环.
所有的三个组成部分,即初始化、条件和post都是可选的.
for condition { }
1
效果与while相似
for { }
1
效果与for(;;)一样
for循环的range格式可以对slice、map、数组、字符串等进行迭代循环
for key, value := range oldMap {
newMap[key] = value
}
1
2
3
2
3
package main
import "fmt"
func main() {
var b int = 15
var a int
numbers := [6]int{1, 2, 3, 5}
/* for 循环 */
for a := 0; a < 10; a++ {
fmt.Printf("a 的值为: %d\n", a)
}
for a < b {
a++
fmt.Printf("a 的值为: %d\n", a)
}
for i,x:= range numbers {
fmt.Printf("第 %d 位 x 的值 = %d\n", i,x)
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
运行结果：
a 的值为: 0
a 的值为: 1
a 的值为: 2
a 的值为: 3
a 的值为: 4
a 的值为: 5
a 的值为: 6
a 的值为: 7
a 的值为: 8
a 的值为: 9
a 的值为: 1
a 的值为: 2
a 的值为: 3
a 的值为: 4
a 的值为: 5
a 的值为: 6
a 的值为: 7
a 的值为: 8
a 的值为: 9
a 的值为: 10
a 的值为: 11
a 的值为: 12
a 的值为: 13
a 的值为: 14
a 的值为: 15
第 0 位 x 的值 = 1
第 1 位 x 的值 = 2
第 2 位 x 的值 = 3
第 3 位 x 的值 = 5
第 4 位 x 的值 = 0
第 5 位 x 的值 = 0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
代码示例1
package main
import "fmt"
func main() {
/*
1.标准写法
for 表达式1;表达式2;表达式3{
循环体
}
2.同时省略表达式1和表达式3
for 表达式2{
}
相当于while(条件)
3.同时省略3个表达式
for{
}
相当于while(true)
注意点: 当for循环中,省略表达式2,就相当于直接作用在了true上
4.其他的写法: for循环中同时省略几个表达式都可以..
省略表达式1: 变量定义要放在外部
省略表达式2: 循环永远成立--->死循环
省略表达式3: 变量的变化就需耀写在循环里
*/
i := 1
for i <= 5 {
fmt.Println(i)
i++
}
fmt.Println("--->", i)
fmt.Println("----------------------")
for {
fmt.Println("--->", i)
i++
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
代码示例2
package main
import "fmt"
func main() {
/*
for循环练习:
1.打印58-23数字
2.求1-100的和
sum := 0
sum = +1+2+3+4...+100
3.打印1-100内,能够被3整除,但是不能被5整除的数字,统计被打印的数字的个数,每行打印5个
*/
// 58-23
for i := 58; i >= 23; i-- {
fmt.Println(i)
}
fmt.Println("----------------------")
sum := 0
for i := 1; i <= 100; i++ {
sum += i
}
fmt.Println("1-100的和: ", sum)
fmt.Println("----------------------")
count := 0
for i := 1; i <= 100; i++ {
if i%3 == 0 && i%5 != 0 {
fmt.Print(i, "\t")
count++ // 5,10/15,20...
if count%5 == 0 {
fmt.Println()
}
}
}
fmt.Println()
fmt.Println("--->", count)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
# 2.2 多层for循环
for循环中又有循环嵌套,就表示多层循环了.
代码示例1
package main
import "fmt"
func main() {
/*
循环嵌套: 多层循环嵌套在一起
练习:
*****
*****
*****
*****
*****
*/
//for j := 0; j < 5; j++ {
// fmt.Print("*")
//}
//fmt.Println()
for i := 1; i <= 5; i++ {
for j := 0; j < 5; j++ {
fmt.Print("*")
}
fmt.Println()
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
代码示例2
package main
import "fmt"
func main() {
/*
循环嵌套: 多层循环嵌套在一起
练习二:
1x1=1
2x1=2 2x2=4
3x1=3 3x2=6 3x3=9
......
9x1=9 9x2=18 9x3=27 ... 9x9=81
*/
for i := 1; i < 10; i++ {
//fmt.Println(i)
for j := 1; j <= i; j++ {
fmt.Printf("%d x %d = %d\t", j, i, i*j)
}
fmt.Println()
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# 三、break和continue
# 3.1.break语句
- break: 跳出循环体.
break语句用于在接收其正常执行之前突然终止for循环
示例代码:
package main
import "fmt"
func main() {
/*
循环结束:
循环条件不满足,循环自动结束了
但是可以通过break和continue来强制的结束循环
循环控制语句:
break:
continue:
*/
for i := 1; i <= 10; i++ {
if i == 5 {
break
}
fmt.Println(i)
}
fmt.Println("main...over...")
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 3.2.continue语句
- 就跳出一次循环.
continue语句用于跳过for循环的当前迭代.在continue语句后面的for循环中的素有代码将不会在当前迭代中执行.循环将继续到下一个迭代.
示例代码:
package main
import "fmt"
func main() {
/*
循环结束:
循环条件不满足,循环自动结束了
但是可以通过break和continue来强制的结束循环
循环控制语句:
break: 彻底的结束循环...终止
continue: 结束某一次循环,下次继续...终止
注意点: 多层循环嵌套,break和continue,默认结束是里层循环
如果想结束指定的某个循环,可以给循环贴标签(起名).
break 循环标签名
continue 循环标签名
*/
for i := 1; i <= 10; i++ {
if i == 5 {
break
}
fmt.Println(i)
}
fmt.Println("---------------------------")
out: # 标签
for i := 1; i <= 5; i++ {
for j := 1; j <= 5; j++ {
if j == 2 {
break out
//continue out
}
fmt.Printf("i:%d,j:%d\n", i, j)
}
}
fmt.Println("main...over...")
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
# 四、for循环练习
# 4.1. 1~100的和
package main
import "fmt"
func main() {
/*
for循环的练习题：
练习1：打印58-23数字
练习2：求1-100的和
sum := 0
sum = +1+2+3+4...+100
sum = sum + 1
sum = sum + 2
sum = sum + 3
...
sum = sum + 100
练习3：打印1-100内,能够被3整除,但是不能被5整除的数字,统计被打印的数字的个数,每行打印5个
*/
for i := 58; i >= 23; i-- {
fmt.Println(i) // 58,57,56...23
}
fmt.Println("------------------")
sum := 0
for i := 1;i <= 100;i++{
sum += i // i : 1,2,3,4..100
}
fmt.Println("1-100的和：",sum)
fmt.Println("-----------------")
count := 0 //计数器
for i := 1;i <= 100;i++{
if i % 3 == 0 && i % 5 != 0{
fmt.Print(i,"\t")
count++ //5, 10, 15, 20..
if count % 5 == 0{
fmt.Println()
}
}
}
fmt.Println()
fmt.Println("count-->",count)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
# 4.2.求素数
package main
import (
"fmt"
"math"
)
func main() {
/*
打印2-100内的素数(只能被1和本身整除)
2,3,5,7,11,13,17....
*/
/* for i := 2; i <= 100; i++ {
flag := true //记录i是否是素数
for j := 2; j < i; j++ { //判断到根号i就可以,不需要到i的前一个
if i%j == 0 {
flag = false //不是素数了
break
}
}
if flag { //==true
fmt.Println(i)
}
}*/
for i := 2; i <= 100; i++ {
flag := true //记录i是否是素数
for j := 2; j <= int(math.Sqrt(float64(i))); j++ { //判断到根号i就可以,不需要到i的前一个
if i%j == 0 {
flag = false //不是素数了
break
}
}
if flag { //==true
fmt.Println(i)
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
# 4.3.猜数字游戏
package main
import "fmt"
import "math/rand"
import "time"
func CreatNum(p *int) {
//设置种子
rand.Seed(time.Now().UnixNano())
var num int
for {
num = rand.Intn(10000) //一定是4位数
if num >= 1000 {
break
}
}
//fmt.Println("num = ", num)
*p = num
}
func GetNum(s []int, num int) {
s[0] = num / 1000 //取千位
s[1] = num % 1000 / 100 //取百位
s[2] = num % 100 / 10 //取百位
s[3] = num % 10 //取个位
}
func OnGame(randSlice []int) {
var num int
keySlice := make([]int, 4)
for {
for {
fmt.Printf("请输入一个4位数：")
fmt.Scan(&num)
// 999 < num < 10000
if 999 < num && num < 10000 {
break
}
fmt.Println("请输入的数不符合要求")
}
//fmt.Println("num = ", num)
GetNum(keySlice, num)
//fmt.Println("keySlice = ", keySlice)
n := 0
for i := 0; i < 4; i++ {
if keySlice[i] > randSlice[i] {
fmt.Printf("第%d位大了一点\n", i+1)
} else if keySlice[i] < randSlice[i] {
fmt.Printf("第%d位小了一点\n", i+1)
} else {
fmt.Printf("第%d位猜对了\n", i+1)
n++
}
}
if n == 4 { //4位都猜对了
fmt.Println("全部猜对!!!")
break //跳出循环
}
}
}
func main() {
var randNum int
//产生一个4位的随机数
CreatNum(&randNum)
//fmt.Println("randNum: ", randNum)
randSlice := make([]int, 4)
//保存这个4位数的每一位
GetNum(randSlice, randNum)
//fmt.Println("randSlice = ", randSlice)
/*
n1 := 1234 / 1000 //取商
//(1234 % 1000) //取余数，结果为234 234/100取商得到2
n2 := 1234 % 1000 / 100
fmt.Println("n1 = ", n1)
fmt.Println("n2 = ", n2)
*/
OnGame(randSlice) //游戏
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
# 4.4. 打印九九表
package main
import "fmt"
func main() {
/*
循环嵌套: 多层循环嵌套在一起
练习一:
*****
*****
*****
*****
*****
练习二:
1x1=1
2x1=2 2x2=4
3x1=3 3x2=6 3x3=9
......
9x1=9 9x2=18 9x3=27 ... 9x9=81
*/
//for j := 0; j < 5; j++ {
// fmt.Print("*")
//}
//fmt.Println()
//for i := 1; i <= 5; i++ {
// for j := 0; j < 5; j++ {
// fmt.Print("*")
// }
// fmt.Println()
//}
for i := 1; i < 10; i++ {
//fmt.Println(i)
for j := 1; j <= i; j++ {
fmt.Printf("%d x %d = %d\t", j, i, i*j)
}
fmt.Println()
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
# 4.5. 打印三角形图案
# 直角三角形
package main
import "fmt"
func main() {
// 打印直角三角形
var lineNum1 int
fmt.Print("请输入需要三角形行数：")
fmt.Scanln(&lineNum1)
// 打印标记行数
for i:=1;i<=lineNum1;i++{
// 打印每行的星号
for j:=1;j<=2*i-1;j++{
fmt.Print("*")
}
fmt.Println() // 作用：每行打印完毕换行
}
}
# 等腰三角形
package main
import "fmt"
func main() {
var lineNum2 int
fmt.Print("请输入三角形的行数：")
fmt.Scanln(&lineNum2)
// 标记行数
for i:=1;i<=lineNum2;i++{
// 打印前面的空格
for k:=1;k<=lineNum2-i;k++{
fmt.Print(" ")
}
// 打印每行星号
for j:=1;j<=2*i-1;j++{
fmt.Print("*")
}
fmt.Println() // 作用：每行打印完毕换行
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
# 4.6.求水仙花数
package main
import (
"fmt"
"math"
)
func main() {
/*
水仙花数: 三位数(100,999)
每个位上的数字的立方和,刚好等于该数字本身,那么就叫水仙花数.4个
比如: 153
1*1*1 + 5*5*5 + 3*3*3 = 1+125+27=153
268:
268/100=2
268%10=8
268-->26 %10 = 6
268-->68 /10= 6
*/
for i := 100; i < 1000; i++ {
x := i / 100 //百位
y := i / 10 % 10 // 十位
z := i % 10 //个位
if math.Pow(float64(x), 3)+math.Pow(float64(y), 3)+math.Pow(float64(z), 3) == float64(i) {
fmt.Println(i)
}
}
fmt.Println("---------------------------------")
/*
百位: 1-9
十位: 0-9
个位: 0-9
*/
for a := 1; a < 10; a++ {
for b := 0; b < 10; b++ {
for c := 0; c < 10; c++ {
n := a*100 + b*10 + c*1
if a*a*a+b*b*b+c*c*c == n {
fmt.Println(n)
}
}
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
# 4.7.百钱百鸡
古代数学家张丘建 (opens new window)在《算经》一书中提出的数学问题：鸡翁一值钱五，鸡母一值钱三，鸡雏三值钱一。百钱买百鸡，问鸡翁、鸡母、鸡雏各几何？
# 解法一
package main
import (
"fmt"
)
func main() {
//一只公鸡值五钱 ，一只母鸡值三钱 三只小鸡值一钱 现在要用百钱买百鸡，请问公鸡 母鸡 小鸡各多少只
sum:=0
for i := 0; i <= 100; i+=5 { //买公鸡的钱只能是5的倍数
var k int=0
//小鸡不能超过100只，即公鸡+母鸡共用的钱不能少于67
if i<=67{
k=(67-i)/3*3
}
for j:=k; j<=100 -i;j+=3 { //买母鸡的钱只能是3的倍数
iz:=i/5
jz:=j/3
//if (100-iz-jz)%3!=0 {//剩下的小鸡只数如果不是3的倍数，则不再继续
// continue
//}
xz:=(100-i-j)*3
sum++
if 100-iz-jz==xz{
fmt.Println("公鸡：",iz,"只",i,"钱，","母鸡：",jz,"只",j,"钱，","，小鸡：",xz,"只",100-i-j,"钱")
}
}
}
fmt.Println("循环",sum,"次")
}
# 解法二
package main
import "fmt"
func main(){
sum:=0
for i := 0; i <= 20; i++ {
for j := 0; j <= 33; j++ {
x:=100-i-j
sum++
if x%3 == 0 && i*5+j*3+x/3 == 100 {
fmt.Printf("公鸡%d只，母鸡%d只，小鸡%d只\n",i,j,x)
}
}
}
fmt.Printf("循环%d次",sum)
}
# 解法三
func main(){
sum:=0
for i := 0; i <20; i++ { //i 为公鸡
j:=25-(7*i)/4
x:= 75 + (3*i)/4
sum++
if j>0&&x>0 {
if x%3 == 0 && 5*i+3*j+x/3 == 100 {
fmt.Printf("公鸡%d只，母鸡%d只，小鸡%d只\n",i,j,x)
}
}
}
fmt.Println(sum)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
上次更新: 2024/04/09, 16:48:42
- 01
- AWS NAT-NetWork-Firwalld配置(一)04-09
- 02
- AWS NAT-NetWork-Firwalld配置(二)04-09
- 03
- kubernetes部署minio对象存储01-18