naive | Learn JavaScript the hard way | Parser library

I'm implementing a simple task queue using redis in Rust, but am struggling to deserialize the returned values from redis into my custom types.

In total I thought of 3 approches:

1. Deserializing using serde-redis
2. Manually implementing the FromRedisValue trait
3. Serializing to String using serde-json > sending as string > then deserializing from string

The 3rd approach worked but feels artificial. I'd like to figure out either 1 or 2, both of which I'm failing at.

I have a simple Task definition:

Sorting data from huge lists with two levels of keys is helpful for interpreting dataset and calling by couple or one level of keys some slice of data, especially when creating plots.

I use a very naive and, I guess, inefficient way to create from a 2D-list of data a dict of dicts (two levels of keys) that returns a list of data. How to make this code more elegant, possibly faster and more readable? I guess using collection module but I didn't find a smart way.

Example:

The problem is the following: I got a png file : example.png

• that I filter using chan vese of skimage.segmentation.chan_vese

  • It's return a png file in black and white.

• i detect segments around my new png file with cv2.ximgproc.createFastLineDetector()

  • it's return a list a segment

But the list of segments represent disjoint segments.

I use two naive methods to polygonize this list of segment:

-It's seems that cv2.ximgproc.createFastLineDetector() create a almost continuous list so I just join by creating new segments:

I succeeded to solve this using "naive" solution checking for each node the longest path including this node but was told there is a better solution.

I am looking for help with how to solve this problem efficiently and how to approach similar problems (tips or thinking method will be appreciated)

Say I have a tree where each node is orange or white. I need to write an algorithm to get the length of the longest "good" path

a "good" path is a path that starts at a white node, climbs up 0 or more white nodes and then go down 0 or more orange nodes

given the next tree as an example

the algorithm should return 4 because the longest path starts at 18 and ends with 15

I want to merge two columns in PostgresQL query by the following rule:

select (column_1 or column_2) as column_3 from my_table

Is there a way to achieve it? Though quite clear, I want to prefer column_1 value as column_3 but if it is null, I would like column_2 value as column_3.

Sorry if this sounds naive, thanks!

So I was solving this LeetCode question - https://leetcode.com/problems/palindrome-partitioning-ii/ and have come up with the following most naive brute force recursive solution. Now, I know how to memoize this solution and work my way up to best possible with Dynamic Programming. But in order to find the time/space complexities of further solutions, I want to see how much worse this solution was and I have looked up in multiple places but haven't been able to find a concrete T/S complexity answer.

I'm currently working on a (laravel) project that should result in two versions, but I find myself constantly rebasing and merging my code. I guess it's my git workflow that is mistaken, but I need some heads up on what I'm doing wrong.

My macro-question is: Much like IntelliJ maintains dozens of IDEs that have almost the same basic functionalities but are built into different versions, is there some specific VCS tactic or best practices for doing so?

Say I have a project (one code base) that is for two clients A and B. A wants a blue theme and B wants a green one, so currently I just have them on two separate branches. These branches often have client-specific changes.

Now I have a new feature that I want to work on, which applies to both A and B. This is how I do it now:

1. Create branch new_feature_branch from main
2. Finish the code on new_feature_branch
3. Send PR and merge to main
4. Rebase client_a_branch and client_b_branch on main

This works fine on normal features, but when there is a minor bug (say, a typo) on the main branch, having to go over all these every time just so that the patched code could get to the client branches just seem kind of awkward and... unintuitive(?) to me.

I just want to make sure if this is how "multiple versions with same code-base" projects are handled generally? If not, how is it commonly done? (A simple link or keyword to what I should look into would be helpful enough)

I'm totally unaware of how things work in production, and I'm also not confident about my git knowledge, so sorry if this question seems naive or whatsoever.

Thanks in advance!

I understand why it's important that all nodes on the Ethereum mainnet must execute any smart contract function call which changes the internal state of the contract or the chain. (For example, transfers from one account to another ec.)

What I'm wondering is, if its true that every node must execute every function called on any smart contract, even if the function doesn't result in a state change.

For example, if an ERC721 smart contract has a function "getName()" which just returns the name of the artwork the NFT represents which is stored in the NFt. Let's say joe connects to the network, and wants executes getName() on a contract. Does that mean that all 9,000 nodes end up spinning cycles executing getName(), even though Joe only needs it to be executed once? Does the gas cost of running "getName()" compensate each of the nodes for the overhead of running "getName()"? If that is true (that every node gets paid) will gas get even more expensive as more nodes join the pool?

Is one of the reasons gas prices are high is because of the inefficiency of every node having to execute every function called on a smart contract, even those that have no effect on state?

If so it would seem to be a very (and perhaps unnecessarily) expensive proposition to execute a computationally intensive but "pure" (no side effects) function on Ethereum, right?

Thanks. apologies for the possibly naive question!

Suppose I have the following data