minimo | An elegant , simplified new tab page for your web browser | Browser Plugin library

Use keyup event to check the values of both the fields and enable or disable the button.

I believe that checking functions like that won't do for the button conditioning since there is no value parameter being passed but in general, I would assume you could initialise a new data property for checks like:

Firstly, your existing code had an error:

Here's an efficient recursive solution. It likely doesn't scale as well as solving a mixed integer program would, but it's simple and doesn't require an external library. You could probably make it even faster by memoizing it, at the expense of a lot of memory.

The core idea is: form all possible groups that meet the minimum; for each such group, make the max number of groups out of the remaining rolls; take the best solution. The rest is optimization.

The first optimization is to loop over only some groups. Since we might as well put every roll in a group, the largest roll is in some group. To avoid looping over all permutations of the groups, enumerate the possibilities for that group only.

The second optimization is to stop searching if we find a provable optimum. Obviously we can't make more groups than the floor of the sum over the minimum. If we make this many, we can't improve.

The third optimization is to avoid enumerating duplicate groups. When we decrease i, we're considering groups that did not include the element at that position. To avoid duplicates, we skip i over the elements identical to the one that we just rejected.

In Python 3:

The geom_errorbar() layer supports a width argument which does this. Try different values:

You Need to Use random.uniform() for that. So The Updated Code Would Be

Two things I noticed after a quick look where you can definitely save some time. Both require some more thinking before, but afterwards you will be rewarded with an optimised and cleaner code.

1. Try to avoid using append. append is highly inefficient. You start with an empty array, and afterwards need to allocate more memory each time. This leads to inefficient memory handling, as you copy your array each time you append a number. The longer the array gets, the more inefficient append becomes.

Alternative: Use np.zeros((m,n)) to initialise the array, with m and n being the size it will end up with. Then you need a counter that puts the new values in the corresponding places. If the size of the array is not defined before your calculation, you can initialise it as a big number, and afterwards cut it.

2. Try to avoid using for loops. They are generally very slow, especially when iterating through large matrices, as you need to index each entry individually.

Alternative: Matrix operations are generally much faster. For example, instead of r = np.sqrt(sum((matposg[j,:]-matposg[k,:])**2)) inside two for loops, you could first define two matrices A and B that correspond to matposg[j,:] and matposg[k,:] (should be possible without the use of loops!) and then simply use r = np.linalg.norm(A-B)

My old method it was very "heavy". When i set the permission to the folder and files, i had to call a lot of times the Driver API and the services. Other problem it was that the parent folder had a lot of folders and many files which made it take a long time to set the permissions to the user or revocate permissions. My new method was create a folder with edit permission for the users and move the files and folder to the destiny folder for other users. My objetive was set the correct permissions for final users.This is my new code. The javascript's code doesn't have problems: