目录
前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到网站前言 – 床长人工智能教程
https://www.cbedai.net/gkbskc
Java中split主要用于分隔字符串，十分的常用
具体分析如下:
1、如果用“.”作为分隔的话,必须是如下写法,String.split("\\."),这样才能正确的分隔开,不能用String.split(".")。
2、如果用“|”作为分隔的话,必须是如下写法,String.split("\\|"),这样才能正确的分隔开,不能用String.split("|")，“.”和“|”都是转义字符,必须得加"\\"。
3、如果在一个字符串中有多个分隔符,可以用“|”作为连字符,比如,“acount=? and uu =? or n=?”,把三个都分隔出来,可以用String.split("and|or")。
class Solution {
public String reverseWords(String s) {
String str[]=s.split(" ");
StringBuilder res= new StringBuilder();
for(int i=0;i<str.length;i++){
StringBuilder sb=new StringBuilder(str[i]);
res.append(sb.reverse().append(" "));
sb.delete(0,sb.length());
}
return res.toString().trim();
}
}
学习了LocalDate类，他适合处理日期星期问题
在import java.time.LocalDate;包下
//获取当前时间
LocalDate localDate = LocalDate.now();
//输入年月日设置时间
LocalDate localDate = LocalDate.of(year,month,day);
import java.util.Scanner;
import java.time.LocalDate;
// 1:无需package
// 2: 类名必须Main, 不可修改
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
//在此输入您的代码...
LocalDate sd=LocalDate.of(2000,1,1);
LocalDate ad=LocalDate.of(2020,10,1);
int sum=0;
while(true){
if(sd.getDayOfMonth()==1||sd.getDayOfWeek().getValue()==1){
sum+=2;
}else{
sum+=1;
}
if(sd.isEqual(ad)){
System.out.println(sum);break;
}
sd=sd.plusDays(1);
}
scan.close();
}
}import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
//在此输入您的代码...
int arrMonth[]={0,31,28,31,30,31,30,31,31,30,31,30,31};
int runSum=0;int month=12;int week=6;
for(int i=2000;i<=2020;i++){
if(i==2020)month=9;//2020年只算到9月就行
for(int j=1;j<=month;j++){
int monthDaySum=isHowDaysMonth(i,j,arrMonth);//看这年的这个月有多少天
for(int k=1;k<=monthDaySum;k++){
if((k==1)||(week==1))runSum+=2;//周日或者月初
else runSum+=1;
week++;
if (week>7){
week=1;
}
// System.out.println(runSum);
}
}
}
runSum+=2;//加上10月1的两千米
System.out.println(runSum);
scan.close();
}
public static int isHowDaysMonth(int year,int month,int arrMonth[]){
boolean runYear = isRunYear(year, arrMonth);
// if (runYear)System.out.println(year+"是闰年"+arrMonth[2]);
// else System.out.println(year+"不是闰年"+arrMonth[2]);
return arrMonth[month];
}
public static boolean isRunYear(int year,int arrMonth[]){
if((year%400==0)||(((year%4==0)&&(year%100!=0)))){
arrMonth[2]=29;
return true;
}
arrMonth[2]=28;
return false;
}
}
2、回车符之间的区别
其实我么发现next(),nextInt()和nextFloat()看到空格符或回车符都认为读取结束，此时不会读取回车符。
意思就是回车符只会留在这里等待下一个可以读取回车符号的读取流来把这个回车符接收掉
nextLine()也是以回车符为结束，并且只是以回车符结束,并且会读取回车符
Math.pow(n,m)为n的m次方
Math.pow(n,1.0/m)为开n的m次方
System.out.printf("%.3f",Math.pow(16.0, 1.0 / 3));保留三位小数，运算结果会四舍五入
所在包
import java.math.BigInteger
1. 赋值：
BigInteger a=new BigInteger("1"); // 字符
BigInteger b=BigInteger.valueOf(1); // 整型
2. 运算
① add(); 大整数相加
BigInteger a=new BigInteger(“23”);
BigInteger b=new BigInteger(“34”);
a. add(b);
②subtract(); 相减
③multiply(); 相乘
④divide(); 相除取整
⑤remainder(); 取余
⑥pow(); a.pow(b)=a^b
⑦gcd(); 最大公约数
⑧abs(); 绝对值
⑨negate(); 取反数
⑩mod(); a.mod(b)=a%b=a.remainder(b);
b.bitLength()//求二进制位数
String a = "123456789";
//String转为BigInteger
BigInteger b=new BigInteger(a);
//BigInteger转为String
String c = String.valueOf(b);
import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改
import java.math.BigInteger;
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
//在此输入您的代码..
BigInteger bigInteger=new BigInteger("2");//赋初始值
BigInteger subtract = bigInteger.pow(11213).subtract(BigInteger.valueOf(1));//bigInteger-1
String str=String.valueOf(subtract);//转为字符串
System.out.println( str.substring(str.length()-100));//取最后一位
}
}
class Solution {
List<List<Integer>> res=new LinkedList<>();
LinkedList<Integer> track=new LinkedList<>();
int sum=0;
public List<List<Integer>> combinationSum(int[] candidates, int target) {
if(candidates.length==0)return res;
backtrack(candidates,target,0);
return res;
}
void backtrack(int[] candidates, int target,int start){
if(sum==target){
res.add(new LinkedList<>(track));
return ;
}
if(sum>target)return;
for(int i=start;i<candidates.length;i++){
sum+=candidates[i];
track.add(candidates[i]);
backtrack(candidates,target,i);
sum-=candidates[i];
track.removeLast();
}
}
}
for(int i=start;i<candidates.length;i++){
sum+=candidates[i];
track.add(candidates[i]);
backtrack(candidates,target,i);//还是从i开始，表示可复选的
sum-=candidates[i];
track.removeLast();
}
for(int i=start;i<candidates.length;i++){
sum+=candidates[i];
track.add(candidates[i]);
backtrack(candidates,target,i+1);//还是从i+1开始，表示不可复选的
sum-=candidates[i];
track.removeLast();
}
for(int i=start;i<candidates.length;i++){
sum+=candidates[i];
track.add(candidates[i]);
backtrack(candidates,target);//表示可复选的，是排序的
sum-=candidates[i];
track.removeLast();
}
import java.util.*;
// 1:无需package
// 2: 类名必须Main, 不可修改
//回溯算法解决排序问题
public class Main {
static List<List<Character>> res=new LinkedList<>();
static LinkedList<Character> track=new LinkedList<>();
static boolean userd[];//定义是否用过
public static void main(String[] args) {
String str="LANQIAO";
paixu(str);
System.out.println(res.size());
}
static List<List<Character>> paixu(String str){
char c[]=str.toCharArray();
Arrays.sort(c);
userd=new boolean[str.length()];
backtrack(c,userd);
return res;
}
static void backtrack(char c[],boolean us[]){
if(track.size()==c.length){//达到总长度即退出
res.add(new LinkedList<>(track));
return;
}
for(int i=0;i<c.length;i++){
if(userd[i])continue;//当前用过则跳过，因为不重复
if(i>0&&c[i]==c[i-1]&&!userd[i-1])continue;//相等就跳过，前一个没有用过也跳过
//进行加入和标记已经使用
track.add(c[i]);
userd[i]=true;
backtrack(c,userd);//继续调用
//回溯，撤销之前的操作
track.removeLast();
userd[i]=false;
}
}
}
import java.util.*;
// 1:无需package
// 2: 类名必须Main, 不可修改
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
String str = sc.nextLine();
char cs[] = str.toCharArray();
int count = sc.nextInt();
Stack<Character> stack = new Stack<>();
//L A //AN //ANQ //AI //AIA
for (int i = 0; i < cs.length; i++) {
while (!stack.isEmpty() && stack.peek() > cs[i]&&count>0) {//元素更大的话
stack.pop();//弹出去
if (count--<0){
break;
}
}
stack.push(cs[i]);//加入
}
StringBuilder sb=new StringBuilder();
while(!stack.isEmpty()){
sb.append(stack.pop());
}
System.out.println(sb.reverse().toString());
}
}import java.util.*;
// 1:无需package
// 2: 类名必须Main, 不可修改
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
String str=sc.nextLine();
char chars[]=str.toCharArray();
int count=sc.nextInt();
LinkedList<Character> array=new LinkedList<>();
for (int i=0;i<chars.length;i++){
//当后一个比前一个更小时，移除前一个，直到，后一个不在小于前一个或者已经达到指定的移除次数
while(!array.isEmpty()&&chars[i]<chars[i-1]&&count-->0){
array.removeLast();
}
array.add(chars[i]);
}
for (Character character : array) {
System.out.print(character);
}
}
}
import java.util.Scanner;
import java.util.Stack;
public class 不同字符最小 {
public static void main(String[] args) {
Scanner sc =new Scanner(System.in);
String s = sc.nextLine();
System.out.println(smallestSubsequence(s));
}
public static String smallestSubsequence(String s) {
Stack<Character> stack=new Stack<>();
char chars[]=s.toCharArray();
int count[]=new int[256];
boolean inStack[]=new boolean[256];
for (char c:chars){
count[c]++;//统计每个字符数量
}
for (char c:chars){
count[c]--;//每次遍历都少一个
if (inStack[c])continue;//已经存在了
while(!stack.isEmpty()&&stack.peek()>c){
if (count[stack.peek()]==0)break;//只有一个就不弹出栈了
inStack[stack.pop()]=false;//标为没有用过
}
stack.push(c);
inStack[c]=true;
}
StringBuilder sb=new StringBuilder();
while(!stack.isEmpty()){
sb.append(stack.pop());
}
return sb.reverse().toString();
}
}
解法二：使用集合（原理和栈相同）
import java.util.*;
public class 不同字符的最小子序列 {
public static void main(String[] args) {
Scanner sc =new Scanner(System.in);
String s = sc.nextLine();
System.out.println(smallestSubsequence(s));
}
public static String smallestSubsequence(String s) {
char chars[]=s.toCharArray();
int count[]=new int[256];
for(int i=0;i<chars.length;i++){//统计有这个字符串中的某个字符有多少个
count[chars[i]]++;
}
boolean inChars[]=new boolean[256];
LinkedList<Character> link=new LinkedList();
for(int i=0;i<chars.length;i++){
count[chars[i]]--;
if (inChars[chars[i]])continue;
while(!link.isEmpty()&&link.getLast()>chars[i]){//表示前一个元素还有
if(count[link.getLast()]==0)break;//栈顶元素只存在一个
inChars[link.removeLast()]=false;//删掉了，改成没添加
}
link.add(chars[i]);
inChars[link.getLast()]=true;//已经添加了
}
String res="";
for(char ss:link){
res+=ss;
}
return res;
}
}
//时间复杂度为O(n)
static int fib2(int N) {
int dp[]=new int[N+1];
dp[1] = dp[2] = 1;
for (int i = 3; i <= N; i++){
dp[i] = dp[i - 1] + dp[i - 2];
}
return dp[N];
}根据斐波那契数列的状态转移方程，当前状态只和之前的两个状态有关，其实并不需要那么长的一个数组来存储所有的状态，只要想办法存储之前的两个状态就行了。
//时间复杂度为O(1)
static int fib(int n) {
if (n < 2) return n;
int prev = 0, curr = 1;
for (int i = 0; i < n - 1; i++) {
int sum = prev + curr;
prev = curr;
curr = sum;
}
return curr;
}对比一下两者所消耗时间
法一：带备忘录的递归
package LanQiaoBei.动态规划;
import java.util.Arrays;
public class 零钱兑换 {
public static void main(String[] args) {
int coins[]={1,3,5};
int amount=11;
System.out.println(coinChange(coins, amount));
}
//备忘录
static int memory[];
public static int coinChange(int coins[],int amount){
memory=new int[amount+1];
Arrays.fill(memory, -66);//初始化
return dp(coins, amount);
}
public static int dp(int coins[],int amount){
if (amount==0)return 0;
if (amount<0)return -1;
//查询备忘录，防止重复
if (memory[amount]!=-66)return memory[amount];//已经查过
int res=Integer.MAX_VALUE;
for (int coin:coins){
//计算子问题结果
int subPro = dp(coins, amount - coin);
if (subPro==-1)continue;//跳过，说明这个不通
res=Math.min(res, subPro+1);//在子问题求得最优解后，每次加一
}
memory[amount]=res==Integer.MAX_VALUE?-1:res;//等于最大值说明一直被跳过
return memory[amount];
}
}
法二：dp 数组的迭代解法
int coinChange(int[] coins, int amount) {
int[] dp = new int[amount + 1];
// 数组大小为 amount + 1，初始值也为 amount + 1
Arrays.fill(dp, amount + 1);
// base case
dp[0] = 0;
// 外层 for 循环在遍历所有状态的所有取值
for (int i = 0; i < dp.length; i++) {
// 内层 for 循环在求所有选择的最小值
for (int coin : coins) {
// 子问题无解，跳过
if (i - coin < 0) {
continue;
}
dp[i] = Math.min(dp[i], 1 + dp[i - coin]);
}
}
return (dp[amount] == amount + 1) ? -1 : dp[amount];运用异或运算的性质：
一个数和它本身做异或运算结果为 0，即 a ^ a = 0；一个数和 0 做异或运算的结果为它本身，即 a ^ 0 = a。
一个数异或n个数的和顺序无关
查找只出现一次的元素
int singleNumber(int []nums) {
int res = 0;
for (int n : nums) {
res ^= n;
}
return res;
} //返回值则是a和b的最大公约数
static int gcd(int a,int b){
return b == 0 ? a:gcd(b,a%b);
}
//返回值为a和b的最小公倍数
static int lcm(int a, int b){
return a*b/gcd(a,b);//最小公倍数=两数之积÷两数最大公约数
}https://leetcode.cn/problems/first-bad-version/
public class Solution extends VersionControl {
public int firstBadVersion(int n) {
int left = 1, right = n;
while (left < right) { // 循环直至区间左右端点相同
int mid = left + (right - left) / 2; // 防止计算时溢出
if (isBadVersion(mid)) {
right = mid; // 答案在区间 [left, mid] 中
} else {
left = mid + 1; // 答案在区间 [mid+1, right] 中
}
}
// 此时有 left == right，区间缩为一个点，即为答案
return left;
}
}
不用从i<n开始，可以从i*i<n开始，因为之后的都是对称的
一个数只要是素数的整数倍那他不是素数。
int countPrimes(int n) {
boolean[] isPrime = new boolean[n];
// 将数组都初始化为 true
Arrays.fill(isPrime, true);
for (int i = 2; i < n; i++)
if (isPrime[i])
// i 的倍数不可能是素数了
for (int j = 2 * i; j < n; j += i)
isPrime[j] = false;
int count = 0;
for (int i = 2; i < n; i++)
if (isPrime[i]) count++;
return count;
}
法二：
class Solution {
public int countPrimes(int n) {
boolean[] isPrime = new boolean[n];
Arrays.fill(isPrime, true);
for (int i = 2; i * i < n; i++)
if (isPrime[i])
for (int j = i * i; j < n; j += i)
isPrime[j] = false;
int count = 0;
for (int i = 2; i < n; i++)
if (isPrime[i]) count++;
return count;
}
}
题目：买不到的数
对于互质的两个数a和b，其不能组成的最大整数为a*b-a-b。
public class 正则 {
public static void main(String[] args) {
// $0 表示匹配到的第一个字符（即该大写字母）
// _$0 表示在匹配到的大写字母前加一个下划线（作为分隔符使用）
String str="LanTaiXiaoQiao";
String temp = str.replaceAll("[A-Z]", "_$0");
System.out.println(temp);
String[] split = temp.split("_");
}
}
1.postman介绍Postman一款非常流行的API调试工具。其实，开发人员用的更多。因为测试人员做接口测试会有更多选择，例如Jmeter、soapUI等。不过，对于开发过程中去调试接口，Postman确实足够的简单方便，而且功能强大。2.下载安装官网地址:https://www.postman.com/下载完成后双击安装吧，安装过程极其简单，无需任何操作3.使用教程这里以百度为例,工具使用简单，填写URL地址即可发送请求，在下方查看响应结果和响应状态码常用方法都有支持请求方法:getpostputdeleteGet、Post、Put与Delete的作用get：请求方法一般是用于数据查询，
Ⅰ软件测试基础一、软件测试基础理论1、软件测试的必要性所有的产品或者服务上线都需要测试2、测试的发展过程3、什么是软件测试找bug，发现缺陷4、测试的定义使用人工或自动的手段来运行或者测试某个系统的过程。目的在于检测它是否满足规定的需求。弄清预期结果和实际结果的差别。5、测试的目的以最小的人力、物力和时间找出软件中潜在的错误和缺陷6、测试的原则28原则：20%的主要功能要重点测（eg：支付宝的支付功能，其他功能都是次要的）80%的错误存在于20%的代码中7、测试标准8、测试的基本要求功能测试性能测试安全性测试兼容性测试易用性测试外观界面测试可靠性测试二、质量模型衡量一个优秀软件的维度①功能性功
目录前言滤波电路科普主要分类实际情况单位的概念常用评价参数函数型滤波器简单分析滤波电路构成低通滤波器RC低通滤波器RL低通滤波器高通滤波器RC高通滤波器RL高通滤波器部分摘自《LC滤波器设计与制作》，侵权删。前言最近需要学习放大电路和滤波电路，但是由于只在之前做音乐频谱分析仪的时候简单了解过一点点运放，所以也是相当从零开始学习了。滤波电路科普主要分类滤波器：主要是从不同频率的成分中提取出特定频率的信号。有源滤波器：由RC元件与运算放大器组成的滤波器。可滤除某一次或多次谐波，最普通易于采用的无源滤波器结构是将电感与电容串联，可对主要次谐波（3、5、7）构成低阻抗旁路。无源滤波器：无源滤波器，又称
最近在学习CAN，记录一下，也供大家参考交流。推荐几个我觉得很好的CAN学习，本文也是在看了他们的好文之后做的笔记首先是瑞萨的CAN入门，真的通透；秀！靠这篇我竟然2天理解了CAN协议！实战STM32F4CAN！原文链接：https://blog.csdn.net/XiaoXiaoPengBo/article/details/116206252CAN详解（小白教程）原文链接：https://blog.csdn.net/xwwwj/article/details/105372234一篇易懂的CAN通讯协议指南1一篇易懂的CAN通讯协议指南1-知乎(zhihu.com)视频推荐CAN总线个人知识总
深度学习部署：Windows安装pycocotools报错解决方法1.pycocotools库的简介2.pycocotools安装的坑3.解决办法更多Ai资讯：公主号AiCharm本系列是作者在跑一些深度学习实例时，遇到的各种各样的问题及解决办法，希望能够帮助到大家。ERROR:Commanderroredoutwithexitstatus1:'D:\Anaconda3\python.exe'-u-c'importsys,setuptools,tokenize;sys.argv[0]='"'"'C:\\Users\\46653\\AppData\\Local\\Temp\\pip-instal
ES一、简介1、ElasticStackES技术栈：ElasticSearch：存数据+搜索；QL；Kibana：Web可视化平台，分析。LogStash：日志收集，Log4j:产生日志；log.info(xxx)。。。。使用场景：metrics：指标监控…2、基本概念Index（索引）动词：保存（插入）名词：类似MySQL数据库，给数据Type（类型）已废弃，以前类似MySQL的表现在用索引对数据分类Document（文档）真正要保存的一个JSON数据{name:"tcx"}二、入门实战{"name":"DESKTOP-1TSVGKG","cluster_name":"elasticsear
我完全不是程序员，正在学习使用Ruby和Rails框架进行编程。我目前正在使用Ruby1.8.7和Rails3.0.3，但我想知道我是否应该升级到Ruby1.9，因为我真的没有任何升级的“遗留”成本。缺点是什么？我是否会遇到与普通gem的兼容性问题，或者甚至其他我不太了解甚至无法预料的问题？ 最佳答案 你应该升级。不要坚持从1.8.7开始。如果您发现不支持1.9.2的gem，请避免使用它们(因为它们很可能不被维护)。如果您对gem是否兼容1.9.2有任何疑问，您可以在以下位置查看:http://www.railsplugins.or
如何学习ruby的正则表达式？(对于假人) 最佳答案 http://www.rubular.com/在Ruby中使用正则表达式时是一个很棒的工具，因为它可以立即将结果可视化。 关于ruby-我如何学习ruby的正则表达式？，我们在StackOverflow上找到一个类似的问题： https://stackoverflow.com/questions/1881231/
深度学习12.CNN经典网络VGG16一、简介1.VGG来源2.VGG分类3.不同模型的参数数量4.3x3卷积核的好处5.关于学习率调度6.批归一化二、VGG16层分析1.层划分2.参数展开过程图解3.参数传递示例4.VGG16各层参数数量三、代码分析1.VGG16模型定义2.训练3.测试一、简介1.VGG来源VGG（VisualGeometryGroup）是一个视觉几何组在2014年提出的深度卷积神经网络架构。VGG在2014年ImageNet图像分类竞赛亚军，定位竞赛冠军；VGG网络采用连续的小卷积核（3x3）和池化层构建深度神经网络，网络深度可以达到16层或19层，其中VGG16和VGG
（本文是网络的宏观的概念铺垫）目录计算机网络背景网络发展认识"协议"网络协议初识协议分层OSI七层模型TCP/IP五层(或四层)模型报头以太网碰撞路由器IP地址和MAC地址IP地址与MAC地址总结IP地址MAC地址计算机网络背景网络发展 是最开始先有的计算机，计算机后来因为多项技术的水平升高，逐渐的计算机变的小型化、高效化。后来因为计算机其本身的计算能力比较的快速：独立模式：计算机之间相互独立。 如：有三个人，每个人做的不同的事物，但是是需要协作的完成。 而这三个人所做的事是需要进行协作的，然而刚开始因为每一台计算机之间都是互相独立的。所以前面的人处理完了就需要将数据