算法: 滑动窗口题目练习

news2024/11/17 16:53:47

文章目录

  • 滑动窗口
    • 长度最小的子数组
    • 无重复字符的最长子串
    • 最大连续1个个数 III
    • 将x减到0的最小操作数
    • 水果成篮
    • 找到字符串中所有字母异位词
    • 串联所有单词的子串
    • 最小覆盖子串
  • 总结

滑动窗口

长度最小的子数组

在这里插入图片描述
做这道题时,脑子里大概有个印象,知道要用滑动窗口,但是对于滑动窗口为什么就对,不会落情况吗?对于这一点不是很清楚.

emmm虽然独自做出来了,但是还是在怀疑滑动窗口的正确性.

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int left = 0;
        int sum = 0;
        int min = Integer.MAX_VALUE;
        for(int right = 0; right < nums.length;right++) {
            sum += nums[right];
            if(sum >= target) {
                while(sum >= target) {
                    sum -= nums[left++];
                }
                int tmp = right - left + 2;
                if(min > tmp) {
                    min = tmp;
                }
            }
        }
        return min==Integer.MAX_VALUE?0:min;
    }
}

看完题解后,明白了.
在这里插入图片描述
看题解后的代码:

  • 使用了Math.min(),加快了做题速度,在比赛中可以省下时间.
  • 其他的都差不多~
class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int left = 0;
        int sum = 0;
        int min = Integer.MAX_VALUE;
        for(int right = 0; right < nums.length;right++) {
            sum += nums[right];
            while(sum >= target) {
                min = Math.min(min,right-left+1);
                sum -= nums[left++];
            }
        }
        return min==Integer.MAX_VALUE?0:min;
    }
}

无重复字符的最长子串

在这里插入图片描述
自己使用滑动窗口+哈希表做出来了.
最开始想只用滑动窗口解决,结果想不出来.然后就想到了hash.
刚开始写时没写对,后来画了两次图,根据图,然后就写出来了~

看题解前:

class Solution {
    public int lengthOfLongestSubstring(String s) {
        int max = 0;
        int n = s.length();
        char[] ss = s.toCharArray();
        boolean[] hash = new boolean[1080];
        int left = 0,right = 0;
        while (right < n) {
            if(!hash[ss[right]]) {
                hash[ss[right++]] = true;
                max = Math.max(max,right-left);
            }else {
                hash[ss[left++]] = false;
            }
        }
        return max;
    }
}

看题解后:

  • 我用的boolean,他用的int.都差不多吧.
  • 还有就是我的hash数组给大了.
class Solution {
    public int lengthOfLongestSubstring(String s) {
        int max = 0;
        int n = s.length();
        char[] ss = s.toCharArray();
        int[] hash = new int[128];
        int left = 0,right = 0;
        while (right < n) {
            hash[ss[right]]++;
            while(hash[ss[right]] > 1) {
                hash[ss[left++]]--;
            }
            max = Math.max(max,right-left+1);
            right++;
        }
        return max;
    }
}

最大连续1个个数 III

在这里插入图片描述
自己写的代码,能过,但是看起来不美观,效率也不够高.

class Solution {
    public int longestOnes(int[] nums, int k) {
        int left = 0, right = 0;
        int n = nums.length;
        int max = 0;
        while (right < n) {
            if (nums[right] == 1) {
                max = Math.max(max, right - left + 1);
                right++;
            }else{
                if (k > 0) {
                    max = Math.max(max, right - left + 1);
                    right++;
                    k--;
                } else {
                    while(nums[left]==1) {
                        left++;
                    }
                    k++;
                    left++;
                }
            }
        }
        return max;
    }
}

看题解:

  • emm,只能说没有对比,就没有伤害.人家写的代码又少又快~
  • 题解使用了for循环,这样可以少写几个if,比如说当nums[right]==1时,我们可以忽略,自动让right++就行;
  • 与我写的不同的是,他的k可以小于0,而我的k不能.
class Solution {
    public int longestOnes(int[] nums, int k) {
        int max = 0;
        for(int right = 0,left = 0;right < nums.length;right++) {
            if(nums[right] == 0) k--;
            while(k < 0) 
                if(nums[left++] == 0) k++;
            max = Math.max(max,right-left+1);
        }
        return max;
    }
}

翻了翻题解,发现还有高手!
以下是大佬的题解.
难理解的地方在于为啥能直接返回 right - left.
滑动窗口，极简代码，新增图解

// 1
class Solution {
    public int longestOnes(int[] A, int K) {
        int left=0 ,right=0;
        while (right<A.length){
            if(A[right++]==0) K--;
            if(K < 0) {
                if(A[left++]==0) K++;
            }
        }
        return right-left;
    }
}

	
// 2
class Solution {
    public int longestOnes(int[] A, int K) {
        int left=0 ,right=0;
        while (right<A.length){
            K -= A[right++]^1;
            if(K < 0) K += A[left++]^1;
        }
        return right-left;
    }
}

作者：怕冷的三十三
链接：https://leetcode.cn/problems/max-consecutive-ones-iii/solutions/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

将x减到0的最小操作数

在这里插入图片描述

刚开始看到题目确实感觉难以下手,"移除数组 nums 最左边或最右边的元素"这是什么鬼???

后来想了想,我们只需要让 数组中剩下的元素 = 原始数组中全部元素的和 - x . 就行了.
这道题目也就变成了寻找能满足上面的条件时,数组的最大值.
找到这个最大值然后让 数组的原始长度 - 最大值,就可以得到最小操作数啦~

但是有个坑(踩了两次qwq)

  • 当 原始数组中全部元素的和 - x == 0 时,说明此时不需要进行任何操作(因为元素都是正数),直接返回数组长度就OK
  • 当 原始数组中全部元素的和 - x < 0 时,说明把数组中的所有元素凑起来也凑不出x.此时直接返回-1.

错了好几次,通过不断地画图,分析,总算是做出来了~
代码:

class Solution {
    public int minOperations(int[] nums, int x) {
        int max = 0;
        int left = 0;
        int right = 0;
        int sum = 0;
        int sum2 = 0;
        for (int i = 0; i < nums.length; i++) sum2 += nums[i];
        
        sum2 -= x;
        
        if (sum2 < 0) return -1;
        if (sum2 == 0) return nums.length;
        while (right < nums.length) {
            if (sum < sum2) {
                sum += nums[right++];
            }
            while (sum > sum2) {
                sum -= nums[left++];
            }
            if (sum == sum2) {
                max = Math.max(max, right - left);
                sum -= nums[left++];
            }
        }
        return max == 0 ? -1 : nums.length - max;
    }
}

在这里插入图片描述

看了题解,跟我写的差不多,但是我写的还有可以优化的地方.

优化后:

class Solution {
    	public int minOperations(int[] nums, int x) {
		int max = 0;
		int left = 0;
		int right = 0;
		int sum = 0;
		int sum2 = 0;
		for (int i = 0; i < nums.length; i++) sum2 += nums[i];

		sum2 -= x;

		if (sum2 < 0) return -1;
		if (sum2 == 0) return nums.length;
		while (right < nums.length) {
			sum += nums[right++];

			while (sum > sum2)
				sum -= nums[left++];
			if (sum == sum2)
				max = Math.max(max, right - left);
		}
		return max == 0 ? -1 : nums.length - max;
	}
}

水果成篮

在这里插入图片描述
emmm,太久没用HashMap了,都快不会用了.

class Solution {
    public int totalFruit(int[] fruits) {
        int max = 0;
        HashMap<Integer,Integer> hashMap = new HashMap<>();
        for(int left=0,right=0; right < fruits.length;right++) {
            hashMap.put(fruits[right],hashMap.getOrDefault(fruits[right],0)+1);
            while(hashMap.size() > 2) {
                hashMap.put(fruits[left],hashMap.get(fruits[left])-1);
                if(hashMap.get(fruits[left]) == 0)
                    hashMap.remove(fruits[left]);
                left++;
            }
            max = Math.max(max,right-left+1);
        }
        return max;   
    }
}

还可以不使用HashMap,因为它给出了
0 <= fruits[i] < fruits.length
可以使用数组来模拟.
多定义了一个 kinds 变量,用来统计水果的种类.

	public int totalFruit2(int[] fruits) {
		int max = 0;
		int n = fruits.length;
		int[] hashMap = new int[n + 1];
		for (int left = 0, right = 0, kinds = 0; right < fruits.length; right++) {
			int in = fruits[right];
			if (hashMap[in] == 0) kinds++;
			hashMap[in]++;

			while (kinds > 2) {
				int out = fruits[left];
				hashMap[out]--;
				if (hashMap[out] == 0)
					kinds--;
				left++;
			}
			max = Math.max(max, right - left + 1);
		}
		return max;
	}

找到字符串中所有字母异位词

在这里插入图片描述
没写出来,最开始是想用两个hashMap,后来写着写着,又改成使用一个hashMap一个数组模拟.再然后又改成一个数组模拟,emmm改来改去,把自己绕晕了~

看了看题解,发现没有我想的那么复杂.
最开始想的是从窗口里一个一个对比P中出现的字符.搞了半天,没写出来.

其实只需要将窗口的长度固定下来就OK.

  1. 入窗口,hash[in]++.
  2. 判断一下right-left+1 是否大于 p字符串的长度.
    • 大于,出窗口
  3. 判断是否要更新结果(right - left + 1 == p字符串的长度)
    • 相等,比较两个hash表中的字符出现次数.如果完全一致,那就更新结果.

也有一些小坑:

  • 字符串s的长度必须要大于字符串p的长度,不然不可能有结果.
  • 如果使用数组模拟hash表,并且设置数组大小为26.那么别忘了要 -'a'.
class Solution {
    public List<Integer> findAnagrams(String s, String p) {
		List<Integer> list = new ArrayList<>();
		int n1 = s.length(), n2 = p.length();
		if (n1 < n2)
			return list;
		char[] ss = s.toCharArray();
		int[] hash = new int[26];
		int[] hashP = new int[26];
		for (int i = 0; i < n2; i++) {
			hashP[p.charAt(i) - 'a']++;
		}

		for (int left = 0, right = 0; right < n1; right++) {
			char in = ss[right];
			hash[in - 'a']++;

			if (right - left + 1 > n2) {
				char out = ss[left++];
				hash[out - 'a']--;
			}

			if (right - left + 1 == n2) {
				int i = 0;
				for (; i < 26; i++) {
					if (hash[i] != hashP[i]) {
						break;
					}
				}
				if (i >= 26) {
					list.add(left);
				}
			}
		}

		return list;
	}
}

在以上代码的基础上做一下优化~

上述代码中,在检查两个hash表中的内容是否相等时,用的方法不是很好.
这道题给出了s串和p串中只有小写字母.由于小写字母只有26个,所以检查起来很快.
但是接下来还有一道题目,让你判断两个字符串,如果还是用上面的方法,那就会超时~

具体的优化思路:

维护一个count,count用来记录"有效字符个数".

具体一点:

  1. 进窗口: 如果hash[in] <= hashP[in],那么count++.
  2. 出窗口: 如果hash[out] <= hashP[out],那么count–;
  3. 更新结果: 如果count == p串长度,更新结果.

坑:

  • 注意count维护的时机.

优化后:

class Solution {
    public List<Integer> findAnagrams2(String s, String p) {
		List<Integer> list = new ArrayList<>();
		int n1 = s.length(), n2 = p.length();
		if (n1 < n2)
			return list;
		char[] ss = s.toCharArray();
		int[] hash = new int[26];
		int[] hashP = new int[26];
		for (int i = 0; i < n2; i++) {
			hashP[p.charAt(i) - 'a']++;
		}
		int count = 0;
		for (int left = 0, right = 0; right < n1; right++) {
			int in = ss[right] - 'a';
			hash[in]++;
			if (hash[in] <= hashP[in]) count++;

			if (right - left + 1 > n2) {
				int out = ss[left++] - 'a';
				if (hash[out] <= hashP[out]) count--;
				hash[out]--;
			}

			if (count == n2) {
				list.add(left);
			}
		}

		return list;
	}
}

串联所有单词的子串

在这里插入图片描述
尝试了两次,没写出来.

  • 想不到,可以这样写.
  • String/StringBuilder 中有的方法不知道,而且用的不熟练.比如说substring.
  • 在出窗口这里卡了一下.

看完题解后,自己写出来的代码:
count 的位置和加减容易写错.

public List<Integer> findSubstring(String s, String[] words) {
		List<Integer> list = new ArrayList<>();
		int lenS = s.length();
		int lenWords = words.length;
		int lenWord = words[0].length();
		HashMap<String, Integer> hashWords = new HashMap<>();
		for (String str : words)
			hashWords.put(str, hashWords.getOrDefault(str, 0) + 1);

		for (int i = 0; i < lenWord; i++) {
			HashMap<String, Integer> hashS = new HashMap<>();
			int count = 0;
			for (int left = i, right = i + lenWord; right <= lenS; right += lenWord) {
				String in = s.substring(right - lenWord, right);
				hashS.put(in, hashS.getOrDefault(in, 0) + 1);
				if (hashS.get(in) <= hashWords.getOrDefault(in, 0))
					count++;
				if (right - left > lenWord * lenWords) {
					String out = s.substring(left, left + lenWord);
					if (hashS.get(out) <= hashWords.getOrDefault(out, 0))
						count--;
					hashS.put(out, hashS.get(out) - 1);
					left += lenWord;
				}
				if (count == lenWords)
					list.add(left);
			}
		}
		return list;
	}

题解代码:

class Solution {
 public List<Integer> findSubstring(String s, String[] words) {
        List<Integer> ret = new ArrayList<>();//返回答案
        HashMap<String, Integer> hash1 = new HashMap<>();//hash1用来记录words中出现过的单词以及对应次数
        for (String str : words) {
            hash1.put(str, hash1.getOrDefault(str, 0) + 1);
        }
        int len = s.length();
        int wordLength = words[0].length();
        int wordsLength = words.length;
        for (int i = 0; i < wordLength; i++) {
            HashMap<String, Integer> hash2 = new HashMap<>();
            for (int right = i, left = i, count = 0; right + wordLength <= len; right += wordLength) {
                String str = s.substring(right, right + wordLength);
                hash2.put(str, hash2.getOrDefault(str, 0) + 1);
                if (hash2.get(str) <= hash1.getOrDefault(str, 0)) {
                    count++;
                }
                if (right - left + 1 > wordLength * wordsLength) {
                    String str2 = s.substring(left, left + wordLength);
                    if (hash2.get(str2) <= hash1.getOrDefault(str2, 0)) {
                        count--;
                    }
                    hash2.put(str2,hash2.get(str2)-1);
                    left += wordLength;
                }
                if(count == wordsLength) {
                    ret.add(left);
                }
            }
        }
        return ret;
    }
}

最小覆盖子串

在这里插入图片描述
emmm,怎么说呢,没写出来,但是看完题解,发现我的代码只需要把一个if改成while就能过了,而且速度很快…

	class Solution {
		public String minWindow(String ss, String tt) {
			int min = Integer.MAX_VALUE;
			char[] s = ss.toCharArray();
			char[] t = tt.toCharArray();
			int len = tt.length();
			StringBuilder ret = new StringBuilder();
			int count = 0, left1 = 0, right1 = 0;
			int[] hashS = new int[58];
			int[] hashT = new int[58];
			for (char ch : t) hashT[ch - 'A']++;
			for (int right = 0, left = 0; right < s.length; right++) {
				int in = s[right] - 'A';
				hashS[in]++;
				if (hashS[in] <= hashT[in]) {
					count++;
				}
				while (count == len) {
					if (min > right - left + 1) {
						right1 = right;
						left1 = left;
						min = right - left + 1;
					}
					int out = s[left++] - 'A';
					if (hashS[out] <= hashT[out])
						count--;
					hashS[out]--;
				}
			}
			while (left1 <= right1) {
				ret.append(s[left1++]);
			}
			return min == Integer.MAX_VALUE ? "" : ret.toString();
		}
	}

总结

  1. 感觉滑动窗口本质上还是双指针,只不过是同向双指针.
  2. 使用滑动窗口时要用到单调性.
  3. 使用滑动窗口的套路就是:进窗口,出窗口,根据题意找个地方更新结果.
  4. 对于一些需要记录 单词出现次数/种类 的题目,可以定义一个count来优化代码.

本文到这里就结束啦~

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2170531.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

基于 LangChain 的自动化测试用例的生成与执行

基于 LangChain 的自动化测试用例的生成与执行

在前面的章节中&#xff0c;分别介绍了 Web、App、接口自动化测试用例的生成。但是在前文中实现的效果均为在控制台打印自动化测试的用例。用例需要手动粘贴&#xff0c;调整之后再执行。 那么其实这个手动粘贴、执行的过程&#xff0c;也是可以直接通过人工智能完成的。 应用…
阅读更多...
基于springboot+vue学生宿舍管理系统设计与实现

基于springboot+vue学生宿舍管理系统设计与实现

博主介绍&#xff1a;专注于Java vue .net php phython 小程序 等诸多技术领域和毕业项目实战、企业信息化系统建设&#xff0c;从业十五余年开发设计教学工作 ☆☆☆ 精彩专栏推荐订阅☆☆☆☆☆不然下次找不到哟 我的博客空间发布了1000毕设题目 方便大家学习使用 感兴趣的…
阅读更多...
【PyTorch】环境配置

【PyTorch】环境配置

Window11RTX4060配置CUDA11.8pytorch2.0.0 下载CUDA11.8 进入官网下载Link&#xff0c;然后点击Archive of Previous CUDA Releases&#xff0c;找到对应版本11.8。 选择对应操作系统版本&#xff0c;点Download下载到本地。 下载cuDNN 点击链接Link&#xff0c;找到CU…
阅读更多...
【Java】多线程基础操作

【Java】多线程基础操作

多线程基础操作 Thread类回顾Thread类观察线程运行线程的休眠常用方法构造方法属性获取方法 中断线程线程状态线程等待 初识synchronized问题引入初步使用初步了解可重入锁死锁 volatile问题引入初步使用volatile 与 synchronized 线程顺序控制初步了解wait()notify()防止线程饿…
阅读更多...
有效解决配置管理混乱，麒麟桌面操作系统V10 sp1 2403最新版本推出统一配置系统

有效解决配置管理混乱，麒麟桌面操作系统V10 sp1 2403最新版本推出统一配置系统

了解更多银河麒麟操作系统全新产品&#xff0c;请点击访问 麒麟软件产品专区&#xff1a;https://product.kylinos.cn 开发者专区&#xff1a;https://developer.kylinos.cn 文档中心&#xff1a;https://documentkylinos.cn 当前桌面操作系统中可通过配置定义的应用有限&a…
阅读更多...
分享一个基于python的智慧居家养老服务平台 django社区养老管理系统与可视化统计（源码、调试、LW、开题、PPT)

分享一个基于python的智慧居家养老服务平台 django社区养老管理系统与可视化统计（源码、调试、LW、开题、PPT)

&#x1f495;&#x1f495;作者&#xff1a;计算机源码社 &#x1f495;&#x1f495;个人简介&#xff1a;本人 八年开发经验&#xff0c;擅长Java、Python、PHP、.NET、Node.js、Android、微信小程序、爬虫、大数据、机器学习等&#xff0c;大家有这一块的问题可以一起交流&…
阅读更多...
JavaScript的条件语句

JavaScript的条件语句

if条件语句 if结构先判断一个表达式的布尔值&#xff0c;然后根据布尔值的真伪&#xff0c;执行不同的语句。所谓布尔值&#xff0c;指的是JavaScript 的两个特殊值&#xff0c;true表示真&#xff0c;false表示伪。 if语句语法规范 if(布尔值){语句;}var m3if(m3){console.l…
阅读更多...
注意 秋季饮酒的正确打开方式

注意 秋季饮酒的正确打开方式

选择合适的白酒1.秋季气候干燥&#xff0c;适合选择一些口感醇厚、温润的白酒。比如酱香型白酒&#xff0c;它具有浓郁的香气和醇厚的口感&#xff0c;能在秋季给你带来温暖的感觉。2.浓香型白酒也是不错的选择&#xff0c;香气扑鼻&#xff0c;口感绵甜&#xff0c;能为秋季增…
阅读更多...
基于nodejs+vue的宠物医院管理系统

基于nodejs+vue的宠物医院管理系统

作者&#xff1a;计算机学姐 开发技术&#xff1a;SpringBoot、SSM、Vue、MySQL、JSP、ElementUI、Python、小程序等&#xff0c;“文末源码”。 专栏推荐&#xff1a;前后端分离项目源码、SpringBoot项目源码、Vue项目源码、SSM项目源码 精品专栏&#xff1a;Java精选实战项目…
阅读更多...
外包干了两年，收获真不少...

外包干了两年，收获真不少...

有一种打工人的羡慕&#xff0c;叫做“大厂”。 真是年少不知大厂香&#xff0c;错把青春插稻秧。 但是&#xff0c;在深圳有一群比大厂员工更庞大的群体&#xff0c;他们顶着大厂的“名”&#xff0c;做着大厂的工作&#xff0c;还可以享受大厂的伙食&#xff0c;却没有大厂…
阅读更多...
99%的人都不知道的AI绘图变现赚钱秘诀，都在这里了！

99%的人都不知道的AI绘图变现赚钱秘诀，都在这里了！

AI绘画发展至今&#xff0c;已经有很多实际落地的应用场景&#xff0c;这里介绍几种AI绘图热门变现方式 AI儿童绘本 各大平台上故事绘本、幼儿园儿歌、英文绘本、古诗词&#xff0c;从下图里&#xff0c;可以看出需求量很大 AI儿童绘本 实现方式 \1. gpt\2. leonardo.ai\3.…
阅读更多...
Find My汽车钥匙|苹果Find My技术与钥匙结合，智能防丢，全球定位

Find My汽车钥匙|苹果Find My技术与钥匙结合，智能防丢，全球定位

随着科技的发展&#xff0c;传统汽车钥匙向智能车钥匙发展&#xff0c;智能车钥匙是一种采用先进技术打造的汽车钥匙&#xff0c;它通过无线控制技术来实现对车门、后备箱和油箱盖等部件的远程控制。智能车钥匙的出现&#xff0c;不仅提升了汽车的安全性能&#xff0c;同时也让…
阅读更多...
敏感内容识别技术有哪些？ (敏感信息防泄密解决方案)

敏感内容识别技术有哪些？ (敏感信息防泄密解决方案)

随着信息化进程的加快&#xff0c;越来越多的企业面临着敏感信息泄露的风险。为了防止机密数据被不当传播&#xff0c;敏感内容识别技术成为信息安全管理中的关键环节。 这些技术能够自动识别和分类企业内部的敏感数据&#xff0c;并采取相应的防护措施&#xff0c;有效防止数…
阅读更多...
在GPU计算型实例中安装Tesla驱动超详细过程

在GPU计算型实例中安装Tesla驱动超详细过程

摘要&#xff1a;在深度学习、AI等通用计算业务场景或者OpenGL、Direct3D、云游戏等图形加速场景下&#xff0c;安装了Tesla驱动的GPU才可以发挥高性能计算能力&#xff0c;或提供更流畅的图形显示效果。如果您在创建GPU计算型实例&#xff08;Linux&#xff09;时未同时安装Te…
阅读更多...
linux-windows挂载NFS

linux-windows挂载NFS

挂载NFS linux安装Windows安装连接完成设置开机自启动linux开机自启动windows开机自启动 卸载NFSlinux 使用NFS共享将Linux系统上的磁盘映射到Windows电脑上作为本地磁盘。 linux安装 1.安装NFS服务&#xff1a; sudo apt-get install nfs-kernel-server2.编辑/etc/exports文…
阅读更多...
什么是敏感内容识别？企业如何进行敏感内容识别？（一文告诉你详情！）

什么是敏感内容识别？企业如何进行敏感内容识别？（一文告诉你详情！）

“防微杜渐&#xff0c;安全为先。”在信息爆炸的时代&#xff0c;敏感内容识别不仅是企业数据安全的守门人&#xff0c;更是企业稳健发展的基石。 那么&#xff0c;什么是敏感内容识别&#xff1f;企业又该如何有效进行这一关键步骤呢&#xff1f; 小编将为您进行详细解答&a…
阅读更多...
Chrome开发者工具如何才能看到Vue项目的源码

Chrome开发者工具如何才能看到Vue项目的源码

大家好&#xff0c;我是 程序员码递夫。 今天给大家分享的是 Chrome开发者工具如何才能看到Vue项目的源码。 问题 我们在编写一下Vue项目时&#xff0c;常常要通过 chrome 进行本地调试后&#xff0c;才打包 生产版本。 但有时打开 chrome 的开发者工具后&#xff0c;看到的…
阅读更多...
如何有效抵御商标侵权？

如何有效抵御商标侵权？

在品牌竞争日益激烈的商业环境中&#xff0c;商标作为企业的核心标识&#xff0c;不仅是品牌形象的载体&#xff0c;更是企业无形资产的重要组成部分。然而&#xff0c;商标侵权现象屡见不鲜&#xff0c;给企业的品牌价值和市场利益带来了严重威胁。 商标侵权的形式 1.假冒商标…
阅读更多...
MySQL 中 FIELD() 自定义排序示例详解，实现按照指定顺序排序

MySQL 中 FIELD() 自定义排序示例详解，实现按照指定顺序排序

在 MySQL 中&#xff0c;你可以使用 ORDER BY FIELD() 来自定义排序顺序。这个函数允许你指定字段的自定义排序顺序 field() 函数&#xff1a;是将查询的结果集按照指定顺序排序 格式&#xff1a; FIELD(str,str1,str2,str3,…) 什么时候用&#xff1a; 想让某几个特定的字段…
阅读更多...
大屏走马灯与echarts图表柱状图饼图开发小结

大屏走马灯与echarts图表柱状图饼图开发小结

一、使用ant-design-vue的走马灯(a-carousel)注意事项 <!-- 左边的轮播图片 --><a-carousel :after-change"handleCarouselChange" autoplay class"carousel" :transition"transitionName"><div v-for"(item, index) in it…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023