start

一、Spliterator　　　　 Spliterator<T> trySplit(); trySplit接口就相当于我们之前写的AccumulatorRecursiveTask类里面的分割任务，如果满足条件就继续往下分，返回一个新的spliterator出来。 Spliterator就相当于我们写的fork join逻辑，Stream就是使用Spliterator来实现fork join的功能，来实现多任务切分的。 代码例子： 1 package com.cy.java8; 2 3 import java.util.Objects; 4 import java.util.Optional; 5 import java.util.Spliterator; 6 import java.util.function.Consumer; 7 import java.util.stream.IntStream; 8 import java.util.stream.Stream; 9 import java.util.stream.StreamSupport; 10 11 public class SpliteratorInAction { 12 private static String text = 13 "Lorem ipsum dolor sit amet, consectetur

场景描述： 武汉热浪网吧收费标准如下： 6：00-12：00收费5.5/h，实时收费 12：00-18：00收费6/h，实时收费 18：00-23：00收费7/h，实时收费 23：00-第二天6：00，收费5/h，上限15收费 上限收费指实时收费超出上限时，按照上限收费，否则实时收费。 一.声明时段对象： 1 /// <summary> 2 /// 时段收费区间 3 /// </summary> 4 public class State 5 { 6 public TimeSpan start { get; set; } 7 public TimeSpan end { get; set; } 8 public double pay { get; set; } 9 public double maxpay { get; set; } 10 11 /// <summary> 12 /// 某时间内的费用/小时 13 /// </summary> 14 /// <param name="_start">开始时间</param> 15 /// <param name="_end">结束时间</param> 16 /// <param name="_pay">每小时费用</param> 17 /// <param name="_maxpay">时段上限收费，为0时代表实时收费</param>

题目描述 wls有一个钟表，当前钟表指向了某一个时间。 又有一些很重要的时刻，wls想要在钟表上复现这些时间（并不需要依次复现）。我们可以顺时针转动秒针，也可以逆时针转动秒针，分针和时针都会随着秒针按规则转动，wls想知道秒针至少转动多少角度可以使每个时刻至少都会被访问一次。 注意，时钟上的一种时针分针秒针的组合，可以代表两个不同的时间。 输入 第一行一个整数n代表有多少个时刻要访问。 第二行三个整数h，m，s分别代表当前时刻的时分秒。 最后n行每一行三个整数hi，mi，si代表每个要访问的时刻的时分秒。 1≤n≤86,400 0≤h,hi<24 0≤m,mi,s,si<60 输出 输出一行一个数代表秒钟转的角度，答案保留两位小数。 样例输入 复制样例数据 1 0 1 0 0 1 1 样例输出 6.00 Contest1780 - 2019年我能变强组队训练赛第十八场 clock 题解：把时间排序去重后进行顺时针及逆时针的暴力； 例如顺时针暴力是：枚举每一个点，让开始时间先顺时针到这个点，再逆时针从这个点到这个点的下一个点； 逆时针暴力和顺时针差不多，只是把方向都换一下就好，就是先让开始时间先逆时针到一个点，再顺时针从这个点到下一个 #include <bits/stdc++.h> using namespace std; typedef long long ll; const

一、Java线程 线程：线程是指进程内的一个执行单元,也是进程内的可调度实体. 表示程序执行的基本流程，cpu执行的基本单位 进程：进程是一个具有独立功能的程序关于某个数据集合的一次运行活动 在一个进程中可以包含若干个线程 二、线程的生命周期（状态） * java中的线程状态：创建，就绪，运行，阻塞，死亡 * 1.创建：在生成线程对象，并没有调用该对象的start方法，这是线程处于创建窗台 * 2.就绪：当调用了线程对象的start方法后，该线程就进入了就绪状态，但此时线程调度程序还没有把该线程设置为当前线程，此时处于就绪状态,在线程运行之后，从等待或者睡眠中回来后，也会处于就绪状态 * 3.运行：线程调度程序将处于就绪状态的线程设置为当前线程，此时线程进入了一个运行状态，开始运行run方法体中的代码 * 4.阻塞：线程在运行的时候被暂停，通常是为了等待某个时间某项操作的发生之后再运行，sleep、suspend、wait等方法都可以导致阻塞（线程各个api方法如何使用？sleep和wait有什么区别？） * 5.死亡：如果一个线程的run方法执行结束或者滴啊用stop方法后，该线程就会死亡， 对于已经死亡的线程，无法通过start进入就绪状态！！！ 三、线程的启动方式： 启动线程的唯一方法就是通过Thread类的start()实例方法 ,run方法只是把线程当成一个普通方法来执行

小易来到了一条石板路前，每块石板上从1挨着编号为：1、2、3....... 这条石板路要根据特殊的规则才能前进：对于小易当前所在的编号为K的 石板，小易单次只能往前跳K的一个约数(不含1和K)步，即跳到K+X(X为K的一个非1和本身的约数)的位置。 小易当前处在编号为N的石板，他想跳到编号恰好为M的石板去，小易想知道最少需要跳跃几次可以到达。 例如： N = 4，M = 24： 4->6->8->12->18->24 于是小易最少需要跳跃5次，就可以从4号石板跳到24号石板 #include<iostream> #include<vector> #include<algorithm> #include<sstream> #include<string> #include<limits.h> using namespace std; int minimumstep(int start,int end){ vector<int>dp(end+1,INT_MAX); dp[start]=0; for(int i=start;i<end;i++){ if(dp[i]==INT_MAX) continue; for(int j=2;(j*j)<=i;j++){ if(i%j == 0){ if(i+j <= end){ dp[i+j] = min(dp[i]+1,dp[i+j]); } if

Oracle中使用start with...connect by prior实现递归查询： 今天碰到一个问题，需要插叙某个机构的各级上级机构号，例如： 假设数据是这样的： 机构号br_id 上级机构号par_br_id 1067 1005 1005 1002 1002 9909 问题就是，如何使用sql查询机构1067的各级上级机构，即将1005,1002等都查询出来。 使用sql的话，在Oracle中，我们可以采用如下语句来进行递归查询： select ID, PARENT_ID from ORG where [条件列表1] start with [递归起始条件] connect by prior [递归条件] 例如： SELECT * FROM ifs_org where corp_flag='1' START WITH br_id = '1067' connect BY prior par_br_id=br_id ; start with 后面所跟的就是就是递归的种子。 递归的种子也就是递归开始的地方 connect by 后面的"prior" 如果缺省：则只能查询到符合条件的起始行，并不进行递归查询； connect by prior 后面所放的字段是有关系的，它指明了查询的方向。 来源： https://blog.csdn.net/sungaochao/article

一、Process的join的用法 ​ 阻塞住主进程再等待子进程结束，然后再往下执行，（了解的是：内部会待用wait（））。 from multiprocessing import Process import time def foo(): print('进程 start ') time.sleep(2.3) print('进程 end ') if __name__ == '__main__': p = Process(target=foo) p.start() p.join() print('主') #并行 if __name__ == '__main__': p1 = Process(target=foo,args=(1,)) p2 = Process(target=foo,args=(2,)) p3 = Process(target=foo,args=(3,)) start = time.time() p1.start() # p2.start() # p3.start() # # 核心需求就是 # time.sleep(5) p3.join() #1s p1.join() #1s p2.join() #1s # 总时长：按照最长的时间计算多一点。 end = time.time() print(end-start) #3s多 or 6s多 ？ 正解：3s多 print(

class Solution { public ListNode reverseKGroup(ListNode head, int k) { ListNode dummy = new ListNode(0); dummy.next = head; ListNode pre = dummy; ListNode end = dummy; while(end.next != null){ for(int i = 0; i < k && end != null; i++){ end = end.next; } if(end == null){ break; } ListNode next = end.next; ListNode start = pre.next; end.next = null;//将k段分出去以后需要在后面添上一个null已断开连接 pre.next = reverse(start); start.next = next; pre = start; end = start; } return dummy.next; } public static ListNode reverse(ListNode start){ ListNode pre = null; ListNode cur = start; while(cur != null){ ListNode next =

给定一个字符串，找出不含有重复字符的最长子串的长度。 示例： 给定 "abcabcbb" ，没有重复字符的最长子串是 "abc" ，那么长度就是3。 给定 "bbbbb" ，最长的子串就是 "b" ，长度是1。 给定 "pwwkew" ，最长子串是 "wke" ，长度是3。请注意答案必须是一个子串， "pwke" 是 子序列 而不是子串。 1.我的思路： 1 class Solution: 2 def lengthOfLongestSubstring(self, s): 3 n = len(s) #字符串长度 4 l = list(s) #将字符串转换成list 5 resultList = [] #构建一个新的list存放第0个至第n-1个元素开头的最长字串长度 6 for x in range(n): #遍历每个可能的字符串子串，找到不重复的最大长度子串并将长度返回到resultList 7 number=0 8 while len(l[x:x+number+1]) == len(set(l[x:x+number+1])) and x+number+1<=n: 9 number=number+1 10 resultList.append(number) 11 if resultList == []: #返回resultList中的最大值 12 return 0 13 else:

孤儿进程（亚索进程） 我们上次讲了僵尸进程，今天就来讲讲孤儿进程。 所谓孤儿，就是亚索，没爹的东西。 就是一个子进程的父进程挂掉的时候，这个子进程就会成为一个孤鹅，他将会被一个叫做init的进程收养，然后被人道毁灭。说到底，孤鹅进程是没啥关系的，不像僵尸进程，死又死不掉，又占着茅坑不拉屎，最后导致进程号都不够用了。 一共有三种情况： 情况1 无害父进等着子进程都死，回收僵尸进程。 情况2 无害父进程死了，子进程活着，都要被init进程接管并且回收。 情况3父进程一直不死，造成了大量僵尸进程。占用了大量的pid号 解决方案是什么，最直接的办法就是直接把他们的爸爸杀了，只要他们的父进程死了，无论怎么样，这些子进程最后都会挂掉！ Process的join用法 from multiprocessing import Process import time def foo(): print('进程 start ') time.sleep(2.3) print('进程 end ') if __name__ == '__main__': p = Process(target=foo) p.start() # # 核心需求就是 # time.sleep(5) p.join() # 阻塞住主进程再等待子进程结束，然后再往下执行，（了解的是：内部会待用wait（）） print('主')