Eighteen Blog

前两篇文介绍了css3的过滤器filter用来实现图片的高斯模糊效果,还有js拖拽的功能。
要实现局部模糊就要把两者结合起来,计算位移就可以了。

实现原理

原理其实很简单,就是两张图的叠加。底部一张清晰的图,上面一个高斯模糊过的图,将高斯模糊的图当作上层元素的背景,利用背景定位使其只显示一部分,然后把这个高斯模糊的窗口放置在高清图的上层,背景图片的位置与下面的图片位置一致,这样看起来就像一张高清的图片打上了马赛克一样。讲起来不是很清楚,大家可以看一下代码。

Css

@TOC

更新

2020/6/03

  1. 接口已恢复。感谢蒟蒻…的帮助, 才能这么快解决这个问题。有兴趣可以查看他的关于sign获取的文章
  2. 之前分出了ts的分支,主要开始维护ts分支,master可能会更新的晚一点,如果需要自己启服务的话可以下载ts分支,有问题也可以回复,我可以协助一下。

    2020/5/27

  3. 发现获取vkey的接口现在获取不到了,应该是官方换了请求方式,目前播放地址受到了影响,无法播放,修复时间待定。

    2020/5/7

  4. 之前要使用api的话只能通过服务端请求,嗯嗯..想了想,现在支持跨域了。还是仅测试使用,服务器太渣渣。。经不起造。

    2020/2/25

  5. 最近在做新的项目,叫小鱼干APP,可以在百度,vivo,小米,apple store 中下载,暂时没有时间来搞这个音乐api的东西了,不过服务没有停,如果想用来测试或者玩玩的还是可以用的。

2019/12/26

  1. 获取歌曲播放地址接口 增加 lyric参数代表是否获取歌词。
  2. 增加获取歌词接口

2019/12/24

  1. 所有音乐接口更改,增加一层music/ ,获取地址改为 music/song
  2. 增加福利图片接口
  3. 示例接口更改为https

接口仅供交流学习使用

Github 项目地址

因为之前使用网络上别人封装的音乐api现在无法使用,或者一些需要付费使用,当然这也无可厚非。

但对我而言,只需要简单的一些音乐api做一些东西。 感觉给钱有点亏。 就自己搞一个简单的符合我的需求的吧。

文档

api

title: JavaScript:leetcode_16. 最接近的三数之和(排序+双指针)
date: 2020-06-24 16:27:44
categories: [‘Algorithm’,’每日一题’]
tags: Algorithm

keywords: leetcode_16, 最接近的三数之和(排序+双指针)

题目说明

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
给定一个包括 n 个整数的数组 nums 和 一个目标值 target。找出 nums 中的三个整数,使得它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在唯一答案。



示例:

输入:nums = [-1,2,1,-4], target = 1
输出:2
解释:与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。


提示:

3 <= nums.length <= 10^3
-10^3 <= nums[i] <= 10^3
-10^4 <= target <= 10^4

首先这个题可以使用3重for循环来遍历求值,并记录最接近target的值,但是会超时。

解题思路一

  1. 对数组进行从小到大排列
  2. 结果由三个数构成,我们提取出第一个数字nums[i], 剩下的值就是target-nums[i],我们需要在剩余数组元素中找到两个值nums[pb],nums[pc],最接近target-nums[i]
  3. 由于三个元素不可重复,所以我们首先遍历nums,然后在每次遍历中,设定pb的初始值为 i + 1pc的初始值为nums.length - 1
  4. 当前我们所求的当前值为target_close_help = nums[i] + nums[pb] + nums[pc];,另外用target_close记录最接近target的值。
  5. 每次遍历,nums[i]是确定的。所以只需要判断target_close_help 是否大于 target,如果大于pc--,否则pb++;若target_close_help等于target则直接返回。
    1. 由于nums小到大排列,所以pc--代表nums[pc]的值会变小target_close_help的值也会变,这样才会慢慢接近target,反之亦然pb++是同样的道理。
  6. 最后判读target_close_help 是否更接近target,若更接近则用target_close记录该次target_close_help
  7. 若没有相等于target的情况出现,最后则返回target_close的值。

    代码实现一

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    /**
    * @param {number[]} nums
    * @param {number} target
    * @return {number}
    */
    var threeSumClosest = function(nums, target) {
    nums = nums.sort((a,b) => {
    return a-b;
    })
    let target_close = 100001;
    for (let i = 0; i < nums.length; i++) {
    let pb = i + 1;
    let pc = nums.length - 1;
    while(pc > pb) {
    let target_close_help = nums[i] + nums[pb] + nums[pc];
    if (target_close_help < target) {
    pb++;
    } else if (target_close_help > target) {
    pc--;
    } else {
    return target;
    }
    if (Math.abs(target_close_help - target) < Math.abs(target_close - target)) {
    target_close = target_close_help;
    }
    }
    }
    return target_close;
    };

title: JavaScript:leetcode_739. 每日温度(栈)
date: 2020-06-11 11:27:28
categories: [‘Algorithm’,’每日一题’]
tags: Algorithm

keywords: leetcode_739, 每日温度(栈)

题目说明

1
2
3
4
5
根据每日 气温 列表,请重新生成一个列表,对应位置的输出是需要再等待多久温度才会升高超过该日的天数。如果之后都不会升高,请在该位置用 0 来代替。

例如,给定一个列表 temperatures = [73, 74, 75, 71, 69, 72, 76, 73],你的输出应该是 [1, 1, 4, 2, 1, 1, 0, 0]。

提示:气温 列表长度的范围是 [1, 30000]。每个气温的值的均为华氏度,都是在 [30, 100] 范围内的整数。

暴力方法就不提了,直接循环判断即可。

解题思路一(栈)

  1. 首先i位的值,为j-i的差值。j为下一位比i处大的最小下标
  2. 建立一个index栈,先入栈下标0,遍历T,判断T[i]T[index[index.length-1]] (栈顶元素对应的T内值)。
  3. T[i] > T[index[index.length-1]] 将栈顶排出indexTop = index.pop(); 赋值T[indexTop] = i - indexTop
  4. 循环此步骤直到栈顶对应的T值大于T[i]。
  5. 最后将i置入栈内。
  6. 遍历完数组,最后将栈排空,栈内剩余值都为0。(我们也可以初始化结果数组为0)

代码实现一

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/**
* @param {number[]} T
* @return {number[]}
*/
var dailyTemperatures = function(T) {
let res = new Array(T.length).fill(0);
let index = [0];
for (let i = 1; i < T.length; i++) {
while (T[i] > T[index[index.length - 1]]) {
let indexTop = index.pop();
res[indexTop] = i - indexTop;
}
index.push(i);
}
return res;
};

title: JavaScript:leetcode_198. 打家劫舍(动态规划)
date: 2020-05-27 11:59:13
categories: [‘Algorithm’,’每日一题’]
tags: Algorithm

keywords: leetcode_198, 打家劫舍

题目说明

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
你是一个专业的小偷,计划偷窃沿街的房屋。每间房内都藏有一定的现金,影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统,如果两间相邻的房屋在同一晚上被小偷闯入,系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组,计算你 不触动警报装置的情况下 ,一夜之内能够偷窃到的最高金额。

示例 1:

输入: [1,2,3,1]
输出: 4
解释: 偷窃 1 号房屋 (金额 = 1) ,然后偷窃 3 号房屋 (金额 = 3)。
偷窃到的最高金额 = 1 + 3 = 4 。
示例 2:

输入: [2,7,9,3,1]
输出: 12
解释: 偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9),接着偷窃 5 号房屋 (金额 = 1)。
偷窃到的最高金额 = 2 + 9 + 1 = 12 。

条纹背景

背景知识:CSS线性渐变,background-size

CSS线性渐变

1
2
3
4
background: linear-gradient(red, yellow, blue);
background: linear-gradient(red 0%, yellow 50%, blue 100%);
background: linear-gradient(to right, red 0%, yellow 50%, blue 100%);
background: linear-gradient(90deg, red 0%, yellow 50%, blue 100%);
  1. to right代表渐变偏移角度,to right (相当于90deg)
  2. red,yellow,blue代表渐变色,表示从red - yellow - blue (相当于red 0% - yellow 50% - blue 100%)。 意思是从0%距离处为red,通过0%-50%的距离渐变到yellow,再通过50%-100%的距离渐变到blue。
    1. linear-gradient(90deg, red 0%, yellow 50%, blue 0) 等价于 linear-gradient(90deg, red 0%, yellow 50%, blue 50%) 因为当你的色标位置值设置为0时,会自动调整为前一个色标位置值。
    2. linear-gradient(90deg, red 20%, yellow 50%, blue 100%); 代表从0-20%都为red色
    3. linear-gradient(90deg, red 20%, yellow 20%, blue 100%); 代表从20%处颜色突然变化为yellow。(20%-20%之间没有渐变距离
    4. linear-gradient(90deg, red 20%, yellow 20%, yellow 50%, blue 100%); 代表从20%-50%处都是黄色,然后从50%处开始渐变直到100%变化为blue

css线性渐变小结

  1. line-gradient中相邻的两个颜色值代表,从色标A渐变到色标B。
  2. 颜色后紧跟的数值,代表AB两个颜色之间的渐变区间。(差值为渐变区间的长度,若差值为0,则为突变)
  3. 颜色后的数值为0时,自动取前一位的数值。
Css

题目说明

给定一个含有 n 个正整数的数组和一个正整数 s ,找出该数组中满足其和 ≥ s 的长度最小的连续子数组,并返回其长度。如果不存在符合条件的连续子数组,返回 0。

示例:

输入:s = 7, nums = [2,3,1,2,4,3]
输出:2
解释:子数组 [4,3] 是该条件下的长度最小的连续子数组。

进阶:

如果你已经完成了 O(n) 时间复杂度的解法, 请尝试 O(n log n) 时间复杂度的解法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

### 解题思路一
1. 第一种方法,比较常规,符合我们的脑回路。
2. 遍历数组,求遍历过的和sum。
3. 当sum >= s时,依次减去sum前面的数字,并判断是否依旧符合sum >= s。
4. 直到sum >= s不成立,记录start--到end的长度。
5. 继续遍历数组的下一位,循环2-3步骤,比较之后取最小长度。
### 代码实现一
```javascript
/**
* @param {number} s
* @param {number[]} nums
* @return {number}
*/
var minSubArrayLen = function(s, nums) {
let sum = 0;
let start = 0;
let end = 0;
let min = nums.length + 1;
for(let i = 0; i < nums.length; i++) {
sum += nums[i];
if (sum >= s) {
end = i;
while(sum >= s) {
sum -= nums[start++];
}
start--;
sum += nums[start];
if (min > (end - start)) {
min = end - start + 1;
}
}
}
if (min > nums.length) {
return 0;
}
return min;
};

解题思路二(双指针)

  1. 先求出nums数组中第一次符合条件的情况。也就是看nums的前多少位>=s。记录start,end。
  2. start,end即为我们的双指针,分别代表子序列的开头和结尾。
  3. 如果sum >= s, 我们就右移动start,求最小长度。
  4. 如果sum < s, 我们就右移动end,求符合条件的情况。
  5. 直到end到达nums的尾部结束。

    代码实现二

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    /**
    * @param {number} s
    * @param {number[]} nums
    * @return {number}
    */
    var minSubArrayLen = function(s, nums) {
    let sum = 0;
    let start = 0;
    let end = 0;
    let min = nums.length + 1;
    while (sum < s) {
    sum += nums[end++];
    }
    min = Math.min(end - start, min);
    while(end <= nums.length) {
    if (sum >= s) {
    sum -= nums[start++];
    if (sum >= s) {
    min = Math.min(end - start, min);
    }
    } else {
    sum += nums[end++];
    }
    }
    if (min > nums.length) {
    return 0;
    }
    return min;
    };

多重边框

背景知识:box-shadow的基本用法,outline基本用法

1
/* x偏移量 | y偏移量 | 阴影模糊半径 | 阴影扩散半径 | 阴影颜色 */
1
box-shadow: 2px 2px 2px 1px rgba(0, 0, 0, 0.2);

以上是box-shadow的基本参数。box-shadow是为元素添加阴影效果的样式。但是我们可以通过对其属性的设置,呈现边框效果。

Css