In the world of locked rooms, the man with the key is king. And honey, you should see me in a crown.

# Miscellaneous

过了周五，这个学期就要告以段落了。

然后接下来就是一周的疯狂复习了，加上考试了。

这段时间一直没有更新blog, 感觉还是应该偶尔记一点流水账的。今天早上起来巨冷，于是坐了Tram去学校，打算好好学几个小时习来着，但是被昨天下载的游戏耽误了好多时间> – <

在Tram上无意看到了昨天在超市买厨房打火机被多收了很多钱，所以下了Tram之后就直奔Caltron的ANZ去问了一下，结果人家并不怎么care这件事，说是直接去找Merchant就好。接着去修车行取了昨天拜托修的自行车，貌似除了链条还有很多问题，估计得我自己订零件修了（车行修车太贵了）

晚上和Angle去吃了晚饭，看了中华剧社的话剧《疯子，你好》，感觉故事很不错，最后的结尾挺让人感动的。把Angle送回家之后，我去找昨天的超市撕逼，结果人家的退款速度简直一气呵成，我也就只能All good了。

下周估计又是一场硬仗了（毕竟感觉这个学期没有好好学习。。），希望考完试可以有一个愉快的新旅程LoL

# Piles of Boxes

Several days ago, I’ve joined a Hackathon that sponsored by Facebook.

As qualifying people to this event, they hand out an easy algorithm question. Shortly, you need to calculate how less time to move a bunch of boxes in same heigh.

Here is a solution for reference:

```
import collections
def box(boxesInPiles):
sortBoxes = collections.OrderedDict(sorted(collections.Counter(boxesInPiles).items()))
count = 0
for index, key in enumerate(sortBoxes):
count += index * sortBoxes[key]
return count
print(box([4, 5, 5, 2, 4]))
```

# Musician

Let’s say there are two persons, **Composer** and **Performer**.

The **Composer** randomly selects three different **Pitch** which constructed by two part, **Note** and **Octave**. **Note** in the range of “A” to “G”, **Octave** in the range of “1” to “3”.

For example, here is a typical **Pitch** combined by ‘A’ and ‘1’, in which ‘A’ is the **Note**, and ‘1’ is the **Octave**.

Once **Composer** selected a Combination, **Performer** needs to guess it as quick as possible. After each guess, **Performer** get a feedback which indicates that:

- how many pitches in the guess are included in the target (
**correct pitches**) - how many pitches have the right note but the wrong octave (
**correct notes**) - how many pitches have the right octave but the wrong note (
**correct octaves**)

Now, the question is how to get the corrected answer as less times as possible.

```
-- Subject : UniMelb 2019 SM1 COMP90048 Declarative Programming
-- File : Proj1.hs
-- Author : Mingzhe Du
-- Origin : Mon Apr 8 2019
-- Purpose : This program for guessing a target chord. In each round of the game,
-- the program will generate a chord from a possible set, and then a feedback
-- against the guess will be given. Depanding on these feedbacks, the aim of this
-- program is get the correct chord with as less as possible guess times.
module Proj1 (Pitch, GameState, toPitch, feedback, initialGuess, nextGuess) where
-- Pitch structure
data Pitch = Pitch { note :: Char,
octave :: Char
} deriving (Eq)
instance Show Pitch where
show (Pitch note octave) = [note, octave]
-- Game State
data GameState = GameState { times :: Int, -- Guess times
cCombinations :: [[[Char]]] -- Possible set
} deriving (Eq, Show)
-- Converting String to Pitch
toPitch :: String -> Maybe Pitch
toPitch (a:b:t)
| not (null t) = Nothing
| (elem note' ['A'..'G']) && (elem octave' ['1'..'3']) = Just Pitch {note = note', octave = octave'}
| otherwise = Nothing
where note' = a
octave' = b
-- Comparing target chord and guessed chord
feedback :: [Pitch] -> [Pitch] -> (Int,Int,Int)
feedback pitch_a pitch_b
| (length pitch_a == 3) && (length pitch_b == 3) = (c_p, c_n - c_p, c_o - c_p)
| otherwise = (0,0,0)
where get_key key = foldr (\x acc -> key x:acc) []
c_p = getCounter pitch_a pitch_b 0 -- Correct pitches
c_n = getCounter (map note pitch_a) (map note pitch_b) 0 -- Correct notes
c_o = getCounter (map octave pitch_a) (map octave pitch_b) 0 -- Correct Octaves
-- Initial guess
initialGuess :: ([Pitch], GameState)
initialGuess = (currentGuess, gameState)
where currentGuess = combinationToPitch (cGuess)
gameState = GameState 0 all_combinations
all_items = getCombination "ABCDEFG" "123"
cGuess:all_combinations = subsequencesOfSize 3 all_items -- New guess and new possible set
getCombination p_note p_octave = foldr (\x acc -> (map (\y -> y:[x]) p_note) ++ acc) [] p_octave
combinationToPitch combinations = map (\(Just x) -> x) $ map toPitch combinations -- Converting String to Pitch
-- Get the next guess
nextGuess :: ([Pitch], GameState) -> (Int,Int,Int) -> ([Pitch],GameState)
nextGuess (pGuess, pGameState) pFeedback = (cGuess, cGameState)
where cGuess':cCombs = getNewCombination pGuess pCombinations pFeedback
pCombinations = cCombinations pGameState
cGuess = toChord cGuess'
cGameState = GameState ((times pGameState) + 1) cCombs
toChord = map (\x -> Pitch (x !! 0) (x !! 1))
-- Help Functions
-- remove an item from a list
removeItem :: (Eq a) => a -> [a] -> [a]
removeItem _ [] = []
removeItem x (y:ys)
| x == y = ys
| otherwise = y : removeItem x ys
-- get the number of same elements in two lists
getCounter :: (Eq a) => [a] -> [a] -> Int -> Int
getCounter [] y c = c
getCounter (x:xs) y c
| elem x y = getCounter xs (removeItem x y) (c+1)
| otherwise = getCounter xs y c
-- Generate combinations by a specifc size
subsequencesOfSize :: Int -> [a] -> [[a]]
subsequencesOfSize n xs = let l = length xs in if n>l then [] else subsequencesBySize xs !! (l-n)
where subsequencesBySize [] = [[[]]]
subsequencesBySize (x:xs) = let next = subsequencesBySize xs in zipWith (++) ([]:next) (map (map (x:)) next ++ [[]])
-- Converting a string list to pitch list
toChord :: [[Char]] -> [Pitch]
toChord a = map (\x -> Pitch (x !! 0) (x !! 1)) a
-- retrive a new guess
getNewCombination :: [Pitch] -> [[[Char]]] -> (Int, Int, Int) -> [[[Char]]]
getNewCombination guess allCombinations pFeedback = foldr (\x acc -> if checkFeedback (toChord x) then x:acc else acc) [] allCombinations
where checkFeedback nChord = if pFeedback == (feedback guess nChord) then True else False
```

# Haskell moment

Here are some Haskell code chunks, which both are simple recursion algorithms.

Quicksort is a sort of poster child for Haskell because everyone does it to showcase how elegant Haskell is.

```
quicksort :: (Ord a) => [a] -> [a]
quicksort [] = []
quicksort (x:xs) =
let smallerSorted = quicksort [a | a <- xs, a <= x]
biggerSoted = quicksort [a | a <- xs, a > x]
in smallerSorted ++ [x] ++ biggerSoted
```

```
maximum' :: (Ord a) => [a] -> a
maximum' [] = error "List is empty!"
maximum' [x] = x
maximum' (x:xs) = (max x (maximum' xs))
replicate' :: Int -> b -> [b]
replicate' n x
| n <= 0 = []
| otherwise = (x:(replicate' (n-1) x))
take' :: Int -> [a] -> [a]
take' n (x:xs)
| n <= 0 = []
| otherwise = x:(take' (n-1) xs)
reserve' :: [a] -> [a]
reserve' [] = []
reserve' (x:xs) = (reserve' xs) ++ [x]
```

# How to swap two variables without extra space

Let’s say, we have two variables, A and B, and our task is swapping these two variables without extra space.

First, we can this:

A = A + B

and,

B = A – B = A + B – B = A (import A from Step 1)

finally,

A = A – B = A + B – A = B (import A, B from Step 1 and 2 respectively)

That’s it, Dude!

# Keep going

Listen, smile, agree, and then do whatever the fuck you were gonna do anyway.

最近其实挺迷茫的。

因为还有不到一年的时间就要结束自己的研究生阶段了。但是感觉还有很多事情没有实现。比如到底是继续读博还是工作；是在国内发展还是在国外发展；让体重身材变得正常；说流利的英语；老妈一直关心的找女朋友。

每件事情其实都不是一蹴而就的。我一直相信现在的自己，藏着所有走过的路，读过的书和喜欢崇拜过的人。如果让我现在就决定到底要不要读博士或者去工作的话，真的很难。所以说我只有每天都让自己变得好一点，多看看书，多去健身房运动一下，还有多参加俱乐部认识新的朋友。总有那么一天，在积累了足够多的努力之后，成功就会追上你了。

最近因为学校的事情不得不回学校上课，非常感谢小槐树可以认可我，让我可以假期再回微软玩耍。所以想一想，其实生活中还是有很多好的事情在发生的嘛。

然后是最近的规划。因为刚开学，除了上课还是比较轻松的。希望可以利用这段时间认识一些新的朋友，学一些新的知识，努力充实自己：）

# 告别

其实真正的告别没有长亭古道 没有劝君更尽一杯酒 就是一个和平时一样的早晨 有的人就留在昨天了

# Shadowsocks 优化

Shadowsocks是我一直在用的一款代理软件（菜鸡不会像鱼神那样自己写一套型的协议出来）。为了发挥出SS最大的效率，我们在配置好基础的SS Server之后，可以对SS的配置进行一下优化。

其中优化主要是三个层面：1.系统层面 2.加密层面 3.网络层面

Continue reading# 随缘食单

越来越觉得，其实所谓觉得好吃，是因为那里有美好的回忆。

Continue reading