broot | new way to see and navigate directory trees | Command Line Interface library

I have a use case where I need to create a map mapping from KClass to a (lambda) function that converts instances of that class to something else (in my case a String). In java, I would write something along the lines of this:

I use multiple rust packages in my desktop. To install those packages i use

I am using ViewPager 2 and Paging 3 Libraries with dates. I am trying to create a list of dates with specific sizes i.e. numbers of items in a list, and some important conditions are:-

1. List will create dates until End Date.

2. Otherwise, list will create unlimited dates.

1st example

My list's sizes will always be smaller than or equal to 5 and I am passing initial date as the current date with no end range.

I cannot see what the error is here. I only think these are Warnings.

What is there error message, and a probable cause?

Update: I ran linting in VS Code using Ctrl+Shift+P: >Python: Run Linting. Pushed changes and ran the pipeline again.

test_ontology_tagger.py:

From a bluetooth device I get data in an array of bytes. 20 bytes are reserved for a string the other bytes contain data like short and int values. The bytes for the string are converted to a string using Charset.UTF_8 (or US_ASCII). The problem is I can not get ride of the part that contains ordinary zero's like in other languages as c, c# and c++. Tried droplast after determining the first zero character. Nothing works. What am I missing. The piece of code is this:

Theory vs practice here. Regarding time complexity, and I have a conceptual question that we didn't get to go deeper into in class.

Here it is:

There's a barbaric BROOT force algorithm, O(n^3)... and we got it down o O(n) and it was considered good enough. If we dive in deeper, it is actually O(n)+O(n), two separate iterations of the input. I came up with another way which was actually O(n/2). But those two algorithms are considered to be the same since both are O(n) and as n reaches infinity, it makes no difference, so not necessary at all once we reach O(n).

My question is:

In reality, in practice, we always have a finite number of inputs (admittedly occasionally in the trillions). So following the time complexity logic, O(n/2) is four times as fast as O(2n). So if we can make it faster, why not?