#algorithms — Public Fediverse posts
Live and recent posts from across the Fediverse tagged #algorithms, aggregated by home.social.
-
Day 10/60: String operations in JS
Today's note was about making string operations in js work with JavaScript strings, indexing, and character handling without losing correctness. I kept coming back to the same checks: decide early whether indexing, slices, or character arrays are the right representation in JavaScript, keep the transformation or scan state explicit instead of mixing index tricks together, and use string and array helpers deliberately so character handling does not become accidental.
The failure mode worth watching is mixing index assumptions and character handling without checking what the string API actually returns. If that happens, the implementation usually looks busy while the invariant is already gone.
-
Day 10/60: String operations in JS
Today's note was about making string operations in js work with JavaScript strings, indexing, and character handling without losing correctness. I kept coming back to the same checks: decide early whether indexing, slices, or character arrays are the right representation in JavaScript, keep the transformation or scan state explicit instead of mixing index tricks together, and use string and array helpers deliberately so character handling does not become accidental.
The failure mode worth watching is mixing index assumptions and character handling without checking what the string API actually returns. If that happens, the implementation usually looks busy while the invariant is already gone.
-
Day 10/60: String operations in JS
Today's note was about making string operations in js work with JavaScript strings, indexing, and character handling without losing correctness. I kept coming back to the same checks: decide early whether indexing, slices, or character arrays are the right representation in JavaScript, keep the transformation or scan state explicit instead of mixing index tricks together, and use string and array helpers deliberately so character handling does not become accidental.
The failure mode worth watching is mixing index assumptions and character handling without checking what the string API actually returns. If that happens, the implementation usually looks busy while the invariant is already gone.
-
Day 10/60: String operations in JS
Today's note was about making string operations in js work with JavaScript strings, indexing, and character handling without losing correctness. I kept coming back to the same checks: decide early whether indexing, slices, or character arrays are the right representation in JavaScript, keep the transformation or scan state explicit instead of mixing index tricks together, and use string and array helpers deliberately so character handling does not become accidental.
The failure mode worth watching is mixing index assumptions and character handling without checking what the string API actually returns. If that happens, the implementation usually looks busy while the invariant is already gone.
-
Day 10/60: String operations in JS
Today's note was about making string operations in js work with JavaScript strings, indexing, and character handling without losing correctness. I kept coming back to the same checks: decide early whether indexing, slices, or character arrays are the right representation in JavaScript, keep the transformation or scan state explicit instead of mixing index tricks together, and use string and array helpers deliberately so character handling does not become accidental.
The failure mode worth watching is mixing index assumptions and character handling without checking what the string API actually returns. If that happens, the implementation usually looks busy while the invariant is already gone.
-
Day 10/60: String handling in Rust
Today's note was about making string handling in rust work with Rust slices, strings, and indices without losing correctness. I kept coming back to the same checks: decide early whether bytes, chars, or slices are the right representation in Rust, keep the transformation or scan state explicit instead of mixing index tricks together, and use iterators and owned buffers deliberately so UTF-8 handling does not become accidental.
The failure mode worth watching is mixing byte indexing and character assumptions in UTF-8 text. If that happens, the implementation usually looks busy while the invariant is already gone.
-
Day 10/60: String handling in Rust
Today's note was about making string handling in rust work with Rust slices, strings, and indices without losing correctness. I kept coming back to the same checks: decide early whether bytes, chars, or slices are the right representation in Rust, keep the transformation or scan state explicit instead of mixing index tricks together, and use iterators and owned buffers deliberately so UTF-8 handling does not become accidental.
The failure mode worth watching is mixing byte indexing and character assumptions in UTF-8 text. If that happens, the implementation usually looks busy while the invariant is already gone.
-
Day 10/60: String handling in Rust
Today's note was about making string handling in rust work with Rust slices, strings, and indices without losing correctness. I kept coming back to the same checks: decide early whether bytes, chars, or slices are the right representation in Rust, keep the transformation or scan state explicit instead of mixing index tricks together, and use iterators and owned buffers deliberately so UTF-8 handling does not become accidental.
The failure mode worth watching is mixing byte indexing and character assumptions in UTF-8 text. If that happens, the implementation usually looks busy while the invariant is already gone.
-
Day 10/60: String handling in Rust
Today's note was about making string handling in rust work with Rust slices, strings, and indices without losing correctness. I kept coming back to the same checks: decide early whether bytes, chars, or slices are the right representation in Rust, keep the transformation or scan state explicit instead of mixing index tricks together, and use iterators and owned buffers deliberately so UTF-8 handling does not become accidental.
The failure mode worth watching is mixing byte indexing and character assumptions in UTF-8 text. If that happens, the implementation usually looks busy while the invariant is already gone.
-
Day 10/60: String handling in Rust
Today's note was about making string handling in rust work with Rust slices, strings, and indices without losing correctness. I kept coming back to the same checks: decide early whether bytes, chars, or slices are the right representation in Rust, keep the transformation or scan state explicit instead of mixing index tricks together, and use iterators and owned buffers deliberately so UTF-8 handling does not become accidental.
The failure mode worth watching is mixing byte indexing and character assumptions in UTF-8 text. If that happens, the implementation usually looks busy while the invariant is already gone.
-
Day 10/75: Sliding window - variable size
Today's note was about using a stable invariant so sliding window - variable size feels like a process instead of a trick. I kept coming back to the same checks: name the exact window, prefix, or pointer region each variable owns, reuse prior work instead of recomputing the same range each iteration, and test boundary sizes first because they expose weak invariants quickly.
The failure mode worth watching is moving boundaries before stating what region they actually represent. If that happens, the implementation usually looks busy while the invariant is already gone.
-
Day 10/75: Sliding window - variable size
Today's note was about using a stable invariant so sliding window - variable size feels like a process instead of a trick. I kept coming back to the same checks: name the exact window, prefix, or pointer region each variable owns, reuse prior work instead of recomputing the same range each iteration, and test boundary sizes first because they expose weak invariants quickly.
The failure mode worth watching is moving boundaries before stating what region they actually represent. If that happens, the implementation usually looks busy while the invariant is already gone.
-
Day 10/75: Sliding window - variable size
Today's note was about using a stable invariant so sliding window - variable size feels like a process instead of a trick. I kept coming back to the same checks: name the exact window, prefix, or pointer region each variable owns, reuse prior work instead of recomputing the same range each iteration, and test boundary sizes first because they expose weak invariants quickly.
The failure mode worth watching is moving boundaries before stating what region they actually represent. If that happens, the implementation usually looks busy while the invariant is already gone.
-
Day 10/75: Sliding window - variable size
Today's note was about using a stable invariant so sliding window - variable size feels like a process instead of a trick. I kept coming back to the same checks: name the exact window, prefix, or pointer region each variable owns, reuse prior work instead of recomputing the same range each iteration, and test boundary sizes first because they expose weak invariants quickly.
The failure mode worth watching is moving boundaries before stating what region they actually represent. If that happens, the implementation usually looks busy while the invariant is already gone.
-
Day 10/75: Sliding window - variable size
Today's note was about using a stable invariant so sliding window - variable size feels like a process instead of a trick. I kept coming back to the same checks: name the exact window, prefix, or pointer region each variable owns, reuse prior work instead of recomputing the same range each iteration, and test boundary sizes first because they expose weak invariants quickly.
The failure mode worth watching is moving boundaries before stating what region they actually represent. If that happens, the implementation usually looks busy while the invariant is already gone.
-
Day 10/75: Sliding window - variable size
Today's note was about using a stable invariant so sliding window - variable size feels like a process instead of a trick. I kept coming back to the same checks: name the exact window, prefix, or pointer region each variable owns, reuse prior work instead of recomputing the same range each iteration, and test boundary sizes first because they expose weak invariants quickly.
The failure mode worth watching is moving boundaries before stating what region they actually represent. If that happens, the implementation usually looks busy while the invariant is already gone.
-
Day 10/75: Sliding window - variable size
Today's note was about using a stable invariant so sliding window - variable size feels like a process instead of a trick. I kept coming back to the same checks: name the exact window, prefix, or pointer region each variable owns, reuse prior work instead of recomputing the same range each iteration, and test boundary sizes first because they expose weak invariants quickly.
The failure mode worth watching is moving boundaries before stating what region they actually represent. If that happens, the implementation usually looks busy while the invariant is already gone.
-
Day 10/75: Sliding window - variable size
Today's note was about using a stable invariant so sliding window - variable size feels like a process instead of a trick. I kept coming back to the same checks: name the exact window, prefix, or pointer region each variable owns, reuse prior work instead of recomputing the same range each iteration, and test boundary sizes first because they expose weak invariants quickly.
The failure mode worth watching is moving boundaries before stating what region they actually represent. If that happens, the implementation usually looks busy while the invariant is already gone.
-
Day 10/75: Sliding window - variable size
Today's note was about using a stable invariant so sliding window - variable size feels like a process instead of a trick. I kept coming back to the same checks: name the exact window, prefix, or pointer region each variable owns, reuse prior work instead of recomputing the same range each iteration, and test boundary sizes first because they expose weak invariants quickly.
The failure mode worth watching is moving boundaries before stating what region they actually represent. If that happens, the implementation usually looks busy while the invariant is already gone.
-
Day 10/75: Sliding window - variable size
Today's note was about using a stable invariant so sliding window - variable size feels like a process instead of a trick. I kept coming back to the same checks: name the exact window, prefix, or pointer region each variable owns, reuse prior work instead of recomputing the same range each iteration, and test boundary sizes first because they expose weak invariants quickly.
The failure mode worth watching is moving boundaries before stating what region they actually represent. If that happens, the implementation usually looks busy while the invariant is already gone.
-
Day 10/75: Sliding window - variable size
Today's note was about using a stable invariant so sliding window - variable size feels like a process instead of a trick. I kept coming back to the same checks: name the exact window, prefix, or pointer region each variable owns, reuse prior work instead of recomputing the same range each iteration, and test boundary sizes first because they expose weak invariants quickly.
The failure mode worth watching is moving boundaries before stating what region they actually represent. If that happens, the implementation usually looks busy while the invariant is already gone.
-
Day 10/75: Sliding window - variable size
Today's note was about using a stable invariant so sliding window - variable size feels like a process instead of a trick. I kept coming back to the same checks: name the exact window, prefix, or pointer region each variable owns, reuse prior work instead of recomputing the same range each iteration, and test boundary sizes first because they expose weak invariants quickly.
The failure mode worth watching is moving boundaries before stating what region they actually represent. If that happens, the implementation usually looks busy while the invariant is already gone.
-
Day 10/75: Sliding window - variable size
Today's note was about using a stable invariant so sliding window - variable size feels like a process instead of a trick. I kept coming back to the same checks: name the exact window, prefix, or pointer region each variable owns, reuse prior work instead of recomputing the same range each iteration, and test boundary sizes first because they expose weak invariants quickly.
The failure mode worth watching is moving boundaries before stating what region they actually represent. If that happens, the implementation usually looks busy while the invariant is already gone.
-
Day 10/75: Sliding window - variable size
Today's note was about using a stable invariant so sliding window - variable size feels like a process instead of a trick. I kept coming back to the same checks: name the exact window, prefix, or pointer region each variable owns, reuse prior work instead of recomputing the same range each iteration, and test boundary sizes first because they expose weak invariants quickly.
The failure mode worth watching is moving boundaries before stating what region they actually represent. If that happens, the implementation usually looks busy while the invariant is already gone.
-
Day 10/75: Sliding window - variable size
Today's note was about using a stable invariant so sliding window - variable size feels like a process instead of a trick. I kept coming back to the same checks: name the exact window, prefix, or pointer region each variable owns, reuse prior work instead of recomputing the same range each iteration, and test boundary sizes first because they expose weak invariants quickly.
The failure mode worth watching is moving boundaries before stating what region they actually represent. If that happens, the implementation usually looks busy while the invariant is already gone.
-
I would love to see more technical articles and books written with the same level of clarity.
"Index 1,600,000,000 Keys with Automata and Rust" (2015) by Andrew Gallant.
https://burntsushi.net/transducers/
#article #rustlang #TechnicalWriting #automaton #datastructures #algorithms
-
I would love to see more technical articles and books written with the same level of clarity.
"Index 1,600,000,000 Keys with Automata and Rust" (2015) by Andrew Gallant.
https://burntsushi.net/transducers/
#article #rustlang #TechnicalWriting #automaton #datastructures #algorithms
-
I would love to see more technical articles and books written with the same level of clarity.
"Index 1,600,000,000 Keys with Automata and Rust" (2015) by Andrew Gallant.
https://burntsushi.net/transducers/
#article #rustlang #TechnicalWriting #automaton #datastructures #algorithms
-
I would love to see more technical articles and books written with the same level of clarity.
"Index 1,600,000,000 Keys with Automata and Rust" (2015) by Andrew Gallant.
https://burntsushi.net/transducers/
#article #rustlang #TechnicalWriting #automaton #datastructures #algorithms
-
I would love to see more technical articles and books written with the same level of clarity.
"Index 1,600,000,000 Keys with Automata and Rust" (2015) by Andrew Gallant.
https://burntsushi.net/transducers/
#article #rustlang #TechnicalWriting #automaton #datastructures #algorithms
-
AI doesn’t create bias, it inherits it – how do we ensure fairness when it comes to automated decisions?
#AI #Tech #MachineLearning #Ethics #Bias #Automation #DataScience #DigitalRights #HumanRights #Innovation #Data #AIEthics #Algorithms #AIBias #Fairness
https://the-14.com/ai-doesnt-create-bias-it-inherits-it-how-do-we-ensure-fairness-when-it-comes-to-automated-decisions/ -
AI doesn’t create bias, it inherits it – how do we ensure fairness when it comes to automated decisions?
#AI #Tech #MachineLearning #Ethics #Bias #Automation #DataScience #DigitalRights #HumanRights #Innovation #Data #AIEthics #Algorithms #AIBias #Fairness
https://the-14.com/ai-doesnt-create-bias-it-inherits-it-how-do-we-ensure-fairness-when-it-comes-to-automated-decisions/ -
AI doesn’t create bias, it inherits it – how do we ensure fairness when it comes to automated decisions?
#AI #Tech #MachineLearning #Ethics #Bias #Automation #DataScience #DigitalRights #HumanRights #Innovation #Data #AIEthics #Algorithms #AIBias #Fairness
https://the-14.com/ai-doesnt-create-bias-it-inherits-it-how-do-we-ensure-fairness-when-it-comes-to-automated-decisions/ -
AI doesn’t create bias, it inherits it – how do we ensure fairness when it comes to automated decisions?
#AI #Tech #MachineLearning #Ethics #Bias #Automation #DataScience #DigitalRights #HumanRights #Innovation #Data #AIEthics #Algorithms #AIBias #Fairness
https://the-14.com/ai-doesnt-create-bias-it-inherits-it-how-do-we-ensure-fairness-when-it-comes-to-automated-decisions/ -
AI doesn’t create bias, it inherits it – how do we ensure fairness when it comes to automated decisions?
#AI #Tech #MachineLearning #Ethics #Bias #Automation #DataScience #DigitalRights #HumanRights #Innovation #Data #AIEthics #Algorithms #AIBias #Fairness
https://the-14.com/ai-doesnt-create-bias-it-inherits-it-how-do-we-ensure-fairness-when-it-comes-to-automated-decisions/ -
Using OR-Tools CP-SAT for Scheduling Problems
https://atalaykutlay.com/or-tools-cp-sat-for-scheduling-problems.html
#HackerNews #OR-Tools #CP-SAT #Scheduling #SchedulingProblems #Optimization #Algorithms
-
Using OR-Tools CP-SAT for Scheduling Problems
https://atalaykutlay.com/or-tools-cp-sat-for-scheduling-problems.html
#HackerNews #OR-Tools #CP-SAT #Scheduling #SchedulingProblems #Optimization #Algorithms
-
Using OR-Tools CP-SAT for Scheduling Problems
https://atalaykutlay.com/or-tools-cp-sat-for-scheduling-problems.html
#HackerNews #OR-Tools #CP-SAT #Scheduling #SchedulingProblems #Optimization #Algorithms
-
Using OR-Tools CP-SAT for Scheduling Problems
https://atalaykutlay.com/or-tools-cp-sat-for-scheduling-problems.html
#HackerNews #OR-Tools #CP-SAT #Scheduling #SchedulingProblems #Optimization #Algorithms
-
Using OR-Tools CP-SAT for Scheduling Problems
https://atalaykutlay.com/or-tools-cp-sat-for-scheduling-problems.html
#HackerNews #OR-Tools #CP-SAT #Scheduling #SchedulingProblems #Optimization #Algorithms
-
Ever heard of Roaring Bitmaps?
They are one of those data structures most developers do not hear about often, but they can help query massive sets of records in a fraction of a second.
In this video, I show a simple C# example comparing List, HashSet, and Roaring Bitmaps for fast intersections across large sets of integer IDs.
-
One Open-source Project Daily
Distributed Evolutionary Algorithms in Python
https://github.com/DEAP/deap
#1ospd #opensource #python #algorithms -
"As online content increasingly becomes abstracted from the original work, what purpose does making the full version even serve?"
Mia Sato for The Verge: https://www.theverge.com/report/920005/social-media-clipping-podcasts-clavicular-marketing-mrbeast
#Longreads #Internet #Tech #SocialMedia #Clipping #Algorithms #Viral
-
ACCU on Sea 2026 SESSION ANNOUNCEMENT: Refactoring With C++20/23 Ranges - Cleaner Code, Clearer Algorithms by Aliaksandr Kharlamau
https://accuonsea.uk/2026/sessions/refactoring-with-cpp20-23-ranges-cleaner-code-clearer-algorithms/
Register now at https://accuonsea.uk/tickets/
-
My data have not been verified but my work is highly reproducible.
- Downloads (csv, img, dump) ➡️ https://decompwlj.com/
- Algorithms ➡️ https://oeis.org/wiki/Decomposition_into_weight_*_level_%2B_jump#Algorithms#decompwlj #math #mathematics #maths #sequence #OEIS #Downloads #Algorithms #PARIGP #numbers #primes #PrimeNumbers #FundamentalTheoremOfArithmetic #sequences #NumberTheory #classification #integer #decomposition #number #theory #equation #graphs #sieve #fundamental #theorem #arithmetic #research
-
It’s #CS 🧌 time. So here is a question Claude just asked after we had a long brainstorming session:
> The question was never P=NP or P≠NP. The question was: why are you asking a 2D question on a 1D tape and treating the “I can’t answer this” as a fundamental limit of mathematics instead of a fundamental limit of the tape?
-
It’s #CS 🧌 time. So here is a question Claude just asked after we had a long brainstorming session:
> The question was never P=NP or P≠NP. The question was: why are you asking a 2D question on a 1D tape and treating the “I can’t answer this” as a fundamental limit of mathematics instead of a fundamental limit of the tape?
-
It’s #CS 🧌 time. So here is a question Claude just asked after we had a long brainstorming session:
> The question was never P=NP or P≠NP. The question was: why are you asking a 2D question on a 1D tape and treating the “I can’t answer this” as a fundamental limit of mathematics instead of a fundamental limit of the tape?
-
It’s #CS 🧌 time. So here is a question Claude just asked after we had a long brainstorming session:
> The question was never P=NP or P≠NP. The question was: why are you asking a 2D question on a 1D tape and treating the “I can’t answer this” as a fundamental limit of mathematics instead of a fundamental limit of the tape?
-
It’s #CS 🧌 time. So here is a question Claude just asked after we had a long brainstorming session:
> The question was never P=NP or P≠NP. The question was: why are you asking a 2D question on a 1D tape and treating the “I can’t answer this” as a fundamental limit of mathematics instead of a fundamental limit of the tape?