Lnyan's Blog – Stand out to be outstanding

Let’s Encrypt 如何更新手动模式获取的证书

2016年9月19日 by Lnyan·0评论

通过手动模式获取的 letsencrypt 证书是无法通过 certbot new 更新的。

如果输入 certbot renew 只会得到如下形式的报错

2016-09-19 21:01:50,123:WARNING:certbot.renewal:Attempting to renew cert from /etc/letsencrypt/renewal/llonely.com.conf produced an unexpected error: The manual plugin is not working; there may be problems with your existing configuration.
The error was: PluginError('Running manual mode non-interactively is not supported',). Skipping.

2016-09-19 21:01:50,123:WARNING:certbot.renewal:Attempting to renew cert from /etc/letsencrypt/renewal/llonely.com.conf produced an unexpected error: The manual plugin is not working; there may be problems with your existing configuration.

The error was: PluginError('Running manual mode non-interactively is not supported',). Skipping.

certbot 的 manual 插件不支持非交互形式，因此，如果需要更新通过 manual 插件获取的证书，需要再次执行此前获取该证书时输入的命令，例如 certbot certonly --manual -d llonely.com 。

交换左右声道的方法

2016年9月8日 by Lnyan·0评论

今天看到了一个关于交换左右声道的问题，搜索后找到了两种有效方法，记录如下：

最为简单粗暴——使用转换线，自然不是直接的左右声道转换线（或许会有些有问题的延长线会产生这样的效果？），而是一根 RCA 公头 to 3.5mm 母头线缆和一根 3.5mm 公头 to RCA 母头线缆就可以解决问题。

两线的 RCA 接口左右对调相接，即可获得一根可以交换左右声道的耳机延长线。(lll￢ω￢)咦，我怎么没想到这么简单的方法。

当然也是有着零成本的方式，有些声卡的驱动程序本身就能够实现交换左右声道，如果不支持的话，这时可以祭出神奇的 Equalizer APO 。只需在配置文件中增加如下文本即可实现左右声道的交换。

Copy: L=R R=L

1	Copy: L=R R=L

具体使用方法则可以参考其文档。

LeetCode-167. Two Sum II – Input array is sorted

2016年9月7日 by Lnyan·0评论

Problem:

Given an array of integers that is already sorted in ascending order, find two numbers such that they add up to a specific target number.

The function twoSum should return indices of the two numbers such that they add up to the target, where index1 must be less than index2. Please note that your returned answers (both index1 and index2) are not zero-based.

You may assume that each input would have exactly one solution.

Input: numbers={2, 7, 11, 15}, target=9
Output: index1=1, index2=2

Solutions:

func twoSum(nums []int, target int) []int {
    result := make([]int, 2)
    var i, j int
    n := len(nums)
    for i = 0; i < n-1; i++ {
        for j = i + 1; j < n; j++ {
            if nums[i]+nums[j] == target {
                result[0] = i + 1
                result[1] = j + 1
                return result
            }
        }
    }
    return result
}

func twoSum(nums []int, target int) []int {

result := make([]int, 2)

var i, j int

n := len(nums)

for i = 0; i < n-1; i++ {

for j = i + 1; j < n; j++ {

if nums[i]+nums[j] == target {

result[0] = i + 1

result[1] = j + 1

return result

}

return result

}

func twoSum(nums []int, target int) []int {
    var temp int
    var flag bool
    record := make(map[int]int)
    result := make([]int, 2)
    for i, v := range nums {
        temp, flag = record[target-v]
        record[v] = i
        if flag == true {
            result[0] = temp + 1
            result[1] = i + 1
            return result
        }
    }
    return result
}

func twoSum(nums []int, target int) []int {

var temp int

var flag bool

record := make(map[int]int)

result := make([]int, 2)

for i, v := range nums {

temp, flag = record[target-v]

record[v] = i

if flag == true {

result[0] = temp + 1

result[1] = i + 1

return result

}

return result

}

func twoSum(numbers []int, target int) []int {
    result := make([]int, 2)
    total := len(numbers)
    temp := 0
    for i := 0; i < total-1; i++ {
        if target-numbers[i] <= numbers[total-1] {
            temp = isExist(numbers[i+1:], target-numbers[i])
            if temp != -1 {
                result[0] = i + 1
                result[1] = temp + i + 2
                return result
            }
        }
    }
    return result
}

func isExist(numbers []int, target int) int {
    if len(numbers) == 1 {
        if target == numbers[0] {
            return 0
        } else {
            return -1
        }
    }
    if numbers[len(numbers)/2] < target {
        temp := isExist(numbers[len(numbers)/2:], target)//用 slice 实现的二分搜索反而变麻烦了
        if temp != -1 {
            return temp + len(numbers)/2
        } else {
            return temp
        }
    } else if numbers[len(numbers)/2] > target {
        return isExist(numbers[:len(numbers)/2], target)
    } else {
        return len(numbers) / 2
    }
}

func twoSum(numbers []int, target int) []int {

result := make([]int, 2)

total := len(numbers)

temp := 0

for i := 0; i < total-1; i++ {

if target-numbers[i] <= numbers[total-1] {

temp = isExist(numbers[i+1:], target-numbers[i])

if temp != -1 {

result[0] = i + 1

result[1] = temp + i + 2

return result

}

return result

}

func isExist(numbers []int, target int) int {

if len(numbers) == 1 {

if target == numbers[0] {

return 0

} else {

return -1

}

if numbers[len(numbers)/2] < target {

temp := isExist(numbers[len(numbers)/2:], target)//用 slice 实现的二分搜索反而变麻烦了

if temp != -1 {

return temp + len(numbers)/2

} else {

return temp

}

} else if numbers[len(numbers)/2] > target {

return isExist(numbers[:len(numbers)/2], target)

} else {

return len(numbers) / 2

}

1-Two-Sum 的改动版，有序的数组就可以考虑使用二分搜索进行查找，偷懒写了递归版，本以为使用 slice 写二分查找会比较赞，但是实际上并没有简化的感觉。

LeetCode-1. Two Sum

2016年9月7日 by Lnyan·0评论

Problem:

Given an array of integers, return indices of the two numbers such that they add up to a specific target.

You may assume that each input would have exactly one solution.

Example:

Given nums = [2, 7, 11, 15], target = 9,

Because nums[0] + nums[1] = 2 + 7 = 9,
return [0, 1].

Given nums = [2, 7, 11, 15], target = 9,

Because nums[0] + nums[1] = 2 + 7 = 9,

return [0, 1].

The returned answers should be zero-based.

Solutions:

func twoSum(nums []int, target int) []int {
    result := make([]int, 2)
    var i, j int
    n := len(nums)
    for i = 0; i < n-1; i++ {
        for j = i + 1; j < n; j++ {
            if nums[i]+nums[j] == target {
                result[0] = i
                result[1] = j
                return result
            }
        }
    }
    return result
}

func twoSum(nums []int, target int) []int {

result := make([]int, 2)

var i, j int

n := len(nums)

for i = 0; i < n-1; i++ {

for j = i + 1; j < n; j++ {

if nums[i]+nums[j] == target {

result[0] = i

result[1] = j

return result

}

return result

}

func twoSum(nums []int, target int) []int {
    var temp int
    var flag bool
    record := make(map[int]int)
    result := make([]int, 2)
    for i, v := range nums {
        temp, flag = record[target-v] //Retrieve `record[target-v]` first to avoid duplicate
        record[v] = i
        if flag == true {
            result[0] = temp
            result[1] = i
            return result
        }
    }
    return result
}

func twoSum(nums []int, target int) []int {

var temp int

var flag bool

record := make(map[int]int)

result := make([]int, 2)

for i, v := range nums {

temp, flag = record[target-v] //Retrieve `record[target-v]` first to avoid duplicate

record[v] = i

if flag == true {

result[0] = temp

result[1] = i

return result

}

return result

}

Brute Force 不值一提，本该用 HashTable 解决的问题在遇到了 Go 自带的 map 后就变得十分简单了，虽然写一个开地址哈希表也并不费事。

基于 MatLab 的图形配准

2016年5月29日 by Lnyan·0评论

Preview:

Repo: https://github.com/lkwq007/Image-Registration

Open with Sublime Text – 此应用无法在你的电脑上运行 – 解决方案

2016年5月16日 by Lnyan·2条评论

上周突然从某一天开始，右键菜单中的 Open with Sublime Text 突然出现了这个问题，Sublime Text 本身可以正常使用，但是用右键菜单中的 Open with Sublime Text 来打开文件的话，就会弹出“此应用无法在你的电脑上运行”这一提示。不得不事先将 Sublime Text 打开，然后将所需编辑的文件拖入打开……煞是令人苦恼。

搜索也未能发现解决方案，似乎只有在知乎上有人问过这个问题，但没有解决方案，也没有相关的英文搜索结果……更新至 Build 3114 ，并尝试重装 Sublime Text 后，也没有解决。

~~无奈下，在注册表中查看了一下 Open with Sublime Text 的键值，在这里发现了问题。~~

该键值位于 HKEY_CLASSES_ROOT\*\shell\Open with Sublime Text\command ，举个我的例子，默认安装情况下的值为 D:\Program Files\Sublime Text 3\sublime_text.exe "%1" ，考虑到可能是空格的问题（顺便参考了一下 Atom 的右键菜单键值），加引号修改为 "D:\Program Files\Sublime Text 3\sublime_text.exe" "%1" 后工作正常。

上述思路不完全正确。

考虑到之前没有出现这个问题，发现情况与 Unquoted Service Paths 现象有点相像，然后我在 D 盘目录下发现了一个名为’Program’的文件，打开后发现是某 license manager 的日志文件，问题就这么解决了。（2333 这个软件没有处理好路径中的空格……）

以 D:\Program Files\Sublime Text 3\sublime_text.exe 为例，windows 默认的解析方式是

D:\Program Files\Sublime Text 3\sublime_text.exe

空格后的内容被视为参数，若当前文件不存在则尝试下一匹配方式。

因此，删除对应的文件或者对键值路径加引号都能解决问题。但为了确保其他存在类似 Unquoted Paths 的情况的软件能够正常运行，最好删除对应的无关文件。

具体关于 Unquoted Service Paths 的内容：

http://www.commonexploits.com/unquoted-service-paths/

http://www.tenable.com/sc-report-templates/microsoft-windows-unquoted-service-path-enumeration

一个修复脚本（针对 service 的）：

https://gallery.technet.microsoft.com/scriptcenter/Windows-Unquoted-Service-190f0341

有道词典去广告方法

2016年5月7日 by Lnyan·14条评论

最近在别人的安利之下用上了有道词典，发现确实是比我手机上的朗文和欧陆词典要方便一些。尤其是某次课前查看隔离器和环形器的相关资料时，发现有道词典对于某些专业术语的翻译十分准确。于是便又装了本地版尝试了一下，感觉还是不错，除了查询结果中混入的广告……

对于一款免费软件而言，这样是无可厚非的，只是那广告稍微有点碍眼的感觉，尤其是在注意力比较集中的阅读过程中，难免不会被那广告耗散掉些许的注意力。还是不显示要舒服一些……

继续阅读

LeetCode-338. Counting Bits

2016年4月6日 by Lnyan·0评论

Given a non negative integer number num. For every numbers i in the range 0 ≤ i ≤ num calculate the number of 1’s in their binary representation and return them as an array.

Example:
For num = 5 you should return [0,1,1,2,1,2].

Follow up:

It is very easy to come up with a solution with run time O(n*sizeof(integer)). But can you do it in linear time O(n) /possibly in a single pass?
Space complexity should be O(n).
Can you do it like a boss? Do it without using any builtin function like __builtin_popcount in c++ or in any other language.

Hint:

You should make use of what you have produced already.
Divide the numbers in ranges like [2-3], [4-7], [8-15] and so on. And try to generate new range from previous.
Or does the odd/even status of the number help you in calculating the number of 1s?

一开始没看 Hint ，看到题目的要求下意识的想到了树状数组中 lowbit 的用法，但是感觉这样还是不能满足 O(N) 的时间要求……

思路大体是这样的，首先从 num 开始计算出 1 的个数，然后通过形似 num-=(num&-num) 的运算消去最后一个 1 ，完成对下一个 num 的计数，然后依次类推。之后从 num 递减，若出现了未记录的数，则继续如上的计算。

代码如下：

/**
 * Return an array of size *returnSize.
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* countBits(int num, int* returnSize) {
    int *result,i,j,temp=0;
    *returnSize=num+1;
    result=(int *)malloc(*returnSize*sizeof(int));
    for(i=0;i<*returnSize;i++)
    {
    	result[i]=0;
    }
    for(i=num;i>=0;i--)
    {
    	if(result[i]!=0)
    	{
    		continue;
    	}
    	else
    	{
    		temp=i;
    		for(j=0;j<8*sizeof(int);j++)
    		{
    			if(temp&1)
    			{
    				result[i]++;
    			}
    			temp=temp>>1;
    		}
    		temp=i;
    		j=0;
    		while(temp!=0)
    		{
    			if(temp&1)
    			{
    				j++;
    			}
    			temp=temp>>1;
    			result[temp]=result[i]-j;
    		}
    		temp=i;
    		j=1;
    		while(temp!=0)
    		{
    			temp-=(temp&-temp);
    			result[temp]=result[i]-j;
    			j++;
    		}
    	}
    }
    return result;
}

/**

* Return an array of size *returnSize.

* Note: The returned array must be malloced, assume caller calls free().

int* countBits(int num, int* returnSize) {

int *result,i,j,temp=0;

*returnSize=num+1;

result=(int *)malloc(*returnSize*sizeof(int));

for(i=0;i<*returnSize;i++)

{

result[i]=0;

}

for(i=num;i>=0;i--)

{

if(result[i]!=0)

{

continue;

}

else

{

temp=i;

for(j=0;j<8*sizeof(int);j++)

{

if(temp&1)

{

result[i]++;

}

temp=temp>>1;

}

temp=i;

j=0;

while(temp!=0)

{

if(temp&1)

{

j++;

}

temp=temp>>1;

result[temp]=result[i]-j;

}

temp=i;

j=1;

while(temp!=0)

{

temp-=(temp&-temp);

result[temp]=result[i]-j;

j++;

}

return result;

}