Algorithm to find non-overlapping intervals that minimize standard deviation
Let the $n$ numbers be $x[1..n]$, and the minimum interval size $k$.

Formulating an objective function

There's a conflict here between two goals: Reporting more intervals will often mean reporting worse intervals.  We need an unambiguous way to decide which set of intervals is "best".  A good way to resolve this is by assigning some score value to any interval that includes two terms: a positive term (perhaps dependent on the length), as well as a negative term for the "quality" (here, standard deviation).  The goal is now to choose a set of nonoverlapping intervals that maximises the sum of scores.  For example, we could say that the score $s(i, j)$ of the interval $i..j$ is $10 + j - i - 7*StdDev(x[i..j])$.

A quadratic-time dynamic programming algorithm

The following dynamic programming algorithm takes $O(n^2)$ time and $O(n)$ space to find a solution having optimal score (there may in general be more than one such), and works for any scoring function $s$ that depends only on the beginning and end positions of the given interval (so you may certainly tweak my example function until you get results that look good).  It seems likely to me that a faster (linear or at least log-linear) algorithm exists for simple scoring functions, but in any case the following is flexible and will certainly handle $n$ up to 10000 in well under a second on any modern-day computer.

For any $1 \le i \le n$, let $f(i)$ be the maximum sum of scores achievable by any set of nonoverlapping intervals on the subproblem consisting of just the first $i$ elements of $x$.  So in particular, $f(n)$ will be the maximum sum of scores achievable on the entire dataset.  For now, let's imagine that we have an algorithm to compute $f(i)$, and use that to compute a related quantity for an "end-inclusive" variant of the problem: let $g(i)$ be the maximum sum of scores achievable by any set of nonoverlapping intervals on the subproblem consisting of just the first $i$ elements of $x$ that places the final ($i$-th) element inside an interval.  We can compute $g(i)$ as follows:

$g(0 \le i &lt; k) = -\infty$

$g(i \ge k) = \max_{0 \le j &lt; i}(f(j) + s(j+1, i))$

The first equation expresses that there can be no valid end-inclusive solution if there are fewer than $k$ items in total.  Using negative infinity is essentially a trick to ensure that this value is "ignored" by any $\max$ expression it happens to find itself in.  You wouldn't need to actually represent negative infinity in a program; any sufficiently large negative number would work.

The second equation says that we can always form an optimal solution to the length-$i$ end-inclusive subproblem by taking an optimal solution to some length-$j$ subproblem (which may or may not be end-inclusive), and appending a final interval to it containing every element after the $j$-th, up to the $i$-th -- specifically, whichever choice of $j$ yields the highest combined score.  This is the core insight of the algorithm; it's worth taking the time to convince yourself that this is really true.

From here, it's simple to compute $f(i)$:

$f(0) = 0$

$f(i \ge 1) = \max \{g(i), f(i-1)\}$

The first equation is obvious.  The second says that we can always form an optimal solution to the length-$i$ unrestricted subproblem by taking either the optimal solution to the corresponding end-inclusive variant of this subproblem (which puts $x[i]$ in an interval), or an optimal solution to the one-shorter unrestricted subproblem (which doesn't) -- whichever has higher score.  Again, it's worth checking that this is indeed true.

Memoisation

You can turn each of the above equations into program code to get a working, but exponential-time recursive program that can calculate $f(n)$, the maximum score achievable.  To speed this up to quadratic time only requires not recomputing answers to subproblems that we have seen before.  This can be as simple as using an array $m[0..n]$, initially filled with some placeholder value like -1, to record answers just before you return them: When $f(i)$ is called, we first check whether $m[i]$ contains a non-placeholder value, and if so immediately return that.  This approach to dynamic programming is called memoisation (that's right, there's no "R" in there).

Actually computing a solution

You may have noticed that until now, the things we have been computing ($f(\cdot)$ and $g(\cdot)$) are not actual solutions to the problem but just the scores of those solutions.  Fortunately, an actual solution can be recovered without much effort using a technique called traceback.

The key idea is that $\max$ function evaluations encode the "decisions" made by the algorithm.  We start at the end with the final total score value $f(n)$, which we know to be optimal, and work backwards, at each step determining which argument to a $\max$ function "won" (was highest): this tells us which subproblem to consider next, and (implicitly) describes one piece of the optimal solution.  (Actually there may be multiple highest-equal arguments to a $\max$; convince yourself that choosing any of them will lead to an optimal solution.)  We must do this for both $f$ and $g$.

For example, suppose that $n=1000$ and that in the very first step we have $f(1000)=150$.  From looking at the second equation defining $f$, our first question is whether this 150 value arose from $g(1000)$ (indicating that $x[1000]$ is in an interval) or from $f(999)$ (indicating that it isn't).  Suppose $g(1000)=150$ and $f(999)=133$: then the former wins, so it must be that $x[1000]$ is in an interval in every optimal solution.  The next step is to determine which $j$, in the range 0-999, gave rise to the value $g(999)=150$; this will implicitly tell us the length of this final interval, and provide the next subproblem to consider.

Often tracing back is sped up by storing the index of the "winner" in an extra array during the initial forward pass, but it can also be accomplished by recomputing the $f(\cdot)$ or $g(\cdot)$ function value at each step during the backward pass (which is slower, but not asyptotically so).