# [Java][LeetCode][HashMap] Bulls and Cows

Traverse element of secret and guess at the same time. The count will be pulsed one when the guess character is the same as the secret character at the same index. If the secret and guess character are different, the character will be put in map and count the number. The next step is traverse elements of the guess string. If the character is appeared in map, I will subtract the count of character and I will count B number at the same time. Until the count is 0, then remove the character in the map.

--

--

# [Java][LeetCode][Stack]Asteroid Collision #735

1. 兩個行星要不同的方向
2. 行星是依序碰撞的，不會跳著碰撞
3. 小的行星會被撞毀，一樣大小的時候會兩個都撞毀
4. 後者往前看要撞擊的行星，如果被撞掉了，就再繼續往前比較
5. 當前者為負的，後者為正的，不會被撞掉

Asteroids collision conditions are:
1. They are in different directions.
2. Asteroids collide in order in the sequence.
3. The small one will explode. The same size will explode with each other.
4. back one collides front one, if the front is explode, the back one will collide continuously. Until all ahead asteroids explode.
5. When the front one is negative, and the back one is positive, they won’t collide.
with the mention above, I got those conditions:
current<top of the stack: current will collide. The current asteroids will not be kept.
current = top: current and top will collide. the top one will be removed from the stack.
current>top: collide continuously.

--

--

# [Java][LeetCode][BFS][DFS][Graph] Number Of Islands #200

DFS用遞迴的方式，BFS用Queue的方式。

1. 上下左右的位置必須在有matrix圍內:

x≥0 && x<grid.length && y≥0 && y<grid[0].length

2. 上下左右的值為1

grid[m][n]==’1'

DFS is with recursive, and BFS is with Queue.
Traversal all position of ‘1’. Dependent on the position, change the value of neighbors to ‘0’. Keeping in mind:
1. Positions of neighbors are inside the edge of the matrix.

x≥0 && x<grid.length && y≥0 && y<grid[0].length

2. the value of the neighbor is ‘1’

grid[m][n]==’1'

--

--

# [Java][LeetCode][Graph][BFS]

Time complexity is O(m*n)

1. 找每個1，然後去找最近的0，特殊案例就是大多都是1，只有一個0
2. 找每個0，然後去找0附近的1，特殊案例就是大多都是0，只有一個1

“return the distance of the nearest 0 for each cell”
consider 1. find each 1, then find the nearest 0 and count the distance. The worst case is [[1,1,1],[1,1,1],[1,0,1]].
consider 2. find each 0, depend on the coordinate of 0 to search 1 and calculate the level. The worst case is [[0,0,0],[0,0,0],[0,0,1]].
level by level to search is qualify BFS.

--

--

# [Java][LeetCode][Tree][BFS][DFS]

DFS:

BFS:

Implement with DFS and BFS, the time complexity both are O(N).
DFS:
Create a global variable to return the sum when the tree is traversal done. The number of each level is the number of the last level multiple 10 and adds the current node value. The number needs to be delivered to the next level. Until, all nodes were traversed, quite the while loop.
BFS:
Create two Queue, one is to keep the node, and one is to keep the number of the last level calculated. While this side of the tree is traversed, put the number into a list, I will calculate the sum when the two sides of the tree are finished.

--

--

# [Java][LeetCode][Bitwise] Binary Number with Alternating Bits #693

The wrong approach is to do modulo and keep modulo in the list until n=0. Pair compare each other. Even I can get the binary array of n and through the pair compare to check n is sparse or not. But when n is a larger number( n=60000)…

--

--

# [Java][LeetCode][BFS] Binary Tree Right Side View #199

Given the `root` of a binary tree, imagine yourself standing on the right side of it, return the values of the nodes you can see ordered from top to bottom.
Input: root = [1,2,3,null,5,null,4]
Output: [1,3,4]

imagine yourself standing on the right side of it

The first time, I did not take care that sentence:

imagine yourself standing on the right side of it

I just only saw right side. I output all right side elements. Absolutely, It is failed… I return to reading this problem again and saw the sentence. My approach is: to keep the last value at every layer, I don’t matter other values at this layer.

The code includes a test suit.

--

--

# [Java][LeetCode][BFS] Binary Tree Zigzag Level Order Traversa #103

Given the `root` of a binary tree, return the zigzag level order traversal of its nodes' values. (i.e., from left to right, then right to left for the next level and alternate between).
Input: root = [3,9,20,null,null,15,7]
Output: [[3],[20,9],[15,7]]

output is dependent on Layer, so this problem is BFS. I need to output order and reverse order alternate. When this term is reverse order, I need to reverser list. The first time, I had wrong direction. I think is InOrder and PostOrder alternate.
This code include Test Suit at LeetCode.

--

--

# [Android][Firebase] Firebase connect with Android Studio

Add Firebase using the Firebase Console

1. Create a Firebase Project
2. Register an App with Firebase
4. Add Firebase SDKs to App
5. Sync app to ensure that all dependencies have the necessary versions.

--

--

# [Java][LeetCode][BFS] Maximum Depth of Binary Tree #104

Given the `root` of a binary tree, return its maximum depth. A binary tree’s maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node.

Example 1:

`Input: root = [3,9,20,null,null,15,7]Output: 3`

Face to BFS of Binary Tree…
This theme of the problem is “Depth”, so it depends on the Level concept. This is the BFS concept. According to Input of example, this is In Order node. Initialize a Queue to keep node, initialize a counter to count node level, when it gets in a level, count will plus one.

--

--