"Life is all about sharing. If we are good at something, pass it on." - Mary Berry

Terraform failed to acquire state lock: 403: Access denied., forbidden



We stored Terraform state in gcs. For some reasons, we got this error randomly when running on BitBucket pipelines:

 1 2│ Error: Error acquiring the state lock
 3 4│ Error message: 2 errors occurred:
 5* writing
 7│ failed: googleapi: Error 403: Access denied., forbidden
 8* storage: object doesn't exist
 9101112│ Terraform acquires a state lock to protect the state from being written
13│ by multiple users at the same time. Please resolve the issue above and try
14│ again. For most commands, you can disable locking with the "-lock=false"
15│ flag, but this is not recommended.


The King of Vietnamese language game show


My family likes to watch “The King of Vietnamese language” game show together. I want to encourage our son to love Vietnamese. At the end of the game, the player has to find 7 complex words from the letters, for e.g,

đ / ă / n / g / c / a / y

One evening a few weeks ago, while we were watching the final round, my wife suddenly came up with an idea: this game could be programmed.


SICP Exercise 2.43: Eight queens: interchange the order of the nested mappings


Exercise 2.43: Louis Reasoner is having a terrible time doing exercise 2.42. His queens procedure seems to work, but it runs extremely slowly. (Louis never does manage to wait long enough for it to solve even the 6× 6 case.) When Louis asks Eva Lu Ator for help, she points out that he has interchanged the order of the nested mappings in the flatmap, writing it as


SICP Exercise 2.42: Eight queens puzzle


Exercise 2.42: The “eight-queens puzzle” asks how to place eight queens on a chessboard so that no queen is in check from any other (i.e., no two queens are in the same row, column, or diagonal).

One way to solve the puzzle is to work across the board, placing a queen in each column. Once we have placed k - 1 queens, we must place the kth queen in a position where it does not check any of the queens already on the board.


SICP Exercise 2.41: Triple sum


Exercise 2.41: Write a procedure to find all ordered triples of distinct positive integers i, j, and k less than or equal to a given integer n that sum to a given integer s.

unique-triples can be written easily base on unique-pairs in 2.40:

1(define (unique-triples n)
2    (flatmap
3        (lambda (i)
4            (flatmap
5                (lambda (j)
6                    (map (lambda (k) (list i j k))
7                         (enumerate-interval 1 (- j 1))))
8                (enumerate-interval 1 (- i 1))))
9        (enumerate-interval 1 n)))


SICP Exercise 2.35: Counting leaves of a tree


Exercise 2.35: Redefine count-leaves from section 2.2.2 as an accumulation:

1(define (count-leaves t)
2    (accumulate <??> <??> (map <??> <??>)))

The count-leaves procedure from section 2.2.2:

1(define (count-leaves x)
2    (cond ((null? x) 0)
3          ((not (pair? x)) 1)
4          (else (+ (count-leaves (car x))
5                   (count-leaves (cdr x))))))


SICP Exercise 2.27: Reversing nested lists


Exercise 2.27: Modify your reverse procedure of exercise 2.18 to produce a deep-reverse procedure that takes a list as argument and returns as its value the list with its elements reversed and with all sublists deep-reversed as well. For example,

 1(define x (list (list 1 2) (list 3 4)))
 4((1 2) (3 4))
 6(reverse x)
 7((3 4) (1 2))
 9(deep-reverse x)
10((4 3) (2 1))

First, look at my reverse procedure:

 1#lang racket/base
 2(require racket/trace)
 4(define (reverse items)
 5    (iter items null))
 7(define (iter remaining result)
 8    (trace iter)
 9    (if (null? remaining)
10        result
11        (iter (cdr remaining) (cons (car remaining) result))))
13(trace reverse)
14(reverse (list (list 1 2) (list 3 4)))


SICP Exercise 1.25: A simpler expmod?


Exercise 1.25: Alyssa P. Hacker complains that we went to a lot of extra work in writing expmod. After all, she says, since we already know how to compute exponentials, we could have simply written:

1(define (expmod base exp m)
2    (remainder (fast-expt base exp) m))

Is she correct? Would this procedure serve as well for our fast prime tester? Explain.

First, look at the original algorithm:

 1 (define (expmod base exp m)
 2     (cond ((= exp 0) 1)
 3         ((even? exp)
 4             (remainder
 5                 (square (expmod base (/ exp 2) m))
 6                 m))
 7         (else
 8             (remainder
 9                 (* base (expmod base (- exp 1) m))
10                 m))))


SICP Exercise 1.16: Iterative Exponentiation


I am reading SICP.

Section 1.2.4 talks about the problem of computing the exponential of a given number.

The authors start with a recursive procedure:

1#lang sicp
3(define (expt b n)
4    (if (= n 0)
5        1
6        (* b (expt b (- n 1)))))

This requires O(n) steps and O(n) space.

then an iterative procedure:

 1#lang sicp
 3(define (expt b n)
 4    (expt-iter b n 1))
 6(define (expt-iter b counter product)
 7    (if (= counter 0)
 8        product
 9        (expt-iter b
10                   (- counter 1)
11                   (* b product))))


SICP Exercise 1.14: orders of growth of count-change


Exercise 1.14: Draw the tree illustrating the process generated by the count-change procedure of section 1.2.2 in making change for 11 cents. What are the orders of growth of the space and number of steps used by this process as the amount to be changed increases?

The count-change procedure:

 1(trace-define (count-change amount)
 2    (cc amount 5))
 4(trace-define (cc amount kinds-of-coins)
 5    (cond ((= amount 0) 1)
 6        ((or (< amount 0) (= kinds-of-coins 0)) 0)
 7        (else (+ (cc amount
 8                     (- kinds-of-coins 1))
 9                 (cc (- amount
10                        (first-denomination kinds-of-coins))
11                     kinds-of-coins)))))
13(define (first-denomination kinds-of-coins)
14    (cond ((= kinds-of-coins 1) 1)
15          ((= kinds-of-coins 2) 5)
16          ((= kinds-of-coins 3) 10)
17          ((= kinds-of-coins 4) 25)
18          ((= kinds-of-coins 5) 50)))