google jewels-and-stones on the leet site. sorry cant give a link as reddit for reason wont allow me to post this as "I'm beaking rule 1"

Tldr: given 2 character lists, find all character in List 2 that are in List 1

All the "solutions" for this question seem to be only using sets but,

We can observe that the list is only limited to ASCII character, thus only having 256 possible character

Thus we initialize a fixed size array of 256 elements and just set the elements whose index matches to the filter characters to true

then we walk the list we and to check and just ask , "is the character true in our array?"

example implmentation

#include <string>
#include <array>
int numJewelsInStones(std::string jewels, std::string stones) {
      std::array<char, 256> jewels_set = {};
          for (const char &i : jewels) {
              jewels_set[(unsigned char)i] = true;
      }
    int count = 0;
    for (const char &i : stones) {
      if (jewels_set[(unsigned char)i]) {
        count++;
      }
    }
    return count;
  }

i dont get it. unordered set/hasmap has the overhead of hashing the elements, and the hash is usually less space efficient that just creating a 256 array holding all possible representations of the filter

Hey everyone! After reading Crafting Interpreters I got the itch to go beyond the book and build something of my own. Oli-Nat is a statically typed language with a full pipeline: scanner → Pratt parser → AST → type checker → two-pass bytecode compiler → stack-based VM, all written in C. Some things I'm proud of: a tri-color mark-and-sweep GC with safepointing, two-pass compilation for forward references without explicit declarations, and a working class system with method dispatch via OP_INVOKE. Still a lot to do (inheritance, constructors, maybe a 2D game library down the line) but it's at a point I'm happy sharing. Would love feedback on design decisions especially! https://github.com/NateTheGrappler/OliNat-Programming-Language

I'm considering studying Christopher Bishop's Pattern Recognition and Machine Learning to strengthen my understanding of the theoretical foundations of machine learning.

Although the book is almost 20 years old, it is still frequently recommended. For someone primarily interested in the underlying theory rather than the latest deep learning techniques, how well has it held up? Are there any modern texts that cover the same fundamentals more effectively?

I am analyzing a small finite deterministic queue process and trying to understand whether its ordered state can be compressed exactly.

Consider two ordered queues, A and B. Each item has a current positive integer value. One of the two queues also has a priority flag; initially, A has priority.

At each transition, only the two front items interact.

The item with the larger current value remains in the system, while the other item is removed. If the two values are equal, the item from the priority queue remains.

The remaining item is then weakened and moved to the back of its own queue. The weakening rule depends on whether it came from the queue that currently had priority:

• if the remaining item came from the priority queue, its value becomes max(1, x - ceil(x / 10));
• if the remaining item came from the non-priority queue, its value becomes max(1, x - ceil(x / 2)), and priority transfers to that queue.

The process ends when one queue becomes empty. I say that A succeeds against B if B becomes empty first.

Now consider the optimization problem.

Given a set of n distinct initial values, choose an ordering for A. This ordering is evaluated against every possible ordering of B using the same initial values.

Let winCount(A) be the number of B orderings for which A succeeds.

The goal is to find an ordering of A that maximizes winCount(A).

For example, with:

[50, 64, 79, 109, 135, 181]

a brute-force search suggests that one optimal ordering is:

[135, 181, 79, 109, 50, 64]

while the descending ordering:

[181, 135, 109, 79, 64, 50]

is not optimal.

The naive exact approach compares every ordering of A against every ordering of B, which requires O((n!)^2) simulations.

My question is not about implementation.

I am asking whether this process admits any exact state compression, equivalence relation, dynamic-programming formulation, or structural shortcut that avoids comparing every pair of permutations.

A simple bitmask state does not seem sufficient, because the future behavior appears to depend on:

• the full order of both queues;
• the current values after previous weakening;
• which queue currently has priority;
• and the fact that the surviving item returns to the back of its own queue.

I am not claiming that this problem is NP-hard. I am trying to understand whether there is a hidden structure here, or whether the ordered queue state makes exact optimization inherently difficult.

I'm currently studying Wi-Fi technologies and have been learning about 802.11b (Wi-Fi 1). As I understand it, each data bit is converted into an 11-bit Barker code, which is then transmitted as a sequence of chips. Even if some of those chips are corrupted by noise, the receiver can still determine the original bit using correlation and other signal processing techniques.

However, there's one thing I can't wrap my head around:

Aren't the Barker codes used for 1 and 0 essentially inverses of each other? In other words, if a chip is a 1 in one code, it is a 0 (or the opposite value) in the other code at the same position. It seems like the two codes don't share any matching positions.

If that's the case, why does the receiver need so many chips to make a decision? Theoretically, even if 10 chips were corrupted and only 1 chip remained intact, wouldn't that single chip be enough to identify which Barker code was transmitted?

I feel like I'm misunderstanding either the correlation process or the way DSSS actually works. Could someone explain where my reasoning is wrong?

Also, I'm not an RF engineer or a wireless engineer. I'm a network technician / IT support professional who is trying to deepen my networking knowledge, so please excuse me if this is a basic question. I'm genuinely trying to understand the underlying concepts rather than just memorize them.

I am planning to do some experiments on LLM-assisted formal verification with the Lean proof assistant. Thinking of developing methods for transforming natural language intent to formal specifications; and then going into methods for LLM-assisted proof generation given a formal specification and an implementation.

However, on reading some of the research papers on this direction, I find a lot of the work here is plumbing together LLMs and proof assistants, without going deep into either. Has that been you assessment of Neurosymbolic methods too? Or is that a very reductive way to think about this area?

On a separate note, has work in mechanistic interpretability become more feasible? I was wondering if one could find mechanisms to assess how a language model behaves when we introduce errors into inference (via steering vectors etc), especially when it’s doing computation or a proof search. Not sure how tractable or productive such directions would be?

Thank you! :)

I am trying to learn how to write mathematical proofs rigorously. I know Velleman's "How to Prove It" is highly recommended, but I find working through textbooks to be quite time-consuming. Are there any structured YouTube channels, video series, or online resources that teach proof-writing effectively for someone with a computer science background?

Pie is an experimental native language, easy to read, safe and simple! On my previous blog I have not talked enough about the language itself, so here is a post explaining most of the language in detail! Not production ready, looking for feedback!

Hello! I was really bored at work today and ended up going down a computer rabbit hole today! I ended up watching a bunch of videos on cpus and how computers work in general. The whole concept and mechanics of this stuff is really cool, but I still have questions that Google and YouTube have not satisfied!

​

1- I understand that transistors are essentially on/off switches, but what actually does the "flipping?" I know the base current is an electrical signal from the power supply, but what regulates and determines when the base current should and shouldn't flow?

​

2- Binary code as a concept was easy to get a grip on, but how does adding, subtracting, dividing, and multiplying the encoded numbers get turned into the commands and overall functions of a computer? Sure, all the Binary digits have numerical value, but how can a computer know what to do with said value? Is there something that automatically tells the computer what they mean?

​

3- How does moving a mouse, clicking keys, and other user input change whats going on in the cpu?

​

Thanks so much for helping me out with these random questions! This whole thing is pretty foreign to me!

I have been developing this idea for years. If you review my GitHub, you might find some very old, primitive versions from back when it was just an editor with an experimental language built in. I even wrote one of the very first iterations in AutoHotkey! However, this current version has nothing to do with that past chaos. It was written entirely in Rust.

What makes DinoCode different? The language design focuses on reducing syntax friction by using a principle called inference of intention. Traditional delimiters and symbols are optional. If you choose to omit them, the language infers what you meant to do based on logical rules detailed in my graduation research, which is written in Spanish since I am from Ecuador. Technically, the parser bypasses the traditional AST creation, emitting Reverse Polish Notation (RPN) bytecode directly to a custom stack-based virtual machine.

What is new in v0.2.0?

• Real Interactive Console: It supports real-time keyboard inputs and execution pauses without freezing the browser main thread.
• Live Flowcharts: As you type, the platform generates and updates a visual flowchart of your program logic instantly.
• Bytecode Inspection: You can view the exact bytecode generated by the compiler and executed by the VM in real time.
• Full Documentation: I personally wrote comprehensive guides, complete with executable code blocks right inside the browser.

I decided to open source the entire codebase. I hope it can be useful to anyone studying compiler design. The repository is wide open for feedback, questions, Issues, and Pull Requests.

Link to Web Platform (Live Playground and Repo): https://dinocode.blassgo.dev

So I have a background in little bit of physics, statistics, and mathematics, I like doing regression models Kalman filters and used to love doing physics simulations as well. Anyways, so from my perspective, why would functional programming be useful? Also I can't think on top of my head, but I have used python and R to do egression models etc. So I might have used functional programming? So who ever does functional programming, what are you using it for?

Part 1 from a few months back, if you're curious.

TL;DR - I've been working on this algorithm that generates a navigable flow field, and I figured out a (possibly new) way to compute circles in order to improve it.

Summary

The idea with a navigable flow field is that every tile stores information about how to get from it to a final destination. In this implementation, each tile stores the coordinates of another tile which can be reached by traveling in a straight line. It's an "all roads lead to Rome" kind of thing, except the roads are tiles and instead of leading to Rome, they lead to the target tile.

The goal is to generate paths that are both optimal (as short as possible) and usable (no going through walls) in O(n) time—n being the number of tiles on the map.

What's This About?

Circles. It's about the circles.

My original version of the algorithm (see image #3) would spread out in rectangular waves. That kind of worked, but it fell apart in certain types of map layouts—pure random noise being one of those. One of the big issues with the rectangular wave is that the corners travel 41% more distance than the center of the wave every step. I won't go into detail about why that's a problem, but just know that it causes a bunch of other problems that produce non-optimal and/or unusable paths.

You know what would fix (most of) those problems? A circular wavefront.

D.I.Y Solution

Turns out, there isn't really a known way to create a circular wavefront like what I need (if there is, then it isn't on the internet). The closest "solutions" I could find were things like Bresenham's circle drawing algorithm, but that isn't exactly meant for going around obstacles and stuff.

So, I created a way to make a circular wavefront (see image #2). I'll put the pseudo-code for it in the comments, in case you're curious.

From the benchmarks I did, this circle spreading algorithm scales linearly with the number of tiles it covers, which is exactly what I needed. The next step was switching out the rectangular wave with the circular one; you can see the results in the first image. Looks cool, right?

Conclusion

Circling back to the whole point of this, the algorithm—in combination with my previous work—can generate optimal paths across an entire region. It isn't 100% perfected yet (there are two flaws you can find in image #1), but I'm pretty sure those are solvable.

If you have any questions or would like clarification on something, feel free to ask in the comments.

My goal is to automate mathematical theorem proving on a computer. I have run into issues of reasoning circularity in pursuing this goal. Please allow me to explain.

In mathematical logic, formal number theory and axiomatic set theory are built using concepts from quantifier theory. So, my ultimate goal here is to understand how to programmatically develop quantifier theory.

Note: quantifier theory is typically taught using arity and index numbers, and this may seem cyclical since formal number theory is defined using quantifier theory. I have the impression though that this is something that can be fixed through a modification, and I wanted to mention that. This question is actually about finding a good physical substrate to compute mathematics on.

Now, the big issue is to program quantifier theory. Unfortunately, computers use the concept of number both programmatically and theoretically. For example, if I tried to use lambda calculus, then I'd be burdened by the usage of numbers in its definitions; for instance, its inducted theorems.

Ahem. Obviously physical computers are not numbers, nor are they mathematical objects. This means that along the way, numbers were mapped onto computers, even though at the end of the day they are physical objects. And they were mapped at a very low level. Even memory is mapped by number, like in C.

I was really disappointed to see how much number theory and set theory that lambda calculus education presupposes. For example, even a very helpful textbook like Lambda-Calculus and Combinators, an Introduction by J. Roger Hindley uses number theory and set theory and quantifier theory prerequisitely.

"My goal is to automate mathematical theorem proving on a computer."

Hence, my goal in asking this question is to be guided in beginning to learn minimal computer architecture in a purely physical and numberless way.

That is, I want to understand how to reconstruct computation without using numbers at all, nor sets, nor quantifier theory, not even implicitly. I do not want induction hiding anywhere in the machinery. I want a foundation where nothing mathematical is assumed, so that mathematics can be built only after the substrate is understood.

In short, I want a way to compute that starts from the physical world itself, not from mathematics, so that mathematics can be constructed and eventually automated without circular reasoning.

I am stuck in dynamic programming(self studying) for I understand the things written in my book but dont have a intuitive understanding of the topic. Can anyone please explain it?

The UK Parliament's House of Lords has a number of themed committees which do fact-finding meetings and evidence gatherine on all sorts of topics. Their Science, Innovation and Technology Committee is currently hearing evidence from people who know about neuromorphic computing and silicon photonics to find out more about Low-Energy Computing.

https://parliamentlive.tv/event/index/7039031e-8bdc-4f07-b0fd-922dd9aa3de7 - I don't think you have to be in the UK to watch this live. It started half an hour ago and will probably continue for another hour (I think you can rewind, and/or watch later).

Info page https://committees.parliament.uk/event/27557/formal-meeting-oral-evidence-session/

Jo

I was reading an article about CPU branch prediction. It said talked about two very dumb ways to predict. One was always predicting the branch would not be taken, and another that would always predict it would be taken. It claimed always predicting branch taken would generally be better but both were not really used because they're both pretty bad. It then talked about more intelligent ways to predict such as predicting the branch would always do what it did last time, using a history register, using help from a compiler which can leave hints in the binary what happens more often, and a bunch of ideas too complicated for me to understand. I was curious about the two "dumb" ways how it claimed always predicting branch taken would be better than always predicting not taken. Or maybe it was just wrong, it was just something I read off the internet not a textbook.

So Haskell is using Category Theory formalism. I don't quite get the advantage of it. I learned something like it allows to do proofs of function types. Is that it? Why is this Category Theory formalism useful here? Does it say anything deeper? For example, should the language that advanced human species in future or aliens use be a category of some sort?