精华内容
下载资源
问答
  • 在for循环中,我们很容易得到循环次数,因为是作为条件出现的。在while也可以得到,如下:
  • 有以下程序段 int k=0; while(k=1) k++; 则while 循环执行次数是:( ) A) 无限次 B) 有语法错,不能执行 C) 一次也不执行 D) 执行1次 为什么是a
  • 程序短如下: char k=1;while (k>0) k=k+1
  • while循环次数限制

    千次阅读 2019-09-21 00:24:42
    版本一,该版本最后加了if else 用来判断guess_count的次数,中间的‘不等于’环节代码重复了,但是理解方便。 lucky_num = 66 input_num = -1 #定义input_num ,python程序从上到下...# while lucky_num != inp...
    版本一,
    该版本最后加了if else 用来判断guess_count的次数,中间的‘不等于’环节代码重复了,但是理解方便。

    lucky_num = 66
    input_num = -1      #定义input_num ,python程序从上到下,必须先定义初始值。   
    guess_count =0      #定义游戏次数
    # while lucky_num != input_num:     #让幸运数字跟猜的数字不相等,只要不相等,就无限循环,相等就终止循环
    while lucky_num != input_num and guess_count<3: #游戏次数要小于3次 and是并且,要同时满足两个条件
        input_num = int(input("input the guess number"))
    
        if (input_num > lucky_num):
            print("is bigger real number")
        elif(input_num < lucky_num):
            print("Is smaller real number")
        # guess_count=guess_count+1
        guess_count += 1
    if lucky_num == input_num:      #这里加了if,else判断,用来判断竞猜次数,但是代码有重复性
        print ("bingo")
    else:
        print('to many retrys')

     



    版本二
    lucky_num = 66
    input_num = -1      #定义input_num ,python程序从上到下,必须先定义初始值。   
    guess_count =0      #定义游戏次数
    # while lucky_num != input_num:     #让幸运数字跟猜的数字不相等,只要不相等,就无限循环,相等就终止循环
    # while lucky_num != input_num and guess_count<3: #游戏次数要小于3次 and是并且,要同时满足两个条件
    while guess_count<3:    #while循环用来判断次数,内部的if,elif,else循环判断正确性
        input_num = int(input("input the guess number"))
    
        if (input_num > lucky_num):
            print("is bigger real number")
        elif(input_num < lucky_num):
            print("Is smaller real number")
        else:               #添加else判断,直接循环内部判断正确性
            print('bingo')
            break       #用break跳出
        # guess_count=guess_count+1
        guess_count += 1
    else:
        print('to many retrys')

     



    版本三

    for 循环

    lucky_num = 66
    input_num = -1
    # lucky_num != input_num and
    for i in range(3):
        input_num = int(input("input the guess number"))
    
        if (input_num > lucky_num):
            print("is bigger real number")
        elif(input_num < lucky_num):
            print("Is smaller real number")
        else:
            print("bingo")
            break
    
    else:
        print("too many retrys")

     




    转载于:https://www.cnblogs.com/PYlog/p/8573612.html

    展开全文
  • LabVIEW的While循环

    2021-01-19 23:04:53
    While循环位于结构子选板“编程→结构→While循环”,同时也存在于选板“Express→执行过程控制→While循环”,如图1所示。结构子选板中的While循环执行过程控制子选板中的While循环用法和作用是相同的,只不过在...
  • C语言while循环语句 do while语句 for循环语句

    万次阅读 多人点赞 2019-06-10 14:17:53
    一、循环结构的思想及意义: 知道了循环结构,那么在生活中也一样...第一种思维那就是说一下命令就让B执行动作,B执行完动作后,A再继续说命令,B再继续做动作,同样的事情重复十遍。如果利用所学的知识,让你输出十...

    一、循环结构的思想及意义:
    知道了循环结构,那么在生活中也一样,我们每天都在重复做着相同的事情,例如:吸气呼气的过程;又如夏天开电扇,电扇一圈一圈的转,这都是在重复。现在大家玩个游戏,一个人A来说一个人B来做,一个人A说命令“敬礼,礼毕”,另一人B做动作十遍;第一种思维那就是说一下命令就让B执行动作,B执行完动作后,A再继续说命令,B再继续做动作,同样的事情重复十遍。如果利用所学的知识,让你输出十遍“敬礼,礼毕”,你会怎么写程序呢?

    /* 输出敬礼礼毕十遍 */
    #include "stdio.h"
    void main()
    {
        printf("1.敬礼、礼毕\n");
        printf("2.敬礼、礼毕\n");
        printf("3.敬礼、礼毕\n");
        printf("4.敬礼、礼毕\n");
        printf("5.敬礼、礼毕\n");
        printf("6.敬礼、礼毕\n");
        printf("7.敬礼、礼毕\n");
        printf("8.敬礼、礼毕\n");
        printf("9.敬礼、礼毕\n");
        printf("10.敬礼、礼毕\n");    
    }
    

    那A要让B说一万遍呢,显然如果还是用上面的程序来写的话,那么今天你一个小时不用做别的了,你就在这里慢慢复制粘贴吧!所以肯定有好的办法:A应该对B说执行命令动作“敬礼、礼毕”十遍。同样的问题大家来看第二段程序代码:

    /* 输出敬礼礼毕十遍 */
    #include "stdio.h"
    void main()
    {
    	int i;
    	i=1;
        while(i<=10)
    	{
    printf("%d.敬礼、礼毕\n",i);
    i=i+1;
    	}   
    }
    

    二、while的基本格式
    while的基本格式:(流程图如右图所示)
    while(表达式)
    {
    语句1;
    ……
    语句 n;
    }
    其中表达式代表了循环条件,整个复合语句为循环体。
    while语句规范:
    1:{和}自成一行
    2:语句1—语句n自动缩进
    while循环属于当型循环,也就是先判断表达式的值是否为真的(也可以理解为条件是否成立),若为真则循环,否则退出循环。
    它的格式变形如下;
    表达式1;
    while(表达式2)
    {
    语句;
    表达式3;
    }
    其中表达式1代表了程序循环前的初始值,表达式2代表了控制条件,表达式3代表了增量变化
    拿输出1到100为例分析。
    最初始的值(假设变量为i)应该是i=1;条件是i<101(或i<=100);语句是输出相应的变量值 printf(“%d ”,i);而表达式3应该是输出一个后进入下一个数,也就是i++;
    所以它的代码也就很容易就出来了:

    void main()
    {
        int i;
        i=1;
        while(i<101)
    {
      printf(“%d ”,i);
      i++;   
    }
    }
    

    do—while循环语句
    do–while语句
    在循环中有当型循环,还有直到型循环。接下来我们就来学习下直到型循环。
    一、do—while语句格式
    1.do—while语句格式1
    表达式1;
    do
    {
    语句;
    表达式3;
    } while(表达式2);
    其中表达式1代表了程序循环前的初始值,表达式2代表了控制条件,表达式3代表了增量变化
    这种格式在程序中已经很少用了。主要应用于下种变形格式:
    2.do—while语句格式变形
    do
    {
    语句;
    } while(条件表达式);
    二、do-while语句的思想及意义
    do英文翻译成中文是做的意思,那么从上面的结构我们也能看出,do语句后判断条件表达式,如果条件还表达式成立,再次执行语句,直到条件表达式不成立,往下继续执行。所以do—while的中心思想是至少执行一次循环语句。
    三、do-while循环结构实例
    下面我们一些操作实例来讲解循环结构的逻辑思维过程。
    1.求1+2+3+4±—+100和是多少?
    (1)步骤1,首先我们应该分析的是,我们要求一个数即和,那么和初值是几呢? sum=0
    (2)sum+=1;
    (3)sum+=2;
    (4)sum+=3;
    (5)假如我们如一个变量i来代表值的变化的话那么我们应该也能推算去,求和其实就是
    (6)sum+=i;只是i要从1变化到100
    (7)while代码参考代码如下

    /*求1+2+3+---+100的和*/
    #include "stdio.h"
    void main()//求各
    {
    	//定义变量并初始化
    	int i=1;
    	int sum=0;
    	while(i<=100)  //条件表达式
    	{
    		sum+=i;
    		i+=1; //步长
    	}	
    	printf("和是%d",sum);
    }
    

    (8)do–while代码参考代码如下

    /*求1+2+3+---+100的和*/
    #include "stdio.h"
    void main()//求各
    {
    	//定义变量并初始化
    	int i=1;
    	int sum=0;
    	do
    	{
    		sum+=i;
    		i+=1; //步长
    	}	while(i<=100); //条件表达式
    	printf("和是%d",sum);
    }
    

    2.输入qq的密码;输入正确则显示登录成功,否则可以一直输入密码直到对为至,假设密码为123456
    (1)那么我们分析题目,应该是先输入后判断的一种循环方式,那么应该选择do—while语句
    (2)程序中要求我们输入密码,密码可以变,所以要给密码定义成一个变量,我们假设int password;
    (3)因为密码是输入的,所以没有初始值
    (4)输入密码以后我们应该判断密码是否和默认密码相同
    (5)相同则登录成功
    (6)不相同则重新
    (7)do–while代码参考代码如下

    /*判断qq密码*/
    #include "stdio.h"
    void main()//登录
    {
    	//定义变量并初始化
    	int password;
        do	
    	{
    		printf("请输入qq登录密码:");
    		scanf("%d",&password);
    	}while(password!=123456);  	//条件表达式
    	printf("登录成功");
    }
    

    (8)do—while语句是可以被while()替换,其实循环之间的语句都可以相互替换,哪种方法更适合你,就选那种,也就是说一定要有一种是自己专长的。

    (9)参考代码如下
    /*登录*/
    #include "stdio.h"
    #include "stdlib.h"
    void main()//登录
    {
    	//定义变量并初始化
    	int password;
        while(1)
    	{
    		printf("请输入qq登录密码:");
    		scanf("%d",&password);
    		if(password==123456)
    		{
    			printf("登录成功");
    			break;
    			}
    	}
    	
    }
    

    3.while 与do—while的相同与不同总结?
    (1)while 语句是先计算表达式的值,再执行循环体,do…while是执行完一次循环体,再计算表达式的值
    (2)当表达式的值第一次为假时,while的循环体一次都不执行,do…while则执行一次循环体;
    (3)当表达式的值为真时,两者无区别
    (4)在不确定条件次数的情况下,程序一般用while比较多

    for循环语句
    for 循环为当型循环。for循环最容易实现计数控制循环方法。for循环的使用最为灵活,且适合应用在循环次数确定的情况下。
    for循环的思想是,先分析清楚循环的初始值,循环的控制条件,循环变量的步长变化,然后直接把语句再写到for的循环体里即可,这样可以让问题想的很清楚,流程也很清楚。
    二、for循环语句的应用
    for语句是c语言所提供的功能更强,使用更广泛的一种循环语句。
    1.for语句的一般格式
    (1)第1种情况
    for(表达式1;表达式2;表达式3)
    语句;
    (2)第2种情况
    for(表达式1;表达式2;表达式3)
    {
    语句块;
    }
    2.for语句的注意事项
    (1)各表达式之间分号不能省略
    (2)表达式1与表达式2与表达式3均可省略,一般是不省略的。
    ①当表达式1省略时,相当于省去了为循环变量赋初值,此时应在for语句之前给循环变量赋初值
    ②当表达式2省略时,表示不判断循环条件,也就是认为表达式2始终为真, 这时应在循环体内设法结束循环,否则将成为死循环
    ③当表达式3省略时,即省去修改循环变量的值,但此时应在循环体内设法结束循环
    (3)虽然说表达式可以省略,但是在使用for时,还是要正常使用的,也就是该有的都有。
    三、for的逻辑思维过程
    for语句和while语句一样,它的思想是在做循环之前,也是先有一个初值表达式1,然后判断条件表达式2是否成立,如果成立就执行{}里的语句然后跳转到表达式3,表达式3再跳转到表达式2,再次判断表达式2,如若成立再次,执行{}里的语句语句然后跳转到表达式3,表达式3再跳转到表达式2,如果成立就再重复执行,如果不成立就退出循环。
    for的流程图走向和while语句一模一样,但是for的思维过程,可以直接先分析从第一次开始执行,执行条件是什么,步长是多少,然后执行的语句是什么,套用for的结构即可。

    展开全文
  • while循环是前测试循环,这意味着是否终止的条件判断是在执行代码之前,因此,循环的主体可能根本不执行。其语法如下: while(expression) statement 当expression为ture时,程序会不断执行statement语句,直到...
  • 代码执行顺序之循环执行 循环执行的分类 for循环 while循环 dowhile循环 for循环 语法: for(循环初始化表达式;循环条件表达式;循环后的操作表达式){ ​ // 循环体 } 执行步骤分析: 循环初始化表达式最先...

    代码执行顺序之循环执行

    循环执行的分类

    1. for循环
    2. while循环
    3. dowhile循环

    for循环

    语法:

    for(循环初始化表达式;循环条件表达式;循环后的操作表达式){

    ​ // 循环体

    }

    执行步骤分析:

    1. 循环初始化表达式最先执行,并且只执行一次

    2. 当循环条件表达式为true时,则执行循环体

      当循环条件表达式为fasle时,则跳出循环,执行循环外的语句

    3. 当循环体执行完毕,立刻执行循环后的操作表达式

    4. 当循环后的操作表达式执行完毕,立刻执行循环条件表达式,判断成不成立

    画图分析:
    在这里插入图片描述

    总结:

    1. 循环初始化表达式中声明的变量,称为循环变量

    2. 循环条件表达式返回结果必须是boolean类型,如果省略循环条件表达式,默认值为ture

    3. 循环初始化表达式和循环后的操作表达式没要求,语法编译能通过即可

      代码展示:

      public class ForTest{
          public static void main(String[] args){
              int i = 0;
              for(System.out.println("A");i < 3;System.out.println("C")){
                  System.out.println("B");
              }
          }
      }
      

      代码展示:

      public class ForTest{
          public static void main(String[] args){
              for(int i = 1,j = 5;j > -1;i += 2,j -= 3){
                  System.out.println("i = " + i + "j = " + j);
              }
          }
      }
      

    练习:

    1. 输出[1,100]之间的所有整数

      代码展示:

      public class ForTest{
          public static void main(String[] args){
              for(int i = 1;i <= 100;i++){
                  System.out.println(i);
              }
          }
      }
      
    2. 输出0(包含)到100(包含)之间的数, 分别以递增和递减的方式实现

      代码展示:

      public class ForTest{
          public static void main(String[] args){
              // 递增
              for(int i = 0;i<=100;i++){
                  System.out.println(i);
              }
              // 递减
              for(int i = 100;i>=0;i--){
                  System.out.println(i);
              }
          }
      }
      
    3. 输出1到100之间的奇数和偶数;

      代码展示:

      public class ForTest{
          public static void main(String[] args){
              for(int i = 1;i <= 100;i++){
                  if(i % 2 == 0){
                      continue;
                  }
                  System.out.println("奇数i = " + i);
              }
              for(int i = 2;int i <= 100;i+=2){
                  System.out.println("偶数i = " + i);
              }
          }
      }
      
    4. 输入一个正整数n,计算1+2+3+…+n的和

      代码实现:

      public class ForTest{
          public static void main(String[] agrs){
              java.util.Scanner input = new java.util.Scanner(System.in);
              System.out.print("请输入一个正整数:");
              int n = input.nextInt();
              int sum = 0;
              for(int i = 1;i<=n;i++){
                  sum += i;
              }
              System.out.println(sum);
          }
      }
      
    5. 输入一个正整数n,计算1-2+3-4+5-6+…-(n-1)+n的和

      代码展示:

      public class ForTest{
          public static void main(String[] args){
              java.util.Scanner input = new java.util.Scannner(System.in);
              System.out.print("请输入一个正整数:");
              int n  = input.nextInt();
              int sum = 0;
              for(int  i = 1;i<=n;i++){
                  if(i % 2 == 0){
                      sum -= i;
                  }else{
                      sum += i;
                  }
              }
              System.out.println(sum);
          }
      }
      
    6. 输出1到1000之间既能被5整除又能被3整除的数,并且每行输出5个。

      代码展示:

      public class ForTest{
          public static void main(String[] args){
              int count = 0;
             for(int i = 1;i<=1000;i++){
                 if(i % 5 == 0 && i %  3 == 0){
                     System.out.print(i + "\t");
                     count++;
                     if(count %  5 == 0){
                         System.out.println();
                     }
                 }
             }
          }
      }
      
    7. 请问以下代码执行完,循环后i的值是多少?

      public class ForTest{
          public static void main(String[] args){
              int i = 1;
              for(;i <= 3;i++){
                  System.out.println(i);
              }
              System.out.println(i); // 4
          }
      }
      

      答:循环后的i的结果是4

    while循环

    语法:

    while(循环条件表达式){

    ​ // 循环体

    }

    执行:

    1. 判断循环条件表达式是否成立,如果成立就执行循环体,否则跳出循环,执行循环外的语句
    2. 当循环体执行完毕,再次去判断循环条件表达式是否成立

    注意:循环后的操作表达式放在循环体前|后有本质区别,使用时一定切忌

    代码展示:

    public class ELTest{
        public static void main(String[] args){
            int i = 1;
            while(i<=10){
                System.out.println(i);
                i++;
            }
        }
    }
    

    代码展示

    public class ELTest{
        public static void main(String[] args){
            int i = 1;
            while(i <= 10){
                i++;
                System.out.println(i);
            }
        }
    }
    

    练习:

    1. 输出1到1000之间既能被5整除又能被3整除的数,并且每行输出5个

      代码展示:

      public class ElTest{	
          public static void main(String[] args){
              int count = 0;
              int i = 1;
              while(i<=1000)){
                  if(i % 5 == 0 && i % 3 == 0){
                      System.out.println(i + "\t");
                      count++;
                      if(count % 5 ==0){
                          System.out.println();
                      }
                  }
                 i++;
              }   	
          }
          }
      

    dowhile循环

    语法:

    do{

    // 循环体

    }while(循环条件表达式);

    注意:“循环后的操作表达式”在“循环体”的前|后面有本质区别,谨慎使用

    实例:类似生活中的先学习后考试,考试通过才能到下一阶段学习

    whiledowhile循环的区别

    while:先判断后执行,循环体可能一次也不会执行

    dowhile:先执行后判断,循环体至少会被执行一次

    循环执行的总结

    for循环最常用,while其次,dowhile几乎不用

    循环需要循环变量

    1. 循环变量需参与运算,一定要设置好初始值
    2. 循环变量不需要参与运算,只用于控制循环次数

    死循环不需要循环变量

    代码展示:

    public class DoWhileTest{
        public static void main(String[] args){
            int i = 1;
            do{
                System.out.println(i);
                i++;
            }while(i <= 10);
        }
    }
    

    练习:

    1. 输入[1,100]间的所有正整数

      代码展示:

      public class ShowNumTest{
          public static void main(String args[]){
              int i = 1;
              do{
                  System.out.println(i);
                  i++;
              }while(i<=100);
          }
      }
      

    关于死循环的讲解

    死循环:循环体始终执行,终止不了程序的运行

    死循环的分类:

    1. 对程序有害的死循环
    2. 对程序有利的死循环
    对程序有害的死循环:

    起因:每趟循环执行完毕都离循环的终止条件越来越远,属于逻辑错误

    代码展示:

    public class ForTest{
        public static void main(String[] args){
            for(int i = 1;i<=100;i--){
                System.out.println(i);
            }
        }
    }
    
    对程序有利的死循环:

    需求:不明确循环次数时,可使用死循环

    注意:死循环一般配合break关键字使用

    代码展示:

    public class Test{
    	public static void main(String[] args){
            int i = 0;
            do{
                i++;
                if(i == 3){
                    break;
                }
                System.out.println(i);
            }while(i < 10);
    	}   
    }
    
    死循环的用法

    针对for循环的死循环,省略“循环条件表达式”,默认为true(使用较少

    语法:

    for( ; ;){

    ​ // 循环体

    }

    代码展示:

    public class ForTest{
        public static void main(String[] args){
            for(;;){
                System.out.println("哈哈");
            }
        }
    }
    

    针对while循环的死循环,可读性强,语法便捷(最常用)

    语法:

    while(true){

    ​ // 循环体

    }

    代码展示:

    public class WhileTest{
        public static void main(String[] args){
            while(true){
                System.out.println("嘻嘻");
            }
        }
    }
    

    break关键字(最常用)

    使用场合:

    1. 循环(for、while{} 、do{}while();)
    2. switch语句

    作用:

    1. 若作用于switch语句,用于结束switch语句,执行switch语句外的代码
    2. 若作用于循环,用户结束当前循环,执行循环外的语句

    代码展示:

    // Switch 
    public class SwitchTest{
        public static void main(String[] args){
            java.util.Scanner input = new java.util.Scanner(System.in);
            int month =  input.nextInt();
            switch(month){
                case 1:
                case 2:
                case 12:
                    System.out.println("冬季");
                    break;
                case 3:
                case 4:
                case 5:
                    System.out,println("春季");
                    break;
                case 6:
                case 7:
                case 8:
                    System.out.println("夏季");
                    break;
                case 9:
                case 10:
                case 11:
    				System.out.println("秋季");
                    break;
                default:
                    System.out.println("季节不存在");
            }
        }
    }
    
    // for
    public class ForTest{
        public static void main(String[] args){
       		for(int i = 1;i<=10;i++){
    			if(i == 3){
                    break;
                }
                System.out.println(i);
            }
            System.out.println("over");
        }
    }
    
    // dowhile
    public class DowhileTest{
        public static void main(String[] args){
            int i = 0;
            do{
                i ++ ;
                if(i == 3){
                    break;
                }
                System.out.println(i);
            }while(i <= 9);
        }
    }
    
    // while
    public class WhileTest{
        public static void main(String[] args){
            int i = 0;
            while(i<=9){
                i++;
                if(i==3){
                    break;
                }
                System.out.println(i);
                
            }
            System.out.println("over");
        }
    }
    

    注意:break作用于离其最近的循环语句|switch语句

    画图分析:
    在这里插入图片描述


    return关键字

    使用场合:

    只能在方法中使用

    作用:

    结束当前方法

    returnbreak区别:

    break可用于结束当前循环,循环后的代码会正常执行

    return用于结束当前方法,循环后的代码将不会 被执行

    代码展示:

    public class ReturnTest{
     	public static void main(String[] agrs){
        	for(int i = 0;i< 9 ;i++){
                if(i == 3){
                    return;
                }
                System.out.println(i);
            } 
            System.out.println("over");
     	}
    }
    

    注意:在return&break之后不要书写任何代码,因为这些代码是死代码,永远不会被执行

    练习:

    1. 韩信点兵,三人一组余两人,五人一组余三人,七人一组余四人,请问需要多少士兵?

      代码展示:

      public class  ForTest{  
         public static void main(String[] args){
         		
              for(int i = 1;;i++){
                  if( i % 3 == 2 && i % 5 == 3 && i % 7 == 4){
                  	System.out.println("韩信点兵需要的人数为"+ i);
                      break;
                  }
                }
              
          }
      }
      

      总结:“死循环”一般和“break”关键字一起使用,当不明确循环次数时,建议直接使用死循环

    2. 输入一个任意整数,判断它是否为质数,如果是质数就输出“是质数”,否则输出‘不是质数’。

      质数:除了1和它本身之外,不能被其他数整除的正整数称质数。

      代码展示:

       // 方式一:
      public class MethodOne{
         public static void main(String[] args){
         		     Scanner input  = new Scanner(System.in);
           		 System.out.println("请输入一个正整数:");
            		 int  num = input.nextInt();
           		 boolean flag = true;
           	     for(int i = 2;i< num;i++){
               	 if(num % i == 0){
                    	flag = false;
                    	break;
               	 }
           	 }
           	 if(flag){
                	System.out.println("num 是一个质数,num = " + num);
           	 }else{
                	System.out.println("num不是一个质数,num = " + num);
            	}
      	}
      }
      
      // 方式二:
      public class MethodTWo{
      public static void main(String[] args){
         Scanner input = new Scanner(System.in);
         System.out.println("请输入一个正整数:");
         int num  = input.nextInt();
         int i = 2;
         for(;i < num;i++){
             if(num % i == 0){
                 break;
             }
         }
         if(num == i){
             System.out.println("num 是一个质数,num = " + num);
         }else{
             System.out.println("num不是一个质数,num = " + num);
         }
      }
      }
      

    continue关键字(使用较少)

    作用:

    结束当次本次循环,继续执行下一次循环

    使用场合:

    只能在循环中使用

    注意:在return、continue和break之后,不要写代码,因为这些是死代码,永远不会执行

    代码展示:

    public class ContinueTest{
        public static void main(String[] args){
            for(int i = 0;i<=10;i++){
                if(i == 2){
                    continue;
                }
                System.out.println(i);
            }
        }
    }
    
    
    public class ContinueTest{
        public static void main(String[] args){
            int i = 10;
            while(i<=20){
                if(i==15){
                    continue;
                }
                System.out.println(i);
                i++;
            }
        }
    }
    

    画图分析:
    在这里插入图片描述

    练习:

    1. 使用continue关键字实现输出1到100之间能被5整除的数

      代码展示:

      public class ContinueTest{
          public static void main(String[] args){
              if(int i = 1; i <= 100;i++){
              	if(i % 5 != 0){
                      continue;
                  }    
                  System.out.println(i);
              }
              
          }
      }
      

      嵌套循环

      特点:外出循环变量变化一次,内侧循环的循环变量完整执行一整遍

      注意:外侧循环用来控制行数,内侧循环用来控制空格数和星星数

      练习:

      1. 在控制台先打印矩形

        如图所示:
        在这里插入图片描述

        代码展示:

        public class Demo{
            public static void main(String[] args){
                for(int i = 0;i < 3;i++){
                    for(int j = 1;j < 10;j++){
                        System.out.prnt("*")
                    }
                    System.out.println();
                }
            }
        }
        
      2. 打印平行四边形

        如图所示:
        在这里插入图片描述

        代码展示:

        public class Test{
            public static void main(String[] args){
            	for(int i = 0;i < 4;i++){
        			// 内侧循环:用来控制空格数
        			for(int j = 0;j < i;j++){
        				System.out.print(" ");
        			}
        			// 内侧循环:用来控制星星数
        			for(int j  = 0;j < 9;j++){
        				System.out.print("*");
        			}
        			System.out.println();
        		}
            }
        }
        
      3. 打印等腰三角形

        如图所示:
        在这里插入图片描述

        代码展示:

        import java.util.Scanner;
        public class DouleLoopTest{
            public static void main(String[] args){
                Scanner input = new Scanner(System.in);
        		System.out.println("请输入行数");
        		int num = input.nextInt();
                // 外侧循环用来控制行数
        		for(int i = 0;i<num;i++){
                    // 内侧循环用来控制空格数
        			for(int j = 0;j< num - i - 1;j++){
        				System.out.print(" ");
        			}
                    // 内侧循环用来控制星星数
        			for(int j = 0;j < 2 * i + 1;j++){
        				System.out.print("*");
        			}
        			System.out.println();
        		}
            }
        }
        
      4. 打印菱形

        如图所示:
        在这里插入图片描述

        代码展示:

        import java.util.Scanner;
        public class DoubleLoopTest{
            public static void main(String[] args){
               Scanner input = new Scanner(System.in);
        	        System.out.print("请输入菱形的行数:");
        	        int length =  input.nextInt();
        	        // 外侧循环 : 用来控制行数
        	        for(int i = 0;i < length / 2 + 1; i++){
        	        	// 内侧循环1:用于控制空格数
        				for(int j = 0; j < length/2+1 - i - 1; j++) {
        					System.out.print(" ");
        				}
        				// 内侧循环2:用于控制星星数
        				for(int j = 0; j < 2 * i + 1; j++) {
        					System.out.print("*");
        				}
        				System.out.println();
        	    	}
        	         // 外侧循环用来控制行数
        	        for(int i = 0;i < length / 2;i++){
        	            // 内侧循环用来控制空格数
        	            for(int j = 0;j < i + 1;j++){
        	                System.out.print(" ");
        	            }
        	            // 内侧循环用来控制星星数
        	            for(int j = 0;j < 2 * (length / 2 - i -1) + 1;j++){
        	                System.out.print("*");
        	            }
        	            System.out.println();
        	        }
            }
        }
        
      5. 打印空心菱形

        如图所示:
        在这里插入图片描述

        代码展示:

        import java.util.Scanner;
        public class DoubleLoopTest{
            public static void main(String[] args){
                Scanner input = new Scanner(System.in);
                System.out.println("请输入菱形的行数:");
                int length = input.nextInt();
                for(int i = 0 ;i < length / 2 + 1;i++){
                    for(int j = 0;j < length / 2 + 1 - i - 1;j++){
                        System.out.print(" ");
                    }
                    for(int j = 0;j < 2 * i + 1;j++){
                        if(j == 0 || j == 2 * i){
                            System.out.print("*");
                        }else{
                            System.out.print(" ");
                        }
                    }
                    System.out.println();
                }
                for(int i = 0; i < length / 2 ;i ++ ){
                    for(int j = 0;j < i + 1;j++){
                        System.out.print(" ");
                    }
                    for(int j = 0;j < 2 * (length/2-i-1) + 1;j++){
                        if(j == 0 || j == 2 * (length/2-i-1)){
                            System.out.print("*");
                        }else{
                            System.out.print(" ");
                        }
                    }
                    System.out.println();
                }
                   
            }
        }
        
      6. 打印乘法口诀表

        如图所示:
        在这里插入图片描述

        代码展示:

        public class NineNineTable {
        	public static void main(String[] args) {
        		// 打印九九乘法口诀表
        		// 外侧循环控制行数
        		for(int i = 1;i <= 9;i++){	
        			for(int j = 1 ;j <= i;j++){
        				System.out.print(j+ "*" + i  + "=" + (j*i)+"\t");
        			}
        			System.out.println();
        		}
        	}
        }
        
      7. 输入[0,9]之间的一个数,输出数字构成的1~5位整数的和,如输入2,则计算出2 + 22 + 222 + 2222 + 22222之和

        代码展示:

        import java.util.Scanner;
        public class DoubleLoopTest01 {
        	public static void main(String[] args) {
        		Scanner input = new Scanner(System.in);
        		System.out.print("请输入[0,9]之间的整数:");
        		 int num = input.nextInt();
        		 int result = 0;
        		 int sum = 0;
        		 for(int i = 0;i < 5;i++){
        			 result *= 10;
        			 result += num;
        			 sum += result;
        		 }
        		 System.out.println(sum);
        	}
        }
        
      8. 搬砖问题:36块砖,36个人搬,男搬4块,女搬3块,两个小孩搬1块,要求一次搬完,问需要男、女、小孩各多少人?

        代码展示:

        public class DoubleLoopTest01{
            public static void main(String[] args){
                for(int x = 0;x < 9 ;x++){
        			for(int y  = 0 ;y < 12;y++){
        				for(int z = 0;z < 36;z += 2){
        					if(x+y+z == 36 && x * 4 + y * 3 + z / 2 == 36){
        						System.out.println("男人:" + x + " 女人:" + y + " 小孩:" + z);
        					}
        				}
        			}
        		}
            }
        }
        

        此文章于11月25日编辑完毕,小编也是个初学者,或许有些内容写的有错误的,我对自己的要求是:有错改之,无错加勉。还望大家能在评论区指点迷津,不胜感激,同时也希望大家口下留情!!

    展开全文
  • 第四课 Python while 循环次数限制

    万次阅读 2018-06-25 14:42:22
    一:定义三个初始值number为初始执行次数 二:while 判断限制为3次 三:进入循环体再进行if判断,如果成立则跳出循环 四:number执行次数加1 五:while后加else代表循环结束后执行的内容 #!/usr/bin/env ...

    一:定义三个初始值 number为初始执行次数

    二:while 判断限制为3次

    三:进入循环体再进行if判断,如果成立则跳出循环

    四:number执行次数加1

    五:while后加else代表循环结束后执行的内容

    #!/usr/bin/env python3
    # -*- coding: utf-8 -*-
    # @Author:
    # @Date  : 2018/6/25
    
    b = 8
    a = 0
    number = 0
    while number < 3:
    
        a = int(input("lucky number:"))
    
        if a > b:
            print("小一点!")
        elif a < b:
            print("大一点!")
        else:
            print("Bingo!")
            break
    
        number += 1
    
    else:
        print("次数已用完!")

    解释:如果输入的a大于b,则输出:小一点;又如果输入的a小于b,则输出:大一点;如果a等于b,则输出bingo跳出循环,循环一次number次数加1,如果number不小于3时则循环结束,输出:次数已用完

    执行结果:

    展开全文
  • do_while循环练习

    2017-07-27 07:17:47
    实现菜单切换:如果用户输入错误,可以重复输入,知道输入正确,执行相应的操作后退出循环
  • php中的while循环循环执行代码块制定的次数,或者当指定的条件为真时循环执行代码块。 ————————————————————- 在我们编写代码是时候,我们经常需要一块代码块重复执行多次。我们就可以使用...
  • While循环位于结构子选板“编程→结构→While循环”,同时也存在于选板“Express→执行过程控制→While循环”,如图1所示。结构子选板中的While循环执行过程控制子选板中的While循环用法和作用是相同的,只不过在...
  • while循环语法格式与执行流程

    千次阅读 2020-07-17 20:52:38
    语法格式 while(条件表达式){ 循环体语句; ... //while循环条件语句在while循环之前进行变量初始化 int sum = 0; //这是声明一个存放1-100之和的变量 while(i <= 100){ sum += i; //进
  • PHP 循环While 循环

    2021-01-03 03:54:29
    循环执行代码块指定的次数,或者当指定的条件为真时循环执行代码块。 PHP 循环 在您编写代码时,您经常需要让相同的代码块一次又一次地重复运行。我们可以在代码中使用循环语句来完成这个任务。 在 PHP 中,提供了...
  • // 循环次数未知, 循环终止条件已知(建议用while循环): 先求项, 再判断, 满足则累加 例: //求Π(pai)值 //Π/4=1-1/3+1/5-1/7+... //求Π值, 直到最后一项的绝对值小于10的-6次幂 //while: 项-->判断-->求和 #...
  • 关于for循环和while循环中的次数问题

    千次阅读 2015-07-08 23:55:33
    每当使用到for 和 while循环,到底循环多少次的问题每次都搞的我头脑很乱,不能专注于更重要的实现。今天,解决了: 画个表,一列表示一次。 这样,多少次,在脑海中很清晰。
  • while循环是Shell脚本中最简单的一种循环,当条件满足时,while重复地执行一组语句,当条件不满足时,就退出while循环。 Shell while 循环的语法结构: while condition do statements done 这里condition表示判断...
  • 基于while和for 循环次数的确定

    千次阅读 2018-07-21 09:29:56
    不用太多话,但是很重要。 对于while来说,内置i++的情况下,,如下图: i=1; while(i&lt;=k) //k是有一个值 { ...执行 k-i+1 个语句。这是显而易见的,但是,在复杂情况下总是会弄混。  ...
  • 由以下while构成的循环循环执行次数是( )。  int k=0;  while ( k= -1 ) k++; A)无限次 B)一次也不执行 C)执行一次 D)有语法错,不能执行
  • 使用for循环和while循环都可以去实现,那么到底两者之间有什么区别? 1、从内存角度考虑: 局部变量在栈内存中存在,当...如果一个需求明确循环的次数,那么使用for循环(开发中使用for循环的几率大于while循环)如果一个...
  • int i=1; while(i&amp;amp;lt;=10){//条件 代码执行区 i++;//改变条件 } 条件i&amp;amp;lt;=10时,代码重复执行,直到条件不满足是,跳出循环
  • 但是一旦环境出问题或者其他的原因导致接口一直没有返回预期的结果跳出这个while controller循环,这样会导致线程一直处于运行状态无法自动结束,所以这里在while Controller中的条件可以增加一些轮询次数判断,一旦...
  • do-while循环while循环的区别是do-while的循环体至少被执行一次,
  • 1)while循环语句一般是通过一个变量控制其循环的次数。 2)while循环语句的循环体代码如果只有一个语句的时候,那么可以省略大括号。但是和if判断语句一样不建议大家省略。 3)while循环语句的判断条件后面不能跟...
  • 9.6 MATLAB while循环结构

    千次阅读 2016-12-05 21:34:10
    while循环在一个逻辑条件的控制下重复执行一组语句一个不定的次数,匹配的end语句描述该语句。while循环体的具体语法结构如下: while expression  commands end 说明: (1)在while和end之间的命令组被称为...
  • 执行循环体,再进行判断 while(a!=0) { cin&amp;gt;&amp;gt;a; cout&amp;lt;&amp;lt;a&amp;lt;&amp;lt;endl; } 改进版 while(true) { cin&amp;gt;&amp;gt;a; ...
  • while循环定义: 满足判断语句时进入循环,进入循环后,当判断语句不满足时,跳出循环。 基本形式: While 判断语句: 执行语句 实例: 代码: #coding=utf-8 print("打卡开始") count = 1 #定义一个整数,表示...
  • while和do while循环结构

    2020-01-14 18:41:14
    while循环 while循环的语法 while ( 条件表达式) { 循环体; } 注意: 当条件表达式的结果为真的时候,执行内部循环体;然后再判断条件表达式的真假。 当条件表达式的结果为假的时候,结束循环 while循环的末尾不要...
  • dos 实现while循环

    2021-01-02 10:26:34
    面临问题 最近需要进行并发测试,面临以下问题: 因需要同时执行多个dos批理脚本,..._main.bat: 为主脚本,主要负责控制循环次数,并调用实际业务功能脚本; t1.bat:为实际的业务脚本,可根据实际情况扩展; 脚本:
  • while循环

    万次阅读 2020-01-10 17:19:07
    while循环 while语句用于循环执行程序,执行过程依赖指定条件 语法: while(条件表达式): 语句块 示例 x = 5 count = 1 while(x<=20): print("第%s次循环输出:"%count,x) x = x + 5 count = count...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 146,114
精华内容 58,445
关键字:

while循环执行次数