CheckiO | Solutions for tasks from http : //www.checkio.org/

I guess the problem is to find the distribution of the sum of dice. An efficient way to do that is via discrete convolution. The distribution of the sum of variables is the convolution of their probability mass functions (or densities, in the continuous case). Convolution is an n-ary operator, so you can compute it conveniently just two pmf's at a time (the current distribution of the total so far, and the next one in the list). Then from the final result, you can read off the probabilities for each possible total. The first element in the result is the probability of the smallest possible total, and the last element is the probability of the largest possible total. In between you can figure out which one corresponds to the particular sum you're looking for.

The hard part of this is the convolution, so work on that first. It's just a simple summation, but it's just a little tricky to get the limits of the summation correct. My advice is to work with integers or rationals so you can do exact arithmetic.

After that you just need to construct an appropriate pmf for each input die. The input is just [1, 1, 1, ... 1] if you're using integers (you'll have to normalize eventually) or [1/n, 1/n, 1/n, ..., 1/n] if rationals, where n = number of faces. Also you'll need to label the indices of the output correctly -- again this is just a little tricky to get it right.

Convolution is a very general approach for summations of variables. It can be made even more efficient by implementing convolution via the fast Fourier transform, since FFT(conv(A, B)) = FFT(A) FFT(B). But at this point I don't think you need to worry about that.

This is a ternary operator (or conditional expression), here a very underperformant way of writing:

You can accomplish that using a single liner

You're creating a new surface and a new texture every frame. Yeah it's going to be slow, creating textures is a ridiculously slow operation. Don't do it so often.

If you need to write pixels directly, create a texture of the right size once (with SDL_TEXTUREACCESS_STREAMING) and then use SDL_LockTexture and SDL_UnlockTexture to update it (note: don't use SDL_UpdateTexture for this, it's not really much - if at all - better than recreating the texture performance wise). I'm guessing the windows version is fast "by accident" because your driver implementation notices you're doing something strange and quietly ignores what you're telling it to do and does something faster.

Of course without looking at the code it's hard to say this is the only problem with it, but this is pretty likely to be a (or maybe even the) bottleneck.

The first problem is that with if isinstance(a[i],type(dict)) you are testing whether the item is an instance of type(dict), which is type, not dict, but that does not fix all the problems.

If we take the example of the word "help":

subj.isupper() returns true if subj="HELP"

subj.endswith('!!!') returns true if subj="help!!!"

subj.lower() forces the string into lowercase subj="HelP"-> subj="help"

re.search('+[.!-]*'.join(c for c in word) joins/removes occurences of the same characters next to each other, for instance, it will transform "heeellp" into "help"

you'd be better off splitting your sentence, then count the words, not the substrings:

You may use collections.Counter to do it directly.
Consider the following example.

Here's one solution using zip with itertools.islice: