hades | based HTTP/2 reverse proxy | REST library

I believe your goal and your current situation as follows.

• From your provided official document, I thought that you might use the method of "Waitlist" in "Waitlist".

• When I saw the sample curl command, it is as follows.

I think a lot of what you did, specifically around data wrangling, was not necessary, especially since you called d3.hierarchy() and d3.cluster() afterwards. I've replaced this with d3.stratify (which deals with hierarchical data that is not yet in the right format).

I've also replaced d3.cluster with d3.tree() because it was unclear to me why you'd want to use d3.cluster here. Your data has multiple parents, multiple roots and even floating nodes, and d3 is not meant to deal with that. My workaround has been to attach pseudonodes to every level, so as to make sure that there is only one node and that all nodes are at the right level at all times. To make sure the links were drawn correctly, I've written a custom getLinks function, that can deal with multiple parents.

I've also written a custom link generator that draws the links somewhat in the way that you want them. d3 doesn't offer much of flexibility here, but you can use the source code for inspiration.

Edit

I've changed the logic to be more focused on which "partners" got a child, so both links to the same child are on the same level - like in your picture. I've also drawn the nodes based on how many partners they have, and have given every link an offset so the lines are more distinct.

I've sorted the nodes so that the real pro-creators are at the top (Zeus), which gives a more balanced and less crowded view.

Cleaned it up a bit, and got it working nicely for ya!

if (esthos[name]) checks whether the the value held at ethos[name] is truthy. To explicitly cast it to a boolean, you can do if (!!esthos[name]). The reason for this is that javascript uses truthy and falsy values.

You can read more about it in this article.

Create a Map a below

The closing parenthesis has to be after the arrow function's body:

Unfortunately OpenClover does not print per-test coverage information in the XML report. Extracting this information from the HTML report is not easy either.

I suggest to have a look at the SnapshotPrinter utility, it prints information for files and classes:

https://openclover.org/doc/manual/latest/hacking--measuring-per-test-coverage-for-manual-tests.html

As OpenClover is open-source, you could extend the SnapshotPrinter to get information for individual methods as well, see:

https://github.com/openclover/clover/blob/c3729a8251787ea550b45260270d5cb48cb8f0f9/clover-core/src/main/java/com/atlassian/clover/optimization/SnapshotPrinter.java

https://github.com/openclover/clover/blob/c3729a8251787ea550b45260270d5cb48cb8f0f9/clover-core/src/main/java/com/atlassian/clover/optimization/Snapshot.java

Alternatively, you could read this information from the clover.db database directly. Please have a look at my answer to a similar question here:

https://community.atlassian.com/t5/Clover-questions/How-to-get-clover-coverage-percentage-for-one-test-case-on-a/qaq-p/1348720#M2200

Cheers

You're mixing form encodings. CURLOPT_POSTFIELDS expects a URL-encoded form (e.g. username = 11111&password =1111&client=wap) whereas curl_formadd generates multipart/form-data encoded forms. Either use CURLOPT_HTTPPOST with curl_formadd, or use CURLOPT_POSTFIELDS on the url-encoded form.

In either case you don't need to add the Content-Type header since it will be added automatically.

For non-polish readers: you are given those books only when preparing your solution, you won't have access to them during test. If you try to bundle them with binary somehow those would exceed 10kb limit hence you need to compress information somehow.

I would go for Naive Bayes classifier by default for a simple solution .

Due to time constraint I would go a little bit different route though.

Read all files in and tokenize them. Would be easiest with Python's split functionality (and whole program would be easiest, time constraint probably won't be a problem). Split on whitespace and punctuation as those are mostly noise and are not representative of texts.

Now calculate how often each of the tokens (words) occurs in each text, e.g. dog occured 15 times in first text and 3 times in another. Save those in three separate dictionaries, if the size of dict exceeds 10kb remove words occurring least frequently and adjust accordingly.

Use 3 unsigned long variables to keep results for each texts to keep overflow in check (it should be enough).

For every input text split it just like above.

For every word check in dictionaries how often those occured for each text and add this to one of 3 result variables. If it doesn't exist just add 0.

Finally return text which gathered "most points" this way. This should get quite a good score.

Naive Bayes with probabilities would work much better but given competition constraints I don't think it is a viable solution.

To do it, you would have to calculate probability of each word for each text and use log operstions during summation to avoid aforementioned overflow, just throwing it out for you to consider, doable but probably overkill.