0x01.问题
 
由 n 个连接的字符串 s 组成字符串 S，记作 S = [s,n]。例如，["abc",3]=“abcabcabc”。
 
如果我们可以从 s2 中删除某些字符使其变为 s1，则称字符串 s1 可以从字符串 s2 获得。例如，根据定义，“abc” 可以从 “abdbec” 获得，但不能从 “acbbe” 获得。
 
现在给你两个非空字符串 s1 和 s2（每个最多 100 个字符长）和两个整数 0 ≤ n1 ≤ 10^6 和 1 ≤ n2 ≤ 10^6。现在考虑字符串 S1 和 S2，其中 S1=[s1,n1] 、S2=[s2,n2] 。
 
请你找出一个可以满足使 [S2,M] 从 S1 获得的最大整数 M 。
 
 
 
示例： 输入： s1 =“acb”,n1 = 4 s2 =“ab”,n2 = 2
 返回： 2
 
 
public int getMaxRepetitions(String s1, int n1, String s2, int n2) 
 
0x02.详细分析
 
初看问题，发现有些晦涩难懂，再读。。。
 
抓住问题的关键：
 
字符串 S1 由n1个相同的字符串s1构成。
字符串 S2 由n2个相同的字符串s2构成。
题目要求的是，字符串S2 最多 在S1中出现几次。
其中，这个出现指的是只要按照顺序在S1里面出现就行，不需要一定相连。
比如：字符串S2='ASCASC'在字符串S1='ADSFCADSFC'最多出现了一次。
 
弄清楚了问题的本质后，开始想办法去解决这个问题，首先，第一条思路，最原始，最暴力的思路：
 
遍历S1，看在里面最多能找出多少个S2。
 
这条思路直击问题的本质，毫无疑问是可以解决这个问题的，但是作用并不大。
 
以为注意到n可能非常的大，所以，如果要遍历完整个的字符串，肯定效率不高。
 
那么我们就要想办法从中去消减时间，也就是俗称的 剪枝。
 
如何剪起呢？
 
我们一刚开始就想生成S1和S2，但是我们似乎忘了点什么，S1和S2都是高度循环的字符串呀，如果我们直接拼起来，那么我们就忽略循环字符串的这个特性，就当做了一个普通的字符串来处理，这也是我们这条思路得弊端。
 
说明，问题的关键还是要利用这个循环的特性。
 
我们设想一下，S1是高度循环的，S2也是高度循环的，最终要找的是S2在S1里面出现的次数，如果我们知道在S1里面有这样一个特殊的字符串：
 
它包含了整个的S2，或者S2的一小部分相同的字符串，并且，它在S1里面循环出现。
 
如果有这样一个字符串，那么，我们后面的计算，只要做简单的乘法运算，即可算出中间一大段的数量，这样省去了非常多的时间。
 
然后，问题就来到了如何去寻找这样的字符串，（这样的字符串其实叫做循环结）
 
我们可以维护一个哈希表，索引是s2里面的一个下标，代表当前匹配到s2里面的index位，而此时匹配的状态，记录当前匹配到第cous1个s1，第cous2个s2。
如果相同的下标在哈希表内重复出现了，说明找到了一个循环结。
说明：说明再两次匹配中，匹配到相同的s2，所以出现了循环结。
 
找到循环结后，计算出中间一大段的cous1和cous2，最后整理答案：
 
模拟cir1表示，这个循环结占据多少个s1。
模拟cir2表示，这个循环结占据多少个s2。
那么匹配s1的个数cous1+=cir1*((n1-cous1)/cir1)
那么匹配s2的个数cous2+=cir2*((n1-cous1)/cir1)
最终返回的是cous2/n2，表示总共匹配的s2的个数与S2里面s2的个数之比。
 
0x03.解决代码–循环结剪枝
 
class Solution {
public int getMaxRepetitions(String s1, int n1, String s2, int n2) 
    {
        if(n1==0||n2==0) return 0;
        char[] c1=s1.toCharArray();
        char[] c2=s2.toCharArray();
        int len1=s1.length();
        int len2=s2.length();
        int cous1=0;//记录遍历s1的次数
        int cous2=0;//记录遍历s2的次数
        int index=0;//记录遍历s2的下标
        //哈希表记录每一次遍历s1后，对于index而言此时匹配的状态值
        Map<Integer,int[]> hash=new HashMap<>();
        while(cous1<n1){
            //遍历s1
            for(int i=0;i<len1;i++){
                //匹配s2中的字符
                if(c1[i]==c2[index]){
                    index++;
                    //匹配到s2的末尾
                    if(index==len2){
                        index=0;
                        cous2++;
                    }
                }
            }
            cous1++;
            
            if(!hash.containsKey(index)){
                //未出现相同状态，直接存入哈希表
                hash.put(index,new int[]{cous1,cous2});
            }else{
                //出现相同状态，说明出现了循环结
                int[] cou=hash.get(index);
                //这个循环结在s1里面占多少个相同字段数
                int cir1=cous1-cou[0];
                //这个循环结在s2里面占多少个相同字段数
                int cir2=cous2-cou[1];
                // s2中占的相同字段数  *  剩下循环的次数        
                cous2+=cir2*((n1-cous1)/cir1);
                // s1中占的相同字段数  *  剩下循环的次数
                cous1+=cir1*((n1-cous1)/cir1);
            }
        }
        //最终的答案是匹配的s2的总次数/s2的总重复数
        return cous2/n2;
    }
}
 
 
 
ATFWUS --Writing By 2020–04-19
 

 
 
 
 
 
 
 
 
 
     
 
      
主要有以下五种循环：Exit When、Loop、While、For(普通循环)、For(游标循环)，下面举例一一说明(均为存储过程)。
 
      

 1、Exit When循环：
 create or replace procedure proc_test_exit_when is
 i number;
 begin
 i:=0;
 LOOP
 Exit When(i>5);
 Dbms_Output.put_line(i);
 i:=i+1;
 END LOOP;
 end proc_test_exit_when;
 ——————————————————–俺是分割线—————————————————————–
 
      
2、Loop循环：
 create or replace procedure proc_test_loop is
 i number;
 begin
 i:=0;
 loop
 i:=i+1;
 dbms_output.put_line(i);
 if i>5 then
 exit;
 end if;
 end loop;
 end proc_test_loop;
 ——————————————————–俺是分割线—————————————————————–
 
      
3、While循环：
 create or replace procedure proc_test_while is
 i number;
 begin
 i:=0;
 while i<5 loop
 i:=i+1;
 dbms_output.put_line(i);
 end loop;
 end proc_test_while;
 ——————————————————–俺是分割线—————————————————————–
 
      
4、For普通循环：
 create or replace procedure proc_test_for is
 i number;
 begin
 i:=0;
 for i in 1..5 loop
 dbms_output.put_line(i);
 end loop;
 end proc_test_for;
 ——————————————————–俺是分割线—————————————————————–
 
      
5、For游标循环：
 create or replace procedure proc_test_cursor is
 userRow test%rowtype;
 cursor userRows is
 select * from test;
 begin
 for userRow in userRows loop
 dbms_output.put_line(userRow.id||’,'||userRow.Name||’,'||userRows%rowcount);
 end loop;
 end proc_test_cursor;
 ——————————————————–俺是分割线—————————————————————–
 
      
上面所示为存储过程相应代码，你可以通过如下方式进行测试：
 
      
进入pl/sql, 执行 文件->新建->程序窗口->空白，拷贝以上各段代码，到pl/sql空白窗口中，安F8执行编译。
 
      
再 执行 文件->新建->命令窗口 进入命令窗口 执行一下  set serveroutput on 这句代码，然后，输入exec 相应存储过程，ok。
 
      
第5中循环 要求新建一个名为test的表 字段 id、name，插入几条数据，进行测试即可。
 
     
 
 

  
 
  前几天老师讲了while循环，自己认真总结了一下，写了个笔记，拿出来与大家分享一下。同时也希望大家有什么东西都拿出来晒晒，老憋在怀里也不好，好东西也会闷坏的。我希望我们有知识一同分享，有问题自行解决，大家共同进步！
 
    要学好while循环（以下简称循环），我觉得首先应该理解好循环，把握住循环的特点，多问几遍三个“W”，我们要循环是干什么的，能带给我们什么好处，怎样用？循环实际上就是每循环一次，执行大括号里的内容一次，或把输出结果显示在控制台上。我们可以先在大脑中创建一个模型，以便于理解。模型是什么都可以，但要与循环有共同点，循环干什么，这个模型就干什么。这样当我们在看代码的时候，就想像自己创建的模型在工作。这样就可以避免我们看到代码，不知道电脑在干什么。（仅供参考，我创建的模型是，想像有一台打印机和一台计算器，计算器负责计算，打印机负责打印，两个相互联系。）
 
   循环最简单的是单循环，简单却很重要。单循环理解好了，复杂的循环也都好理解。
 
public class Danxunhuan{
 public static void main(String[]args){
  int i=1;   //声明变量，并赋值  （需注意的是，变量的作用域问题）
  while(i<=8){     //循环条件是必须的
   System.out.println("*");
   i++;     //改变变量的值，使其能跳出循环
  }//大括号内的都被称为循环体，即循环一次便执行一次
 }
} 
  
 
 
 
 
 
 
 
动物
 
 
移动方式
 
 
时间比例
 
 
实际移动
 
 
乌龟
 
 
快速爬行
 
 
 
 
 
50%
 
 
 
 
 
向右3个方格
 
 
 
 
 
滑倒
 
 
 
 
 
20%
 
 
 
 
 
向左6个方格
 
 
 
 
 
慢速爬行
 
 
 
 
 
30%
 
 
 
 
 
向右1个方格
 
 
兔子
 
 
睡觉
 
 
 
 
 
20%
 
 
 
 
 
原地不动
 
 
 
 
 
大跳跃
 
 
 
 
 
20%
 
 
 
 
 
向右9个方格
 
 
 
 
 
摔大跟斗
 
 
 
 
 
10%
 
 
 
 
 
向左12个方格
 
 
 
 
 
小跳跃
 
 
 
 
 
30%
 
 
 
 
 
向右1个方格
 
 
 
 
 
摔小跟斗
 
 
 
 
 
20%
 
 
 
 
 
向左1个方格
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

for循环分为两种：
第一种为普通的for循环
    这种for循环通常需要三个步骤即 for（初始表达式；条件表达式；递增表达式）有时候递增表达式也可以省去，一般是在使用Iterator迭代时（Iterator的hasNext方法判断时，可以省去递增表达式）。这种for循环很常用。
第二种为增强的for循环（也就是foreach循环）
    这种for循环的内部是调用了Iterator实现的(实现了Iterator接口)，和Iterator遍历效果是一样（你可以断点调试跟踪代码看看内部原理），主要用于遍历数组、集合的每一个元素。优点是写法简便，无需获得数组、集合长度，也无需根据索引来访问元素。缺点是不能在循环里动态的删除元素和获取元素下标,还有一点，在多线程下使用增强for来改变元素会出错误，因为通过迭代器实现的增强for对该数组或集合会现有一个拷贝，改变元素是会导致不能正常遍历数组和集合。所以说多线程下增强for是不安全不推荐用。

拿数组ArrayList和链表LinkedList来区分记忆： 
1.ArrayList由于使用数组实现，因此下标明确，最好使用普通for循环。
2.而对于 LinkedList 由于获取一个元素，要从头开始向后找，因此建议使用增强for循环，也就是iterator。
看代码吧，让这个问题更明朗些。


import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
public class ForTest {
 public static void main(String[] args) {
   //List<Integer> list = new ArrayList<Integer>();
  List<Integer> list = new LinkedList<Integer>();
  for (int i = 0; i < 60000; i++) {
   list.add(5);
  }
  int resutl = 0;
  long start = System.currentTimeMillis();
  //使用普通for循环
  for (int i = 0; i < list.size(); i++) {
   resutl = list.get(i);
  }
  System.out.println("普通循环使用了:" + (System.currentTimeMillis() - start)
    + "毫秒");
  start = System.currentTimeMillis();
  //使用增强for循环，这里什么也不做
  for (int c2 : list) {
  }
  System.out.println("增强for循环使用了:" + (System.currentTimeMillis() - start)
    + "毫秒");
 }
}



上面的输出结果为：


 

 

 


 很明显遍历链表时，使用增强for是非常合适的。如果注释掉LinkedList换上一句代码后，输出结果为：


 

 

  
 
  看得出遍历ArrayList数组时，使用普通for是明智的选择。


 注意：增强for由于实现了迭代器（java中是Iterator）对数组和集合会先有一个拷贝，改变元素值是不能正常输出的，如果在多线程中则会出错。