显式状态模型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
def bfs_recursive(queue, visited, graph):
    if not queue:
        return
    next_queue = []
    for node in queue:
        print(node)  # do actual work here
        for neighbor in graph[node]:
            if neighbor not in visited:
                visited.add(neighbor)
                next_queue.append(neighbor)
    bfs_recursive(next_queue, visited, graph)

graph = {
    'A': ['B', 'C'],
    'B': ['D', 'E'],
    'C': ['F'],
    'D': [],
    'E': [],
    'F': []
}
visited = set(['A'])
bfs_recursive(['A'], visited, graph)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include <stdio.h>

void printValue(void *ptr, char type) {
    switch (type) {
        case 'i': // int
            printf("Integer value: %d\n", *(int *)ptr);
            break;
        case 'f': // float
            printf("Float value: %.2f\n", *(float *)ptr);
            break;
        case 'c': // char
            printf("Char value: %c\n", *(char *)ptr);
            break;
        default:
            printf("Unknown type\n");
    }
}

int main() {
    int i = 10;
    float f = 3.14f;
    char c = 'A';

    // 什么类型在这里都可以被当成float来使用, 哪怕这会导致严重问题
    printValue(&i, 'f');
    printValue(&f, 'f');
    printValue(&c, 'f');

    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
;; 声明一个namespace
(ns explicit-state-model.atom-example)

;; 定义一个validator, 让其校验传入的n是否是偶数
(defn even-validator [n]
    (even? n))

;; 创造一个"atom变量"
(def counter (atom 0 :validator even-validator))

;; swap是原子化的, 并且当且仅当validator返回true时才能成功
(swap! counter + 2)
;; => 2

;; reset也是原子化的, 这里会失败
(try
    (reset! counter 3)
    (catch IllegalStateException e
        (println "Validation failed:" (.getMessage e))))
;; => Validation failed: Invalid reference state

;; 从这个atom变量中取值
@counter
;; => 2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
(ns agent-example.core)

;; 定义一个修改agent变量的值的函数, 我们一般称之为action函数
(defn increment [state]
    (inc state))

;; 定义一个"agent变量"
(def counter (agent 0))
;; 把action函数发送给agent变量
(send counter increment)
;; 等待action结束
(await counter)
;; 从agent中取值
(println "Counter value:" @counter)

1
2
3
4
5
6
7
8
9
10
11
12
fn work() {
    // 在堆内存上新建一个变量b, 可以理解为Box能自动管理堆内存, 是rust中的"智能指针"
    let b = Box::new(42);

    // 从b中取值需要*操作符
    println!("The value in the box is: {}", *b);

    // 在堆内存上创建一个vector
    let boxed_vec = Box::new(vec![1, 2, 3]);
    println!("The boxed vector is: {:?}", boxed_vec);
}
// 在work函数结束后, b和boxed_vec会自动释放

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import weakref

class MyClass:
    def __init__(self, value):
        self.value = value
    def __repr__(self):
        return f"MyClass({self.value})"

obj = MyClass(10)
weak_obj = weakref.ref(obj)

print("Original object:", obj)
print("Weak reference:", weak_obj)
print("Dereferenced weakref:", weak_obj())

del obj  # Remove the strong reference

print("After deleting obj, weakref returns:", weak_obj())  #不会报错

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>

int main() {
    int arr[] = {10, 20, 30, 40, 50};
    int *ptr = arr; // Pointer to the first element

    printf("Traversing array using pointer:\n");
    for (int i = 0; i < 5; i++) {
        printf("Element %d: %d (address: %p)\n", i, *ptr, (void*)ptr);
        ptr++; // Move pointer to the next element
    }

    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
def binary_search(arr, target):
    left, right = 0, len(arr) - 1  # 初始化: 搜索整个数组
    
    while left <= right:  # 只要区间存在, 就继续查找
        mid = (left + right) // 2  # 取中间索引
        
        if arr[mid] == target:
            return mid  # 找到目标, 直接返回
        
        elif arr[mid] < target:
            left = mid + 1  # 目标在右半部分, 缩小左边界
            
        else:  # arr[mid] > target
            right = mid - 1  # 目标在左半部分, 缩小右边界
            
        # 此时, 目标值若存在, 必在新的区间[left, right]内(不变式成立)
    
    return -1  # 区间为空, 说明目标不存在