119 lines
2.9 KiB
Plaintext
119 lines
2.9 KiB
Plaintext
---
|
|
title: Testing Test Test Test
|
|
description: Woah this is so cool
|
|
date: 2025-01-29
|
|
featuredImage:
|
|
featuredImageDesc:
|
|
tags:
|
|
- rust
|
|
- python
|
|
- mdx
|
|
- markdown
|
|
---
|
|
import { Notes, PostImage } from "~/components/Markdown"
|
|
import { Tree } from "~/components/Tree"
|
|
|
|
Woah this blog is sooo cool, look at all these beautifully rendered markdown stuffs :OOOO
|
|
|
|
<Notes>
|
|
|
|
Notty Notes
|
|
|
|
</Notes>
|
|
|
|
## Contents
|
|
|
|
<hr />
|
|
|
|
## Python
|
|
|
|
### longestCommonSubsequence
|
|
|
|
```python lang="python" file="leetcode1143.py"
|
|
class Solution:
|
|
def longestCommonSubsequence(self, text1: str, text2: str) -> int:
|
|
|
|
# edge cases
|
|
|
|
# both texts are just length of 1:
|
|
if len(text1) == 1 and len(text2) == 1:
|
|
return int(text1 == text2)
|
|
|
|
# only one row:
|
|
if len(text2) == 1 and len(text1) > 1:
|
|
return int(text2 in text1)
|
|
|
|
# only one col:
|
|
if len(text1) == 1 and len(text2) > 1:
|
|
return int(text1 in text2)
|
|
|
|
rows = len(text2)
|
|
cols = len(text1)
|
|
|
|
# we use bottom up 2D DP
|
|
# reaching here means it is at least 2x2
|
|
dp = [
|
|
[0 for _ in range(cols)] for _ in range(rows)
|
|
]
|
|
|
|
# seed the top left tile
|
|
dp[0][0] = 1 if text1[0] == text2[0] else 0
|
|
|
|
# we seed the first row and first col
|
|
for col in range(1, cols):
|
|
dp[0][col] = dp[0][col - 1] if text1[col] != text2[0] else 1
|
|
|
|
|
|
for row in range(1, rows):
|
|
dp[row][0] = dp[row - 1][0] if text1[0] != text2[row] else 1
|
|
|
|
|
|
# for the inner triangle, we use the following
|
|
# dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]) if text1[i] != text2[j]
|
|
# else max(dp[i - 1][j], dp[i][j - 1]) + 1
|
|
|
|
for row in range(1, rows):
|
|
for col in range(1, cols):
|
|
dp[row][col] = dp[row - 1][col - 1] + 1 if text1[col] == text2[row] else max(dp[row - 1][col], dp[row][col - 1])
|
|
|
|
# return the bottom right tile
|
|
return dp[rows - 1][cols - 1]
|
|
|
|
# space and time complexity: both O(N * M)
|
|
|
|
# CAN OPTIMIZE TO GET SPACE COMPLEXITY OF O(MIN(N, M))
|
|
```
|
|
|
|
## Rust
|
|
|
|
### Async Programming stuffs
|
|
|
|
```rust lang="rust" file="ffi.rs"
|
|
// Here we have the syscalls
|
|
// Unsafe !!!
|
|
#[link(name = "c")]
|
|
extern "C" {
|
|
pub fn epoll_create(size: i32) -> i32;
|
|
pub fn close(fd: i32) -> i32;
|
|
pub fn epoll_ctl(epfd: i32, op: i32, fd: i32, event: *mut Event) -> i32;
|
|
pub fn epoll_wait(epfd: i32, events: *mut Event, maxevents: i32, timeout: i32) -> i32;
|
|
}
|
|
|
|
// Avoid padding by using repr(packed)
|
|
// Data struct is different in Rust compared to C
|
|
#[derive(Debug)]
|
|
#[repr(C)]
|
|
#[cfg_attr(target_arch = "x86_64", repr(packed))]
|
|
pub struct Event {
|
|
pub(crate) events: u32,
|
|
// Using `Token` a.k.a `epoll_data` to track which socket generated the event
|
|
pub(crate) epoll_data: usize,
|
|
}
|
|
|
|
impl Event {
|
|
pub fn token(&self) -> usize {
|
|
self.epoll_data
|
|
}
|
|
}
|
|
```
|