COMP3506/7505 Algorithms and Data Structures

「文智助手」全场景办公AI助理AI+OPC全流程实践方案(大赛作品) 阅读详情

Assignment Two – 25%

Algorithms and Data Structures – COMP3506/7505 – Semester 2, 2024

Due:  3pm on Friday October 18th (week 12)

Summary

The main objective of this assignment is to extend your knowledge from assignment one to build more complex data structures and solve more complex problems.  In particular, you will be working on graph and compression problems.  In this second assignment, we will leave more of the design choices up to you  (like the k-mers part in A1).  This assessment will make up  25% of your total grade. We recommend you start early.

A Getting Started

The assignment is structured similarly to assignment one . The skeleton codebase, data, software dependencies, implementation rules, are described below. Rules  for success: Think before you code. Think before you post an Ed question. Use a pen and paper. Don’t be afraid to be wrong.  Give yourself time to think. Start thinking about these problems  early. Read the entire spec before you do anything at all.

Codebase

The codebase contains a number of data structures stubs that you must implement, as well as some scripts that allow your code to be tested. Figure 1 shows a snapshot of the project directory tree with the different files categorized. Note that we provide you with (simplified) versions of the data structures built during assignment one. You are permitted to modify any of the files listed. You may also use structures/util.py for any utilities that do not deserve their own file, or add your own data structures if you think they may help; store them in their own files inside the structures directory.

Data

We also provide a number of test graphs for you to use, but you are encouraged to build further test graphs of your own; you may also share your test graphs with other students if you wish.  Each graph is represented as a simple text file that stores an adjacency list for each vertex in the graph. There are three specific types of graphs, each with their own subdirectory. All graph types are undirected. 4N graphs are simple graphs where each vertex can be thought of as occupying a position on a square grid/lattice.  As such, these nodes can have at most 4 neighbours. KN graphs are an extension that allow an arbitrary number of neighbors. POSW graphs extend KN graphs to apply positive integer weights to edges.  The appendix in Section M contains an example of each graph type.

Dependencies

Our codebase is written for Python 3.10+ as we have provided type annotations; as such, you  will need to use Python 3.10 at minimum.  The second assignment has one special dependency – the curses library – that allows your algorithms to be visualized in a simple terminal window.

structures

dynamic_array.py

linked_list.py

bit_vector.py

entry.py

graph.py

pqueue.py

map.py

bloom_filter.py

util.py

algorithms

pathfinding.py

problems.py

compression.py

test_structures.py

test_pathfinding.py

test_problems.py

Figure 1 The directory tree organized by data structures (inside the structures directory), and the three executable programs (in the root directory, coloured orange).

4N

one.graph

two.graph

three.graph

four.graph

five.graph

KN

one.graph

two.graph

three.graph

four.graph

five.graph

POSW

one.graph

two.graph

three.graph

four.graph

five.graph

Figure 2 The data tree organized by graph types. 4N are the most simple grid-based graphs. KN are graphs where each node has an arbitrary degree. POSW are graphs with arbitrary degree nodes and positive weights between the edges.

If you are developing locally, you may need to install curses. See the documentation1 for more information. This library is already available on moss.

Note that you can do the entire assignment without using the visualizer, but it will be less fun and you won’t be able to show off to your friends. The visualizer is only useful for the earlier pathfinding solutions on grids (Task 2), and it must be executed in a terminal window.

Implementation Rules

The following list outlines some important information regarding the skeleton code, and your implementation. If you have any doubts, please ask on Ed discussion.

❙ The code is written in Python and, in particular, should be executed with Python 3.10 or higher. The EAIT student server, moss, has Python 3.11 installed. We recommend using moss for the development and testing of your assignment, but you can use your own system if you wish.

❙ You are not allowed to use built-in methods or data structures – this is an algorithms and data structures course, after all. If you want to use a dict (aka {}), you will need to

implement that yourself.  Lists can be used as “dumb arrays” by manually allocating space  like myArray  =  [None]  *  10 but you may not use built-ins like clear,  count,  copy, extend,  index,  insert,  remove,  reverse,  sort, min, max, and so on. List func- tions like  sorted,  reversed,  zip are also banned.   Similarly,  don’t use any other  collections or structures such as set.  You cannot use the default hash function.  Be  sensible – if you need the functionality provided by these methods, you may implement  them yourself.

❙ You are not allowed to use libraries such as numpy, pandas, scipy, collections, etc.

❙ Exceptions: The only additional libraries you can use are random, math, and functools  (but  only  for  the  total_ordering  decorator).   You  are  allowed  to  use  range  and  enumerate to handle looping.  You may use tuples  (for example; mytup  =  ("abc", 123)) to store multiple objects of different types. You may use len wherever you like, and you can use list slicing if given a Python list as input. If we ask for a Python list in  a function return type, you can use append or pop.

B Task  1:  Data Structures

We’ll start off by implementing some new data structures. All we specify is the interface; the choice of design is yours, as long as the interface behaves correctly and efficiently. You may test these with the test_stuctures .py program: python3 .11  test_structures .py.

Task 1.1:  Fix and  Extend the Priority Queue (3 marks)

A queue is a data structure that can handle efficient access to elements on a first-in-first- out basis.  Recall that a priority queue is an extension of a simple queue that supports efficient access to the element with the highest priority; new elements can be inserted with a given (arbitrary) priority, and the priority queue must be able to support efficient dequeue  operations based on the priority order.  For this assignment, we will assume priority values are  numeric and comparable (so, they may be floats or integers), with lower values representing a higher priority. In other words, we’re going to be supporting a min-heap.

We have provided you with a semi-working priority queue in pqueue .py. Unfortunately, we ran out of time to get it working perfectly, so there are a few bugs lurking in the implementation. First, crush these bugs so the priority queue works properly (1 mark)!

Once your heap is operating correctly, we need to handle a few more subtleties; we’d like to support in-place construction in linear time through the ip_build function, and in-place sorting via the sort function. Note that the in-place operations should operate directly on the data array without creating a copy — running in-place heap sort will yield a sorted array, but will destroy the heap ordering. As such, you may assume the user will no longer use the heap once the sort function has been used.  Welcome to UQ(ueue).

You can test via: python3 .11  test_structures .py  --pq

Task 1.2:  Implement a Map (3 marks)

Your next job is to implement a concrete data structure to support the map interface.  Recall that a map allows items to be stored via unique keys. In particular, given a key/value pair (k, v) (otherwise known as an entry), a map M can support efficient insertions (associate k with v in M), accesses (return the value v associated with k if k ∈ M), updates (update the value stored by key k from v to v′ ) and deletes (remove (k, v) from M). In other words, you will be supporting operations like a Python dict (aka {}) class.

Test via: python3 .11  test_structures .py  --map

Task 1.3:  Implement a Bloom Filter (3 marks)

Bloom filters are an interesting probabilistic data structure that can support extremely efficient and compact set membership operations. In particular, they use hashing in combination with bitvectors to toggle on sets of bits; when looking up a given key k, the key is hashed via a series of unique hash functions and mapped to various indexes of the bitvector.  Next, these bits are observed; if they are all on , then we return True which means “yes, this key might be in the set.” Otherwise, we return False which means “No, this key is definitely not in the set.” Your Bloom filter does not need to double check that the True values are definitely in the set; that job is for another data structure.

Test via: python3 .11  test_structures .py  --bloom

C Preliminaries:  The Graph Class

Many of the following problems (all of Task 2, and some aspects of Task 3) will require the use of a graph data structure. We have provided a concrete implementation of a graph data structure for you, and you will need to get familiar with it in order to progress. The graph types are defined in structures/graph.py.

Graph Types

There are two key types of graphs.  The Graph class is the base class which stores nodes and edges.  Each node in the graph (Node) stores an id which is the index of the node in the graph’s adjacency list. For example, if you have a node with an id 22, this means that the node will be stored at the Graph’s self ._nodes[22] and can be accessed via the Graph’s get_node() function. The Graph also provides a function to return a list of neighbours given an index/node identifier.

There is a special LatticeGraph type that extends the Graph class (and a LatticeNode that extends Node).  This specialized graph is used only for graphs that are placed on a lattice. In other words, these graphs can be thought of as simple grids, where each vertex has between zero and four neighbors. As such, some additional properties including the number of logical rows and columns in the (4N) graph are stored. For your purposes, the only real difference you need to know about with this special type is that you can ask for the (x, y) coordinates of a given LatticeNode using the get_coordinates() function. You can also directly return the nodes to the north/south/east/west using the appropriate get_north() (etc) functions.

Your Implementations

All of the following tasks have pre-made function stubs. You should pay close attention to the type hints so you know what is expected to be taken as parameters, and what should be returned.

Figure 3 The Mega Gurkey – Artwork by Jesse Irwin.

D (Optional)  Backstory for the  Remainder of Assignment Two

Last year, the COMP3506/7505 cohort helped Barry Malloc capture an enterprising Aus- tralian Brush Turkey (named Gurkey Tobbler) that was ruining his garden. Afterwards, the chief scientist at MallocLabs (Dr. Amongus) transported Gurkey to the lab to conduct some genomic sequencing. Thanks to your great work on DNA compatibility, Dr. Amongus  has since discovered that Gurkey DNA is compatible with that of the Loxodonta Africana , the African Bush Elephant!

While this is a crowning scientific discovery, there is one (big) problem; Dr.  Amongus has created a giant hybrid mega Gurkey through the irresponsible use of genetic modification tools. Our goal in this section is to find the mega Gurkey before it’s too late, and to help Barry conduct further analysis on the Gurkey genome.

Meta comment: Why do we make up these crazy backstories and bury details inside them? Well, because you need to practice looking at a problem you have and extracting the important details. It is highly unlikely you will ever be given an extremely well specified problem.  It is also a lot more fun this way :-)

E Task 2: Pathfinding Algorithms

Getting Started

To get started, we will focus on lattice graphs. Note that we have provided some graphs for  you already, and the ones we are interested (for now) are those in the data/4N directory. However, your solutions here must also work on the data/KN and data/POSW graphs (note  that KN and POSW are the same types of graph if an algorithm does not use edge weights).

We have provided a program called test_pathfinding.py to help you test your al- gorithms. This program allows different pathfinding algorithms through two dimensional mazes to be tested (mandatory) and visualized (optional).  Note that in order to make  life easier, we’re randomly generating the origin and goal vertices, so you will need to  supply a seed to the random number generator (via --seed) to yield different origins and  goals each time you run the program. All implementations for Task 2 must be inside the  algorithms/pathfinding.py file, where appropriate stubs are provided for you.

Task 2.1:  Breadth-First Search (2 marks)

Given some arbitrary start vertex u, and some goal vertex v, Breadth-First Search (BFS) systematically walks across the graph until either v is found, or there are no remaining vertices to explore.  Figure 4 provides a sketch of this process.  You must implement the bfs_traversal() stub; note that both the visited list, and the path, are expected to be returned.  Please see the type annotations for the specific details about what should be returned.

To make your results reproducible, you must enqueue/push the unvisited neighbours in the order they are given to you from the get_neighbours() function.

Finally, while we will be visualizing our BFS on the lattice graphs, you must ensure  that your algorithms translate to graphs with arbitrary degree.  This should be trivial to  implement. For the avoidance of doubt, your BFS algorithm will be tested on the KN graphs.

Test via: python3.11  test_pathfinding.py  --graph  data/4N/one.graph  --bfs  --seed   [--viz]

Note that the --viz flag is optional (and triggers the visualizer to run) and  should be substituted with an integer.

Task 2.2:  Dijkstra’s Algorithm (3 marks)

BFS is nice; it is quite simple and it works well at finding the Gurkey when the graph is  unweighted.  However, Brisbane is a hilly city, and some paths are more expensive than  others; we’ll need to take this into account to find the true shortest path to the Gurkey. We also don’t necessarily know where the Gurkey will be, so it would be good to find the  shortest path from our current location to all possible locations.

Your goal is as follows. Given a weighted graph and a source node, return the cost of the lowest-cost path to all reachable nodes. If a node is not reachable (for instance, if the Gurkey has destroyed all of the bridges) then you should not return it in your list. Please see the type annotations for the specific details about what this function should return.

Test via: python3.11  test_pathfinding.py  --graph  data/POSW/one.graph  --dijkstra --seed  

Figure 4 A sketch of breadth-first search starting at vertex  B and searching for vertex  H. A queue keeps track of the next vertices to visit, and they are visited as they are dequeued.  A list can be used to track the order in which nodes are visited.

Note that it does not really make sense to use the --viz flag with Dijkstra, because the 4N graphs do not have edge weights (and the viz tool needs to use 4N graphs).

Figure 5 A sketch of Dijkstra’s algorithm.  See the code for the expected output format and structure.

Task 2.3:  Depth-First Search (2 marks – COMP7505 only)

Depth-First Search (DFS) operates very similarly to Breadth-First Search. However, instead of using a FIFO queue, it uses a LIFO stack. You must implement the dfs_traversal() stub (plus any additional data structures you may require); note that both the visited set, and the path, are expected to be returned. Please see the type annotations for the specific details about what these functions should return.

To make your results reproducible, you must push the unvisited neighbours in the order they are given to you from the get_neighbours() function.

Finally, while you can visualize DFS on the lattice graphs, you must ensure that your algorithms translate to graphs with arbitrary degree. This should be trivial to implement. For the avoidance of doubt, your DFS algorithm will be tested on the KN graphs.

Test via: python3.11  test_pathfinding.py  --graph  data/4N/one.graph  --dfs  --seed   [--viz]

Note that the --viz flag is optional (and triggers the visualizer to run) and  should be substituted with an integer.

Figure 6 A sketch of depth-first search starting at vertex B and searching for node I. A stack keeps track of the next vertices to visit, and they are visited as they are popped from the stack.  A list can be used to track the order in which nodes are visited.

F Task 3:  Problem Solving

Now that the mega Gurkey is back in the lab, we will need to conduct additional testing  to ensure such an event never happens again (well, at least until COMP3506/7505 2025). Unfortunately, Dr. Amongus has already been fired, so it is our job to help Barry Malloc  determine how this all happened in the first place.

Task 3.1:  Maybe Maybe Maybe (3 marks)

MallocLabs has a huge database of k-mers that have been sequenced throughout their many years of operation.  To determine which genomes may have been involved in the genetic modification of the Gurkey, we can simply compare the Gurkey genome to all genomes in the database to find out which ones match, and return those for further analysis. The problem, however, is that the database contains trillions of k-mers.

Our job is to create a fast and compact filtering algorithm that, given a list of database k-mers, D, and another list of query k-mers Q, returns a list of k-mers that from Q that are likely to be in D. We award more marks for having lower false positive rates; the maximum allowed false positive rate is 10%, and then we will measure at 5% and 1%. Note that lower false positive rates might come at higher time and space costs.

Test via: python3.11  test_problems .py  --maybe  --seed    --dbcount   --qcount    --k  

Figure 7 A sketch of Maybe3  – See the code for the expected output format and structure.

Task 3.2:  Dora and the Chin  Bicken (3 marks)

MallocLabs’ spies have recently discovered that their main competitor CallocLabs has hired Dr. Amongus, and are planning to release a giant Ibis named Chin Bicken to wreak havoc on MallocLabs HQ! Barry and the team need to get prepared. The head honchos at MallocLabs have decided on the following strategy:

❙ Chin Bicken will, at some point, attack the MallocLabs HQ;

❙ Since Chin Bicken is enormous, it may attack different parts of the building simultaneously; ❙ At this time, MallocLabs will release a robot – Dora – which does the following:

1. It will receive as input an undirected graph  G where vertices represent rooms in MallocLabs HQ, and edges represent undamaged connections between rooms.

2. From its starting location, it will explore all reachable rooms of the building to collect genomic data left by the Chin Bicken.

3. This genomic data comes in the form. of special gene symbols, s, represented by a single character; there is one at each vertex of G.

4. Next, the robot builds a gene symbol frequency table T which maps each gene symbol s to its total frequency in G, denoted fs.

5. Once T is computed, the robot builds a minimum redundancy code via Huffman’s algorithm, resulting in a codebook CG  mapping each s to a codeword cs.

6. Finally, the robot receives a sequence L = 〈s0, . . . , sn−1〉of n symbols, drawn from all symbols appearing in G. This sequence represents the specific body part of Chin Bicken that MallocLabs believes is its weak point. The robot will use CG  to encode all s ∈ L into one long bitvector B .  That is, B will hold the concatenation of the encoding of each symbol in L: cs0 cs1   · · · csn − 1 .

❙ Once the robot produces B, Barry can feed it into the GeneCoder6000 to develop a weapon to fend off the Chin Bicken.  Of course, Dora will need to be fast. It has to visit all vertices in the graph before Chin Bicken causes any further chaos, after all. You have been tasked to write the logic for Dora. Get to it!

python3.11  test_problems .py  --dora  --graph  data/KN/one.graph  --seed  

Figure 8 A sketch of Dora .  See the code for the expected output format and structure.

Task 3.3:  Chain Reaction (3 marks)

To progress further with the reconstruction of Dr.  Amongus’ cloning programme, Barry now needs to find what is called the optimal reaction compound. We are given n candidate compounds,  each of which is represented by a unique  〈x, y〉coordinate  based  on their reactivity in two specific dimensions of interest. Each compound also holds a floating point value known as the spike radius r.

Compound A is said to cause a reaction with compound B if the circle centered on 〈xA , yA〉with radius r overlaps with the compound at 〈xB , yB〉; however, reactions do not occur naturally — they must be triggered by some other reaction. When a compound reacts, any compound that it is reactive with it will also be triggered (and so on).

You are given one charged molecule to set off a chain reaction, and you must select the given compound i ∈ [0, n − 1] that will maximize the total number of compounds in the chain reaction. If there are ties, return the one with the smallest identifier.

Test via: python3.11  test_problems .py  --chain  --seed    --n  

Figure 9 A sketch of the Chain Reaction problem.  See the code for the expected output format and structure.

Task 3.4:  Lost in the Labyrinth (aka notably more k-cool) (2 marks)

The attack from CallocLabs compromised some of the building structure at MallocLabs HQ, and the team is concerned that the Gurkey might break free.  Barry would like to  build a labyrinth to contain the Gurkey, and has offers from various construction companies. However, he is concerned that some of these companies are trying to scam him, so we need  to help him to come up with an algorithm to determine whether a labyrinth can even be  constructed from each offer.

Each company treats the design of a labyrinth as a graph problem. They provide us with four integers: n, m, k, and c, where n is the number of vertices (|V |), m is the number of edges (|E|), k is the diameter of the graph, and c is the cost to produce it. From these four integers, we must determine if their offer is valid or not. A labyrinth is considered valid if it conforms to the following rules:

❙ It is a connected graph.

❙ It has no double edges or self loops.

❙ The largest shortest simple path between any two vertices v1  and v2   (the diameter) is at most k.  (In other words, if you found the shortest simple path between every pair of vertices, the diameter of the graph is the length of longest one of these.)

Given a list of offers, you must return the cheapest offer that can be constructed. If there are ties, return the one with the smallest identifier.

python3.11  test_problems .py  --labyrinth  --seed    --o  

船载 OpenHarmony AIS 航海工作台:告警与防碰撞预警系统 船载OpenHarmony AIS航海工作台的告警与防碰撞系统,集成十余类告警(超速、偏航、会遇、SOS等),通过网格空间索引实现高效邻近判定,保障实时性。告警管理器统一调度规则、去重、通知与日志,支持悬浮球、语音、跑马灯、弹窗多渠道触达,确保航行安全。SOS紧急通道独立运行,避免干扰。系统设计强调性能优化与多场景适配,为航海安全提供核心支撑。 阅读详情

相关推荐

头歌操作系统 课堂练习4.2:页式内存管理 答案 无解析

头歌操作系统 课堂练习4.2:页式内存管理 答案 无解析

kercii的博客 1万+

Algorithms and Data Structures – COMP3506/7505 – Semester 2 2024 TwoPython

assignmentoneadjacencylistundirectedatmoststructuresentry.pygraph.pypqueue.pymap.pyutil.pyalgorithms4None.graphtwo.graphfour.graphfive.graphKNone.graphtwo.graphfour.graphfive.graphPOSWone.graphtwo.graphfour.graph。

wx___codinghelp的博客 1220

【中英双语】Illumina测序原理详解 | 边合成边测序/Sequencing by Synthesis

很多朋友们问我视频讲解时用的笔记可不可以分享,那当然必须是可以呐!但我当时其实没有好好记录,只是打了个草稿就开讲啦!既然大家有需求,俺就重新整理了一下,希望可以帮到大家!

weixin_43843918的博客 7879

COMP3506/7505 Algorithms and Data Structures One Semester 2 2024Python

One15%AlgorithmsandDataStructuresSemester2,2024Due: 3pmonFridayAugust23(weekstructureswarmupwarmup.pymalloclabswilldoublylinkedlistdatanextnode;headandtailarrayprependoperationsfrontbitvector。

tolitdentay的博客 882

【阅读文献笔记】FoundationStereo: Zero-Shot Stereo Matching

提出首个零样本泛化立体匹配基础模型设计 STA 模块融合单目先验提出 AHCF 模块增强代价滤波构建 100 万合成数据集 FSD + 自净化流程。

qq_46460379的博客 1258

算法笔记(胡凡)学习笔记@Kaysen

本文旨在记录算法笔记学习过程中的收获和一些知识点,部分易错知识点只针对个人而言,CCF-CSP考试冲鸭!!! Chapter 2 C/C++快速入门(易错知识点) 2.1 基本数据类型 变量定义注意区分大小写。 一、整型 整型int,32bit(4Byte),取值范围是,绝对值在范围内的整数都可以定义成int。 长整型long long,64bit(8Byte),取值范围是,绝对值超过的整数就需要用long long存储。 ...

Kaysen_Zhao的博客 2899

AI 问数真的能替代 BI 报表吗?

AI问数赋能自然语言查询,提升临时分析效率,但无法替代传统报表。报表适用于稳定输出与持续监控,AI则擅长探索性提问。企业用好AI问数,关键在于夯实数据模型、统一指标口径、健全权限体系与结果校验机制。合理组合报表、仪表板与AI,才能实现高效、准确的业务洞察。

葡萄城技术团队博客 338

WSL2不能上网,Failed to connect to github.com port 443问题解决方案

WSL2不能上网: 问题:ping外网无效 例如:ping www.baidu.com失败 解决方案: 在wsl: $sudo vi /etc/wsl.conf wsl.conf: [network] generateResolvConf = false 在PowerShell: $sudo vi /etc/etc/resolv.conf resolv.conf: # This file was automatically generated by WSL. To stop automatic gen

Jason_Chen__的博客 9528

ChatGPT、Perplexity、Gemini 与 AI Overviews 引用对比:谁的引用更可信

AI 引擎的引用机制差异很大:ChatGPT 以行内引用加 Sources 列表呈现来源,Perplexity 几乎逐句可溯源,Gemini 在回答中内嵌相关来源链接,AI Overviews 则把多源聚合答案与来源列表一起放在搜索结果顶部。本文从引用透明度、来源偏好、可干预性 3 个维度对比这 4 个引擎,并给出 GEO 的 3 点启示,帮企业在多引擎环境下提升被引用的概率。

淡然一笑 的专栏 276

红米12C刷机避坑指南:NV数据损坏的修复与系统版本选择

本文提供了红米12C刷机过程中避免NV数据损坏的详细指南,涵盖系统版本选择、SP刷机工具使用和fastboot命令修复。重点分析了NV数据损坏的原因与表现,并给出通过工程固件和深度修复技巧解决基带未知、IMEI丢失等问题的实操方案,帮助用户安全完成刷机。

cuda7parallel的博客 1077

k8s上分离集群seatunnel部署(生产推荐)

k8s上分离集群seatunnel部署(生产推荐)

寂夜了无痕的博客 891

【从零理解 Spring AI · 12】MCP 的两种角色:做客户端还是做服务端

上一篇讲了 MCP 的概念:标准协议、三大角色、M+N 替代 M×N。

nice_lcj520的博客 614

kaggle学习笔记-餐厅数据挖掘

分析Zomato数据集的基本思想是为了公平地了解影响在班加罗尔不同地方建立不同类型餐厅的因素,每个餐厅的总评级,班加罗尔是这样一个城市,拥有超过12,000家餐厅,餐厅供应来自世界各地的菜肴。每天都有新的餐馆开业,这个行业还没有饱和,需求也在与日俱增。然而,尽管需求不断增加,新餐馆却很难与老牌餐馆竞争。大多数餐厅都供应同样的食物。班加罗尔是印度的IT之都。这里的大多数人主要依靠餐馆的食物,因为他们没有时间自己做饭。由于对餐馆的需求如此巨大,因此研究一个地方的人口统计学就变得很重要。

优快云XXCQ的博客 1862

抽象主义人工智能和生命体AI的内在联系

彭军辉提出“抽象主义人工智能”作为第四大AI范式,批判符号主义、连接主义、行为主义剥离生命本体的误区,确立“智能是现象,生命是本体”的核心公理。主张原生智能必须依附具备存续诉求的生命本体,提出“生命体AI理论”,构建七层演化阶梯与自闭环工程框架,强调智能不可跳过底层存续机制直接模拟语言。该体系为生成式AI提供科学边界,推动从“仿真表象”向“原生智能”的范式跃迁,开辟硅基人工生命新赛道。

抽象主义人工智能和生命体AI 207

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

OpenAI Control Room 架构拆解:给企业 AI Agent 加一套可审计的急停系统

OpenAI 公开了用于追踪和停止研究模型工作负载的 Control Room。本文拆解 job_id、推理前鉴权、35 秒撤销窗口与 Fail Closed 设计,并给出企业 AI Agent 急停控制面的数据模型、FastAPI 参考实现、缓存撤销策略和故障演练清单。

jerry764的博客 341

华为的C语言编程规范.pdf

华为技术有限公司内部技术规范。本规范制定了编写C语言程序的基本原则、规则和建议。从代码的清晰、简洁、可测试、安全、程序效率、可移植各个方面对C语言编程作出了具体指导。

OpenClaw 深度调查:把 AI 助手做成你自己的控制平面

对 openclaw/openclaw 的完整技术尽调:Gateway 架构、Agent 运行时、工具与沙箱、30 个消息通道、181 个插件、安全信任边界、工程代价与采用建议。17 章 / 10 张图,全部数字标注口径,数据截至 2026-10-31。

厚积薄发 349

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

AI赋能智慧港口建设|造形家快速生成港口全要素三维场景

随着智慧港口、港口数字孪生项目的持续推进,港口三维场景的需求日益旺盛。传统港口三维建模,往往需要航拍倾斜摄影采集数据,再人工搭建吊机、岸桥、船舶、集装箱等大量工业设施模型,项目周期长、人力成本高,修改迭代繁琐,制约港口可视化项目落地效率。国产AI三维建模工具,依托卫星影像 AI 识别能力,无需航拍作业,一键快速搭建港口完整三维场景,为港口数字孪生、方案汇报、投标演示提供高效的场景解决方案。

m0_69539167的博客 85

从设备增点到治理闭环:老旧小区物业数智化落地实践

系统连接合同审批、银行流水、收费记录与项目台账,执行到期提醒、收入核验、异常标色和月度对账,让每一笔资金来源明确、去向可查。针对设施老旧、诉求响应慢、公共收益不透明等问题,津南以6类小区为试点场景,统一建设物业数字化底座,关联楼栋、单元、房屋、业主、空间、设施设备、工单、公共收益等核心数据。系统采用统一编码管理,将摄像头、路灯、井盖、道路、绿化等设施纳入资产台账,解决纸质记录更新滞后、故障责任难追溯的问题。基于历史工单建立分类模型和知识库,辅助识别照明、给排水、电梯、环境秩序、秩序维护等问题;

wuyeshuzhihua的博客 159

企业微信iPad协议详解:接口接入、实时消息同步与语音转码实践

深入解析企业微信iPad协议的技术架构与开发思路,涵盖API接口接入、长连接通信、实时消息同步、Silk语音转码、异常重连及高并发优化,帮助开发者了解企业微信自动化系统的设计与实现。

欢迎来到祖安! 511

Product Hunt 热榜 2026-11-13:Plurai Simulation、YouArt Desktop App、Omnigraph

2026-11-13 Product Hunt 新产品精选:Plurai Simulation、YouArt Desktop App、Omnigraph。汇总 15 款产品的中文介绍、功能关键词和产品链接。

LaughingZhu的博客 615

【AI Agent面试系列】AI Agent可观测、评测、安全相关的知识点

之前的文章介绍了和,本文主要介绍AI Agent的测评、可观测等知识。

406

Docling 原理解读:是什么、为什么、怎么样

从论文视角拆解 Docling 的整体架构、DoclingDocument 数据模型、PDF 预处理、版面分析、OCR、TableFormer 双解码器、阅读顺序与装配流程,并解释版面框与 OCR 框的区别。

PLANTTHESON的博客 401

WorkBuddy 实战:一句话需求 → 七屏可交互原型,户外徒步 App 的 AI 设计全流程

WorkBuddy 实战:一句话需求 → 七屏可交互原型,户外徒步 App 的 AI 设计全流程,跟着博主一起来还原整个过程。

夜郎King的博客 5160

从认识人工智能到理解机器学习:我的 AI 入门第一课

正式开始学习人工智能之前,我对 AI 的认识其实比较模糊:知道 ChatGPT、知道大模型,也知道现在很多岗位都在谈 AI,但如果有人问我“人工智能到底是什么”“机器是怎么学会识别一只猫的”,我未必能从头到尾讲清楚。上午的课程更偏向行业全景:人工智能的发展、研究方向、NLP、岗位分工、学习路线和 AI Coding 工具。下午的课程更偏向技术基础:机器学习的原理、有监督学习、深度学习、模型训练和评估方法。

chh563的博客 566
上一篇: MAST90083: Computational Statistics and Data Science
下一篇: MDSB22 FMS Playlist Track 1
wx__codinghelp
博客等级 码龄2年 514粉丝 61原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值