Data-structures | Data structures - List implementation in C | Widget library

This is a simple indentation error.

Remember that the syntax of let in allows there to be a block of multiple definitions. "A block of multiple things"¹ is basically always the context where indentation matters in Haskell, and the rule is always that each of the "things" in the block must start at the same column and if they span more than one line the continuation lines must all be more indented than the alignment column for the block.

That means that this is good:

You don't need parse manually. You can use ChartJs parser like

This is wrong

This quote is taken from a context of searching words in a dictionary:

Trie is an efficient data structure for searching words in dictionaries, search complexity with Trie is linear in terms of word (or key) length to be searched. If we store keys in binary search tree, a well balanced BST will need time proportional to M * log N, where M is maximum string length and N is number of keys in tree. Using trie, we can search the key in O(M) time. So it is much faster than BST.

In a BST these words would be stored such that one node gets one word.

Although in a balanced BST of 𝑁 nodes you need to visit O(log𝑁) nodes to find the targeted value in the worst case, it will also take time to compare a node's string with the target string. As the maximum length of a word is given as 𝑀, the worst case time complexity for each individual string comparison is O(𝑀). As such a comparison happens at each visited node, this gives a total complexity of O(𝑀log𝑁).

You can define spanGaps: true on your dataset.

spanGaps: If true, lines will be drawn between points with no or null data.

For further details, consult the Line Styling section of the Chart.js documentation.

however, the above code prints 3. What is the reason for this?

Because you assign 3 to the i variable that printNumTwo closes over. It doesn't matter that the assignment happens after printNumTwo is created, only that it is the variable that printNumTwo is using.

The difference between var and let in for loops is that a new variable is created for the body of the loop on each loop iteration with let. But you're assigning to that variable within the loop body, so the function closing over (printNumTwo) it sees that value later when you call it.

It's exactly like this:

• Using Object#entries, get the list of key-value pairs from source
• Using Array#filter, iterate over collection. In every iteration, using Array#every, check if all entries in the above sourceEntries match the current object

Even an empty class needs space to store itself, the minimum size of a class is therefore 1. As your no argument DataStructure class is empty and a member it takes up space and causes the rest of the members to take more space to allow for alignment. Making the base non-empty fixes the issue:

In order to make the program slow, you'd need to find 15000 strings (15 chars or less) with an identical hash. That will degrade the performance of insertion on unordered_set to be equivalent to searching within a linked list for a duplicate and appending the new string at the end.

If your code is running in the 32-bit space, a brute force attack on std::hash is feasible to find 15000 strings with the same hash.

Each string is at most 15 characters long. Each character is one of 63 different values (A-Z, a-z, 0-9, or _). For a 15 character string, that's 63¹⁵ possible combinations. But... std::hash returns a size_t value. And sizeof(size_t) == 4 on 32-bit machines. Intuitively thinking... if you hash 4 billion unique strings, you should find at least one pair of strings with identical hashes. And 63¹⁵ divided by 2³² is in the neighborhood of 227 quadrillion string with matching hashes for any given 15 character string in your allowed char set. We only need 15000. And we don't necessarily need a 15 character string either.

So if we hash all strings from "AAAAAAAAAAAAAAAAA" to "ZZZZZZZZZZZZZZZ" to find a given hash, we'll eventually find 15000 unique strings that have the same hash. We can use a shorter string size too to reduce the complexity of hashing.

Basically the algorithm is this: