For April, I’ve selected Computer Networks, this is partly motivated by my work at ELB team at AWS, and the course that I’ll be doing is Stanford CS144.

course website: https://cs144.github.io/

Unit 1

• Important networking design principles:
  • Layering
  • Encapsulation
  • Packet Switching
• Key concept: reliable bytestream over unreliable network
  • can be arranged in different ways to achieve different applications
  • E.g. client-server, bittorrent, skype

Given an unsorted integer array nums. Return the smallest positive integer that is not present in nums.

You must implement an algorithm that runs in O(n) time and uses O(1) auxiliary space.

Example 1:

Input: nums = [1,2,0]
Output: 3
Explanation: The numbers in the range [1,2] are all in the array.

Example 2:

Input: nums = [3,4,-1,1]
Output: 2
Explanation: 1 is in the array but 2 is missing.

Example 3:

Input: nums = [7,8,9,11,12]
Output: 1
Explanation: The smallest positive integer 1 is missing.

Constraints:  

• 1 <= nums.length <= 105
• -231<= nums[i] <= 231- 1

Solution

class Solution {
public:
    int firstMissingPositive(vector<int>& nums) {
        auto it = std::partition(nums.begin(), nums.end(), [](int x) {return x <= 0;});
        if (it == nums.end()) return 1;
        
        long long int si = it-nums.begin();
        for (int idx = si; idx < nums.size(); idx++) {
            int absv = abs(nums[idx]);
            if (si + absv - 1 < nums.size())
                nums[si + absv - 1] = -1 * abs(nums[si + absv - 1]);
        }

        for (int idx = si; idx < nums.size(); idx++) {
            if (nums[idx] > 0)
                return idx - si + 1;
        }
        return nums.size() - si + 1;
        
    }
};

Given an m x n matrix board where each cell is a battleship 'X' or empty '.', return the number of the battleships on board.

Battleships can only be placed horizontally or vertically on board. In other words, they can only be made of the shape 1 x k (1 row, k columns) or k x 1 (k rows, 1 column), where k can be of any size. At least one horizontal or vertical cell separates between two battleships (i.e., there are no adjacent battleships).

Example 1:

Input: board = [["X",".",".","X"],[".",".",".","X"],[".",".",".","X"]]
Output: 2

Example 2:

Input: board = [["."]]
Output: 0

Constraints:

• m == board.length
• n == board[i].length
• 1 <= m, n <= 200
• board[i][j] is either '.' or 'X'.

Solution:

We could simply count the top-left corners of a battleship, and since there are no colliding battleships, these points uniquely identify a battleship

class Solution:
    def countBattleships(self, board: List[List[str]]) -> int:
        m, n = len(board), len(board[0])
        ans = 0
        for i in range(m):
            for j in range(n):
                if board[i][j] == '.':
                    continue
                if i > 0 and board[i-1][j] == 'X':
                    continue
                if j > 0 and board[i][j-1] == 'X':
                    continue
                ans += 1
        return ans