No array languages on the wheel. Hoping for some APL or BQN

“Formally verified”, they said

Statement 1: "A normal youtuber uses an online wheel of fortune" Statement 2: "An embedded programmer builds on themself" These statements don't directly connect and lack context. Here's a breakdown of possibilities for each statement: Statement 1: Online wheel of fortune: Many KZfaqrs use online tools or websites that offer virtual "wheel of fortune" games. These tools allow them to select random options, challenges, or topics to incorporate into their videos, adding an element of chance and audience engagement. Normal KZfaqr: This is a subjective term. Defining what constitutes a "normal" KZfaqr is difficult as the platform hosts a vast variety of content creators with diverse styles and approaches. Statement 2: Embedded programmer: This could refer to a programmer who focuses on developing software components designed to be integrated into other applications or systems. Builds on themself: This phrase is unclear and grammatically incorrect. It's likely meant to convey an idea of personal growth, self-improvement, or continuously building upon one's skills and knowledge.

i meeeeeeeeeeeean

Not to mention wrong.

@@LowLevelLearning It's a circular dependancy.

Fitting. C++ is development tetanus.

Idk to me it seems like rust is trying to be the c++ clone with where it's going at this rate. They are both taking inspiration from each other though.

I thought the same thing. And considering that there is at least one number on each string, the two pass solution would in the worst case scenario read 1 more character then the one-pass solution, so it would be O(n+1) in the worst case scenario, not O(2n). And as you said, it would most times be more efficient than the single pass solution if there are two digits or more

It would be more efficient if you knew the size of each string beforehand. If you were to implement it in C, you would have to first calculate the size of the string (that's one pass) so you don't access invalid memory, and then do the "two-pass" solution. Doing the "one-pass" solution, you wouldn't need to know the size of the string.

Definitely. I originally solved it with practically the exact same 1 pass algorithm. Then I made a 2 pass and got about 3x performance boost.

It's actually not ( i think ), and the reason is that the 2-pass solution actually has 3 passes, of which one is done by std::getline(). If you use getchar instead you can do (the first part) in that same pass you find the newline in, and without allocating any memory too. The second part you can also do in that same pass, but i'm not sure of the effect that has on performance: ( this solution is untested. It merges strcmp's internal loop into the getchar loop, eliminating a lot of duplicate comparisons, but as a result it will fail if a number string overlaps with itself. fortunately that can't happen for 0-9 in English ) uint indices[sizeof numbers] = {0} for c in input: (EOF/null/newline check) (check against literal number) for i in 0 to sizeof(numbers)-1 if !numbers[i][indices[i]] handle match if numbers[i][indices[i]] == c indices[i]++ continue indices[i] = 0

The one pass is always O(n) with n being the length of the string. While the 2 sided is at MOST O(n), but likely less as you can early stop once you encountered a digit.

he doesn't know C++. Let him stay ignorant

@@1337Kupo Doesn't know it for a reason lol. Not worth knowing (unless absolutely required)

@@VivekYadav-ds8oz It is worth knowing if you wanna make statements about it

Braindead take@@VivekYadav-ds8oz

I thing some lisp would be torture part 2

How about Brainfuck?

T-SQL / PL/SQL / PL/pgSQL

C#, specifically using COSMOSOS to make an OS, or maybe some esolangs.

As a java developer I can say that I was quite disappointed to not see it on the wheel...

Thanks so much!

"-1 in uint32s" Yeah that hurt me.

@@bb-sky yes it does exactly that, the compiler allows it because you need to explicitly enable warnings during compilation ( -Wall, -Wextra)

literally never gonna happen 🤣

I tried cobol once, I think I'm still recovering from the experience lol

some fortran would be fun too

@@woofcaptain8212 try handling abends everyone will become sober

More like COOLbol, right guys? 😂

FYI, in C++20 introduced std::format which is inspired by libfmt. It formats the string the same way as libfmt does and then you use cout/printf to output it. EDIT: And in C++23 we get std::print which equivalent to libfmt's print!!! Hooray.

@@sledgex9 Ik, However, if u need to compile it for old platform (debian buster as example), you better go with additional 3rd party dependency, that trying to use c++20. Btw, it is not inspired, but it is actually proposed by the author of libfmt to add it to the standard library.

This is like saying a modern young celebrity popularized a fashion style that's been around, and in and out of style, since the 80's haha

As someone who implemented a backwards lookup, it does work. My testing function for both forward & backward took a char*. If it was a digit, it returned the int value of that digit and I stopped iterating. If it wasn't a digit, I compared the substring starting at that char*, returning an integer based on which string it matched if any. I stopped iterating as soon as I found an answer, so as soon as the char* walked backwards to the `e` in eight, I stopped looking backwards, and the fact that the `one` was also part of it didn't matter. Same with forward iterator: as soon as it saw `one`, it stopped looking

this is what im afraid of

@@LowLevelLearning someone is going to make you learn APL syntax

There are dozens of us!

Why not std::print on 23?

@@heavymetalmixer91 I wrote that, but some compilers didn't implement it yet.

no way they got the rust println, that's awesome

@@VivekYadav-ds8oz technically it's from Python

Not nearly as nice as F# though.

@@Akronymus_ Both are good

Zig is cool, you can embed the input file at compile time so a lot of the input processing is done before you even run. Not sure how flexible the standard library is though.

😏

If you have access to C++20/C++23 take a look at std::format and std::print. If not, then take a look at "fmtlib".

C++23 is bringing std::print and std::println which I'm going to use in a heartbeat over std::cout

The lack of safety? Isn't it safer than printf, though?!

@@assyyn4139 Yup cout is safer than printf. I have no idea what is obfuscated by cout that isn't obfuscated by printf, other than the fact that you don't dangerously use the wrong type specifier anymore. However I think the C++ teacher above is refering to pointer safety. Perhaps they are not teaching their students to use smart pointers over raw owning pointers.

iostream is a pain to use (cin/cout), but it does one C++ thing - it is generic. You can change the type and it will work, there is no need to change the format string.

And intercal

And Unlambda

They'd straightup force him to do it in Malbolge

my first thought was Brainf*ck :D

yes!

lol i dont thats the problem

@@LowLevelLearningOhhhh, that makes sense LMAO

thats actually fivehead.

I thought the same thing. My idea was to do it in one pass at first, but then when you mentioned walking forward and back I realized it would be faster.

In 2 passes, the worst case would be only one digit in the string -> walking from the front takes you d characters, walking from the right takes you N-d + 1 characters -> worst case, you walk the whole line only once in total. I don't think there were lines without digits (those would be 2N, but who cares anyways). In the end, who cares, because it's still linear, as is the reading of the input.

This is supposed to be interpreted as one and eight. I solved the problem using a Trie and the edge case was “seight”, “ninine” And things like that. I solved it by adding all those corner cases to the trie.

The problem with that approach was the string 'eightwo' in the test data. Replacing the 'eight' with '8' will remove the 'two' and yield an incorrect solution. It's tricky to use a find/replace algorithm because it has to be done separately over two copies of the string.

@@tyoda A good workaround! You can then use the code from part one to find the solution. I found the problem to be much trickier then past first nights and I was glad to finish as well, and I went to bed a little late that night.

Simula?

@@mihaelasimerea9700 That as well.