Every so often I have to restore my gpg keys and I'm never sure how best to do it. So, I've spent some time playing around with the various ways to export/import (backup/restore) keys.
cp ~/.gnupg/pubring.gpg /path/to/backups/
cp ~/.gnupg/secring.gpg /path/to/backups/
cp ~/.gnupg/trustdb.gpg /path/to/backups/
| class NQueen: | |
| # @return a list of lists of string | |
| def solveNQueens(self, n): | |
| self.__ans = [] | |
| self.__stack = [] | |
| self.__n = n | |
| self.solve(0) | |
| return self.__ans | |
| class KMP: | |
| def partial(self, pattern): | |
| """ Calculate partial match table: String -> [Int]""" | |
| ret = [0] | |
| for i in range(1, len(pattern)): | |
| j = ret[i - 1] | |
| while j > 0 and pattern[j] != pattern[i]: | |
| j = ret[j - 1] | |
| ret.append(j + 1 if pattern[j] == pattern[i] else j) |
| import sys | |
| from heapq import heappush, heappop | |
| class Dijkstra: | |
| def __init__(self, adjacents): | |
| self.adj = adjacents | |
| self.n = len(adjacents) | |
| def dijkstra(self, start): | |
| dis, vis, hq = {}, {}, [] |
| class RadixSort: | |
| def radix_sort(self, nums): | |
| """ | |
| Input an number list and return an sortd list | |
| Type: [Int] -> [Int] | |
| """ | |
| max_len = max(map(lambda x: len(str(x)), nums)) | |
| tmp, base = 1, 10 | |
| for i in range(max_len): |
| ; Quick miniKanren-like code | |
| ; | |
| ; written at the meeting of a Functional Programming Group | |
| ; (Toukyou/Shibuya, Apr 29, 2006), as a quick illustration of logic | |
| ; programming. The code is really quite trivial and unsophisticated: | |
| ; it was written without any preparation whatsoever. The present file | |
| ; adds comments and makes minor adjustments. | |
| ; | |
| ; $Id: sokuza-kanren.scm,v 1.1 2006/05/10 23:12:41 oleg Exp oleg $ |
| def quick_sort(nums): | |
| if len(nums) <= 1: | |
| return nums | |
| else: | |
| less = filter(lambda x: x <= nums[0], nums[1:]) | |
| large = filter(lambda x: x > nums[0], nums[1:]) | |
| return quick_sort(less) + [nums[0]] + quick_sort(large) |
| from random import randrange | |
| def reservoir_sampling(items, k): | |
| """ | |
| Reservoir sampling algorithm for large sample space or unknow end list | |
| See <http://en.wikipedia.org/wiki/Reservoir_sampling> for detail> | |
| Type: ([a] * Int) -> [a] | |
| Prev constrain: k is positive and items at least of k items | |
| Post constrain: the length of return array is k | |
| """ |
| def knuth_shuffle(items): | |
| """ | |
| Fisher-Yates shuffle or Knuth shuffle which name is more famous. | |
| See <http://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle> for detail | |
| Type : [a] -> None (shuffle inplace) | |
| Post constrain: Should be list | |
| Post constrain: return array of the same length of input | |
| """ | |
| for i in range(len(items)): |
| def count_sort(A, K): | |
| """ A is positive integer array each element is in range [0, K]""" | |
| count = [0] * (K + 1) | |
| for a in A: | |
| count[a] += 1 | |
| for i in range(1, K + 1): | |
| count[i] = count[i - 1] + count[i] | |
| B = [None] * len(A) |