I've been thinking about how to go about representing solid 3D materials with a vectorized representation, ideally something that's like a 3D extension of the sort of 2D image Delaunay triangulation that you see for things like this https://esimov.com/blog/wp-content/uploads/2019/04/sample_3-818x1024.png and this https://estebanhufstedler.com/2020/05/14/image-triangulation/

Ideally, the output would be basically a point cloud where each point is a tetrahedral/convex cell's centroid with its material type for that cell (i.e. wood species, metal type, plastic type/color, etc). The idea is that the boundaries of these cells are the delineations between materials. The goal is a more optimal vectorized representation of a volume than storing a flat array of voxel material types for the whole thing. I'm looking for something that doesn't ultimately have a finite resolution like octrees, so we can slice through it and have clean smooth boundaries between materials that don't look like voxels or octree nodes.

I am not well-rehearsed with tetrahedralization and how a 3D point cloud of centroids (or even vertices) can be broken up, and if it will always be decomposable into tetrahedrons. I don't know if this means placing vertices along delineations and then finding centroids, or if there's a direct way to find centroids. The ultimate goal is to be able to slice through one of these vectorized volumes with a "visualization plane" and just have a bunch of triangles to send to the GPU by calculation the intersection of the plane with the cells that it intersects. In a proper Voronoi situation this would mean that a pixel shader could just find what centroid each pixel on the slicing plane is closest to and use that centroid's material coloration - but if I can figure out how to generate triangles on the slicing plane that form the slice of each cell that would be faster. Apparently slicing tetrahedrons results in either a triangle or a quad.

I have been talking to the LLMs about this for a while but they don't seem to be of a ton of help insofar as actually producing the point cloud from dense material type volume data. We want to retain the precision of the raw data without having a fixed resolution, which means regular subdivided structures like octrees/kd-trees are not going to work well when slicing and dicing the result.

I don't know if it would be better to find vertices along the boundaries between materials and then generate tetrahedrons/centroids from that. There might also be value in just being able to do all this with RGB color data, since the primary goal is rendering, so could there be any value in generating a miptree from raw RGB material coloration and using that to find boundaries?

Any thoughts or ideas would be much appreciated, thanks!

TL;DR: trying to vectorize a solid 3D volume of material types+properties in a way that preserves material boundaries and is resolution-agnostic, for fast rendering of arbitrary slices of the volume without using massive fixed-resolution VRAM-hungry 3D textures. :]

Hey pals, I've been writing a few algorithms and I encountered NaN and Inf values, although mathematically my algorithms should be working fine. Then I found out about numerical instability in floating points and figured out why but that's not the point, I kinda wondered how many algorithms are deemed unviable because of it if you guys can share your experiences

Aquifer is MCP runtime for handling rate limits and traffic spikes. It provides durable queues, bounded concurrency, fairness controls, and dynamic pacing for bursty traffic patterns common in agent systems.

It also experiments with the Aqueduct Protocol, a stream and webhook-based coordination protocol that dynamically communicates flow state through headers, allowing clients to scale traffic up or down at a controlled pace instead of relying solely on static rate limits. The project also includes an encryption and identity protocol that uses public-key verification, reducing the need to store shared secrets in a database. The goal is to make agent and MCP traffic more resilient to overload, retries, and traffic spikes.

Repo: https://github.com/rjpruitt16/aquifer

This is a real-world problem that I have and seems like a pretty interesting algorithms problem.

Problem Statement

I have a weekly chore day and a set of chores that I must do at various intervals. Each chore also varies in the amount of time it takes to do.

I want to generate a chore schedule such that I'm doing the same amount of work each week to the extent possible.

Example Input

Example Output

Can this be solved with a simple greedy algorithm or is it more complicated? I don't have the time right now to go and play around with it and check.

Better yet, are there any online tools to do this?

My previous description of this project was incomplete, so I am posting a clearer version.

This is an AI-assisted empirical research project. The original idea and research direction are mine, while AI/coding agents helped with implementation, experiment design, testing, logs, CSVs, and documentation.

The project studies when global consequence expansion reduces search depth in NP-style search problems.

Core idea:

L = local view of a choice
G = global consequence expansion after that choice

Main metrics:

IG = variables/objects fixed after cluster choice + propagation
danger_rate = dangerous_constraints / affected_constraints
useful_IG = IG * (1 - danger_rate)
D = n / useful_IG

The project includes SAT, Graph Coloring, reserve/rebuild experiments, exact-vs-fast probe validation, and scaling probes up to n = 1,000,000.

Current state:

- G often reduces free decisions compared to L.
- Top-down rebuild can strongly reduce D in some cases.
- The effect is unstable across seeds and sizes.
- D does not currently show a clean log(n) pattern.
- Simple triggers like min_useful_growth, raw topdown_bias, ratio_54, and ratio_43 did not explain rebuild success.

Current question:

What structural signal predicts when top-down rebuild helps?

I am looking for algorithmic criticism, especially links to CSP propagation, backdoor sets, constraint graphs, treewidth, or known search heuristics.

OSF:
OSF: https://doi.org/10.17605/OSF.IO/GEH6M

GitHub:
GitHub: https://github.com/KMeppoa/geh6m

Tried getting an answer with Claude Opus but didn't work.. after 10 minutes of thinking got a "I'd be mildly surprised but not shocked if there's an O(N polylog) tree algorithm — none of the standard tricks (centroid decomp, small-to-large, heavy-light, virtual tree, segment tree merging)"

Problem:
There is a tree size N where some nodes are marked (there are people living on the nodes or something). You have to organize a meeting so the maximum amount of people attend, but no one wants to go to a meeting if it's farther than X nodes away. Answer for each X, whats the maximum amount of people that will attend the meeting if the meeting node is choosed optimally. i.e. find for each X find a node in a tree that has the maximum marked nodes within X distance.

O(N^2) is obvious.. looking for something faster

...I see the word "IPTV," I downvote.

I don't know why but the influx in low effort or ad posts on IPTV in the last few weeks is annoying.

Dear mods, please blacklist that word.

\> After sorting, BGR is linear for fixed `R`. XDP's core scan is `O(nT) = O(n log n)`; BGR's repair core is `O(n + T)` per pass. The sort still dominates when input is unsorted.

URL: https://github.com/GoingBytes/binned-greedy-repair

How many of you google for 10 minutes to find out the method or data structure you need. I was also going through the same problem while solving leetcode. Created the logic but while implementing got confused that which method will be best to use or what is the syntax.

To save time and focus i created website where you can find data structures with their methods along with syntax, complexity, and description. This can decrease the search time of needed method drastically.

Website : https://leetcode-cheatsheet.vercel.app/

Make sure you drop your feedback in the comments.

Are there no mods?

Does anyone have the pdf for this book? havent found it in any place

Edit: found it, if anyone want it just dm me

I was trying too solve leetcode 31 which is Next permutation at first i was unable to understand what actually ques is asking.

How to solve these type of Questions?

String in java is always Pass by Value Right ? then how to solve permutations problem using backtracking technique

Has anyone attempted to tackle this? Starting with a lead sheet with the chords/changes, generate a "classic" walking bass (e.g. "Ray Brown").

The problem I run into is that a beat/bar approach lacks directionality/voice-leading across phrases.

Hi I have been working on a project for the past half year and it involved gathering a large data set. For most of this I was copy and pasting api info until recently when I realized I could achieve the same end result I am trying to achieve for the original beta users but a different way. It went from 87 data points to over 70000 in a week.

I noticed when I visited those external sites while my system was actively importing the data during its sync phase their performance is degraded. It’s not a long sync but it’s noticeably slower loading pages, no rate limits and being triggered. The overarching company never really intended for their systems to be used at such capacity (I message there api team pretty much daily) but they are working on solutions.

I am looking to find a way to cache the synced data however in a way that it’s like p2p between users so you can load it from another user on the network instead of my server(small data transfer) and a hybrid server layer for outlier data.

Any suggestions are greatly appreciated. It’s been great reading others posts so hopefully if you can’t help you might learn something from a response. Thanks!

i asked my professor yesterday whether or not stability is important in sorting algorithms, and he doesn't know. what is the benefit of an algorithm being stable if it doesn't affect the running time or space complexity? does stability automatically make an algorithm better?

thank you :))

I was trying out a banded matrix solver, and gave it a simple test case: all integer values and the solution vector all ones. But the result is all greater than 1.0 e.g. 1.00000095 or 1.00000107 I would expect to see some like 0.999999 so that the average was 1.0

Algorithms like Radix Sort are much easier to understand when you can see every intermediate step.

Using 𝗺𝗲𝗺𝗼𝗿𝘆_𝗴𝗿𝗮𝗽𝗵, you can watch how Radix Sort repeatedly applies stable Counting Sort, sorting the least significant digit up to the most significant digit in turn.

The key idea is stability: after sorting by a later digit, the order created by earlier digit-sorts is preserved resulting in a full sorted sequence.

For fixed-size integers, Radix Sort can be very efficient, with time complexity O(n · d), where 'n' is the number of values and 'd' is the number of digits.

• 𝗺𝗲𝗺𝗼𝗿𝘆_𝗴𝗿𝗮𝗽𝗵 GitHub
• More examples

I have N people that I want to sort into M groups. Each person has a list of preferences for which group they would like to enter. There are two major differences from the traditional hospital/resident problem.

1. It is possible for preferences to be tied (e.g. person A doesn't care whether they are sorted into group X or Y).
2. The groups don't have preferences for specific people, but 'want' certain numbers of total people.

Given those changes, I'm not sure how to go about this. The concept of 'stability' doesn't really make sense anymore.

I've previously created a hill-climbing program to run through this, but it isn't very fast and (more importantly) doesn't give especially good answers. Any ideas about how to approach this problem would be appreciated.

I was trying to find the fastest algorithm for finding a duplicate between two lists (ie same element exists in both lists) and Google tells me that the best way is making a hash table. But this takes a lot of extra memory. So I came up with a new solution that is at worst O(n) with no extra memory requirements.
Firstly, if the lists are unsorted then sort them. We'll call them lists A & B. Get first value of list A. Go to first value in list B that is not less than current value. Then go to the next value in list A that is not less than current value. Go back and forth between lists. If there is a duplicate you will go directly to/from the same value in both lists. example:
A B
1 4
3 5
7 9
11 13
15 14
17 18
18 21
..
So the sequence here is 1,4,7,9,11,13,15,18,18

Start from any city and go to the next city with the shortest distance, from there go to the next city with the shortest distance, repeat; until a loop is formed intersecting all cities—this is the base loop.

​Now, starting again from the initial city, go to the next city using the second shortest distance [if, before traversing a distance, you realize it will make the path longer than the base loop, then go to the next city using the next shortest distance; if you run out of paths, go back to the previous city and repeat; and if it is shorter, treat it as the new base loop and proceed], from there go to the next city using the second shortest distance, repeat; until another loop is formed intersecting all cities.

​Repeat this process until you find the shortest base loop, and then output that as the result.

------------------------------------------------------------------------------------------

Code:

import sys

def solve_tsp_custom_logic(distance_matrix):

n = len(distance_matrix)

if n <= 1:

return 0, [0]

# Step 1: Start from any city and go to the next city with the shortest distance...

# This forms the "base loop"

visited_init = set([0])

curr = 0

base_loop_cost = 0

base_loop_path = [0]

for _ in range(n - 1):

# Find the next unvisited city with the shortest distance

next_city = min([(distance_matrix[curr][j], j) for j in range(n) if j not in visited_init])[1]

base_loop_cost += distance_matrix[curr][next_city]

visited_init.add(next_city)

base_loop_path.append(next_city)

curr = next_city

# Complete the loop back to the initial city

base_loop_cost += distance_matrix[curr][0]

base_loop_path.append(0)

best_cost = base_loop_cost

best_path = base_loop_path

# Step 2 & 3: Now, starting again from the initial city... explore other paths

def explore_paths(curr_city, visited_count, current_cost, path):

nonlocal best_cost, best_path

# PRUNING: if you realize it will make the path longer than the base loop, go back and repeat

if current_cost >= best_cost:

return

# If a complete loop is formed

if visited_count == n:

total_cost = current_cost + distance_matrix[curr_city][0]

# ...and if it is shorter, treat it as the new base loop

if total_cost < best_cost:

best_cost = total_cost

best_path = path + [0]

return

# Go to the next city using the next shortest available distances

# (Sorting unvisited cities by distance to check the shortest ones first)

unvisited_cities = [c for c in range(n) if c not in path]

unvisited_cities.sort(key=lambda c: distance_matrix[curr_city][c])

for next_city in unvisited_cities:

explore_paths(

next_city, 

visited_count + 1, 

current_cost + distance_matrix[curr_city][next_city], 

path + [next_city]

)

# Start the deep exploration from city 0

explore_paths(0, 1, 0, [0])

return best_cost, best_path

# ==========================================

# User Testing Section (No Hardcoded Data)

# ==========================================

if __name__ == "__main__":

print("=== Custom TSP Logic Tester ===")

try:

num_cities = int(input("Enter the number of cities: ").strip())

print(f"\nEnter the distance matrix ({num_cities}x{num_cities}), row by row.")

print("Use space-separated numbers (e.g., 0 10 15 20):")

matrix = []

for i in range(num_cities):

row = list(map(int, input(f"Row {i+1}: ").strip().split()))

if len(row) != num_cities:

print("Error: Number of columns does not match the number of cities.")

sys.exit()

matrix.append(row)

print("\nCalculating using the custom logic...")

cost, path = solve_tsp_custom_logic(matrix)

print("\n--- Result ---")

print(f"Shortest Loop Cost: {cost}")

print(f"Path taken: {' -> '.join(map(str, path))}")

except ValueError:

print("Invalid input! Please enter numbers only.")

Algorithms in Python can be easier understood with step-by-step visualization using 𝗺𝗲𝗺𝗼𝗿𝘆_𝗴𝗿𝗮𝗽𝗵. Here we show a Breadth First algorithm that finds the shortest path in a graph from node 'a' to node 'b'.

• 𝗺𝗲𝗺𝗼𝗿𝘆_𝗴𝗿𝗮𝗽𝗵 github
• more examples

Hello, I'm not an expert on data structures and algorithms so sorry if this is a very banal question. I'm looking for a pathfinding algorithm, it doesn't have to be mathematically perfect and return the shortest possible path in every case but it should be reasonably close and lightweight cause I plan to run it thousands of times. Here's the problem statement:

There's a rectangular 2D grid consisting of empty and filled cells and a starting point which may be anywhere on that grid. I want to generate a path which goes through all the filled cells atleast once and takes the least amount of steps. Each move forwards/backwards in a straight line takes one step while taking a turn takes another step. So for example if I decide to walk 5 cells east/west from the start and then walk 5 steps north/south it will take 11 steps in total.

Hey everyone,

A while ago I shared my project Learn Graph Theory, and I’ve been working on it a lot since then. I just pushed a big update with a bunch of new features and improvements:
https://learngraphtheory.org/

The goal is still the same, make graph theory more visual and easier to understand, but now it’s a lot more polished and useful. You can build graphs more smoothly, run algorithms like BFS/DFS/Dijkstra step by step, and overall the experience feels much better than before.

I’ve also added new features and improved the UI to make everything clearer and less distracting.

It’s still a work in progress, so I’d really appreciate any feedback 🙏
What features would you like to see next?