Exemplo n.º 1
0
    def rewrite_2(self, rooms):
        """
        :type rooms: List[List[int]]
        :rtype: void Do not return anything, modify rooms in-place instead.
        """
        from __builtin__ import xrange

        # find gate position.
        gates = [(i, j) for i in xrange(len(rooms))
                 for j in xrange(len(rooms[0])) if rooms[i][j] == 0]

        empty = 2147483647

        ddir = ((1, 0), (-1, 0), (0, 1), (0, -1))

        while gates:
            tmp_gates = []

            for g in gates:
                for d in ddir:
                    nxt = (g[0] + d[0], g[1] + d[1])
                    if 0 <= nxt[0] < len(rooms) and 0 <= nxt[1] < len(rooms[0]) \
                            and rooms[nxt[0]][nxt[1]] == empty:
                        rooms[nxt[0]][nxt[1]] = rooms[g[0]][g[1]] + 1
                        tmp_gates.append(nxt)

            gates = tmp_gates
Exemplo n.º 2
0
    def wordBreak(self, s, wordDict):
        """
        :type s: str
        :type wordDict: List[str]
        :rtype: bool
        """
        """
        s = lcoa
        dict = ["lco", "lcoa", "coa"]

        代表input s的每個char位置(含以前)的string是否在word dict內.
        [True, False, False, True, True]

        一定要測試 ok[j] 因為這代表著ok[j]以前的字有沒有中,
        如果沒有,則即使s[j:i]中也不能算,因為之前的字為孤魂野鬼,沒中.
        """
        from __builtin__ import xrange

        ok = [True]

        # 由1為始
        for i in xrange(1, len(s) + 1):
            ok += any(
                # 重要,一定要測 ok[j], 代表j以前的字有match,
                # j 之後的match才有意義.
                ok[j] and s[j:i] in wordDict for j in xrange(i)),

        return ok[-1]
Exemplo n.º 3
0
def update_lr(lr, position):
    print lr
    print position
    lrs = [x[0] for x in lr]
    index = lrs.index(position)
    new_lr = []
    _break = False
    for i in xrange(index + 1, len(lr)):
        tmp = lr[i]
        if tmp[1][0] > 0 and not _break:
            new_lr.append((tmp[0], (tmp[1][0] - 1, tmp[1][1])))
        else:
            _break = True
            new_lr.append(tmp)
    _lr = lr[:index]
    _lr.reverse()
    _break = False
    for i in xrange(len(_lr)):
        tmp = _lr[i]
        if tmp[1][1] > 0 and not _break:
            new_lr.insert(0, (tmp[0], (tmp[1][0], tmp[1][1] - 1)))
        else:
            _break = True
            new_lr.insert(0, tmp)
    return new_lr
Exemplo n.º 4
0
    def rob(self, nums):
        """
        :type nums: List[int]
        :rtype: int

        概念: 由198來.
        先由前往後 rob, 但是最後一個不能rob, 因為cycle.
        再由後往前 rob, 但是第一個不能rob, 因為cycle.
        """

        if len(nums) == 1:
            return nums[0]

        if not nums:
            return 0

        from __builtin__ import xrange

        prev = curr = 0

        for i in xrange(len(nums) - 1):
            prev, curr = curr, max(nums[i] + prev, curr)

        max_forward = curr

        # ----分隔----

        prev = curr = 0

        for i in xrange(len(nums) - 1, 0, -1):
            prev, curr = curr, max(nums[i] + prev, curr)

        max_backward = curr

        return max(max_forward, max_backward)
Exemplo n.º 5
0
    def minSteps(self, n):
        """
        :type n: int
        :rtype: int
        """
        from __builtin__ import xrange

        dp = [99999999] * (n + 1)
        dp[0] = 1
        dp[1] = 0

        for current_cnt in xrange(1, n + 1):
            for start_cnt in xrange(1, current_cnt):

                left_cnt = current_cnt - start_cnt

                if not left_cnt % start_cnt:
                    copyable = 1

                    dp[current_cnt] = min(
                        dp[current_cnt],
                        dp[start_cnt] + copyable + left_cnt / start_cnt)
                    # + 1 is to copyall aka. copyable.

        return dp[n]
Exemplo n.º 6
0
def update_lr(lr, position):
    print lr
    print position
    lrs = [x[0] for x in lr]
    index = lrs.index(position)
    new_lr = []
    _break = False
    for i in xrange(index+1, len(lr)):
        tmp = lr[i]
        if tmp[1][0] > 0 and not _break:
            new_lr.append((tmp[0], (tmp[1][0] - 1,tmp[1][1])))
        else:
            _break = True
            new_lr.append(tmp)
    _lr = lr[:index]
    _lr.reverse()
    _break = False
    for i in xrange(len(_lr)):
        tmp = _lr[i]
        if tmp[1][1] > 0 and not _break:
            new_lr.insert(0, (tmp[0], (tmp[1][0], tmp[1][1]-1)))
        else:
            _break = True
            new_lr.insert(0, tmp)
    return new_lr
Exemplo n.º 7
0
    def rewrite(self, rooms):
        """
        :type rooms: List[List[int]]
        :rtype: void Do not return anything, modify rooms in-place instead.
        """
        from __builtin__ import xrange

        empty = 2147483647

        steps = ((0, 1), (0, -1), (1, 0), (-1, 0))

        gates = [(i, j) for i in xrange(len(rooms))
                 for j in xrange(len(rooms[0])) if rooms[i][j] == 0]

        while gates:
            tmp_gates = []

            for g in gates:
                for d in steps:
                    n = (g[0] + d[0], g[1] + d[1])

                    if 0 <= n[0] < len(rooms) and \
                            0 <= n[1] < len(rooms[0]) and \
                            rooms[n[0]][n[1]] == empty:
                        rooms[n[0]][n[1]] = rooms[g[0]][g[1]] + 1
                        tmp_gates.append(n)

            gates = tmp_gates
 def test_create_blank(self):
     color = (205, 205, 205)
     im = DataMatrixCreator.create_blank(600,600,color)
     self.assertTrue(len(im) == 600)
     self.assertTrue(len(im[0]) == 600)
     for x in xrange(im.shape[0]):
         for y in xrange(im.shape[1]):
             self.assertTrue(im[x][y][0]==color[0])
Exemplo n.º 9
0
        def count(ary):
            for i in xrange(len(ary)):
                if i == 0:
                    cnt[0] = cnt[0] + sum(ary[i])
                    continue

                for j in xrange(len(ary[0])):
                    if ary[i][j] == 1:
                        if ary[i - 1][j] != 1:
                            cnt[0] = cnt[0] + 1
Exemplo n.º 10
0
    def rewrite(self, matrix):
        """
        :type matrix: List[List[int]]
        :rtype: bool
        """

        for i in xrange(1, len(matrix)):
            for j in xrange(1, len(matrix[0])):
                if matrix[i][j] != matrix[i - 1][j - 1]:
                    return False
        return True
Exemplo n.º 11
0
     def show(self):
         """ Display the current board state in the terminal. You should not need to edit this. """
         for y in xrange(3):
             if y > 0:
                 print "--+---+--"
             for x in xrange(3):
                 if x > 0:
                     print '|',

                 # Print a space for empty (0), an O for player 1, or an X for player 2
                 print " OX"[self.get_square(x, y)],
             print
Exemplo n.º 12
0
def random_population():
    """
  Return a list of POP_SIZE individuals, each randomly generated via iterating
  DNA_SIZE times to generate a string of random characters with random_char().
  """
    pop = []
    for i in xrange(POP_SIZE):
        dna = ""
        for c in xrange(DNA_SIZE):
            dna += random_char()
        pop.append(dna)
    return pop
    def rewrite(self, matrix):
        """
        :type matrix: List[List[int]]
        :rtype: List[List[int]]
        """
        if not matrix:
            return []

        from __builtin__ import xrange

        # create 2 graph for P and A
        # 要注意!!! 每個row必須為獨立!!! 要小心初始化的方式!
        pgraph = [[0 for _ in xrange(len(matrix[0]))]
                  for _ in xrange(len(matrix))]
        agraph = [[0 for _ in xrange(len(matrix[0]))]
                  for _ in xrange(len(matrix))]

        direction = ((1, 0), (-1, 0), (0, -1), (0, 1))

        def dfs(i, j, graph):
            graph[i][j] = 1

            for d in direction:
                ni = i + d[0]
                nj = j + d[1]

                if ni < 0 or ni >= len(matrix) or \
                        nj < 0 or nj >= len(matrix[0]) or \
                        graph[ni][nj] or \
                        matrix[ni][nj] < matrix[i][j]:

                    continue

                dfs(ni, nj, graph)

        # from up and down
        for j in xrange(len(matrix[0])):
            # pacific
            dfs(0, j, pgraph)

            # atlantic
            dfs(len(matrix) - 1, j, agraph)

        # from left and right
        for i in xrange(len(matrix)):
            # pacific
            dfs(i, 0, pgraph)

            # atlantic
            dfs(i, len(matrix[0]) - 1, agraph)

        result = []

        for i in xrange(len(matrix)):
            for j in xrange(len(matrix[0])):
                if agraph[i][j] and pgraph[i][j]:
                    result.append([i, j])
        return result
Exemplo n.º 14
0
    def rewrite(self, s):
        """
        :type s: str
        :rtype: int
        """
        from __builtin__ import xrange

        roman = {
            'M': 1000,
            'D': 500,
            'C': 100,
            'L': 50,
            'X': 10,
            'V': 5,
            'I': 1
        }

        summ = 0

        # why? because there could be single char.
        for i in xrange(len(s) - 1):
            if roman[s[i]] < roman[s[i + 1]]:
                summ -= roman[s[i]]
            else:
                summ += roman[s[i]]

        summ += roman[s[-1]]

        return summ
Exemplo n.º 15
0
    def rewrite(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: List[int]
            Window position                Max
            ---------------               -----
            [1  3  -1] -3  5  3  6  7       3
             1 [3  -1  -3] 5  3  6  7       3
             1  3 [-1  -3  5] 3  6  7       5
             1  3  -1 [-3  5  3] 6  7       5
             1  3  -1  -3 [5  3  6] 7       6
             1  3  -1  -3  5 [3  6  7]      7
            Therefore, return the max sliding window as [3,3,5,5,6,7].
        """
        from __builtin__ import xrange
        from collections import deque

        result = []
        dq = deque()

        for idx in xrange(len(nums)):

            while dq and nums[dq[-1]] < nums[idx]:
                dq.pop()

            dq += idx,

            if dq[0] == idx - k:
                dq.popleft()

            if idx >= (k - 1):
                result += nums[dq[0]],

        return result
Exemplo n.º 16
0
    def islandPerimeter(self, grid):
        """
        :type grid: List[List[int]]
        :rtype: int
        翻轉四次
        一次只處理單一方向. 即處理北面。
        """
        from __builtin__ import xrange
        cnt = [0]

        def count(ary):
            for i in xrange(len(ary)):
                if i == 0:
                    cnt[0] = cnt[0] + sum(ary[i])
                    continue

                for j in xrange(len(ary[0])):
                    if ary[i][j] == 1:
                        if ary[i - 1][j] != 1:
                            cnt[0] = cnt[0] + 1

        for _ in xrange(4):
            count(grid)
            grid = zip(*grid[::-1])

        return cnt[0]
Exemplo n.º 17
0
    def countComponents(self, n, edges):
        """
        :type n: int
        :type edges: List[List[int]]
        :rtype: int
        """
        from __builtin__ import xrange

        graph = {i: [] for i in xrange(n)}

        # build graph
        for e in edges:
            graph[e[0]] += e[1],
            graph[e[1]] += e[0],

        def dfs(key):
            child = graph.pop(key, [])

            for c in child:
                dfs(c)

        cnt = 0

        while graph:
            key = graph.keys()[0]

            dfs(key)
            cnt += 1

        return cnt
Exemplo n.º 18
0
 def selectedChildren(self):
     """Returns a list of children that are selected."""
     # TODO: hideChildren for Hyperlinks?
     selection = self.querySelection()
     selectedChildren = []
     for i in xrange(selection.nSelectedChildren):
         selectedChildren.append(selection.getSelectedChild(i))
Exemplo n.º 19
0
    def rotateRight(self, head, k):
        """
        :type head: ListNode
        :type k: int
        :rtype: ListNode

        這個太慢啦!!!
        """
        from __builtin__ import xrange
        if not head:
            return

        def move(node):
            onode = node
            prev = None
            ppnode = None

            while node:
                ppnode = prev
                prev = node
                node = node.next

            prev.next = onode

            if ppnode:
                ppnode.next = None
            else:
                prev.next = None

            return prev

        for _ in xrange(k):
            head = move(head)

        return head
    def rewrite(self, prices):
        """
        :type prices: List[int]
        :rtype: int
        """
        from __builtin__ import xrange

        # 差距可以延續 it's transformable.
        tdiff = 0

        mmax = 0

        for i in xrange(1, len(prices)):

            diff = prices[i] - prices[i - 1]

            if tdiff + diff < 0:
                tdiff = 0
                continue

            tdiff += diff

            mmax = max(mmax, tdiff)

        return mmax
Exemplo n.º 21
0
    def nextPermutation(self, num):
        """
        :type nums: List[int]
        :rtype: void Do not return anything, modify nums in-place instead.
        """
        if not num:
            return
        """
        1. 由後往前排序有小到大.
        2. 例: 2 9 4 3 1 , 到2為止. 則將2與之前排序中第一個比2大的交換:
             3 9 4 2 1,
        3. 再將9 4 2 1小到大排序: 3 1 2 4 9
        """
        from __builtin__ import xrange
        count = 0

        for i in xrange(num.__len__() - 1, -1, -1):
            if i == 0:
                if count == (num.__len__() - 1):
                    num[:] = sorted(num)
                    break

            if num[i] > num[i - 1]:
                num[i:] = sorted(num[i:])
                for inx, tval in enumerate(num[i:]):
                    tinx = inx + i
                    if tval > num[i - 1]:
                        """Swap"""
                        num[i - 1], num[tinx] = tval, num[i - 1]
                        break
                break
            else:
                count += 1

        return num
Exemplo n.º 22
0
    def reverse(self, x):
        """
        :type x: int
        :rtype: int
        """

        #  s = cmp(x, 0)
        #  r = int(`s*x`[::-1])
        #  return s * r * (r < 2**31)

        from __builtin__ import xrange

        sx = str(x)[1:] if x < 0 else str(x)
        lsx = list(sx)

        llen = len(lsx)

        for i in xrange(llen / 2):

            lsx[i], lsx[~i] = lsx[~i], lsx[i]

        result = "".join(lsx) if x > 0 else "-" + "".join(lsx)
        #  print(-2 ** 31)
        #  print(2 ** 31)
        #  print(int(result))
        return int(result) if - 2 ** 31 <= int(result) < 2**31 else 0
Exemplo n.º 23
0
    def rewrite(self, s):
        """
        :type str: List[str]
        :rtype: void Do not return anything, modify str in-place instead.
        """
        from __builtin__ import xrange

        for i in xrange(len(s) / 2):
            s[i], s[~i] = s[~i], s[i]

        i = prev_idx = 0
        s += [' ']

        while i < len(s):
            if s[i] == ' ':
                o_i = i

                while prev_idx < i:
                    s[prev_idx], s[i - 1] = s[i - 1], s[prev_idx]
                    prev_idx += 1
                    i -= 1

                i = o_i
                prev_idx = i + 1

            i += 1
        s.pop()
    def maxProfit(self, prices, fee):
        """
        :type prices: List[int]
        :type fee: int
        :rtype: int
        概念:
        買: 負的price , -prices[i]
        賣: 正的price + previous買的負的prices -prices[0] 減去手續費.
        """

        from __builtin__ import xrange

        buyin = -prices[0]
        for_next_buy = 0
        sell = 0

        for i in xrange(1, len(prices)):
            # 買 + 之前的獲利 , 選擇最好的買點
            # 初始 buyin == -prices[0]
            # 這次不處理next_buy, 留在下一個loop跑.
            # max也代表賣的初始價格最低
            for_next_buy = max(buyin, -prices[i] + sell)

            # 目前賣的獲利
            sell = max(sell, prices[i] - fee + buyin)

            # 下一個 loop 買
            buyin = for_next_buy

        return sell
Exemplo n.º 25
0
    def partitionLabels(self, S):
        """
        :type S: str
        :rtype: List[int]

        Input: S = "ababcbaca defegde hijhklij"
        """

        from collections import Counter as cc
        from __builtin__ import xrange

        current_set = set()
        cs = cc(S)
        result = []

        last_idx = 0

        for i in xrange(len(S)):
            current_set.add(S[i])
            cs[S[i]] -= 1

            if cs[S[i]] == 0:
                current_set.remove(S[i])

                if not current_set:
                    result.append(i - last_idx + 1)
                    last_idx = i + 1

        return result
Exemplo n.º 26
0
    def countSubstrings(self, s):
        """
        :type s: str
        :rtype: int

         “center expansion”
        """
        from __builtin__ import xrange

        N = len(s)
        ans = 0
        """
        何以要 2*N -1 ? 因為要traverse每一個點使其成為中點!

        e.g
        abc =>
        abcXXX 則 a b c可以成為中點 當 pivot / 2時!
        """

        for pivot in xrange(2 * N - 1):  # 0 1 2 3 4 => a(x)b(x)c
            center = pivot / 2
            rcenter = center + pivot % 2  # 因為n為偶數時有double center
            # 若為基數時 center 與 rcenter 相同

            while center >= 0 and rcenter < N and s[center] == s[rcenter]:
                ans += 1
                center -= 1
                rcenter += 1

        return ans
Exemplo n.º 27
0
    def areSentencesSimilar(self, words1, words2, pairs):
        """
        :type words1: List[str]
        :type words2: List[str]
        :type pairs: List[List[str]]
        :rtype: bool
        白痴...
        是 1:n 關係...
        """
        from __builtin__ import xrange
        from collections import defaultdict as dd

        if len(words1) != len(words2):
            return False

        dmap = dd(list)

        for k, v in pairs:
            dmap[k].append(v)
            dmap[v].append(k)

        for i in xrange(len(words1)):
            if words1[i] == words2[i]:
                continue

            if words1[i] not in dmap or \
                    words2[i] not in dmap:
                return False

            if words2[i] not in dmap[words1[i]]:
                return False

        return True
Exemplo n.º 28
0
def range(*args):
    """
    Wrapper for range usage, returning an iterator regardless of if
    python 2 or python 3 is used
    """
    if len(args) < 1 or len(args) > 3:
        err_msg = "ERROR: Anguilla range function takes 1, 2, or 3 arguments"
        raise Error.Error(msg=err_msg)

    start = 0
    stop = 1
    step = 1

    if len(args) == 1:
        stop = args[0]

    if len(args) == 2:
        start = args[0]
        stop = args[1]

    if len(args) == 3:
        start = args[0]
        stop = args[1]
        step = args[2]

    if platform.is_python2():
        return builtins.xrange(start, stop, step)
    elif platform.is_python3():
        return builtins.range(start, stop, step)
    else:
        err_msg = "ERROR: Unknown python platform"
        raise Error.Error(msg=err_msg)
Exemplo n.º 29
0
    def isStrobogrammatic(self, num):
        """
        :type num: str
        :rtype: bool
        0 0  不能為第一個.
        1 1
        6 9
        9 6
        8 8
        """
        from __builtin__ import xrange

        dmap = dict(
            (('0', '0'), ('1', '1'), ('6', '9'), ('9', '6'), ('8', '8')))

        if num[0] == '0' and len(num) > 1:
            return False

        if len(num) % 2:
            # corner cases
            if num[len(num) / 2] not in ('0', '1', '8'):
                return False

        for i in xrange(len(num) / 2):
            if num[i] not in dmap or num[~i] != dmap[num[i]]:
                return False
        # -i 保 減 1 去
        return True
Exemplo n.º 30
0
    def monotoneIncreasingDigits(self, N):
        """
        :type N: int
        :rtype: int
        """
        """
        1. check N is increasing or not
        2. through observation,  once pass the check for index number,
            the rest could be all 9s.
        """
        from __builtin__ import xrange
        import math as m

        digits = int(m.log(N, 10)) + 1

        result = [9] * digits

        def gen_number(ary):
            ary = ary[::-1]
            num = 0

            for i, n in enumerate(ary):
                num += n * (10**i)

            return num

        for i in xrange(digits):
            current = result[:i]  # const in the while loop
            rest_digits = digits - i

            while result[i] > 0 and \
                    gen_number(current + [result[i]] * rest_digits) > N:
                result[i] -= 1

        return gen_number(result)
Exemplo n.º 31
0
    def maxCoins(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        """
        1. 夾擠. 總coins和 == [0 , k, n] + [0, x, k] + [k, y, n]
        2. 也就是,若要算[0,k,n] 則表示 0~k中間已經被pop掉,而我們要最大的.
        3. k~n中間也被pop掉,我們要最大的.
        3. 有 左右上下限時,create matrix(m*n) m as 左限, n as 右限.
        """
        from __builtin__ import xrange
        nums = [1] + nums + [1]
        n = len(nums)

        # 為matrix
        dp = [[0] * n for _ in xrange(n)]

        def calculate(i, j):
            # i, j are inclusive.
            if dp[i][j] or j == i + 1:  # j == i + 1 表示i,j相鄰.
                return dp[i][j]

            coins = 0

            # 此 for loop 表示 不含i 不含j
            for k in xrange(i + 1, j):  # find the last balloon
                coins = max(
                    coins, nums[i] * nums[k] * nums[j] + calculate(i, k) +
                    calculate(k, j))

            dp[i][j] = coins
            return coins

        return calculate(0, n - 1)  # [0, n-1] , it's index.
Exemplo n.º 32
0
    def rewrite(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        """
        1. 解決 subproblem
        2. range:
        1 x 1, 1 與 x  之間的要全部pop掉.
        """
        from __builtin__ import xrange

        nums = [1] + nums + [1]
        n_len = len(nums)

        # create dp matrix
        dp = [[0] * n_len for _ in xrange(n_len)]

        def count(i, j):

            if dp[i][j] or i + 1 == j:
                return dp[i][j]

            for k in xrange(i + 1, j):
                summ = nums[i] * nums[k] * nums[j]
                dp[i][j] = max(dp[i][j], summ + count(i, k) + count(k, j))

            return dp[i][j]

        return count(0, n_len - 1)
Exemplo n.º 33
0
 def run(self, set_name, processes=5):
     run = self._get_run(set_name)
     if run:
         items = self._get_items(run)
         for i in xrange(0, len(items), self.batch_size):
             threads = ThreadPool(processes=processes)
             threads.map(self._run_batch, items[i:i+self.batch_size], processes)
             db.reset_queries()
     return True
Exemplo n.º 34
0
def get_lrs(stalls):
    lr = []
    for i in xrange(len(stalls)-1, 0, -1):
        if stalls[i] == 0:
            # Left search
            l = left_s(stalls, i)
            # Right search
            r = right_s(stalls, i)
            lr.insert(0, (i - 1, (l, r)))
    return lr
Exemplo n.º 35
0
def find_next(number):
    # print number
    list = [int(x) for x in str(number)]
    first = list[0]
    for i in xrange(1, len(list)):
        if first > list[i]:
            for k in range(len(list[i:])):
                list[i+k] = 0
            new_num = int(''.join(map(str, list)))
            return new_num - 1
        first = list[i]
Exemplo n.º 36
0
def solve(stalls, ppl):
    lr = get_lrs(stalls)
    for i in xrange(ppl):
        # lr = get_lrs(stalls)
        stalls, pos, lr = occupy(lr, stalls)
        # print_stall(stalls)
    _full = all([x == 1 for x in stalls])
    if _full:
        # print 'FULL'
        return '0 0'
    for x in lr:
        if x[0] == pos:
            return '{} {}'.format(x[1][1], x[1][0])
def delele_all_events_for_date(context, summary):
    for attempts in xrange(0, 10):
        # Perform search
        context.execute_steps(u'* Search for events which contain "%s"' % summary)
        # Find the first available appointment
        context.app.instance.menu('Edit').click()
        mnu = context.app.instance.menu('Edit').menuItem('Delete Appointment')
        states = mnu.getState().getStates()
        context.app.instance.menu('Edit').click()
        if pyatspi.STATE_ENABLED in states:
            context.execute_steps(u'* Delete the selected event')
        else:
            break
Exemplo n.º 38
0
def get_ngrams(sent_iterator, n):
    """
    Get a generator that returns n-grams over the entire corpus,
    respecting sentence boundaries and inserting boundary tokens.
    Sent_iterator is a generator object whose elements are lists
    of tokens.
    """
    for sent in sent_iterator:
        # Add boundary symbols to the sentence
        w_boundary = (n - 1) * [(None, "*")]
        w_boundary.extend(sent)
        w_boundary.append((None, "STOP"))
        #Then extract n-grams
        ngrams = (tuple(w_boundary[i:i + n]) for i in xrange(len(w_boundary) - n + 1))
        for n_gram in ngrams:  #Return one n-gram at a time
            yield n_gram
Exemplo n.º 39
0
def getPosition():
    cameraPort = 0
    rampFrames = 30
    camera = cv2.VideoCapture(cameraPort)
    # Ramp the camera - these frames will be discarded and are only used to allow v4l2
    # to adjust light levels, if necessary
    for i in xrange(rampFrames):
        temp = getImage(camera)
    print("Taking image...")
    cameraCapture = getImage(camera)
    cv2.imwrite("gadi" +str(time.time()) + ".png", cameraCapture)
    # cv2.imshow('image',cameraCapture)
    # cv2.waitKey(0)
    # cv2.destroyAllWindows()
    # ipAns = getState(cameraCapture)
    del (camera)
    return 1
Exemplo n.º 40
0
def delete_all_memos_containing(context, summary):
    for attempts in xrange(0, 10):
        # Perform search
        context.execute_steps(u'* Search for "%s" memo' % summary)
        # Find the first available task
        context.app.instance.menu('Edit').click()
        mnu = context.app.instance.menu('Edit').menuItem('Delete Memo')
        states = mnu.getState().getStates()
        context.app.instance.menu('Edit').click()
        if pyatspi.STATE_ENABLED in states:
            context.app.instance.menu('Edit').click()
            context.app.instance.menu('Edit').menuItem('Delete Memo').click()
            dialog = context.app.instance.dialog(' ')
            dialog.button('Delete').click()
            sleep(0.5)
        else:
            break
Exemplo n.º 41
0
def select_memo(context, name):
    context.execute_steps(u'* Search for "%s" memo' % name)

    first_memo_name = context.app.instance.child(roleName='heading').text

    for attempts in xrange(0, 10):
        selected_memo = context.app.instance.child(roleName='heading')
        if selected_memo.text == name:
            fail = False
            break
        dogtail.rawinput.keyCombo("<Down>")
        selected_memo = context.app.instance.child(roleName='heading')
        if first_memo_name == selected_memo.text:
            fail = True
            break

    context.assertion.assertFalse(fail, "Can't find memo named '%s'" % name)
    context.selected_memo = selected_memo
Exemplo n.º 42
0
    def read_counts(self, corpusfile):

        self.n = 3
        self.emission_counts = defaultdict(int)
        self.ngram_counts = [defaultdict(int) for i in xrange(self.n)]
        self.all_states = set()

        for line in corpusfile:
            parts = line.strip().split(" ")
            count = float(parts[0])
            if parts[1] == "WORDTAG":
                ne_tag = parts[2]
                word = parts[3]
                self.emission_counts[(word, ne_tag)] = count
                self.all_states.add(ne_tag)
            elif parts[1].endswith("GRAM"):
                n = int(parts[1].replace("-GRAM", ""))
                ngram = tuple(parts[2:])
                self.ngram_counts[n - 1][ngram] = count
Exemplo n.º 43
0
def getPosition():
    cameraPort = 0
    rampFrames = 30
    camera = cv2.VideoCapture(cameraPort)
    # Ramp the camera - these frames will be discarded and are only used to allow v4l2
    # to adjust light levels, if necessary
    for i in xrange(rampFrames):
        temp = getImage(camera)
    print("Taking image...")
    cameraCapture = getImage(camera)
    # file = "C:\Users\ronib\Desktop\test_image.png"
    # cv2.imwrite(file, cameraCapture)
    # cv2.imshow('image',cameraCapture)
    # cv2.waitKey(0)
    # cv2.destroyAllWindows()

    ipAns = state_resolver.is_in_frame(cameraCapture)

    del (camera)
    # return True
    return ipAns
Exemplo n.º 44
0
    def train(self, corpus_file):
        """
        Count n-gram frequencies and emission probabilities from a corpus file.
        """
        ngram_iterator = \
            get_ngrams(sentence_iterator(simple_conll_corpus_iterator(corpus_file)), self.n)

        for ngram in ngram_iterator:
            # Sanity check: n-gram we get from the corpus stream needs to have the right length
            assert len(ngram) == self.n, "ngram in stream is %i, expected %i" % (len(ngram, self.n))

            tagsonly = tuple([ne_tag for word, ne_tag in ngram])  #retrieve only the tags
            for i in xrange(2, self.n + 1):  #Count NE-tag 2-grams..n-grams
                self.ngram_counts[i - 1][tagsonly[-i:]] += 1

            if ngram[-1][0] is not None:  # If this is not the last word in a sentence
                self.ngram_counts[0][tagsonly[-1:]] += 1  # count 1-gram
                self.emission_counts[ngram[-1]] += 1  # and emission frequencies

            # Need to count a single n-1-gram of sentence start symbols per sentence
            if ngram[-2][0] is None:  # this is the first n-gram in a sentence
                self.ngram_counts[self.n - 2][tuple((self.n - 1) * ["*"])] += 1
Exemplo n.º 45
0
    def __init__(self, input=None, label=None,\
                 n_ins=2, hidden_layer_sizes=[3, 3], n_outs=2,\
                 numpy_rng=None):
        
        self.x = input
        self.y = label

        self.sigmoid_layers = []
        self.rbm_layers = []
        self.n_layers = len(hidden_layer_sizes)  # = len(self.rbm_layers)

        if numpy_rng is None:
            numpy_rng = numpy.random.RandomState(1234)

        
        assert self.n_layers > 0


        # construct multi-layer
        for i in xrange(self.n_layers):
            # layer_size
            if i == 0:
                input_size = n_ins
            else:
                input_size = hidden_layer_sizes[i - 1]

            # layer_input
            if i == 0:
                layer_input = self.x
            else:
                layer_input = self.sigmoid_layers[-1].sample_h_given_v()
                
            # construct sigmoid_layer
            sigmoid_layer = HiddenLayer(input=layer_input,
                                        n_in=input_size,
                                        n_out=hidden_layer_sizes[i],
                                        numpy_rng=numpy_rng,
                                        activation=sigmoid)
            self.sigmoid_layers.append(sigmoid_layer)

            # construct rbm_layer
            if i == 0:
                rbm_layer = CRBM(input=layer_input,     # continuous-valued inputs
                                 n_visible=input_size,
                                 n_hidden=hidden_layer_sizes[i],
                                 W=sigmoid_layer.W,     # W, b are shared
                                 hbias=sigmoid_layer.b)
            else:
                rbm_layer = RBM(input=layer_input,
                                n_visible=input_size,
                                n_hidden=hidden_layer_sizes[i],
                                W=sigmoid_layer.W,     # W, b are shared
                                hbias=sigmoid_layer.b)
                
            self.rbm_layers.append(rbm_layer)


        # layer for output using Logistic Regression
        self.log_layer = LogisticRegression(input=self.sigmoid_layers[-1].sample_h_given_v(),
                                            label=self.y,
                                            n_in=hidden_layer_sizes[-1],
                                            n_out=n_outs)

        # finetune cost: the negative log likelihood of the logistic regression layer
        self.finetune_cost = self.log_layer.negative_log_likelihood()
Exemplo n.º 46
0
def test_cdbn(pretrain_lr=0.01, pretraining_epochs=1000, k=1, \
             finetune_lr=0.01, finetune_epochs=1000):
#     xdata = [[0.4, 0.5, 0.5, 0.,  0.,  0.],
#                      [0.5, 0.3,  0.5, 0.,  0.,  0.],
#                      [0.4, 0.5, 0.5, 0.,  0.,  0.],
#                      [0.,  0.,  0.5, 0.3, 0.5, 0.],
#                      [0.,  0.,  0.5, 0.4, 0.5, 0.],
#                      [0.,  0.,  0.5, 0.5, 0.5, 0.]]
#     print xdata
#     x = numpy.array(xdata)
#     print x
#    
#    y = numpy.array([[1, 0],
#                     [1, 0],
#                     [1, 0],
#                     [0, 1],
#                     [0, 1],
#                     [0, 1]])

#     my_data = numpy.loadtxt('../data/NOT_VALID/train-numericdate-norm-cdbn.csv', delimiter=',')
#     xdata = my_data[:,0:38]

    filez = open('../data/NOT_VALID/train-numericdate-norm-cdbn.csv', 'r')
    data = csv.reader(filez, delimiter=',')
    alldata = [map(float, row) for row in data]
#     print alldata
    
#     xdata = alldata[0][:]
#     print alldata[0:][0:38]
#     print alldata[0:38][0]
#     print xdata
#     ydata = [row for row in data[:,38:48]]
    xydata = numpy.array(alldata)
#     x = numpy.array(xdata)
#     y = numpy.array(ydata)
    x = xydata[:,0:38]
    y = xydata[:,38:48]
#     print [x_ for x_ in x]
#     print [y_ for y_ in y]

    rng = numpy.random.RandomState(123)

    # construct DBN
    dbn = CDBN(input=x, label=y, n_ins=38, hidden_layer_sizes=[30, 30, 30], n_outs=10, numpy_rng=rng)

    # pre-training (TrainUnsupervisedDBN)
    dbn.pretrain(lr=pretrain_lr, k=1, epochs=pretraining_epochs)
    
    # fine-tuning (DBNSupervisedFineTuning)
    dbn.finetune(lr=finetune_lr, epochs=finetune_epochs)


    # test
    #x = numpy.array([[0.5, 0.5, 0., 0., 0., 0.],
    #                 [0., 0., 0., 0.5, 0.5, 0.],
    #                 [0.5, 0.5, 0.5, 0.5, 0.5, 0.]])
    
    # TODO predicting train dataset (for now)
    out = dbn.predict(x)
    print "INPUT"
    for x_ in x:
        print [in_el for in_el in x_]
    print "TARGET"
    for y_ in y:
        print [y_el for y_el in y_]
    print "PREDICTION"
    for o_ in out:
        print [out_el for out_el in o_]
    # normalize outputs
    thr = out.max(axis=0) / 2
    out_norm = numpy.zeros((len(out), len(thr)))
    for i in xrange(0, len(out)):
        for j in xrange(0, len(out[i])):
            out_norm[i][j] = (out[i][j] >= thr[j])
    print out_norm
    # compute revenues
    rev = [math.pow(10, numpy.sum(2**numpy.arange(len(out_))*out_[::-1]) / 100) for out_ in out_norm]
    print rev
    # compute RMSE
    filez2 = open('../data/train-numericdate.csv', 'r')
    data2 = csv.reader(filez2, delimiter=',')
    next(data2, None)
    alldata2 = numpy.array([row for row in data2])
    revenue = map(int, alldata2[:,43])
    print revenue
    print "RMSE = " + str(math.sqrt(mse(rev, revenue)))
Exemplo n.º 47
0
 def __iter__(self):
     self.file.seek(self.start)
     for j in xrange(self.size):
         byte = read(self.file, 1)
         assert len(byte) == 1
         yield byte
Exemplo n.º 48
0
def quick_hist(arrs, range=None, nbins=None, weights=None, getPos=False):
	"""
	N-dimensional histogram routine.
	Example:
	> xs=np.random.uniform(size=100); ys= np.random.uniform(size=100)
	> hh = quick_hist((xs,ys), range=[(0,1),(0,1)], nbins=[20,10])
	Arguments:
		arr -- tuple of N-arrays
		range -- list of tuples of ranges
		nbins -- list of numbers of bins 
	Keywords:
		weights -- weighting for the histogram
		getPos -- return the 1D vector of the positions within the histogram
					(-1 if the point is outside the range)
	"""
	from __builtin__ import range as xrange
	nd = len(arrs)
	if range is None:
		range=[]
		for i in xrange(nd):
			range.append((arrs[0].min(),arrs[0].max()))
	if nbins is None:
		nbins = [10]*nd
				
	if len(nbins)!=nd:
		raise ValueError('The array of nbins MUST have the same length as the number of input data vectors')
	if len(range)!=nd:
		raise ValueError('The array of ranges MUST have the same length as the number of input data vectors')

	nx = len(arrs[0])
	for curarr in arrs:
		if len(curarr)!=nx:
			raise ValueError('All the input arrays MUST have the same length!')
	if weights is not None:
		if len(weights)!=nx:
			raise ValueError('The weights array MUST have the same length as the input arrays')
	# convert all the bins into integers 
	nbins = [ int(_tmp) for _tmp in nbins]

	poss = np.zeros((nx,), dtype=np.int64)

	ind = np.ones_like(arrs[0]).astype(bool)
	nbins_rev = nbins + []
	nbins_rev.reverse()
	mults = (reduce(lambda x, y: x + [y * x[-1]], nbins_rev, [1]))[:-1]
 	mults.reverse()	
	for i in xrange(nd):
		cur_arr = np.ascontiguousarray(arrs[i],dtype=np.float64)
		cur_range0 = float(range[i][0])
		cur_range1 = float(range[i][1])
		cur_nbins = nbins[i]
		cur_mult = mults[i]
		code1 = """
		int i, cur_pos;
		double curfac = cur_nbins * 1./ (cur_range1-cur_range0);
		for (i=0; i<nx; i++)
		{
			cur_pos = (int)floor( ( cur_arr(i)-cur_range0) * curfac);

			if ((cur_pos>=0 ) && (cur_pos<cur_nbins))
			{
				poss(i)=poss(i)+cur_pos*cur_mult;
			}
			else
			{
				ind(i)=false;
			}
		}"""
		try:
			scipy.weave.inline(code1, ['cur_range0', 'cur_range1', 'cur_nbins','poss','ind','nx','cur_arr','cur_mult'],
				type_converters=scipy.weave.converters.blitz)
		except:
			print "Sorry the compiled version didn't work :("
			cur_pos = (cur_arr - cur_range0) * (cur_nbins * 
									1. / (cur_range1 - cur_range0))
			cur_pos = np.floor(cur_pos).astype(np.int64)
			ind &= ((cur_pos >= 0) & ( cur_pos < cur_nbins))
			poss += cur_pos * cur_mult

	poss = poss[ind]
	newlen = len(poss)
	if weights is None:
		weights_str = '1'
	else:
		weightsind = weights[ind]
		weights_str = 'weightsind(i)'
	if not getPos:	
		del ind
	res = np.zeros(np.array(nbins, dtype=np.int64).prod())

	code = """
	int i;
	for (i=0; i<newlen; i++)
	{
		res(poss(i)) = res(poss(i)) + %s;
	}"""%weights_str
	try:
		if weights is None:
			scipy.weave.inline(code, ['res', 'poss', 'newlen'],
				type_converters=scipy.weave.converters.blitz)
		else:
			scipy.weave.inline(code, ['res', 'poss', 'newlen','weightsind'],
				type_converters=scipy.weave.converters.blitz)			
	except Exception:
		print "Sorry the compiled version didn't work :("
		if weights is None:
			for i in xrange(len(poss)):
				res[poss[i]]+=1
		else:
			for i in xrange(len(poss)):
				res[poss[i]]+=weights[i]
	if not getPos:
		return res.reshape(nbins)
	else:
		H = np.zeros(len(ind),dtype=np.int64)-1
		H[ind] = poss
		return res.reshape(nbins),H	
		
Exemplo n.º 49
0
 def __iter__(self):
     for j in xrange(self.number_of_words):
         yield self[j]
Exemplo n.º 50
0
 def __init__(self, n=3):
     assert n >= 2, "Expecting n>=2."
     self.n = n
     self.emission_counts = defaultdict(int)
     self.ngram_counts = [defaultdict(int) for i in xrange(self.n)]
     self.all_states = set()