m00nlight

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.

Method 1

Backup the public and secret keyrings and trust database

cp ~/.gnupg/pubring.gpg /path/to/backups/
cp ~/.gnupg/secring.gpg /path/to/backups/
cp ~/.gnupg/trustdb.gpg /path/to/backups/

or, instead of backing up trustdb...

m00nlight

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
        
        

m00nlight

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)

m00nlight

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 = {}, {}, []

m00nlight

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):

m00nlight

;                    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 $

m00nlight

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)

m00nlight

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
    """

m00nlight

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)):

m00nlight

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)