精华内容
下载资源
问答
  • 特殊for循环嵌套执行的次数

    千次阅读 2020-06-12 16:16:02
    for(i=1;i<=n;i*=2) for(j=1;j<=i;j++) laugh++; 请解释一下这里laugh++执行了多少次?...内层for循环上限i的取值为1 2 4...所以,总循环次数为 Sn = 2*(1-)/(1 - 2) + 1 =- 1, 代入k值有:(<=n 且是2的倍数) ...

    for(i = 1; i<=n; i*=2)
      for(j=1; j<=i; j++)
           laugh++;
    请解释一下这里laugh++执行了多少次?

    设循环k次,则有 {n}' = 2^{^{k-1}} \rightarrow k = log_{2}{n}'+1({n}'<=n 且 {n}'是2的倍数)

    内层for循环上限i的取值为1 2 4 8 .... 2^{^{k-1}},是一个等比数列;

    所以,总循环次数为  Sn = 2* (1-2^{^{k-1}})/(1 - 2) + 1 = 2^{k} - 1, 代入k值有: 2^{\log_{2}{n}'+1}-1 ({n}'<=n 且 {n}'是2的倍数)

    当n=11时,{n}'=8,代入得到次数为15;

    展开全文
  • while循环和for循环的区别

    万次阅读 多人点赞 2018-08-04 11:45:59
    for循环适合已知循环次数的操作,while循环适合未知循环次数的操作。另外还有一个do...while...的循环;   1、for循环:适合循环次数是已知的操作。如: int number = 10; for(int i = 0;i &lt;= number;i++...

    for循环适合已知循环次数的操作,while循环适合未知循环次数的操作。另外还有一个do...while...的循环;

     

    1、for循环:适合循环次数是已知的操作。如:

    int number = 10;
    for(int i = 0;i <= number;i++){
        system.out.print(i + "\t");
    }

     

    2、while循环:适合循环次数是未知的操作。如:

    int number = 0;
    while(number < 10){
        system.out.print(number + "\t");
        number++;
    }

     

    3、do...while...循环:适合至少执行一次的循环操作(注:while循环需要有“;”结尾)。如:

    boolean flag;
        do{
    	flag = false;//自我的约定,标识。 false代表没有输入错误,true输入错误了
    	System.out.println("------------------欢迎使用XXXATM自助服务------------------");
    	System.out.println("1.存款  2.取款  3.转账  4.查询余额  5.修改密码  6.退出");
    	int choice = input.nextInt();
    	switch(choice){
    	    case 1:
    	        save();//存款
    //	        showMenu();
    		flag=true;
    		break;
    	    case 2:
    		take();//取款
    //		showMenu();
    		flag=true;
    		break;
    	    case 3:
    		transfer();//转账
    //		showMenu();
    		flag=true;
    		break;
    	    case 4:
    		checkBalance();//查询余额
    		flag=true;
    		break;
    	    case 5:
    		updatePwd();//修改密码
    		break;
    	    case 6:
    		return;
    	    default:
    		System.out.println("输入错误,请重新输入!");
    		flag = true;//输入错误了,应该循环了
    		break;
            }
        }while(flag);

     

    展开全文
  • for循环的经典程序分析

    千次阅读 2016-07-22 22:48:44
    1.单层for循环,利用for循环打印输出1~100之间的所有整数(最基础的)然后通过与if-else语句结合实现更多的功能。 可以看出利用for循环可以遍历整数。/* 1. 输出从1到100之间所有的整数;(简单的单层for循环)**for...

    1.单层for循环,利用for循环打印输出1~100之间的所有整数(最基础的)然后通过与if-else语句结合实现更多的功能。
    可以看出利用for循环可以遍历整数

    /*
        1. 输出从1到100之间所有的整数;(简单的单层for循环)**for循环遍历整数**
        2. 输出从1到100之间所有的奇数;(通过与if-else结合,有条件的输出语句)
        3. 输出从1到100之间所有不能被3整除的数;并输出这些整数的和;(通过增加条件,更合理的练习for循环与if语句结合)
    */
    public class NumberFor {
    
        public static void main (String[] args) {
            //这里利用输出语句打印一个提示语句
            System.out.println("输出从1到100之间所有的整数;");
            //输出从1到100之间所有的整数;
            for (int i = 1; i < 100; i++) {
            /*
                i 为循环因子,根据题意i要初始化为1,i < 100,每个整数都要打印,因此迭代语句自增为1.
                程序执行1~100(没有100)共99次 次数:计算方法(100-1)
            */
                //循环体
                System.out.print(i + " ");
            }
    
            System.out.println("\n" + "输出从1到100之间所有的奇数;");
            //输出从1到100之间所有的奇数
            for (int i = 1; i < 100; i++) {
                //设置条件判断,有条件的输出循环
                if (i % 2 != 0) {
                    System.out.print(i + " ");
                }
            }
    
            System.out.println("\n" + "输出从1到100之间所有不能被3整除的数;并输出这些整数的和");
            //输出从1到100之间所有不能被3整除的数;并输出这些整数的和
            //最后要输出整数的和,要提前声明一个保存和的变量
            int sum = 0;
            for (int i = 1; i < 100; i++) {
                if (i % 3 != 0) {
                    //每次循环都进行判断,若真执行{}中语句
                    System.out.print(i + " ");
                    //将符合条件的i进行累加
                    sum += i;
                }
            }
            System.out.println("\n" + "这些数的和为:" + sum);
        }
    }

    2.嵌套for循环
    先利用for循环打印一个简单的矩形
    矩形形式:

    *****
    *****
    *****  每一行5个星星,共有3行

    思路:若我们每次输出一行5个星星,我们循环3次就可以完成矩形

    class LoopTest1 {
        public static void main(String[] args) {
            //可以称i为循环因子 需要打印3行,循环次数为3(0 1 2)在i = 3时不满足条件,结束循环。
            for (int i = 0; i < 3; i++) {
                //循环体,每次输出5个星星并换行
                System.out.println("*****");
            }
        }
    }

    深入思考,我们是不是也可以把每次输出5个星星这个语句转化成每次输出一个星星,循环输出5次然后构成循环。
    思路:依旧用一个循环控制行数,因为每行都要输出5个星星,因此在i = 0时,它要执行一个循环输出*的循环。i = 1 i =2 都要这样,就得到下面这个嵌套循环程序

    class LoopTest2{ 
        public static void main(String[] args) {
            //外循环控制行数(外循环的循环体是一个内循环)
            for (int i = 0; i < 3; j++) {
                //i :0~3 共3次
                //内循环控制列数,这个循环用来循环输出5个星星
                for (int j = 0; j < 5; i++) {
                    //内循环循环体 j:0~5 共5次 每次打印一个星星
                    //这里不要换行,因为在同一行上打印
                    System.out.print("*");
                }
                //内循环执行完成后进行换行
                System.out.println();
            }
        }
    }

    综上:若是把LoopTest1中的i < 3 ,3改为n的话就可以打印输出n行
    若是把LoopTest2中的j < 5,5改为m的话每行就可以打印输出5个星星,总结一下,可以把外层循环看做控制行数,内层循环控制列数。自己多做几个程序,多思考几次就可以体会到这句话真正的含义了。
    那么打印一个n*m的矩形易如反掌,下面是打印n*m矩形的程序。

    class LoopTest3{
    
        public static void main(String[] args) {
            //从命令行获取n,m
            int n = Integer.parseInt(args[0]);
            int m = Integer.parseInt(args[1]);
            //外循环控制行数
            for (int i = 0; i < n; i++) {
                //外循环控制列数
                for (int j = 0; j < m; j++) {
                    System.out.print("*");
                }
                //内层循环执行完后,进行换行
                System.out.println();
            }
        }
    }

    熟练掌握for嵌套循环可以打印一个空心矩形,下面代码供参考。

    /**
        打印n*m的空心矩形
    */
    public class TestFor {
    
        public static void main(String[] args) {
            //从命令行获取n,m
            int n = Integer.parseInt(args[0]);
            int m = Integer.parseInt(args[1]);
    
            for (int i = 0; i < n; i++) {
                //将首尾行与其他行分开打印
                if (i == 0 || i == n-1) {
                    //打印首尾行
                    for (int j = 0; j < m; j++){
                        System.out.print("*");
                    }
                }else {
                    //打印其他行
                    for (int j = 0; j < m; j++) {
                        //其他行,控制首列和尾列的打印
                        if(j == 0 || j == m-1) {
                            System.out.print("*");
                        }else {
                            System.out.print(" ");
                        }
                    }
                }
                System.out.println();
            }
        }
    }

    3.嵌套循环深入

    /*
    分析过程:
        打印等腰三角形(高度为5)
        底边长度为9     1 3 5 7 9 
        空格数 i            *
            4  0    *       1    
            3  1   ***      3
            2  2  *****     5
            1  3 *******    7
            0  4*********   9
    
            * = 2i + 1      *与行数成正比     y=kx+b
         空格 = 4-i = 5-1-i 空格与行数成反比
    
    */
    public class TestFor {
    
        public static void main(String[] args) {
    
            for(int i = 0; i < 5; i++) {
                //从0行开始
            //程序顺序执行,先打空格,空格与行数的关系 5-1-i//5-(i+1)
                //这里j因为不在同一个{}中,所以都可以用j
                for(int j = 0; j < (5 - 1) - i; j++) {
                    System.out.print(" ");
                }
                //星星打印数1 3 5 7 9 与行数关系(2*行数)+1
                for (int j = 0; j < (2 * i) + 1; j++) {
                        System.out.print("*");
                }
                //换行
                System.out.println();
            }
        }
    }
    /*
        拓展一下,打印高度为n的等腰三角形
        实际只需要将外层循环5换成n就好
    */
    class TestFor1 {
        public static void main(String[] args) {
            //从命令行获取参数
            int n = Integer.parseInt(args[0]);
            //设置外循环控制行数
            for (int i = 0; i < n; i++) {
                //设置内循环控制列中空格的打印
                for (int j = 0; j < n - 1 - i; j++) {
                    System.out.print(" ");
                }
                //设置并列内循环控制列中*的打印
                for (int j = 0; j < (2 * i) + 1; j++) {
                    System.out.print("*");
                }
                //换行
                System.out.println();
            }
        }
    }

    总结:要想使用好循环,首先要观察问题的规律,找出要循环的步骤,直接套用即可。多做循环的题体会循环。

    4.嵌套循环中最高难度的for循环问题(打印质数的问题)

    首先要了解质数的定义,质数:只能被1和其本身整除的数就是质数。1不是质数

    从定义可以知道,若是我们正向考虑,问题极为的复杂,要先找出其所有能被整除的数,然后判断除了1和它本身以外还有其他的吗?若有不是质数,若没有,就是质数。
    这样,我们反向考虑,问题就变得异常简单。

    思路:首先我们要会遍历一个范围内的整数,这个利用简单的单层循环实现,其次对于每一个整数,我们先假设它是质数,然后利用反证法只要找出一个能被它整除的数就可以将它推翻。若找不出能被它整除的数,则它是质数。

    /*
        打印100-200之间的所有质数,并统计个数
        这个题,共有两个问题。
        1.打印100~200所有质数
        2.统计质数的个数
    
        思路:利用反证法
            质数的个数统计应该和质数输出在同一个{}中
    */
    class TestFor1 {
        public static void main(String[] args) {
            //设置计数器,用于统计质数的个数
            int count = 0;
            //利用for循环遍历100~200所有整数,不包括200.
            for (int i = 100; i < 200; i++) {
                //先假设i为质数,利用反证法 设置一个布尔变量,值为true时为质数,值为false时,不是质数
                boolean flag = true;
                //设置内循环对每个数进行判断
                //质数:只能被1和自身整除的数
                for (int j = 2; j < i; j++) {
                    //设置条件判断,若存在可以被整除的数(除1和自身),修改flag为flase,只要存在一个就可以推翻。
                    if(i % j == 0) {
                        flag = false;
                        break;  //此处加个break优化代码,只要找到一个,利用break结束当前循环的特性,直接结束内层循环。
                    }
                }
                //内循环判断质数执行完毕,通过判断flag,打印输出质数,并统计个数
                if(flag) {
                    //打印输出质数
                    System.out.println(i + "是质数");
                    //个数自增
                    count++;
                }
            }
            //打印统计的个数
            System.out.println("质数的个数为:" + count);
        }
    }

    会打了上边的这个求质数的代码,来分析一个更深层次的问题。
    打印1~100内的质数(只打印参数个质数就行,尽可能的优化代码)

    /**
        利用continue,break简化质数的打印
        打印1~100之间的质数(要求打印参数个质数)
    */
    class TestFor2 {
    
        public static void main(String[] args) {
            //从命令行获取参数
            int n = Integer.parseInt(args[0]);
            //设置计数器
            int count = 0;
            //循环遍历2~100(因为1不是质数),并设置标签l1
            l1:for (int i = 2; i < 100; i++) {
                //设置循环判断i能否被除1和其本身之外的数整除,默认认为i是质数
                //因为利用continue加标签所以不用使用再进行最后的真假判断
                l2:for (int j = 2; j < i; j++) {
                    //设置条件判断,若i不是质数,利用continue l1 结束当次循环,(这里的当次循环指的是标签处外循环)
                    // 进入下一次循环(外层循环的迭代语句)
                    if (i % j == 0) {
                        continue l1; 
                    }
                }
                //内循环结束打印输出质数
                System.out.println(i + "是质数");
                //计数器自增1
                count++;
                //判断输出的质数是否符合题意,若符合利用break结束循环(结束的是break所属的循环即外层循环)
                if(count == n){
                    break;
                }
            }
        }
    }

    如果能解决掉上述问题,对for循环的理解和使用非常熟练。
    利用for循环还可以打印直角三角形,倒直角,99乘法表等等。如果会了上边的for循环,这些问题手到擒来。重点是灵活运用java中的基础知识,互相结合得到更多的东西。

    展开全文
  • 本节将探讨嵌套for循环、break、continue,还有for-else(for循环也可以与else搭配的!) 返回到for循环内容,我们看看与for循环相关的其他高级功能,比如,嵌套for循环、中途break退出整个for循环,以及仅终止当前...

    本节将探讨嵌套for循环、break、continue,还有for-else(for循环也可以与else搭配的!)

    返回到for循环内容,我们看看与for循环相关的其他高级功能,比如,嵌套for循环、中途break退出整个for循环,以及仅终止当前循环的continue指令等。

    1.嵌套for循环

    for r in range(1,10):
        for c in range(1,r+1):
            print(f'{c}×{r}={c*r:<2d}',end=' ')
        print("")
    

    上述代码的输出结果如下所示,是一个非常漂亮规整的乘法口诀表。

    1×1=1
    1×2=2  2×2=4
    1×3=3  2×3=6  3×3=9
    1×4=4  2×4=8  3×4=12 4×4=16
    1×5=5  2×5=10 3×5=15 4×5=20 5×5=25
    1×6=6  2×6=12 3×6=18 4×6=24 5×6=30 6×6=36
    1×7=7  2×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49
    1×8=8  2×8=16 3×8=24 4×8=32 5×8=40 6×8=48 7×8=56 8×8=64
    1×9=9  2×9=18 3×9=27 4×9=36 5×9=45 6×9=54 7×9=63 8×9=72 9×9=81
    

    简单分析一下上面的四行代码:

    • 从上述代码的缩进关系可以看得出来,第2个for循环完全包含在第1个(外层)for循环内,与第2个print函数所在行是并列关系,两者均包括于外层for循环的程序块中;
    • 对于这种嵌套for循环,外层for循环每执行一次循环,紧贴着的内层for循环却要完整地执行所有循环,以此类推,还可以继续嵌套第3层、第4层for循环…
    • 在上述例子中,外层for循环用于乘法口诀表在“行”上的控制(r变量标识第r行),内层for循环用于在每行内部“列”上的控制(c变量标识第c列,一个完整的乘法算式代表一列);
    • 外层for循环从r=1、2、3一直循环至9;内层for循环每次循环的次数跟所在行数(即r)相关,比如,第1行(此时r=1),只循环一次(c=1),只打印一列(即:1×1=1),第2行(此时r=2),循环两次(c=1、2),打印两列(即:1×2=2 2×2=4),依次类推,所以c的循环序列为range(1,r+1);
    • 对于内层for循环中的print函数,输入了两个参数,第1个参数是一个采用f-string格式化的字符串,为了整齐划一,对乘法结果采用了左对齐、统一按2个字符的宽度;第2个参数,采用的是关键字参数(以后函数章节会详细讲解),参数名为“end”,传入的参数值为一个空格字符串,要是不传入该参数,默认情况下,每一次print函数调用,都会在结尾(即“end”处)多输出一个换行符(相当于输出了一个“\n”字符串),导致打印换行了,要是主动传入该参数的话,每次print调用则在结尾处输出一个我们通过“end”关键字参数传入的空格字符串(正好用于每列间隙),而不再是默认的换行符了;
    • 内层的for循环把当前行完整打印输出完毕后,我们则需要换行了,这正是上述代码中第二个print的作用,虽然看似打印的是空字符串,但实际的输出正如上面讲到的,print函数默认会多输出一个换行符,正好满足了我们的要求。

    2.break与continue

    当break关键字包含在for循环程序块中时,break指令会直接终止当前整个循环的执行,需要注意的是,若存在多层for循环嵌套,此时终止的只是包含break的最内层for循环(紧贴break的for循环);当continue关键字包含在for循环程序块中时,continue指令会提前结束本轮循环,直接开始下一轮循环。这两个指令通常配合if-else语句一块使用,如下所示。

    for n in range(1,3):
        print('*'*10+f'第{n}次外部循环'+'*'*10)
        for i in range(1,11):
            if i > 5:
                print(f'i={i},>5,break退出整个内层for循环')
                break
            if i % 2 != 0:
                print(f'i={i},奇数,直接返回到内层for循环行,continue下一个i')
                continue
            print(f'i={i},成功找到一个小于等于5的偶数!')
    

    上述代码的输出结果如下所示:

    **********第1次外部循环**********
    i=1,奇数,直接返回到内层for循环行,continue下一个i
    i=2,成功找到一个小于等于5的偶数!
    i=3,奇数,直接返回到内层for循环行,continue下一个i
    i=4,成功找到一个小于等于5的偶数!
    i=5,奇数,直接返回到内层for循环行,continue下一个i
    i=6,>5,break退出整个内层for循环
    **********第2次外部循环**********
    i=1,奇数,直接返回到内层for循环行,continue下一个i
    i=2,成功找到一个小于等于5的偶数!
    i=3,奇数,直接返回到内层for循环行,continue下一个i
    i=4,成功找到一个小于等于5的偶数!
    i=5,奇数,直接返回到内层for循环行,continue下一个i
    i=6,>5,break退出整个内层for循环
    

    简单解释一下上述代码:

    • 采用两层了for循环嵌套(其中,外层for循环2轮),从输出的结果可以证明:内层for循环中的break只会终止内层紧贴其的for循环,对外层for循环不影响;
    • 内层for循环本应该从i=1、2到10,共循环10轮,可是当i=6时,大于5了,执行至break语句时,终止了整个内层for循环的执行,然后继续该for循环以外的其他指令的执行;
    • 内层for循环过程中,当出现i为奇数(即i除以2余数不为0时),会遇到continue语句,会终止本轮for循环下面其他语句的执行(即:不会执行“成功找到一个小于等于5的偶数!”那行的print指令),直接返回到该for循环(内层for循环)的首行,从队列中取下一个i的值,执行下一轮循环;
    • 所以,在内层for循环过程中,只有i小于等于5且为偶数时(即确保不会进入break、continue分支时),才会执行至打印“成功找到一个小于等于5的偶数!”

    3.for-else搭配

    直接看下述代码即可,所有关于代码的解释及输出均以注释的形式融入在代码中了。所谓代码中的“注释”,是用作给程序开发者们看的,Python程序在执行时,解释器会忽略所有的注释行。有两种注释的方法:

    • 单行注释一般采用以“#”开头,“#”及本行内“#”后面的所有内容会被作为注释;
    • 对于多行注释,一般包含在三引号里面(采用三个紧连着的单引号 ‘’’ 或者三个紧连着的双引号 “”"),对于单引号或者双引号的选择,注释的首尾必须保持一致(要么首尾都是三个单引号,或者首尾都是三个双引号),另外,要是注释内容里面本身包含了三个紧连着的单引号,则应选择三个双引号把其注释起来,反之同理。
    # 如下代码所示,range(1,1)返回的是一个空队列(列表),
    # 因此不会进入for下面的程序块,
    # 而是直接跳入到else下面的程序块。
    for i in range(1,1):
        print("1.进入for分支!")
    else:
        print("1.进入else分支!")
    """
    输出结果为:
    1.进入else分支!
    """
    
    # 如下代码所示,因range(1,3),
    # 会进入for下面的程序块2次(i=1、2),
    # 队列穷尽后,进入else下面的程序块。
    for i in range(1,3):
        print(f'2.进入for分支:i={i}')
    else:
        print(f'2.进入else分支!')
    """
    输出结果为:
    2.进入for分支:i=1
    2.进入for分支:i=2
    2.进入else分支!
     """
    
    # 如下代码所示,因range(1,3),
    # 会进入for下面的程序块2次(i=1、2),
    # 且在最后一次会执行continue,
    # 但并不影响在队列穷尽后,进入else下面的程序块。
    for i in range(1,3):
        print(f'3.进入for分支:i={i}')
        if(i>=2):
            print('3.continue')
            continue
    else:
        print(f'3.进入else分支!')
    """
    输出结果为:
    3.进入for分支:i=1
    3.进入for分支:i=2
    3.continue
    3.进入else分支!
     """
    
    # 如下代码所示,因range(1,3),
    # 会进入for下面的程序块2次(i=1、2),
    # 在第2次时会执行break,
    # break直接会跳出整个for循环,
    # 连带else也会忽略。
    for i in range(1,3):
        print(f'4.进入for分支:i={i}')
        if(i>=2):
            print('4.break')
            break
    else:
        print(f'4.进入else分支!')
    
    """
    输出结果为:
    4.进入for分支:i=1
    4.进入for分支:i=2
    4.break
     """
    

    简单总结一下for-else语句:

    • “for”关键字应与其对应的“else”垂直对齐,此时的“else”是“for”语句中的“else”,而不是“if”语句中的“else”,再一次证明了在Python编程时,对齐与缩进的重要性,一不小心多了几个空格或者少了几个空格,直接导致程序逻辑的错误。
    • 当for语句完成其所有队列(列表,应该用“迭代对象”更准确,以后章节会讲到,这里仅为了大家容易理解)的循环,或者for语句中的队列(列表)为空时,若存在else子句,才会执行else子句(即:要么是空/无循环、要么完成了所有循环);但是,若在循环过程中因为break指令导致了提前退出循环,else子句不会被执行。
    • 一句话,仅当执行break导致从for循环意外退出时,才不会进入for循环的else分支,除此之外,在for循环正常穷尽完毕列表后(包括列表为空),都会进入for循环的else分支。在else分支里可以安排for循环正常执行完毕后的收尾工作。
    • 特别说明一下,for循环的else处理分支一般使用的比较少,了解并能看懂相关代码即可。

    青少年、零基础、初学者Python编程从入门到精通,“老马带小马 一块学Python”编程系列

    展开全文
  • 《数据结构 1800题》

    热门讨论 2012-12-27 16:52:03
    14. 计算机执行下面的语句时,语句 s的执行次数为 _______ 。【南京理工大学 2000二、1(1.5分)】 FOR(i=l;i;i++) FOR(j=n;j>=i;j--) s; 15. 下面程序段的时间复杂度为________。(n>1) sum=1; for (i=0;...
  • for循环可以设置次数,while循环条件满足没有次数限制。 两种循环在构造死循环时的区别: while循环里的条件被看成表达式,因此,当用while构造死循环时,里面的TRUE实际上被看成永远真的表达式,这种情况容易...
  • LabVIEW使用For循环的错误

    千次阅读 2018-02-23 18:11:18
    当循环设置0次,此时,For循环未执行,输出空,即“数组”、“数组2”空数组。此小问题,谨记。此种情况可能出现在以数组作为For的循环次数控制...
  • 批处理之 FOR循环

    千次阅读 2018-01-16 11:44:58
    转自脚本之家,感谢作者与版主给我这次学习的机会 基本格式 (这里写的是在命令行里用的格式,...参数:FOR分四种参数 D L R F,并且有的参数还可附加另外的选项下面会分别介绍 变量:(记住如果是在批处理中使用
  • 浅谈 for循环

    千次阅读 多人点赞 2020-02-10 01:14:44
    浅谈for循环for循环习题讲解 文章多看几遍吧~相信你一定会收获不少哇~ 什么是循环? 我认为循环就是把一个步骤一直重复执行的操作。如果没有终止条件,那么这一步骤就会一直执行下去,直到地老天昏。书本...
  • 学习算法的时间复杂度的渐进表示时所遇到的一个例子:计算多层for循环嵌套时的语句频度。语句频度即执行最多的语句(基本语句)重复执行的次数。 for(int i=1;i<=n;i++) for(int j=1;j<=i;j++) for(int k...
  • 利用for循环打印图形

    千次阅读 多人点赞 2019-03-30 11:41:01
    利用for循环打印图形 利用for循环打印图形时,我们需要记住外层循环列,内层循环行,然后们需要做的不外乎是找到它们循环的规律罢了。 打印矩形图形 打印: ***** ***** ***** ***** 此图形是一个4行5列的矩形,...
  • DOS 批处理命令For循环命令详解

    千次阅读 2018-11-08 10:10:01
    for命令是一种对一系列对象依次循环执行同一个或多个命令的在命令行或批处理中运行的命令,结合一些Windows管理中的程序后,其处理功能强大、应用灵活方便程度令人刮目相看。但是,其帮助信息也因此复杂往往令初学者...
  • c++ for循环执行流程

    千次阅读 2020-03-17 11:37:19
    c++中的for循环是一种很基本,而且...for循环允许您编写一个执行特定次数的循环的重复控制结构。 语法 C++ 中for循环的语法: for ( init; condition; increment ) { statement(s); } 下面是 for 循环的控制流...
  • Python语言中的for循环直接迭代对象集合中的元素,如果需要在循环中使用索引下标访问集合元素,则可以使用内置的enumerate()函数 enumerate()函数用于将一个可遍历的数据对象(例如列表、元组或字符串)组合一个...
  • Python的range函数与for循环语句

    千次阅读 2020-01-13 20:00:55
    Python的range函数与for循环语句 米粒教育 发布时间:18-11-1518:49 介绍Python for循环语句和range函数的使用,文中主要讨论for循环语句,Python的for循环语句类似于shell或是脚本语言中的foreach循环,可以迭代...
  • 对可迭代对象进行for循环

    千次阅读 2018-03-16 20:30:59
    一:for循环的定义 for循环是对可迭代对象进行迭代的过程。 看到这个定义,很多萌新肯定会问了:到底什么是迭代,什么是可迭代对象呢?首先,迭代就是从可迭代对象逐个读取元素,直到可迭代对象中的元素都被读取...
  • 使用for循环打印星星

    万次阅读 多人点赞 2017-12-05 20:47:26
    for循环:1.有大括号与无大括号的区别: 循环体只能有一条语句, 如果需要执行的语句超过一条,就要加大括号将它们变为一条复合语句 //for循环如此,while循环也是如此. for(int i=1; i; i++) printf(" A "); ...
  • python中的for循环及函数应用

    万次阅读 2019-02-25 09:41:20
    一、PYTHON中的for循环 a = [1,2,3] for i in a:  print(i) 注意:这与Java中有所不同,while是满足了某个条件,就开启循环;而for循环强调的是遍历某一数据对象 可迭代对象例子: 1.for循环遍历列表: d={'...
  • 前端面试题

    万次阅读 多人点赞 2019-08-08 11:49:01
    判断一个字符串中出现次数最多的字符,统计这个次数 77 写一个获取非行间样式的函数 77 事件委托是什么 78 闭包是什么,有什么特性,对页面有什么影响 78 解释jsonp的原理,以及什么不是真正的ajax 79 ...
  • 测试开发笔记

    万次阅读 多人点赞 2019-11-14 17:11:58
    135 Test Lab 测试执行模块 135 第十六章 PYTHON 137 Python的安装 137 Python的集成环境: 137 数据类型: 137 运算符: 137 缩进: 138 控制语句: 138 IF条件 138 WHILE循环 139 FOR循环 141 BREAK \ CONTINUE ...
  • //for-in 循环是专门循环对象的 多数无益 直接来 var obj = { name : '阿彬' , age : '你猜' , sex : '男' } for ( var attr in obj ) { console . log ( attr ) //这个是 name ...
  • 粒子群优化算法(PSO)python 3实现

    万次阅读 多人点赞 2019-06-10 20:31:20
    #目标函数Sphere函数 def function(self, X): return X**4-2*X+3 #初始化种群 def init_Population(self): for i in range(self.pN): #因为要随机生成pN个数据,所以需要循环pN次 for j in range(self.dim): #每一个...
  • C#基础教程-c#实例教程,适合初学者

    万次阅读 多人点赞 2016-08-22 11:13:24
    本章介绍C#语言的基础知识,希望具有C语言的读者能够基本掌握C#语言,并以此基础,能够进一步学习用C#语言编写window应用程序和Web应用程序。当然仅靠一章的内容就完全掌握C#语言是不可能的,如需进一步学习C#语言...
  • for循环dos

    千次阅读 2013-11-28 17:30:52
    for命令是一种对一系列对象依次循环执行同一个或多个命令的在命令行或批处理中运行的命令,结合一些Windows管理中的程序后,其处理功能强大、应用灵活方便程度令人刮目相看。但是,其帮助信息也因此复杂往往令初学者...
  • 有些时候一个循环已经无法解决问题,就需要循环进行嵌套,这里主要以for循环为例 for(int i = 0; i < 10; i++){ for(int i = 0; i < 2; i++){ System.out.print("*"); } } //外层循环变量变化一次 内层循环...
  • 数据结构(C++)有关练习题

    热门讨论 2008-01-02 11:27:18
    2、 已知a[n]整数数组,试写出实现下列运算的递归代码(C或C++代码均可): 要求: a. 求数组中的最大整数; b. 求n个数的和; c. 利用堆栈类,将本题a和b的代码改成非递归的方式。 实验报告...
  • 在Java中,有三种常用循环结构:while循环、do-while循环、for循环,下面将读者一一介绍: 1、while循环结构 在日常生活中 while循环的结构: while(循环条件){ 循环体; } 示例: // 输出50遍:好好学习,天天...
  • for (int i = 1; i <= 8; i++) { int a, b; for (a = 1; a < i; a++) Console.Write(" "); for (b = 8; b >= i;...
  • MATLAB 粒子群算法,例题与常用模版

    万次阅读 多人点赞 2018-09-06 18:09:18
    如果满足结束条件(误差足够好或到达最大循环次数)退出,否则返回步骤2. 7. 手动实现PSO function[xm,fv] = PSO(fitness,N,c1,c2,w,M,D) % c1,c2:学习因子 % w:惯性权重 % M:最大迭代次数 % D:搜索空间维数 % ...
  • asp循环语句总结

    2021-01-02 22:40:15
    For…Next: 指定循环次数,使用计数器重复运行语句。 For Each…Next: 对于集合中的每项或数组中的每个元素,重复执行一组语句。 现在看几个例子: <body> do while....loop <% 'do while....lo

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 28,094
精华内容 11,237
关键字:

下列for循环的次数为