News said that they have partnered with local crypto exchange Zipmex .
what do you think about this ?
If we have length $n$ unsorted array such that each element is integer and different, how to find $i$ largest numbers in linear time O(n)? but $i leq n^{frac{1}{2}}$.
For example, if we have $A = (11, 6, 8, 1, 9, 100, 88)$ and input $i = 2$, then output is $(100, 88)$ (sorted).
I am trying to develop a simple CMS-agnostic, HTML-PHP-JavaScript-CSS mobile-first contact form.
I want to give my <form> tag a max-width in the CSS file.
I don’t know what should be the max-width to cover all viewports of all “smartphone”s out there.
What is the largest pixel viewport for smartphones?
Is there a standard about viewports per se anywhere? One could help create better user experience
Can someone tell me if this works? It seems to be easier to implement and also creates slightly less paths (though still O(log N) ).
The problem: given any tree of size N, find a way to split it into some disjoint paths such that from any node, you can reach the root by passing through log N paths. Heavy light decomposition: https://cp-algorithms.com/graph/hld.html
I was thinking that a small modification is that instead of choosing an edge only when a child’s subtree is of size at least half of this subtree, you just choose the largest subtree. Proof that this works is the same: when you switch paths, the size of the subtree must at least double.
Edit: just noticed that the link also mentions you can do this, so I’m wondering why heavy-light decomposition is used instead of this, because this seems easier to understand and also slightly more performant (because of less paths).
According to the definition of MSE loss function :
L(w, b) = MSE = 1/2N$sigma(y - h(x))^2$
If one model was so perfectly wrong, then MSE shall be 2N/2N =1.
But most of the time, I would observe value much higher, so I am wondering if there’s upper boundary for loss?
Suppose you have an $ntimes m$ 2D array consisting of each $n$ rows of $m$ real numbers. What is the sequence of indexes $i_1,i_2…i_m$ such that $sum_{j=1}^mA[i_j, j]$ is maximized, subject to the constraint that each run of a value in $i_1…i_m$ must be at least $r$ entries long?
A correct algorithm with time linear in $m$ seems possible with dynamic programming. It would be even nicer to know the name of the problem and some academic reference to a correct solution. This is a minor methodological step in an analysis I’m doing for an interpersonal communication research paper, so ideally I’d like to find a paper to cite. This smells very similar to the dynamic programming homework problems I did in undergrad, so I’d be surprised if there isn’t work on it.
In practice, $m approx 12000$, $n=3$, and $20 leq r leq 200$.
I have a function on $h: (0,1) to (0,1)$ whose output is smooth (polynomial of low degree), and I need to discretize it but I need to save it with three 8 bit numbers. These three 8 bit numbers need to be ok to interpolate, so basically the definition of Lipschitz continuity.
That is I want to find a way to store my $xin (0,1)$ numbers as $f(x)in 2^8 times 2^8 times 2^8$ and I would like:
$$|f(x_1)-f(x_2)| leq K |x_1 – x_2|$$
With K not too large, and store as many $x$s as possible (I am interested in inverting this map later).
Now, I know how to do it with $K=3$ and for $2^8$: Just divide $(0,1)$ into ${ frac{1,2,…,256}{256} }$ and have $f(x) mapsto (256x,256x,256x)$.
The question is how much better can I do? Can I save $2^N$ $x$s with a small $K$ and large $N$? I know I could save $2^{24}$ if $K$ was huge, but I would like to find a middle ground.
As I understand the folding solution from another question will have a big $K$ in my case if we consider neighboring elements in the image of $f$ which cut across the folds.
The four adjacent digits in the 1000-digit number that have the
greatest product are 9 × 9 × 8 × 9 = 5832.73167176531330624919225119674426574742355349194934
96983520312774506326239578318016984801869478851843
85861560789112949495459501737958331952853208805511
12540698747158523863050715693290963295227443043557
66896648950445244523161731856403098711121722383113
62229893423380308135336276614282806444486645238749
30358907296290491560440772390713810515859307960866
70172427121883998797908792274921901699720888093776
65727333001053367881220235421809751254540594752243
52584907711670556013604839586446706324415722155397
53697817977846174064955149290862569321978468622482
83972241375657056057490261407972968652414535100474
82166370484403199890008895243450658541227588666881
16427171479924442928230863465674813919123162824586
17866458359124566529476545682848912883142607690042
24219022671055626321111109370544217506941658960408
07198403850962455444362981230987879927244284909188
84580156166097919133875499200524063689912560717606
05886116467109405077541002256983155200055935729725
71636269561882670428252483600823257530420752963450Find the thirteen adjacent digits in the 1000-digit number that have
the greatest product. What is the value of this product?
This is my solution to the problem above.
> def largest_product_series(n, series):
> series = str(series)
> largest = 0
> for i in range(0,1000-n):
> temp = np.prod((int(series(j)) for j in range(i,n+i)))
> largest = max(temp, largest)
> return largest
I am having a hard time figuring out what is wrong with my code. It works just fine with n = 4. But somehow it didn’t output the correct answer when n = 13.
Here’s the link to the problem. Euler 8
I have a taxonomy (tree) of product categories. To each leaf product category, I have assigned a shop department where the products of a given category can be found.
Now for each department, I would like to find the smallest number of the largest subtrees in the taxonomy.
For instance, in the example below leaf nodes have been assigned one of two departments $A$ and $B$.
The expected solution would be: $A$ has two subtrees, namely $x_2$ and $x_7$, $B$ has one subtree $x_4$.
The solution where $A$ has $x_1$ subtree is wrong because $x_1$ is the ancestor of nodes that belong to another department.
The solution where $A$ has $x_3$ and $x_7$ subtrees is wrong because we want the biggest subtrees possible.
Is it a known problem?
Is there a solution for it?
I’d like to see and hear a range of very good large organs. I like the reverb that occurs in a large church or cathedral, so I would prefer that over a concert hall. Also, since I would like to hear it, I need a location which either has concerts or predictable times when you can hear practice. For example, once I was lucky enough to visit St Paul’s Cathedral in London and happened to hear the organist rehearsing. There are also scheduled recitals, Sunday Organ Recitals, so that is one answer to my question.
Which are the locations of Europe’s largest pipe organs and how can I find them?
I say Europe partly because I am in Europe, but also because I guess that the most impressive organs are here. I am happy to be proved wrong in this assumption.
You may ignore COVID-19. Assume that life eventually returns to normal and what used to be possible becomes possible again.
(The title and text is plural to indicate that I don’t expect a single answer, but a range of recommendations of well regarded organs. I hope that this makes the question less opinion based.)
My interest is musical rather than religious, so I don’t require any specific religion or denomination nor will I reject any. Ideally, I would like recitals unconnected to religious services, but that is not essential. I happy to behave appropriately and respectfully if I need to attend a service.
I am concentrating on cathedral or large church organs rather than the concert hall ones because the experience is quite different.
