text:
Difference of the square of the sum
Find the difference between the square of the sums and sum of the squares.
This is the mathematical representation:
\$\left(\sum n\right)^2-\sum n^2\$
Your program/method should take two inputs, these are your lower and upper limits of the range, and are inclusive.
Limits will be whole integers above 0.
Your program/method should return the answer.
You may use whichever base you would like to, but please state in your answer which base you have used.
Test case (Base 10)
5,9      970
91,123   12087152
1,10     2640

This is usual code-golf, so the shorter the answer the better.

It took me a while to realize the input was the endpoints of a range.

@BradGilbertb2gills edited for clarity

This is simpler than it looks ?

@cat what do you mean by that? Yes the maths is simple Alevel stuff. But it's all down to how you golf it

@george The question and many of the answers make it look like a lot of work, but it's not

@cat I never said it was a lot of work. As I mentioned above, it is simple Alevel mathematics.

I assume not, but may we take an array as input instead of the start and end points?

@cairdcoinheringaahing amazing that people are still going at it a year and half later. When I wrote it I said two inputs, so in theory you could pass two arrays as input, but it must be two. Not one away with both inputs. Although I’d be interested to see both solutions

Python 2, 43 bytes
f=lambda a,b,s=0:b/a and 2*a*s+f(a+1,b,s+a)

Test it on Ideone.
How it works
Call the function defined in the specification \$g(a, b)\$. We have that
$$
\newcommand{\sumab}[2]{\sum_{a \le #1 \le b} #2 \:}
\begin{align}
g(a,b) & = \left( \sumab n n \right)^2 - \sumab n {n^2} \\
& = \sumab {i,j} {ij} - \sumab n {n^2} \\
& = \sumab {i<j} {ij} + \sumab {i=j} {ij} + \sumab {j<i} {ij} - \sumab n {n^2} \\
& = 2 \sumab {j<i} {ij} \\
& = 2 \sumab {i} {\sum_{a \le i < j} ij} \\
& = \sumab {i} {\left( 2i \sum_{a \le j < i} j \right)}
\end{align}
$$
Define the function \$f(x, y, s)\$ recursively as follows.
$$ f(x, y, s) =
\begin{cases}
2xs + f(x+1, y, s+x) & \text{ if } x \le y \\
0 & \text{ if} x > y
\end{cases}
$$
By applying the recurrence relation of \$f(a, b, 0)\$ a total of \$b - a\$ times, we can show that:
$$
\begin{align}
f(a, b, 0) & = 2\cdot0 + f(a+1, b, a) \\
& = 2\cdot0 + 2\cdot(a+1)\cdot a + f(a+2, b, a+(a+1)) \\
& = 2\cdot0 + 2\cdot(a+1)\cdot a + 2\cdot(a+2)\cdot(a+(a+1)) + f(a+3, b, a+(a+1)+(a+2)) \\
& \vdots \\
& = \sumab {i} {\left( 2i \sum_{a \le j < i} j \right)} + f\left(b+1, b, \sumab j j\right) \\
& = \sumab {i} {\left( 2i \sum_{a \le j < i} j \right)} \\
& = g(a, b)
\end{align}
$$
This is the function f of the implementation. While b/a returns a non-zero integer, the code following and is executed, thus implementing the recursive definition of f.
Once b/a reaches 0, we have that b > a and the lambda returns False = 0, thus implementing the base case of the definition of f.

ah okay. Could you explain your method though?

I will, but I'm currently trying to golf it a bit more.

thanks for the formula. I guess I never saw it like that because we don't cover sums of series like that at school. Pretty interesting though!

@george I've finished the explanation.

Wanna tell us a bit more of how in the world the idea to define f came into your mind! The motivation! I'm genuinely interested.

MATL, 9 bytes
&:&*XRssE

Try it online!
Explanation
&:   % Inclusive range between the two implicit inputs
&*   % Matrix of all pair-wise products
XR   % Upper triangular part of matrix, without the diagonal
ss   % Sum of all elements of the matrix
E    % Multiply by 2. Implicit display

Example
These are the partial results of each line for inputs 5 and 9:

&:
5 6 7 8 9

&:&*
25 30 35 40 45
30 36 42 48 54
35 42 49 56 63
40 48 56 64 72
45 54 63 72 81

&:&*XR
0 30 35 40 45
0  0 42 48 54
0  0  0 56 63
0  0  0  0 72
0  0  0  0  0

&:&*XRss
485

&:&*XRssE
970

I really like seeing the partial results. They really help with understanding the program. Thanks for including them!

Jelly, 9 8 bytes
rµS²_²S$

Try it online!
r         inclusive range from first input to second input
 µ        pass the range to a new monadic chain
  S       the sum
   ²      squared
    _     minus...
     ²S$  the squares summed

Thanks to FryAmTheEggman for a byte!

For once, Jelly is actually very readable.

Can I fork this to my answer?

@LeakyNun what does that mean?

This.

Nice earrings: S²_²S

Python 2, 45 bytes
lambda a,b:(a+~b)*(a-b)*(3*(a+b)**2+a-b-2)/12

Closed form solution - not the shortest, but I thought it'd be worth posting anyway.
Explanation
Let p(n) be the nth square pyramidal number, and t(n) be the nth triangular number. Then, for n over the range a, ..., b:

∑n  = t(b)-t(a-1), and
∑n² = p(b) - p(a-1)
So (∑n)²-∑n² = (t(b)-t(a-1))² - (p(b) - p(a-1)).

This expression reduces to that in the code.

Hi could you explain your equation if possible. My python version is 16 bytes longer and I can't figure out how you derived your equation

@george Let p(n) be the nth square pyramidal number, and t(n) be the nth triangular number. Then this is a simplified version of (t(b)-t(a-1))^2 - (p(b) - p(a-1)).

@MartinEnder So that is the exact formula that I have used, but Sp3000 has simplified it in a way that I cannot understand. My python script is: (b*-~b-a*~-a)2/4-(b-~b(2b+1)-a~-a*(2*a-1))/6  if that is of any use. I have golfed as much as I can the two formula

@george Sometimes, with problems like these, the easiest way is to get Wolfram|Alpha to do the tedious part, then double checking to make sure it's right. To be honest, I don't think I could have pulled the (a-b-1) factor out of (b*(b+1)*(2b+1)-a*(a-1)*(2a-1))/6 on my own.

@Sp3000 that's a great way to do it. I'll try that in future

05AB1E, 8 bytes
ŸDOnsnO-

Explained
ŸD       # range from a to b, duplicate
  On     # sum and square first range
    s    # swap top 2 elements
     nO  # square and sum 2nd range
       - # take difference

Try it online

Is 05AB1E a ROT13 version of Jelly maybe? Substitute r by Ÿ, µ by D, S by O, ² by n, _ by s and $ by -.

@ThomasWeller: They are quite different actually. A common offset between some "functions" are most likely a coincident. Jelly is a tacit language about chaining functions (afaik), while 05AB1E is a stack based language.

Mathematica, 21 bytes
Tr[x=Range@##]^2-x.x&

An unnamed function taking two arguments and returning the difference. Usage:
Tr[x=Range@##]^2-x.x&[91, 123]
(* 12087152 *)

There's three small (and fairly standard) golfing tricks here:

## represents both arguments at once, so that we can use prefix notation for Range. Range@## is shorthand for Range[##] which expands to Range[a, b] and gives us an inclusive range as required.
Tr is for trace but using it on a vector simply sums that vector, saving three bytes over Total.
x.x is a dot product, saving four bytes over Tr[x^2].

Would Variance help?

@LeakyNun I don't see how, because one of the two terms in Variance is divided by n and the other by n^2 and I don't see an easy way to undo those separately.

Tr@#^2-#.#&@*Range is only 18 bytes.

@MishaLavrov neat! Feel free to make it a separate answer. :)

Labyrinth, 28 24 bytes
?:?:}+=-:(:(#{:**+**#2/!

Try it online!
Explanation
Since loops tend to be expensive in Labyrinth, I figured the explicit formula should be shortest, as it can be expressed as linear code.
Cmd Explanation                 Stacks [ Main | Aux ]
?   Read M.                     [ M | ]
:   Duplicate.                  [ M M | ]
?   Read N.                     [ M M N | ]
:   Duplicate.                  [ M M N N | ]
}   Move copy to aux.           [ M M N | N ]
+   Add.                        [ M (M+N) | N ]
=   Swap tops of stacks.        [ M N | (M+N) ]
-   Subtract.                   [ (M-N) | (M+N) ]
:   Duplicate.                  [ (M-N) (M-N) | (M+N) ]
(   Decrement.                  [ (M-N) (M-N-1) | (M+N) ]
:   Duplicate.                  [ (M-N) (M-N-1) (M-N-1) | (M+N) ]
(   Decrement.                  [ (M-N) (M-N-1) (M-N-2) | (M+N) ]
#   Push stack depth.           [ (M-N) (M-N-1) (M-N-2) 3 | (M+N) ]
{   Pull (M+N) over from aux.   [ (M-N) (M-N-1) (M-N-2) 3 (M+N) | ]
:   Duplicate.                  [ (M-N) (M-N-1) (M-N-2) 3 (M+N) (M+N) | ]
*   Multiply.                   [ (M-N) (M-N-1) (M-N-2) 3 ((M+N)^2) | ]
*   Multiply.                   [ (M-N) (M-N-1) (M-N-2) (3*(M+N)^2) | ]
+   Add.                        [ (M-N) (M-N-1) (3*(M+N)^2 + M - N - 2) | ]
*   Multiply.                   [ (M-N) ((M-N-1)*(3*(M+N)^2 + M - N - 2)) | ]
*   Multiply.                   [ ((M-N)*(M-N-1)*(3*(M+N)^2 + M - N - 2)) | ]
#   Push stack depth.           [ ((M-N)*(M-N-1)*(3*(M+N)^2 + M - N - 2)) 1 | ]
2   Multiply by 10, add 2.      [ ((M-N)*(M-N-1)*(3*(M+N)^2 + M - N - 2)) 12 | ]
/   Divide.                     [ ((M-N)*(M-N-1)*(3*(M+N)^2 + M - N - 2)/12) | ]
!   Print.                      [ | ]

The instruction pointer then hits a dead end and has to turn around. When it now encounters / it attempts a division by zero (since the bottom of the stack is implicitly filled with zeros), which terminates the program.

Haskell, 34 bytes
a#b=sum[a..b]^2-sum(map(^2)[a..b])

Usage example: 91 # 123 -> 12087152.
Nothing to explain.

Brachylog, 24 bytes
:efL:{:2^.}a+S,L+:2^:S-.

Expects the 2 numbers in Input as a list, e.g. [91:123].
Explanation
:efL                     Find the list L of all integers in the range given in Input
    :{:2^.}a             Apply squaring to each element of that list
            +S,          Unify S with the sum of the elements of that list
               L+:2^     Sum the elements of L, then square the result
                    :S-. Unify the Output with that number minus S

Perl 6,  36 32  31 bytes
{([+] $_=@_[0]..@_[1])²-[+] $_»²}
{([+] $_=$^a..$^b)²-[+] $_»²}
{[+]($_=$^a..$^b)²-[+] $_»²}

Test it
Explanation:
{ # bare block with placeholder parameters $a and $b

  [+](# reduce with &infix:<+>
      # create a range, and store it in $_
      $_ = $^a .. $^b
  )²
  -
  [+] # reduce with &infix:<+>
    # square each element of $_ ( possibly in parallel )
    $_»²
}

Test:
#! /usr/bin/env perl6
use v6.c;
use Test;

my @tests = (
  (5,9) => 970,
  (91,123) => 12087152,
  (1,10) => 2640,
);

plan +@tests;

my &diff-sq-of-sum = {[+]($_=$^a..$^b)²-[+] $_»²}

for @tests -> $_ ( :key(@input), :value($expected) ) {
  is diff-sq-of-sum(|@input), $expected, .gist
}

1..3
ok 1 - (5 9) => 970
ok 2 - (91 123) => 12087152
ok 3 - (1 10) => 2640

Save a byte moving the assignment and evading parens: {$_=$^a..$^b;.sum²-[+] $_»²}

25 bytes: {.sum²-[+] $_»²}o&[..]

Matlab, 30 29 28 bytes
Using Suever's idea of norm gives us 2 bytes less
@(x,y)sum(x:y)^2-norm(x:y)^2

Old (simple) version:
@(x,y)sum(x:y)^2-sum((x:y).^2)

Octave, 27 23 bytes
@(x,y)sum(z=x:y)^2-z*z'

Creates an anonymous function named ans which accepts two inputs: ans(lower, upper)
Online Demo
Explanation
Creates a row vector from x to y (inclusive) and stores it in z. We then sum all the elements using sum and square it (^2). To compute the sum of the squares, we perform matrix multplication between the row-vector and it's transpose. This will effectively square each element and sum up the result. We then subtract the two.

JavaScript (ES6), 50 37 bytes
f=(n,m,s=0)=>n>m?0:2*n*s+f(n+1,m,n+s)

Now a port of @Dennis♦'s Python solution.

Try using n=>m=>eval(`for(s=t=0;n<=m;t+=n++)s+=n*n;t*t-s`)

@MamaFunRoll On the other hand, I could try porting Dennis♦'s Python solution...

Haskell, 36 bytes
m#n=sum[2*i*j|i<-[m..n],j<-[i+1..n]]

λ> m # n = sum [ 2*i*j | i <- [m..n], j <- [i+1..n] ]
λ> 5 # 9
970
λ> 91 # 123
12087152
λ> 1 # 10
2640

Note that
$$\left( \sum_{k=m}^n k \right)^2 -  \sum_{k=m}^n k^2 = \cdots =  \sum_{k_1=m}^n  \sum_{k_2=m\\ k_2 \neq k_1}^n k_1 k_2 = \sum_{k_1=m}^n  \sum_{k_2=k_1+1}^n 2 \,k_1 k_2$$

You don't need the parens around i+1.

Also if you want to talk Haskell and Haskell golfing you can join us in the chat room.

Java, 84 77 characters, 84 77 bytes
7 bytes smaller due to Martin Ender and FryAmTheEggMan, thank you.
public int a(int b,int c){int e=0,f=0;for(;b<=c;e+=b,f+=b*b++);return e*e-f;}
Using the three test cases in the original post: http://ideone.com/q9MZSZ
Ungolfed:
public int g(int b, int c) {
    int e = 0, f = 0;
    for (; b <= c; e += b, f += b * b++);
    return e*e-f;
}

Process is fairly self-explanatory. I declared two variables to represent the square of the sums and the sum of the squares and repeatedly incremented them appropiately. Finally, I return the computed difference.

Welcome to PPCG! You can probably save a byte by putting that ++ on f+=b*b++ (so you can leave the third slot of the for empty) and you also don't need to square e before returning it (i.e. just do return e*e-f).

Actually instead of leaving the third slot of the for empty, move the f+=b*b++ in there, so you can save on both a semicolon and the braces.

Great catch @MartinEnder, thank you :)

Also based on what Martin had in mind, this seems to be a bit shorter.

@FryAmTheEggman Oh, I wasn't aware that you could have multiple statements in the third slot of the for-loop, thanks to you as well.

Apparently, my last comment was incorrect. It is actually a special part of the Java grammar: the final statement of a for is actually a special kind of statement, which is called a statement expression list. This special statement can have more than one statement joined by a comma. See 14.14.1 (you'll have to navigate there yourself, I couldn't find a way to make a more precise link) of the language specification.

You can also move e+=b outside for loop (http://ideone.com/2rgZSh). This will save you one more character

JavaScript (ES6), 46 bytes
f=(x,y,s=0,p=0)=>x<=y?f(x+1,y,s+x,p+x*x):s*s-p

Factor, 48 bytes
[ [a,b] [ [ sq ] map sum ] [ sum sq ] bi - abs ]

An anonymous function.
[
  [a,b] ! a range from a to b
  [
    [ sq ] map sum ! anonymous function: map sq over the range and sum the result
  ]
  [ sum sq ] ! the same thing, in reverse order
  bi - abs   ! apply both anon funcs to the range, subtract them and abs the result
]

Aheui (esotope), 108 bytes(36 chars)
방빠방빠쌍다쌍상싸사타빠밤타빠받다파반다받상싸사빠따따다따따받밤따나망히

Try it online!

Takes two inputs from user(separated by line feed or whitespace) and print result of following function;

\$f(a,b)=((a-b)\cdot(a-b-1)\cdot(3\cdot(a+b)^2+a-b-2))/12\$

APL, 23 20 bytes
-/+/¨2*⍨{(+/⍵)⍵}⎕..⎕

Works in NARS2000.

MATL, 11 bytes
&:ts2^w2^s-

Try it online!
Explanation:
&:           #Create a range from the input
  t          #Duplicate it
   s2^       #Sum it and square it
      w      #swap the two ranges
       2^s   #Square it and sum it
          -  #Take the difference

PowerShell v2+, 47 bytes
Two variations
param($n,$m)$n..$m|%{$o+=$_;$p+=$_*$_};$o*$o-$p

$args-join'..'|iex|%{$o+=$_;$p+=$_*$_};$o*$o-$p

In both cases we're generating a range with the .. operator, piping that to a loop |%{...}. Each iteration, we're accumulating $o and $p as either the sum or the sum-of-squares. We then calculate the square-of-sums with $o*$o and subtract $p. Output is left on the pipeline and printing is implicit.

Pyth, 11 bytes
s*M-F#^}FQ2

Try it online!
s*M-F#^}FQ2
       }FQ    Compute the range
      ^   2   Generate all pairs
   -F#        Remove those pairs who have identical elements
 *M           Product of all pairs
s             Sum.

Nice usage of filter. Though there is already a build-in for this task: s*M.P}FQ2

Japt, 10 bytes
õV
x²aUx ²

Try it

Jelly, 6 bytes
rµÄḋḊḤ

Recent improvements to the Jelly language allow a compact implementation of the \$g\$ function from my Python answer.
Try it online!
How it works
rµÄḋḊḤ  Main link. Arguments: a, b (integers)

r       Range; yield R := [a, ..., b].
 µ      Begin a monadic chain with argument R.
  Ä     Accumulate; take the cumulative sum of R.
    Ḋ   Deque; yield [a+1, ..., b].
   ḋ    Take the dot product, ignoring the last term of the cumulative sum.
     Ḥ  Unhalve; double the result.

Vyxal, 8 bytes
ṡ:²∑$∑²ε

Try it Online!
How?
ṡ:²∑$∑²ε
ṡ        # Inclusive range between (implicit) second input and (implicit) first input
 :       # Duplicate this range
  ²      # Square each of the duplicate
   ∑     # Summate
    $    # Swap so the other range is at the top
     ∑   # Summate
      ²  # Then square
       ε # Absolute difference between the two

Thunno 2, 8 bytes
IDS²s²S-

Attempt This Online!
Explanation
IDS²s²S-  # Implicit input
ID        # Inclusive range; duplicate
  S²      # Sum the list; square the sum
    s     # Swap so the range is back on top
     ²S   # Square each item; sum the list
       -  # Take the difference
          # Implicit output

TI-BASIC, 19 bytes
Prompt N,M
randIntNoRep(N,M
sum(Ans)2-sum(Ans2

randIntNoRep gets the range (shuffled). The rest is pretty self explanatory.

CJam, 17 bytes
q~),>_:+2#\2f#:+-

Test it here.
Explanation
q~       e# Read and evaluate input, dumping M and N on the stack.
),       e# Increment, create range [0 1 ... N].
>        e# Discard first M elements, yielding [M M+1 ... N].
_        e# Duplicate.
:+2#     e# Sum and square.
\2f#:+   e# Swap with other copy. Square and sum.
-        e# Subtract.

Alternatively, one can just sum the products of all distinct pairs (basically multiplying out the square of the sum, and removing squares), but that's a byte longer:
q~),>2m*{)-},::*:+

JavaScript (ES6), 67 bytes
a=>b=>([s=q=0,...Array(b-a)].map((_,i)=>q+=(s+=(n=i+a),n*n)),s*s-q)

Test Suite

f=a=>b=>([s=q=0,...Array(b-a)].map((_,i)=>q+=(s+=(n=i+a),n*n)),s*s-q)
e=s=>`${s} => ${eval(s[0])}` // template tag format for tests
console.log(e`f(5)(9)`)
console.log(e`f(91)(123)`)
console.log(e`f(1)(10)`)

J, 29 bytes
Port of Doorknob's Jelly answer.
[:(+/@(^&2)-~2^~+/)[}.[:i.1+]

Usage
>> f = [:(+/@(^&2)-~2^~+/)[}.[:i.1+]
>> 91 f 123x
<< 12087152

Where >> is STDIN, << is STDOUT, and x is for extended precision.

Pyke, 11 bytes
h1:Ds]MXXs-

Try it here!
h1:         - inclusive_range(input)
   Ds]      -     [^, sum(^)]
      MX    -    deep_map(^, <--**2)
         s  -   ^[1] = sum(^[1])
          - -  ^[0]-^[1]

Julia, 25 bytes
f(a,b,x=a:b)=sum(x)^2-x'x

This is a function that accepts two integers and returns a 1x1 integer array.
The approach is simple: Construct a UnitRange from the endpoints a and b and call it x, then sum x, square it, and subtract its norm, which is computed as transpose(x) * x.
Try it online! (includes all test cases)

a\b=-(x=a:b)'x+sum(x)^2 saves a few bytes.

GeoGebra, 91 bytes
a(x)=(x²+x)/2
b(x)=x³/3+x²/2+x/6
c(x,y)=(a(y)-a(x))²
d(x,y)=b(y)-b(x)
c(x-1,y)-d(x-1,y)

Defines a function (probably e(x,y)) that computes the desired difference.
a(x) calculates the sum of natural numbers between 0 and x.
b(x) calculates the sum of the squares of the natural numbers between 0 and x.
c(x,y) first computes the sum of the natural numbers between x and y, then squares that sum.
d(x,y) calculates the sum of squares between b(x) and b(y).
The last line defines a multi-variable function that finishes the calculation. The function is automatically assigned a name, saving a few bytes.

Hi, how do I call the function that this defines? I was able to figure out the input at https://www.geogebra.org/classic#cas , but couldn't figure out how to find or call the final function.

@sundar: The last line is an expression in x and y. We could prepend e(x,y)= to give it a name, but to save bytes, we don’t here. GeoGebra automatically assigns the expression a name (probably e, since that’s the next available letter). I don’t have the environment available right now, but I wouldn’t use the CAS pane. The algebra pane and input bar should do the job right. (It’s been a while since I used GGb online; my mental image of it may be outdated.)

R - 33 bytes
x=scan():scan();sum(x)^2-sum(x^2)

pass your lower limit to the first scan then your upper limit to the second scan

Fith, 52 bytes
{ 1 + range dup sum 2 pow swap { 2 pow } map sum - }

This is an anonymous function that takes the two numbers on the stack and leaves a single number.
Explanation:
{
    1 + range dup      2 ranges from a to b inclusive
    sum 2 pow          Sum one and square it
    swap               Bring a fresh range to the top
    { 2 pow } map sum  Square every element and sum the list
    -                  Subtract
}

If you like postfix, point-free and stack-based functional prorgamming you might like Factor :D

Whispers v2, 90 bytes
> Input
> Input
> 2
>> 1…2
>> L*3
>> Each 5 4
>> ∑6
>> ∑4
>> 8*3
>> 9-7
>> Output 10

Try it online!

Julia 0.6, 21 bytes
r->sum(r)^2-sum(r.^2)

Returns an anonymous function that takes a Range, eg f(1:10), which then returns the result.
Try it online!

C (gcc), 67 bytes
f(n,m){double a,b;for(;n<=m;a+=n,b+=pow(n++,2));return pow(a,2)-b;}

Try it online!

C (gcc), 48 bytes
a,b;f(n,m){for(a=b=0;m/n;a+=n++)b+=n*n;n=a*a-b;}

Try it online!

Red, 70 bytes
func[a b][s: t: 0 until[s: s + a t: a * a + t  b < a: a + 1]s * s - t]

Try it online!

Excel, 60 bytes
=(B1^2+B1-A1^2+A1)^2/4-(2*B1^3+3*B1^2+B1-2*A1^3+3*A1^2-A1)/6

Algebraic reshuffling of more verbose implementation:
For inputs a and b:
(B1*(B1+1)-A1*(A1-1))/2          // (Sum of b) - (Sum of a-1)
(  )^2                           //  squared
B1*(B1+1)*(2*B1+1)/6             //  Sum of (b squared)
A1*(A1-1)*(2*A1-1)/6             //  Sum of (a-1 squared)

C# (.NET Core), 62 bytes
(a,b)=>{int x=0,y=0;for(;a<=b;a++){x+=a;y+=a*a;}return x*x-y;}

Try it online!
Ungolfed:
(a, b) => {                 // takes in two integer inputs, delimited by a comma
    int x = 0, y = 0;       // initializes x and y
    for(; a <= b; a++)      // increment a until a equals b
    {
        x += a;             // add current a to x
        y += a * a;         // add square of current a to y
    }
    return (x * x) - y;     // return the difference of the square of the sums (x*x) and the sum of the squares (y)
}

Python 3, 66 65 bytes
lambda a,b:sum(x*y*2for x in range(a,b+1)for y in range(x+1,b+1))

Try it online!
with @Dennis formulae and w/o recursion, yet another Python solution (as I cannot comment @leaky-nun solution (not enough reputation)

This is code-golf, you should try to make your code as short as possible. At least remove the unnecessary whitespaces. Try merging two for loops into one if possible.

Sorry @user202729, this is actually my first contribution. I've edited using your comment and reformatted contribution using TIO.

Did it for the first and forgot it for the second... thanks @Stephen

PHP, 58 bytes
for([,$p,$q]=$argv;$p<=$q;$s+=$p++)$t+=$p*$p;echo$s*$s-$t;

Run with -nr or try it online.

Sidef, 46 44 bytes

Translation of: my Factor solution

{|a,b|R=a..b;R.map{.sqr}.sum-R.sum.sqr->abs}

Try it online!
use it like x.run(4, 20) -> 38760
Previous
->(a,b,R=a..b){R.map{.sqr}.sum-R.sum.sqr->abs}

longer, explained
->                       # the next list is a function parameter list
(a, b, R = a .. b )      # R is a RangeNum over the a and b
{                        # a Block
  return                 # return the whole expression
  R.map{ |n|             # map this Block over the range
    return n.sqr         # squared value
  }.sum                  # summed the range
  -                      # subtract
  R.sum.sqr              # sum of the range, squared
  ->abs                  # call Number.abs on everything on the left-hand side of ->
}                        # ok, we're done

Tcl, 76 80 bytes
proc S l\ u {while \$l<=$u {incr Q $l
append R -$l*$l
incr l}
expr $Q**2+$R}

Try it online!

Burlesque - 16 bytes
r@J++2?^j)S[++?-

r@                  range
  J                 dup
   ++               sum
     2?^            square it
        j           swap
         )S[        map (square)
            ++      sum
              ?-    subtract

Alternate versions:
r@JJ?*++j++S[?-ab
r@J++2?^jqS[ms?-
r@J++J?*jqS[ms?-
r@J++J?*jJ?*++?-
r@J)S[++j++S[j?-

^- and this is the art of golfing :(.

Rust, 67 bytes
|b,e|{let mut t=0;let mut s=0;for i in b..=e{t+=i;s+=i*i;}(t*t)-s};

A closure that takes two integers and returns an integer.

Pony, 73 bytes
fun f(m:U64,n:U64,s:U64=0):U64=>if m>n then 0 else(2*m*s)+f(m+1,n,m+s)end

sort of ungolfed
  fun apply(m: U64, n: U64, s: U64 = 0): U64 =>
    if m > n then 0
    else (2 * m * s) + apply(m + 1, n, m + s) end

Port of Neil's JavaScript solution.

K (oK), 24 bytes
{(t*t:+/s)-+/s*s:x_!1+y}

Try it online!
"Boring" but straightforward.

Arturo, 42 35 bytes
$=>[-*<=∑r∑map r:<=&..&'z->z*z]

Try it

JavaScript, 49 bytes
Without recursion:
(b,e)=>eval('for(x=y=0;b<=e;y+=b*b++)x+=b;x*x-y')

Try it:

f=(b,e)=>eval('for(x=y=0;b<=e;y+=b*b++)x+=b;x*x-y')

console.log(f(5,9)); // 970
console.log(f(91,123)); // 12087152
console.log(f(1,10)); // 2640

Pyt, 8 bytes
ŘĐĐƩ²↔·-

Try it online!
Takes two inputs on separate lines as max, min
Ř               implicit inputs; Řange
 ĐĐ             Đuplicate array on stack twice
   Ʃ²           Get square of sum
     ⇹·         Get sum of squares
       -        Subtract; implicit print

Ly, 22 bytes
nnR&s&+:*>l[:*sp<l->]<

Try it online!
This is a straight forward interpretation of the rules...
nnR                     - get the start/end, generate the sequence of numbers
   &s                   - save the sequence...
     &+                 - sum it
       :*               - square the sum
         >l             - load the sequence on a new stack
           [        ]   - while the stack isn't empty
            :*          - square the number
              sp<l      - move the squared number to the other stack
                  ->    - subtract and go back to the second stack
                     <  - switch back to the accumulator stack
                        - the number on the stack prints automatically on exit

J-uby, 33 bytes
:!~|:-%[:sum|g= ~:**&2,:*&g|:sum]

(The space between = and ~ is necessary to keep the Ruby lexer from interpreting them as the =~ operator.)
Explanation
:!~ | :- % [:sum | g = ~:** & 2, :* & g | :sum]

:!~ |                                            # Range, then
      :- % [                   ,              ]  # difference of...
            :sum | g = ~:** & 2                  #   sum, then square (save the square function in g), and
                                 :* & g | :sum   #   map with square, then sum

Attempt This Online!

Python, 62 bytes
lambda a,b:sum(range(a,b+1))**2-sum(x*x for x in range(a,b+1))

Or, longer:
lambda a,b:sum(sum(x*y for y in range(a,b+1)if x-y)for x in range(a,b+1))

Ideone both!

This seems to be 63 bytes? (Did you forget the lambda a,b:?) Anyway, it seems like the naive: lambda a,b:sum(range(a,b+1))**2-sum(x*x for x in range(a,b+1)) is a byte shorter, unfortunately.

I'm not quite sure this works, just ran it against the test and 5,9 yields 995?

Java, 95 bytes
public int d(int a,int b){int i=a,j,s=0;for(;i<=b;i++)for(j=a;j<=b;j++)s+=i==j?0:i*j;return s;}

Ideone it!

Actually, 11 bytes
u@x;♂²Σ@Σ²-

Try it online!

R, 23 bytes
sum(i:j)^2-sum((i:j)^2)

Does pretty much what you expect by taking i and j as inputs.

you can save a byte by assigning the range to a variable in the first sum. sum(a<-i:j)^2-sum(a^2)

This assumes that the variables i and j are already defined, which makes this a snippet. By default we require all submissions to be either full programs which take input from STDIN and print output to STDOUT, or functions that accept arguments and return values. You can fix this by prepending function(i,j) to the beginning.

In fact, all of your answers on the site thus far appear to be snippets. Please adjust them to be programs or functions accordingly.

Actually, 10 bytes
u@x;;*@Σ²-

Try it online!
Explanation:
u@x;;*@Σ²-
u@x         range(a, b+1)
   ;;       two copies
     *      dot product with itself (equal to sum of squares)
      @Σ²   sum remaining copy, square sum
         -  subtract

CoffeeScript, 49 Bytes
f=(n,m,s=0)->if n>m then 0else 2*n*s+f(n+1,m,n+s)
Translation of Neil's answer
Output:
f 91, 123 == 12087152
 => true

Perl 5.10, 41 bytes
map{$s+=$_,$r+=$_**2}(<>..<>);say$s**2-$r

Input is given on 2 lines, for instance:
61
127

Try it here!

Python 2.7, 82 bytes 85 bytes
def a(l, u):
    c=0
    d=0
    for e in range(l, u+1):
        c+=e
        d+=e**2
    return c**2-d

Works in base 10.

Currently your answer is invalid (use the test cases to verify it): 1. You forgot to square c 2. You have to subtract the sum of squares from the square of the sum, so c**2-d 3. I suggest to golf your code, and you can count newlines as one byte instead of two 4. I suggest adding a Try it online! link

Julia 0.6, 21 bytes
r->2triu(r*r',1)|>sum

Try it online!
Julia port of Luis Mendo's MATL answer. Comes out to the same bytecount as the other Julia answer by @gggg. Takes a Range similar to that answer, does a matrix multiply of it with its transpose to get all pairwise products in a matrix. Takes the upper triangular portion of that (the 1 argument is to denote the distance from the leading diagonal to start from), multiplies that by 2, and finally sums the values and returns that implicitly.

Wolfram Language (Mathematica), 18 bytes
Tr@#^2-#.#&@*Range

Try it online!
Composition of Tr@#^2-#.#& (square of sum minus sum of squares, where sum of squares is implemented via dot product) and Range (list of all integers between the two inputs). If you like seeing the operations in order, Range/*Tr@#^2-#.#& is equivalent.
As a bonus, also solves this challenge with no modifications, since Range can either take one argument (giving the range from 1 to the input) or two. (But it's not the most efficient solution possible there.)

Bash, 74 65 bytes
x=y=0;for i in `seq $1 $2`;{ x=$[x+i];y=$[y+i*i]; };echo $[x*x-y]

Try it online!
I'm no expert at bash golfing, but this works.
Managed to cut 9 bytes just by reading through the bash golfing tips thread

for((i=$1;i<=$2;x+=i,y+=i*i++)){ :;};echo $[x*x-y] saves 15 bytes.

Tcl, 105 bytes
proc d a\ b {while {[incr a]<=$b} {set j $a
while \$j<=$b {incr p [expr 2*([incr j]-1)*($a-1)]}}
expr $p}

Try it online!
# Tcl, 112 bytes
proc d a\ b {set i [expr $a-1]
while \$i<$b {set j [incr i]
while \$j<$b {incr p [expr 2*[incr j]*$i]}}
expr $p}

Factor + math.unicode, 34 bytes
[ [a,b] dup Σ sq swap norm-sq - ]

Try it online!

[a,b] Create a range from the input.
dup Σ sq swap Square of sum.
norm-sq Sum of squares.
- Subtract.

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
Decode a Microsoft MS-DOS 5.0 FAT directory entry
The Microsoft FAT file system has a directory table to represent which "files" are in which "folders" on the disk. For the time, these entries crammed a lot of information into a small amount of bits. There are a bunch of technical specifications over on Wiki for the curious, but the challenge here is going to focus on a "simple" decoding of an entry.
Each entry consists of a 32-byte binary word, broken up into several sections. For consistency in this challenge, we'll be using the MS-DOS 5.0 version, the bytes are ordered as big endian, and we're calling byte 0x00 as the left-most, and byte 0x1F as the right-most.
Below is a brief schematic of the relevant sections, and what should be the output for each section (in bold).

The first 11 bytes are the file name in ASCII format (this is where the famous 8.3 filename comes from -- 8 bytes for the file name, 3 bytes for the extension). These are straight ASCII encoding, and should be output as ASCII with a period (.) between.

Note: both the 8 and the 3 parts are padded with spaces to make a full-length entry. The output should ignore spaces (i.e., don't output them).
The file extension may be empty (i.e., all spaces), in which case the output should not output the dot.
Since ASCII only uses the lower 7 bits, the bytes will all have a leading 0.

The next byte (0x0b) is a bitmask of the following:

0x01 Read Only - output RO
0x02 Hidden - output H
0x04 System - output S
0x08 Volume Label - output VL. File size (below) should be output as 0, regardless of its actual entry.
0x10 Subdirectory - output SD. File size (below) should be output as 0, regardless of its actual entry.
0x20 Archive - output A
0x40 Device - ignored for this challenge.
0x80 Reserved - ignored for this challenge.
Since this is a bitmask, multiple flags are possible - all applicable outputs should be concatenated together in any order. For example, 0xff could be ROHSVLSDA (or any other combination).

The next two bytes (0x0c and 0x0d) are not used under MS-DOS 5.0.
The next two bytes (0x0e and 0x0f) are the creation time as follows:

Bits 15 to 11 are the hours in 24-hour format - output 00 to 23
Bits 10 to 5 are the minutes - output 00 to 59
Bits 4 to 0 are the seconds/2 - output 00 to 58 (note that seconds are only in two-second resolution)
For clarification: hhhhhmmmmmmsssss when written big-endian.

The next two bytes (0x10 and 0x11) are the creation date as follows:

Bits 15 to 9 are the year - output 1980 for 0 up to 2107 for 127
Bits 8 to 5 are the months - output 1 to 12 (with or without leading zero)
Bits 4 to 0 are the day - output 0 to 31 (with or without leading zero)
For clarification: yyyyyyymmmmddddd when written big-endian.

The next two bytes (0x12 and 0x13) are the last access date. While used in MS-DOS 5.0, we're ignoring this portion for this challenge.
The next two bytes (0x14 and 0x15) are not used by MS-DOS 5.0.
The next two bytes (0x16 and 0x17) are the last modified time, following the same format as the creation time, above.
The next two bytes (0x18 and 0x19) are the last modified date, following the same format as the creation date, above.
The next two bytes (0x1a and 0x1b) are the cluster location of the file on disk. We're ignoring this portion for this challenge.
The final four bytes (0x1c, 0x1d, 0x1e, and 0x1f) are the file size - output as an unsigned integer, unless the VL or SD flags are set (above), in which case output 0.

Visual representation
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
\______________________________FILENAME________________________________________________/\_ATTR_/\___NOTUSED____/\_CREATIONTIME_/\_CREATIONDATE_/\__LASTACCESS__/\___NOTUSED____/\_MODIFIEDTIME_/\_MODIFIEDDATE_/\___NOTUSED____/\___________FILESIZE___________/

Input

A single 32-byte word (i.e., 256 bits), in whatever format is convenient.

This could be as a string of 1 and 0, as several unsigned ints, an array of Boolean values, etc.
Please specify in your answer what format you're using for input.
You cannot take multiple input (i.e., an array pre-broken into the relevant byte sizes) unless that is the only way for your language to take input. Parsing the input is part of the challenge.

You can assume input to be valid (for example, you don't need to perform date checking to verify that the date is valid).
Bytes that are unused can be all 0, all 1, etc., just so long as they are present. In the below examples, I used all 0 for the unused bytes.

Output
Either printed to screen or returned, the following:

The filename as an ASCII string
The file attributes as an ASCII string
The creation time and creation date, with appropriate separators (colons, slashes, something to distinguish the components)
The modified time and modified date, again with appropriate separators
The file size

The output can be a space-separated or newline-separated single string, separate elements in an array, etc. Please specify in your answer how your output is formatted.
Rules

Standard I/O formats are acceptable.
Either a full program or a function are acceptable.
Standard loopholes are forbidden.
This is code-golf, so all usual golfing rules apply, and the shortest code wins.
Built-ins that perform exactly this function are forbidden.

Examples
0111000001110010011011110110011101110010011000010110110101101101011010010110111001100111000001100000000000000000101000100100010001001000110101000000000000000000000000000000000010100010010001000100100011010100000000000000000000000000000000001101000000000000

programm.ing HS 20:18:08 2016/06/20 20:18:08 2016/06/20 53248

0010000000100000001000000010000001110000011100000110001101100111001000000010000000100000000101000000000000000000010111010110110000111101100111110000000000000000000000000000000010100010010001000100100011010100000000000000000011110000000100111111001011100001

ppcg SDS 11:43:24 2010/12/31 20:18:08 2016/06/20 0

Is it okay if there's excess whitespace around the flags? Eg, would SD S be a valid flag set?

@MorganThrapp Sure, that should be fine.

Out of curiosity, did you get a lot of experience interacting with MS-DOS 5.0 back in the day, or were you just really bored on Wikipedia one day?

@cat Some of both. I've been heavily interested in computers since I was about 5 and received a Commodore VIC-20. One of my grad-level computer science projects about 10 years ago was to build our own filesystem, so I researched a lot for that. For this, I pulled a bunch from Wiki and pared it down to something that could be a challenge.

Verilog, 513 670 617 bytes
Runs using IVerilog. No special compile flags needed.
This is a monster of nested definitions, bit-twiddling, and the annoyance of having to flip bit order due to the endianness (otherwise either the string doesn't print, or the number bit order is wrong). The input is taken through the i port, which is the usual way of taking input into a Verilog module. $display is used to print to standard out. 6 bytes could be saved if leading zeros were not required for the timestamp.
`define r(o,b)wire[3:0]o;assign o={i[b],i[b+1],i[b+2],i[b+3]};
`define R(t,a,b,c,d,s)`r(a,s)`r(b,s+4)`r(c,s+8)`r(d,s+12)wire[15:0]t;assign t={a,b,c,d};
`define p(m,k)i[90+m]?"k":"",
`define F(a,b)"a a a b\t b%d"
module f(input[0:255]i);`R(d,q,w,e,r,112)`R(D,Q,W,E,R,128)`R(s,z,x,c,v,224)`R(S,Z,X,C,V,240)`R(p,t,y,u,o,176)`R (A,b,n,m,l,192)always@(i)$display(`F(%s%s%s,%02d:%02d:%02d%d/%d/%d),i[0:63],i[64:87]=="   "?" ":".",i[64:87],`p(5,RO)`p(4,H)`p(3,S)`p(2,VL)`p(1,SD)`p(0,A)d[15:11],d[10:5],d[4:0]*2,D[15:9]+1980,D[8:5],D[4:0],p[15:11],p[10:5],p[4:0]*2,A[15:9]+1980,A[8:5],A[4:0],|i[91:92]?0:{s,S});endmodule

Demo
Testbench (Not scored):
`timescale 1ns / 1ps

module ftest;
reg [0:255] i;
f uut (
.i(i)
);
initial begin
    i=256'b0111000001110010011011110110011101110010011000010110110101101101011010010110111001100111000001100000000000000000101000100100010001001000110101000000000000000000000000000000000010100010010001000100100011010100000000000000000000000000000000001101000000000000;
    #100;
i=256'b0010000000100000001000000010000001110000011100000110001101100111001000000010000000100000000101000000000000000000010111010110110000111101100111110000000000000000000000000000000010100010010001000100100011010100000000000000000011110000000100111111001011100001;
end

endmodule

Example run:
$ iverilog design.sv testbench.sv  && vvp a.out
programm.ing   HS      20:18:08       2016/ 6/20      53248
    ppcg        S  SD  11:43:24       2010/12/31          0

Python, 485, 479, 442, 438, 431, 429, 418, 402, 395, 391, 370 bytes.
Saved 19 bytes thank to Cᴏɴᴏʀ O'Bʀɪᴇɴ reminding me that I can assign functions to a letter.
Saved 6 bytes thanks to FryAmTheEggman's suggestion to clean up the bitmask filter.
Saved 21 bytes thanks to W0lf's awesome Ruby answer forcing me to golf this down some more. ;)
This is an absolute monster. Pretty sure I can cut it down a bit more, but it's getting pretty close to being golfed out.
a=input()
j=''.join
n=lambda v:int(v,2)
f=j('RO H S VL SD A'.split()[i]for i in range(6)if n(a[88:96])&2**i)
print(j(chr(n(a[x:x+8])).strip()+'.'*(x==56)for x in range(0,88,8)).strip('.'),f,j('%02d:%02d:%02d'%(n(a[b-11:b-6]),n(a[b-6:b]),n(a[b:b+6]))+' %d/%d/%d '%(n(a[b+6:b+12])+1980,n(a[b+12:b+16]),n(a[b+16:b+21]))for b in[123,187]),n(a[208:])*(1-('V'in f or'D'in f)))

maybe you could assign int to a char? or maybe make a function that performs str int.

@CᴏɴᴏʀO'Bʀɪᴇɴ Good idea!

The space between or 'SD' can be removed, I think

@CᴏɴᴏʀO'Bʀɪᴇɴ Yup, just did that.

Wow. Quite a bit shorter than I expected answers to be.

@TimmyD Really? This is way longer than I expected my answer to be.

You think this is a monster? Wait until you see my Java answer...

Haskell, 781 710 bytes
Thanks to BlackCap for some simplification
w n=('0'<$[1..2-length a])++a where a=show n
x s=tail.foldr(\a b->s:a++b)""
t=snd.span(==' ')
y a|all(==' ')a=""|0<1='.':t a
nm=(\(a,b)->t a++y b).splitAt 8
ms n(r,s)|n`mod`2^(r+1)`div`2^r>0=s|0<1=""
tm n=x ':'[w$n`div`2^11,w$n`mod`2^11`div`32,w$2*n`mod`64]
dt n=x '/'[w$1980+n`div`2^9,w$n`mod`2^9`div`32,w$n`mod`32]
pa s=x ' '[nm.map(toEnum.v.take 8).takeWhile(not.null)$iterate(drop 8)a,t,dt$v i,tm$v g,dt$v o,tm$v m,show u,"\n"]where{z n=splitAt(8*n);(a,b)=z 11 s;(c,d)=z 1 b;(e,f)=z 2 d;(g,h)=z 2 f;(i,j)=z 2 h;(k,l)=z 4 j;(m,n)=z 2 l;(o,p)=z 2 n;(q,r)=z 2 p;t=(zip [0..](words"RO H S VL SD A")>>=).ms$v c;u|any(`elem`t)"LD"=0|0<1=v r;v=foldl((+).(2*))0.map(read.pure).filter(`elem`"01")}
main=interact pa

This additionally allows garbage (like a newline character) to appear after the input.

Got you some low hanging fruit: http://pastebin.com/X69jH75f

Java, 1721 1587 1573 1560 1511 bytes:
import java.util.*;class A{int Q(String a,int b){return Integer.parseInt(a,b);}String P(int a){return Integer.toString(a);}ArrayList<String>B=new ArrayList<String>();void J(String O){B.add(O);}String TD(String l,String p,int a,int c,int d){String X,Y,Z;X=Y=Z=new String();int i=0;for(char F:l.toCharArray()){if(i<a){X+=F;}if(a<=i&i<c){Y+=F;}if(c<=i){Z+=F;}i++;}String[]H=new String[3];H[0]=P(d+Q(X,2));H[1]=P(Q(Y,2));H[2]=(p==":")?P(Q(Z,2)*2):P(Q(Z,2));int T=0;for(String A:H){H[T]=(A.length()<2)?"0"+A:A;T++;}return H[0]+p+H[1]+p+H[2];}String D(String i){String K=new String();int L=0;for(char Y:i.toCharArray()){if(L%8<1){K+=" ";}K+=Y;L++;}String[]C=K.split(" ");String[]z={"RO","H","S","VL","SD","A"};int[]l={1,2,4,8,16,32};Map<Integer,String>U=new HashMap<Integer,String>();for (int e=0;e<l.length;e++){U.put(l[e],z[e]);}String[]N={":","/",":","/"};int[]M={15,17,23,25};int[]O={5,7,5,7};int[]P={0,1980,0,1980};for(int y=1;y<9;y++){if((char)Q(C[y],2)!=' '){J(Character.toString((char)Q(C[y],2)));}}for(int v=9;v<12;v++){if((char)Q(C[v],2)!=' '){if(!B.contains(".")){J(".");}J(Character.toString((char)Q(C[v],2)));}}J(" ");int T=(char)Q(C[12],2);while(T>0){int H=l[0];for(int V:l){if(V<=T){H=V;}}J(U.get(H));T-=H;}for(int w=0;w<4;w++){J(" ");J(TD(C[M[w]]+C[M[w]+1],N[w],O[w],11,P[w]));}J(" ");if(B.contains("SD")||B.contains("VL")){J("0");}else{J(P(Q(C[29]+C[30]+C[31]+C[32],2)));}return String.join("",B);}public static void main(String[]a){A H=new A();System.out.print(H.D(new Scanner(System.in).next()));}}

Takes input in the format of 32 byte binary string. Outputs in the format of a space separated string. This may be a very very long answer, but I'm still not disappointed. I'm just happy I was able to implement this in Java. I will still try to golf this as much as I can, though.
Try It Online! (Ideone)

+1 because using Java for low-level problems is pleasantly ironic (much like my Haskell)

Ruby, 344 bytes
m=gets
s=->b,l{b.slice!(0,l).to_i 2}
t=->b{'%02d:%02d:%02d %d/%d/%d'%[s[b,5],s[b,6],2*s[b,5],s[b,7]+1980,s[b,4],s[b,5],]}
i=(0..q=32).map{|i|m[i*8,8].to_i 2}
c=i.map(&:chr).join
n=c[0,8].strip
e=c[8,3].strip
e>?!&&n<<?.+e
f=''
6.times{|j|i[11][j]>0&&f<<%w(RO H S VL SD A)[j]}
$><<[n,f,t[m[112,q]],t[m[176,q]],(f[/VL|SD/]?0:m[-q,q].to_i(2))]*' '

The slightly more readable version is available here.
Online test: http://ideone.com/Fww1Rw

Nice one! Looks like I need to golf off another 27 bytes. ;)

JavaScript (ES6), 369
(b,Z=n=>n>9?n:'0'+n,W=n=>s[n]<<8|s[n+1],U=n=>[Z((t=W(n))>>11)+`:${Z(t>>5&63)}:`+Z(t%32*2),((t=W(n+2))>>9)+1980+`/${t>>5&15}/`+t%32],X=l=>String.fromCharCode(...s.slice(p,p+=l)).trim(),s=b.match(/.{8}/g).map(x=>+('0b'+x)),p=0)=>[X(8)+((x=X(3))?'.'+x:x),[...b].map((b,i)=>'A,SD,VL,S,H,RO'.split`,`[z=(2*z|b)%4294967296,i*b-90]||'',z=0).join``,U(14),U(22),b[92]|b[91]?0:z]

Less golfed
(b,
  Z=n=>n>9?n:'0'+n, // zero pad
  W=n=>s[n]<<8|s[n+1], // get word
  U=n=>[
   Z((t=W(n))>>11)+`:${Z((t>>5&63)}:`+Z(t%32*2),  // decode time
   ((t=W(n+2))>>9)+1980+`/${t>>5&15}/`+t%32 // decode date
  ],
  X=l=>String.fromCharCode(...s.slice(p,p+=l)).trim(), // extract space padded string
  s=b.match(/.{8}/g).map(x=>+('0b'+x)), // convert bits to bytes
  p=0
)=>
  [ X(8)+((x=X(3))?'.'+x:x),
    [...b].map((b,i)=>'A,SD,VL,S,H,RO'.split`,`[i*b-90]||'').join``,
    [...b].slice(-32).map((b,i)=>z=2*z|b,z=0), // this line merged with the preceding one in the golfed code
    U(14),U(22),
    b[92]|b[91]?0:z
  ]

Test

f=(b,Z=n=>n>9?n:'0'+n,W=n=>s[n]<<8|s[n+1],U=n=>[Z((t=W(n))>>11)+`:${Z(t>>5&63)}:`+Z(t%32*2),((t=W(n+2))>>9)+1980+`/${t>>5&15}/`+t%32],X=l=>String.fromCharCode(...s.slice(p,p+=l)).trim(),s=b.match(/.{8}/g).map(x=>+('0b'+x)),p=0)=>[X(8)+((x=X(3))?'.'+x:x),[...b].map((b,i)=>'A,SD,VL,S,H,RO'.split`,`[z=(2*z|b)%4294967296,i*b-90]||'',z=0).join``,U(14),U(22),b[92]|b[91]?0:z]

O.textContent+='\n'+f('0111000001110010011011110110011101110010011000010110110101101101011010010110111001100111000001100000000000000000101000100100010001001000110101000000000000000000000000000000000010100010010001000100100011010100000000000000000000000000000000001101000000000000')
O.textContent+='\n'+f('0010000000100000001000000010000001110000011100000110001101100111001000000010000000100000000101000000000000000000010111010110110000111101100111110000000000000000000000000000000010100010010001000100100011010100000000000000000011110000000100111111001011100001')

Ok, so I just ran this in Safari and got Script error.. But for some reason in Firefox it seems to work perfectly. I wonder why...

@R.Kap probably Safari is less ES6 compatible than Firefox. https://kangax.github.io/compat-table/es6/

PHP, 301 288 bytes
for($b=unpack('A8f/A3e/Cl/n/Nc/N/Nm/n/Ns',$argn);$i<8;$f.=1<<$i++&$b[l]?[RO,H,S,VL,SD,A][$i-1]:'');echo trim($b[f].'.'.$b[e],' .')," $f ",($e=function($a){echo date('H:i:s Y/m/d ',mktime($a>>27&31,$a>>21&63,$a>>15&62,$a>>5&15,$a&31,1980+($a>>9&127)));})($b[c]),$e($b[m]),$b[l]&24?0:$b[s];

Try it online!
Input is a 32 byte word string via STDIN, output to STDOUT.
-13 bytes as a standalone program.

Stax, 111 bytes
¼ΘUßU'ïMo^ø¬├▓> I¬i⌠·╥.↕¥½ßqS,=frT`d_`&&↓⌠ÉûÆiü=┌-< │∟Φ☼⌐¢3²Bu╜lJ╛§≥╪║ε┐╓ù♫╨Z░╖!¥É:╬Çß═╤às8Q←φ,ºï◘≥Ä£}èΦ╡FÉçø¶É

Run and debug it

Oops, my mistake. I'll make a fix.

It's working correctly now at the cost of 3 bytes.

Perl, 249 bytes
Takes 32 bytes as input, output is separated by newlines. unpack is perfect for this kind of binary structure parsing.
($f,$e,$a,$C,$M,$s)=unpack"A8A3CxxNx4Nx2N",<>;$f=~s/ //g;$e=~s/ //g;printf"%s
@{[map+(RO,H,S,VL,SD,A)[$a&1<<$_?$_:9],0..5]}
"."%02d:%02d:%02d %d/%d/%d
"x2 .$s*!($a&24),$f.".$e"x!!$e,map{$_>>27,$_>>21&63,$_>>15&62,$_/512%128+1980,$_>>5&15,$_&31}$C,$M

Some highlights:

The aforementioned unpack.
The turtle operator @{[]} allows to interpolate code in a string. It actually creates an array reference that is then dereferenced.
"$str1"x!!$str2 is a nice way to return $str1 only if $str2 is a non-empty string.

Below is a version that works on real directory entries, with little-endian fields, and only ignoring right padding on the filename and extension (so, e.g. "    ppcg" doesn't have its initial whitespace removed) (254 bytes)
($f,$e,$a,$C,$M,$s)=unpack"A8A3CxxVx4Vx2V",<>;$f=~s/ +$//;$e=~s/ +$//;printf"%s
@{[map+(RO,H,S,VL,SD,A)[$a&1<<$_?$_:9],0..5]}
"."%02d:%02d:%02d %d/%d/%d
"x2 .$s*!($a&24),$f.".$e"x!!$e,map{$_>>11&31,$_>>5&63,2*$_&63,($_>>25)+1980,$_>>21&15,$_>>16&31}$C,$M

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes


text:
Bit-Reversal Permutations
Your goal is to create a function or a program to reverse the bits in a range of integers given an integer \$n\$. In other words, you want to find the bit-reversal permutation of a range of \$2^n\$ items, zero-indexed. This is also the OEIS sequence A030109. This process is often used in computing Fast Fourier Transforms, such as the in-place Cooley-Tukey algorithm for FFT. There is also a challenge for computing the FFT for sequences where the length is a power of 2.
This process requires you to iterate over the range \$[0, 2^n-1]\$, convert each value to binary and reverse the bits in that value. You will be treating each value as a \$n\$-digit number in base 2 which means reversal will only occur among the last \$n\$ bits.
For example, if \$n = 3\$, the range of integers is [0, 1, 2, 3, 4, 5, 6, 7]. These are
i  Regular  Bit-Reversed  j
0    000        000       0
1    001        100       4
2    010        010       2
3    011        110       6
4    100        001       1
5    101        101       5
6    110        011       3
7    111        111       7

where each index \$i\$ is converted to an index \$j\$ using bit-reversal. This means that the output is [0, 4, 2, 6, 1, 5, 3, 7].
The output for \$n\$ from 0 thru 4 are
n    Bit-Reversed Permutation
0    [0]
1    [0, 1]
2    [0, 2, 1, 3]
3    [0, 4, 2, 6, 1, 5, 3, 7]

You may have noticed a pattern forming. Given \$n\$, you can take the previous sequence for \$n-1\$ and double it. Then concatenate that doubled list to the same double list but incremented by one. To show,
[0, 2, 1, 3] * 2 = [0, 4, 2, 6]
[0, 4, 2, 6] + 1 = [1, 5, 3, 7]
[0, 4, 2, 6] ⊕ [1, 5, 3, 7] = [0, 4, 2, 6, 1, 5, 3, 7]

where \$⊕\$ represents concatenation.
You can use either of the two methods above in order to form your solution. If you know a better way, you are free to use that too. Any method is fine as long as it outputs the correct results.
Rules

This is code-golf so the shortest solution wins.
Builtins that solve this challenge as a whole and builtins that compute the bit-reversal of a value are not allowed. This does not include builtins which perform binary conversion or other bitwise operations.
Your solution must be, at the least, valid for \$n\$ from 0 to 31.

"Builtins that solve this challenge as a whole and builtins that compute the bit-reversal of a value are not allowed." Awww, IntegerReverse[Range[2^#]-1,2,#]&. (I don't know why Mathematica needs that built-in but I guess it's not a lot weirder than Sunset...)

@MartinEnder Nice find. Someday, it might be that there will be a builtin for everything in Mathematica, including generating random code-golf challenges.

Can we print 0 instead of [0] or does it have to be a list?

@Dennis Good point. I'll allow it, since it's only important that the output represents a valid permutation regardless of format.

Would returning false instead of 0 be acceptable?

Yes, as long as your language interprets false as 0 and true as 1.

Jelly, 7 6 bytes
Ḥ;‘$$¡

Thanks to @EriktheOutgolfer for golfing off 1 byte!
Try it online!
How it works
Ḥ;‘$$¡  Main link. No arguments.
        Implicit argument / initial return value: 0

     ¡  Read an integer n from STDIN and call the link to the left n times.
    $   Combine the two links to the left into a monadic chain, to be called
        with argument A (initially 0, later an array).
Ḥ         Unhalve; yield 2A.
   $      Combine the two links to the left into a monadic chain, to be called
          with argument 2A.
  ‘         Increment; yield 2A + 1
 ;          Concatenate 2A and 2A + 1.

Haskell, 40 37 bytes
f 0=[0]
f a=[(*2),(+1).(*2)]<*>f(a-1)

Try it online!
Thanks to @Laikoni for three bytes!

05AB1E, 8 bytes
Code:
¾)IF·D>«

Explanation:
¾         # Constant for 0.
 )        # Wrap it up into an array.
  IF      # Do the following input times.
    ·     # Double every element.
     D    # Duplicate it.
      >   # Increment by 1.
       «  # Concatenate the first array.

Uses the CP-1252 encoding. Try it online!.

Nice one! Beats the one I had :)

@Emigna Thanks! What was your version then?

0)ïsF·D>« was close though. Had some issues with the '0'.

@Emigna Oh, I actually have that same issue now. Lemme fix that :p

Nice usage of ¾. Gonna have to remember that trick.

@Emigna I know it's been almost two years, but (out of curiosity) what were the issues of 0) vs ¾)? The test case in the TIO seems to work in both cases.

@KevinCruijssen For input 0, it looks prettier to have the int representation of 0 and not the string representation :). Other than that, there are no differences.

@Adnan Ah ok, it was only a visual difference with [0, ... vs ['0', ...?

@KevinCruijssen Yes, that is correct

J, 15 11 bytes
2&(*,1+*)0:

There is an alternative for 15 bytes that uses straight-forward binary conversion and reversal.
2|."1&.#:@i.@^]

Usage
   f =: 2&(*,1+*)0:
   f 0
0
   f 1
0 1
   f 2
0 2 1 3
   f 3
0 4 2 6 1 5 3 7
   f 4
0 8 4 12 2 10 6 14 1 9 5 13 3 11 7 15

Explanation
2&(*,1+*)0:  Input: n
         0:  The constant 0
2&(     )    Repeat n times starting with x = [0]
2      *       Multiply each in x by 2
     1+        Add 1 to each
    ,          Append that to
2  *           The list formed by multiplying each in x by 2
               Return that as the next value of x
             Return the final value of x

MATL, 13 12 10 9 8 bytes
0i:"EtQh

Try it Online
Explanation
0       % Push number literal 0 to the stack
i:"     % Loop n times
    E   % Multiply by two
    t   % Duplicate
    Q   % Add one
    h   % Horizontally concatenate the result
        % Implicit end of loop, and implicitly display the result

For the sake of completeness, here was my old answer using the non-recursive approach  (9 bytes).
W:qB2&PXB

Try it Online
Explanation
W       % Compute 2 to the power% ofImplicitly thegrab input (n) and compute 2^n
:       % Create an array from [1...2^n]
q       % Subtract 1 to get [0...(2^n - 1)]
B       % Convert to binary where each row is the binary representation of a number
2&P     % Flip this 2D array of binary numbers along the second dimension
XB      % Convert binary back to decimal
        % Implicitly display the result

Jelly, 5 bytes
2ṗ’UḄ

Try it online!
-1 thanks to Dennis.

Java, 422 419 bytes:
import java.util.*;class A{static int[]P(int n){int[]U=new int[(int)Math.pow(2,n)];for(int i=0;i<U.length;i++){String Q=new String(Integer.toBinaryString(i));if(Q.length()<n){Q=new String(new char[n-Q.length()]).replace("\0","0")+Q;}U[i]=Integer.parseInt(new StringBuilder(Q).reverse().toString(),2);}return U;}public static void main(String[]a){System.out.print(Arrays.toString(P(new Scanner(System.in).nextInt())));}}

Well, I finally learned Java for my second programming language, so I wanted to use my new skills to complete a simple challenge, and although it turned out very long, I am not disappointed. I am just glad I was able to complete a simple challenge in Java.
Try It Online! (Ideone)

You can save a few bytes parsing an int from args rather than reading from StdIn

Octave, 37 bytes
@(n)bin2dec(fliplr(dec2bin(0:2^n-1)))

Creates an anonymous function named ans that can simply be called with ans(n).
Online Demo

Mathematica, 56 33 bytes
Byte count assumes an ISO 8859-1 encoded source.
±0={0};±x_:=Join[y=±(x-1)2,y+1]

This uses the recursive definition to define a unary operator ±.

Python 2, 56 55 54 bytes
f=lambda n:[0][n:]or[i+j*2for i in 0,1for j in f(n-1)]

Test it on Ideone.
Thanks to @xnor for golfing off 1 byte!

You can do [0][n:]or.

Perl, 46 45 bytes
Includes +1 for -p
Give input number on STDIN
#!/usr/bin/perl -p
map$F[@F]=($_*=2)+1,@F for(@F=0)..$_;$_="@F"

Python 3, 67 59 bytes
Thanks to @Dennis for -8 bytes
lambda n:[int(bin(i+2**n)[:1:-1],2)//2for i in range(2**n)]

We may as well have a (modified) straightforward implementation in Python, even if this is quite long.
An anonymous function that takes input by argument and returns the bit-reversed permutation as a list.
How it works
lambda n                 Anonymous function with input n
...for i in range(2**n)  Range from 0 to 2**n-1
bin(i+2**n)[:1:-1]       Convert i+2**n to binary string, giving 1 more digit than needed,
                         remove '0b' from start, and reverse
int(...,2)               Convert back to decimal
...//2                   The binary representation of the decimal value has one trailing
                         bit that is not required. This is removed by integer division by 2
:[...]                   Return as list

Try it on Ideone

This ties with my approach, but it golfiness won't survive a port to Python 3.

Pyth - 11 bytes
ushMByMGQ]0

Test Suite.

Javascript ES6, 65 53 51 bytes
f=(n,m=1)=>n?[...n=f(n-1,m+m),...n.map(i=>i+m)]:[0]

Uses the recursive double-increment-concat algorithm.
Example runs:
f(0) => [0]
f(1) => [0, 1]
f(2) => [0, 2, 1, 3]
f(4) => [0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15]

How about f=n=>n>0?(r=f(n-1).map(i=>i*2)).concat(r.map(i=>i+1)):[0]?

@miles Whoops, didn't realize I don't need a base case for n==1, thanks.

I think I managed to shave off 2 bytes by moving the multiplication by two: f=(n,m=1)=>n?[...n=f(n-1,m+m),...n.map(i=>i+m)]:[0]

Ruby, 57 47 39 bytes
->n{[*0...2**n].sort_by{|a|a.digits 2}}

Try it online!
3 years later, 18 bytes golfed.

Dyalog APL, 12 bytes
Requires ⎕IO←0 which is default on many systems.
2⊥⊖2⊥⍣¯1⍳2*⎕

2⊥ from-base-2 of
⊖ the flipped
2⊥⍣¯1 inverse of from-base-2 of
⍳ the first n integers, where n is
2* 2 to the power of
⎕ numeric input
TryAPL online!

For comparison, here is the other method:
(2∘×,1+2∘×)⍣⎕⊢0

( the function train...
 2∘× two times (the argument)
 , concatenated to
 1+ one plus
 2∘× two times (the argument)
)⍣ applied as many times as specified by
⎕ numeric input
⊢ on
0 zero

(⍋,⍨)⍣⎕⊢0 (⎕io←0)

@ngn That has nothing to do with my algorithm.

i thought it was similar to your "other method" but ok, i'll write a separate answer

Ruby, 51 bytes
f=->n{n<1?[0]:(a=f[n-1].map{|i|i*2})+a.map(&:next)}

Try it online!

K (ngn/k), 11 8 bytes
2/|!2|&:

Try it online!
 x:3  / just for testing
 &x   / that many zeroes
0 0 0
 2|&x / max with 2
2 2 2
 !x#2 / binary words of length x, as a transposed matrix
(0 0 0 0 1 1 1 1
 0 0 1 1 0 0 1 1
 0 1 0 1 0 1 0 1)
 |!x#2 / reverse
(0 1 0 1 0 1 0 1
 0 0 1 1 0 0 1 1
 0 0 0 0 1 1 1 1)
 2/|!x#2 / base-2 decode the columns
0 4 2 6 1 5 3 7

& is the last verb in the composition so we need a : to force it to be monadic

JavaScript (Firefox 30-57), 48 bytes
f=n=>n?[for(x of[0,1])for(y of f(n-1))x+y+y]:[0]

Port of @Dennis♦'s Python 2 solution.

ReferenceError: f is not defined

Pyth, 8 bytes
iR2_M^U2

Try it online: Demonstration or Test Suite
Explanation:
iR2_M^U2Q   implicit Q (=input number) at the end
     ^U2Q   generate all lists of zeros and ones of length Q in order
   _M       reverse each list
iR2         convert each list to a number

Julia, 23 22 bytes
!n=n>0&&[t=2*!~-n;t+1]

Rather straightforward implementation of the process described in the challenge spec.
Try it online!

Clojure, 78 bytes
Just following the spec...
(defn f[n](if(= n 0)[0](let[F(map #(* 2 %)(f(dec n)))](concat F(map inc F)))))

PHP, 57 bytes
while($i<1<<$argv[1])echo bindec(strrev(decbin($i++))),_;

takes input from command line parameter, prints underscore-delimited values. Run with -nr.
recursive solution, 72 bytes
function p($n){$r=[$n];if($n)foreach($r=p($n-1)as$q)$r[]=$q+1;return$r;}

function takes integer, returns array

Perl 6, 25 bytes
{[X+] 0,|(0 X(2 X**^$_))}

Try it online!
Perl 6, 42 bytes
{0,{$^p+^($_-$_/2+>lsb ++$)}...$_}o 1+<*-1

Try it online!
Incrementing an integer simply flips a sequence of least-significant bits, for example from xxxx0111 to xxxx1000. So the next bit-reversed index can be obtained from the previous one by flipping a sequence of most-significant bits. The XOR mask can be computed with m - (m >> (ctz(i) + 1)) for m = 2**n or m = 2**n-1.

Japt, 14 13 bytes
2pU Ç¤w ú0U Í

Try it online!
Unpacked & How it works
2pU o_s2 w ú0U n2

2pU    2**n
o_     range(2**n).map(...)
s2       convert to binary string
w        reverse
ú0U      right-pad to length n, filling with '0'
n2       convert binary string to number

Straightforward implementation.

There's actually an undocumented shortcut for n2: Í

APL (Dyalog Classic), 9 bytes
(⍋,⍨)⍣⎕⊢0

Try it online!
⎕ evaluated input
( )⍣⎕⊢0 apply the thing in ( ) that many times, starting with 0
,⍨ concatenate the current result with itself
⍋ indices of a sort-ascending permutation

TI-BASIC, 26 bytes
Input A:{0:For(I,1,A:2Ans:augment(Ans,1+Ans:End:Ans

Prompts the user to input n.
Outputs the bit-reversal permutation as is specified in the challenge.
Explanation:
Input A                  ;prompt the user for "n".  store the input into A
{0                       ;leave {0} in Ans
For(I,1,A                ;loop A times
2Ans                     ;double Ans and leave the result in Ans
augment(Ans,1+Ans        ;add 1 to Ans and append it to the previous result
                         ;  leave the new result in Ans
End                      ;loop end
Ans                      ;leave Ans in Ans
                         ;implicit print of Ans

Examples:
prgmCDGF25

?1
           {0 1}
prgmCDGF25

?3
{0 4 2 6 1 5 3 7}

Note: TI-BASIC is a tokenized language.  Character count does not equal byte count.

Desmos, 71 bytes
f(n)=[total(mod(floor(2i/2^{[1...n]}),2)2^{[n-1...0]})fori=[0...2^n-1]]

Straightforward implementation of the challenge (convert to binary, then reverse), but probably optimizable with actions...
Try It On Desmos!
Try It On Desmos! - Prettified

Factor, 43 bytes
[ { 0 } [ 2 v*n dup 1 v+n append ] repeat ]

Try it online!

x86, 31 bytes
Takes a sufficiently large int[] buffer in eax and n in ecx, and returns the buffer in eax.
Implements the concatenating algorithm given in the challenge statement. It may be possible to save bytes by incrementing the pointers by 4 instead of using array accesses directly, but lea/mov is already pretty short (3 bytes for 3 regs and a multiplier).
.section .text
.globl main
main:
        mov     $buf, %eax          # buf addr
        mov     $3, %ecx            # n

start:
        xor     %ebx, %ebx
        mov     %ebx, (%eax)        # init buf[0] = 0
        inc     %ebx                # x = 1

l1:
        mov     %ebx, %edi
        dec     %edi                # i = x-1
        lea     (%eax,%ebx,4), %edx # buf+x

l2:
        mov     (%eax,%edi,4), %esi # z = buf[i]
        sal     %esi                # z *= 2
        mov     %esi, (%eax,%edi,4) # buf[i] = z
        inc     %esi                # z += 1
        mov     %esi, (%edx,%edi,4) # buf[x+i] = z

        dec     %edi                # --i
        jns     l2                  # do while (i >= 0)

        sal     %ebx                # x *= 2
        loop    l1                  # do while (--n)

        ret

.data
buf:    .space 256, -1

Hexdump:
00000507  31 db 89 18 43 89 df 4f  8d 14 98 8b 34 b8 d1 e6  |1...C..O....4...|
00000517  89 34 b8 46 89 34 ba 4f  79 f1 d1 e3 e2 e7 c3     |.4.F.4.Oy......|

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/


text:
Write a program to elasticize strings
Nice verb there, in the title.
Write a program that given an input string, will "elasticize" this string and output the result. Elasticizing a string is done as follows:
The first character is shown once.
The second character is shown twice.
The third character is shown thrice,
and so on.
As you can see, the amount of duplications of a certain character is related to the character's index as opposed to its previous occurrences in the string.
You can expect to receive only printable ASCII characters. Based off the following link, these characters have decimal values 32-126.
Examples:
Why: Whhyyy
SKype: SKKyyyppppeeeee
LobbY: LoobbbbbbbYYYYY (Note how there are 7 b's since the first b is shown 3 times and the second b is shown 4 times, making a total of 7 b's).
A and B: A  aaannnnddddd      BBBBBBB
Shortest bytes wins :)

That seems to disagree with "no support for whitespace is needed, other than the space character". Should the output be the same as the input then? (Two one letter words?) Also note we have a nice place called the Sandbox where you can put challenges for people to give you feedback before posting them.

FryAmTheEggman your assumption is valid. @TimmyD I realize where I was unclear, you may end up with strings separated my multiple spaces, as seen in the example FryAmTheEggman posted.

I'm assuming that the shortest code wins? ;)

@Adnan Yep, though I'm not sure if I should mark the answer with the shorted program as accepted, as certain languages are made for golfing purposes unlike others.

And here I was ready to be clever and start making strings more expensive as more of them were allocated...

Related: 1, 2

Need it be a full program, or simply a function?

@Zymus Based on the answers, I would say function.

Jelly, 3 bytes
Code:
ĖP€

Explanation:
Ė     # Enumerate.
 P€   # Product of each.
      # Implicit joining of everything.

Uses the Jelly encoding. Try it online!.

Nice abuse of the fact that Python's * does string multiplication. That's not really intended, but it works.

@Dennis: which *? There's no such thing in the whole answer.

@Thomas: Jelly is written in Python, and the Jelly P command calculates product behind the scenes using the Python * operator.  This post is abusing the leaky abstraction of the underlying code actually being in Python, so doing a P (product) command on a string works as expected.

J, 4 bytes
#~#\

Usage
   f =: #~#\
   f 'Why'
Whhyyy
   f 'SKype'
SKKyyyppppeeeee
   f 'LobbY'
LoobbbbbbbYYYYY
   f 'A and B'
A  aaannnnddddd      BBBBBBB

Explanation
#~#\  Input: s
  #\  Computes the length of each prefix of s
      This forms the range [1, 2, ..., len(s)]
#~    For each value in the range, copy the character at the
      corresponding index that many times
      Return the created string

Brainfuck, 15 bytes
,[>+[->+<<.>],]

Pretty straightforward implementation, shifting the memory space by 1 for each input char. Requires an interpreter that gives 0 on EOF, and 32-bit/arbitrary precision cells for inputs longer than 255 chars.
Try it online! (Note: TIO uses 8-bit cells)

Also, I think that this doesn't work for strings longer than 255 characters.

@IsmaelMiguel That would depend on whether the interpreter in question has arbitrary precision integers or not (but indeed, for most implementations, it would cap at 255)

The convention is to use 8-bits. Which is 1 character. But some may indeed implement with 32-bit numbers. Since you specify you need that EOF be 0 (which is a compiler/interpreter-specific behaviour), it should be noted that for strings longer than 255 characters, you need a compiler/interpreter with 32-bit cells. I just though that it should be added to the answer, since it is also a compiler/interpreter-specific behaviour.

@IsmaelMiguel Sure, noted.

Haskell, 29 bytes
concat.zipWith replicate[1..]

Usage example: concat.zipWith replicate[1..] $ "SKype" -> "SKKyyyppppeeeee".
replicate n c makes n copies of c and concat makes a single list out of all the sublists.

id=<< is a nice touch. :)

I just wanted to try it, but assigning f = id=<<zipWith replicate[1..] (in a file) did result in an ugly error, can you tell what I'm doing wrong?

Shouldn't it be possible to assign this (unnamed, right?) function to a name, such that we can use it as  a function? I mean if it is a function, then (id=<<zipWith replicate[1..] ) "SKype" should still work? Otherwise I would consider it as a snippet. The full program you provided does have "SKype" hardcoded.

I'd say if you cannot use it like any other function, it is not a function. E.g. :t does not regard id=<<zipWith replicate[1..] as a function (it just throws an error) however (id=<<).zipWith replicate[1..] is considered as a function. I'd say the first one is just a snipped, that just works if you hardcode the input, but the second one that you just postet is a function (and :t agrees), would you agree on that?

Ok, great! If you disagree with my "definition", I think we should start a meta post for clearing this up. In the mean time I'm trying to find some other haskellians for their opinion on this, as this is just my view.

On the other hand, can :t consider something as anything but a function? I think everything is a function as long as there is no errror, but then again, I'm still a newbie=)

@flawr: there are also values (e.g. :t "test") and kinds.

@flawr: I agree, my first version is a snippet. Thanks for bringing it up for discussion. Btw: :t checks the type (function or value) :k checks the kind.

I didn't know about kinds! Couldn't you still consider values as constant functions?

@flawr: yes, most of the time (especially outside the Haskell terminology) you can see values as constant functions. Back to :t I'd consider it necessary but not sufficient for some Haskell code to pass a :t test to be a function. If :t throws an error it's definitely not a function. Not everything :taccepts is a function even in a broader sense and in particular not in our (PPCG) sense.

Java, 158 121 bytes
Saved a whopping 37 bytes thanks to Kevin Cruijssen!
interface a{static void main(String[]A){int b=0,B;for(char c:A[0].toCharArray())for(B=b+++2;--B>0;)System.out.print(c);}}

As a bonus, this program can handle all Unicode characters in the existence, including the control characters located at the very end of Basic Multilingual Plane.

Huh, this is very short for a Java code.

You can shorten it by 1 byte by replacing for(int C=c+1;C>0;C--) with for(int C=c+2;--C>0;)

Or even shorter (121 bytes): interface a{static void main(String[]A){int x=0,i;for(char c:A[0].toCharArray())for(i=x+++2;--i>0;)System.out.print(c);}}

Well, just make it a lambda or a method

Wow, using an interface for the default public methods. That's smart.

Apologies for no clarification, but your answer would still be valid as a function (therefore no interface is needed, as well as the main method).

I know it's been a while, but you can golf it by 1 more byte: interface a{static void main(String[]A){int b=0,B;for(char c:A[0].toCharArray())for(B=b++;B-->=0;)System.out.print(c);}}. (Also, @MarDev said you are now allowed to use functions, so with a Java 8 lambda you can use s->{int b=0,B;for(char c:s)for(B=b++;B-->=0;)System.out.print(c);}, with a char-array as parameter.)

Perl, 16 bytes
s/./$&x$+[0]/ge

+1 byte for the -p flag.
s/./        /    find every character
             g   globally
              e  and replace with the eval'd result of
    $&           the matched string
      x          repeated
       $+[0]     by the index of the character after the match

Python, 39 bytes
f=lambda s:s and f(s[:-1])+s[-1]*len(s)

Test it on Ideone.

CJam, 9 8 7 bytes
Thanks to jimmy23013 for saving 1 byte.
Sl+eee~

Test it here.
Explanation
Using the LobbY example:
                                      Stack:
S    e# Push space.                   [" "]
l    e# Read input.                   [" " "LobbY"]
+    e# Append.                       [" LobbY"]
ee   e# Enumerate.                    [[[0 ' ] [1 'L] [2 'o] [3 'b] [4 'b] [5 'Y]]]
e~   e# Run-length decode.            ["LoobbbbbbbYYYYY"]

MATLAB, 45 bytes
g=@(m)sort(m(m>0));@(s)s(g(hankel(1:nnz(s))))

Explanation: The key is hankel, which produces a Hankel matrix of a given vector. From this matrix, we can extract a vector of indices, which defines which character of the string is at which position in the output. E.g. hankel(1:4) produces following matrix:
 1  2  3  4
 2  3  4  0
 3  4  0  0
 4  0  0  0

From this matrix we can extrac the vector 1,2,2,3,3,3,4,4,4,4,4. This vector allows us to output the first character of the string once, the second one twice e.t.c.

Javascript ES6, 39 bytes
x=>x.replace(/./g,(y,i)=>y+y.repeat(i))

Same length, but more fun:
x=>x.replace(i=/./g,y=>y.repeat(i=-~i))

Snippet demo:

f= x=>x.replace(/./g,(y,i)=>y+y.repeat(i))
run.onclick=_=>output.textContent=f(input.value)
<input id="input" value="SKype">
<button id="run">Go</button>

Small error, the program does not support spaces, which is required as a submission (check the OP).

@MarDev I changed the snippet to use
 instead of
, that should help.

@Neil Ah, so the result was correctly computed, but the output was rendered incorrectly by the HTML. Forgot that  does that.

..."and output the result"

@spender returning is a valid form of output for functions

x=>x.replace(/./g,(y,i)=>y.repeat(i+1)) - 39 bytes, same length

APL (dzaima/APL), 6 5 bytes
⍳∘≢⌿⊢

Try it online!
⍳∘≢ enumeration of the argument... (indices of its length)
⌿ replicates the elements of...
⊢ the unmodified argument

link to interpreter?

@cat See edit (in header).

@cat What was your edit?

Identical to yours down to the character, because I googled it myself and my edit took 10 minutes to submit

Also, in which codepage is this 6 bytes?

Wow, that's twice on the same answer I idly answered my own question.

Wait, each of the lines in the explanation is a separate UCS-2 character? That's interesting.

APL (8)
{⍵/⍨⍳⍴⍵}

I.e.:
      {⍵/⍨⍳⍴⍵} ¨  'Why' 'SKype' 'LobbY'
┌──────┬───────────────┬───────────────┐
│Whhyyy│SKKyyyppppeeeee│LoobbbbbbbYYYYY│
└──────┴───────────────┴───────────────┘

Explanation:

⍴⍵: length of given vector
⍳: numbers 1..N
⍵/⍨: replicate each element in ⍵ N times.

Javascript ES6, 42 41 bytes
s=>[,...s].map((e,i)=>e.repeat(i)).join``

Example runs:
f=s=>[,...s].map((e,i)=>e.repeat(i)).join``

f("Why")   => "Whhyyy"
f("SKype") => "SKKyyyppppeeeee"
f("LobbY") => "LoobbbbbbbYYYYY"

Same length: s=>[...s].reduce((a,b,i)=>a+b.repeat(i+1))

-1 byte: s=>[,...s].map((e,i)=>e.repeat(i)).join\``

@nderscore Aha, thats clever, thanks!

Brachylog, 13 bytes
:ImC,0:Ie,Cw\

This prints the result to STDOUT.
Explanation
This is a good example of exploiting backtracking to loop.
:ImC            C is the Ith character of the Input
    ,
     0:Ie       Unify an implicit variable with an integer between 0 and I
         ,
          Cw    Write C to STDOUT
            \   False, trigger backtracking. It will go back to 0:Ie and unify the implicit
                variable with another integer, until all integers were used. After that, it
                will backtrack to :ImC and unify I and C with the next character.

R, 83 50 bytes
-23 Thanks to Giuseppe, though he used essentially an entire new method altogether
function(s)intToUtf8(rep(utf8ToInt(s),1:nchar(s)))

My original post:
function(s){r="";for(i in 1:nchar(s))r=paste0(r,strrep(el(strsplit(s,""))[i],i));r}

Try it online!
I feel like there's definitely a better way to do this, but with my new knowledge of a few functions in R, this is my approach.

Not a golfing tip, but your code link output was messed up. Here

Ah, I see. I'm new to TIO, so I didn't quite understand the header/footer portions. Thank You!

Using scan saves 1 byte!

Very nice! However, using rep and the argument collapse="" to paste is shorter, and utf8ToInt is shorter still! TIO

Using \(x) instead of function(x) will save a few bytes

... and charToRaw seems to fit for the purpose as well, so: \(x)rawToChar(rep(charToRaw(x),1:nchar(x)))

K/Kona, 14 bytes
{,/(1+!#x)#'x}

Usage:
k){,/(1+!#x)#'x}"A and B"
"A  aaannnnddddd      BBBBBBB"

Perl 6,  22 20  19 bytes
{S:g/(.)/{$0 x$/.to}/}
{S:g[(.)]=$0 x$/.to}
{[~] .comb Zx 1..*}
Explanation:
{          # implicit parameter $_
  [~]      # string concatenate the following list
    .comb  # the NFG characters from $_
    Z[x]   # zip combined using the string repetition operator
    1 .. * # 1 to infinity
}

What are the first two lines for?

@MarkReed Those are the first two versions I came up with

Oh! the 22- and 20-char solutions listed in the title. I'm dumb. :)

VBA, 75 bytes
Function e(s):For a=1 To Len(s):e=e &String(a,Mid(s,a,1)):Next:End Function

Call as e.g. a user function in a spreadsheet.
=e(A1)
┌─────────┬───────────────┐
│   SKype │SKKyyyppppeeeee│
└─────────┴───────────────┘

It truncates if you feed it its own output a few times :-).

Welcome to the site! =)

Retina, 22 bytes
Byte count assumes ISO 8859-1 encoding.
.
$&$.`$*·
+`(.)·
$1$1

Try it online!
Basically, we insert the right amount of · as placeholders between the characters (since these extended ASCII characters can't appear in the input), then fill them up with the adjacent character in the second stage.

Julia, 32 bytes
!s=join(split(s[k=1:end],"").^k)

Unlike Dennis's solution, this is not recursive. split with argument "" separates the string into an array of strings of length 1. The [k=1:end] is a trick to create a range from 1 to the number of characters in the string, and this range is used to concatenate n copies of the n-th character. join then recombines the array of strings into a single string, in order.
Usage example: !"SKype"

PHP, 68 bytes
<?php foreach(str_split($argv[1])as$i=>$a)echo str_repeat($a,$i+1);

Hi, and welcome to PPCG! Nice first post!

You can get it down to 47 bytes: for(;$a=$argv[1][$i++];)echo str_repeat($a,$i);.

PowerShell v2+, 36 bytes
-join([char[]]$args[0]|%{"$_"*++$i})

Takes input $args[0], explicitly casts it as a char array, sends that into a loop |%{...}. Each iteration we take the current letter/character "$_" and use the * overloaded operator to concatenate the string pre-incremented $i times. The result of each loop iteration is encapsulated in parens to form an array and then -joined together to form a string. That string is left on the pipeline and output is implicit.
Examples
PS C:\Tools\Scripts\golfing> .\elasticize-a-word.ps1 Why
Whhyyy

PS C:\Tools\Scripts\golfing> .\elasticize-a-word.ps1 SKype
SKKyyyppppeeeee

PS C:\Tools\Scripts\golfing> .\elasticize-a-word.ps1 LobbY
LoobbbbbbbYYYYY

PS C:\Tools\Scripts\golfing> .\elasticize-a-word.ps1 'a b'
a  bbb

MATLAB, 23 bytes
@(x)repelem(x,1:nnz(x))

Creates an anonymous function ans that can be called using ans('stringtoelacticize')

What version are you using? Cannot find repelem in my (relatively old) version =(

@flawr repelem was introduced in R2015a

05AB1E, 2 bytes
ƶJ

Try it online or verify all test cases.
Explanation:
ƶ   # Multiply each character in the (implicit) input-string by its 1-based index
 J  # Join the list of substrings together to a single string
    # (after which the result is output implicitly)

Vyxal s, 2 bytes
Þż

Try it online, or see a 3 byte flagless version

3, 2 with the s flag

Ah, thought so. I saw that and wondered if that was it but I wasn't sure, thanks.

BQN, 9 8 bytes
⊢/˜1+↕∘≠

Anonymous tacit function. Try it at BQN online!
Explanation
⊢/˜1+↕∘≠
       ≠  Length of argument
     ↕∘   Range
   1+     Add 1 to each, making it an inclusive range from 1 to the length
 /˜       Replicate that many times the elements of
⊢         The original input

><> (Fish), 33 bytes
1:i:0(?^$:?v~~1+00.
.!02o:$;!-1<|

Try the animated version

Basically if the counter is 0 skip to the second :, otherwise the first :. Properly adjust the counters.

Python, 40 bytes
f=lambda s,i=1:s and s[0]*i+f(s[1:],i+1)

Julia, 34 bytes
!s=s>""?!s[1:(e=end)-1]*s[e:e]^e:s

Try it online!

Your solution was good. But I managed to beat it.

I saw. I had c%n="$c"^n;~s=join([s[r=1:end]...].%r), but that's actually longer. split was the missing piece of the puzzle.

TSQL, 97 bytes
Golfed:
DECLARE @x varchar(max)='Lobby'
DECLARE @ int=LEN(@x)WHILE @>0SELECT
@x=STUFF(@x,@,1,REPLICATE(SUBSTRING(@x,@,1),@)),@-=1PRINT @x

Ungolfed:
DECLARE @x varchar(max)='Lobby'

DECLARE @ int=LEN(@x)
WHILE @>0
  SELECT
    @x=STUFF(@x,@,1,REPLICATE(SUBSTRING(@x,@,1),@)),
    @-=1

PRINT @x

Try it online

Mathematica, 46 bytes
""<>Table@@@(#^Range@Length@#&@Characters[#])&

Unnamed function. Takes the characters of the input string and raises them to the power of their position in the string (i.e. "abc" becomes {"a"^1, "b"^2, "c"^3}). Yes, MMA don't give a shit 'bout types :-)
The FullForm of the above list elements is Power["a", 1], etc.
Table@@@ acts on the list, replacing the head of each element (in this case Power) with Table.
Results in {Table["a"], Table["b", 2], Table["c", 3]} (because "a"^1 -> "a").
This evaluates to {"a", {"b", "b"}, {"c", "c", "c"}} Finally the infix concatenation operator <> concatenates this with the empty string.
I exploited the fact that Power is Listable, i.e. it automatically threads over corresponding elements of lists, but not orderless (because "a" + 1 would evaluate to Plus[1, "a"]).

LINQPad w/ C#, 82 bytes
void m(string s){Console.Write(s.SelectMany((x,i)=>new string(x,++i)).ToArray());}

Single output operation.

@MartinEnder using System; & using System.Linq; are not necessary in LINQPad.

Oh, I wasn't aware of that.

C, 84 bytes
main(c,v,i,j)char**v;{for(i=0;i<strlen(v[1]);++i)for(j=0;j<=i;++j)putchar(v[1][i]);}

This should compile on gcc with no flags. Input is taken through the first command-line argument. E.g.
$ ./elasticize Why
Whhyyy
$ ./elasticize SKype
SKKyyyppppeeeee
$ ./elasticize LobbY
LoobbbbbbbYYYYY
$ ./elasticize A and B
A  aaannnnddddd      BBBBBBB

Ungolfed:
int main(int argc, char** argv) {
    int i, j;
    for(i = 0; i < strlen(argv[1]); ++i) {
        for(j = 0; j <= i; ++j) {
            putchar(v[1][i]);
        }
    }
}

Pyth - 5 bytes
1 byte saved thanks to @FryAmTheEggman.
s*VSl

Test Suite.

@FryAmTheEggman ah, nice one.

Actually, 7 bytes
' +ñ♂πΣ

Try it online!
Explanation:
' +ñ♂πΣ
' +      prepend a space
   ñ     enumerate ("abc" -> [[0, 'a'], [1, 'b'], [2, 'c']])
    ♂π   map: for each character, repeat it n times
      Σ  concatenate

Python 3, 48 47 bytes
Thanks to mego for saving a byte with the -~i trick.
lambda s:''.join(c*-~i for i,c in enumerate(s))

This is mostly self-explanatory. One thing for those not versed in Python: The * operator is overloaded to act like Perl's x operator, repeating its string argument the number of times specified by its numeric argument. E.g. 'foo' * 3 == 'foofoofoo'

c*-~i is shorter than c*(i+1).

know your language... there is an offset argument to enumerate :) - still 47 bytes though: lambda s:''.join(c*i for i,c in enumerate(s,1))

C#, 81 Bytes
void f(string s){for(int i=0;i<s.Length;i++)Console.Write(new String(s[i],i+1));}

you can save 1 byte by changing to a foreach loop, e.g. foreach(var a in s)Console.Write(new C(a,1*i++));

but if its a foreach we don't have the i variable so you'd need to declare it.

It seems you're missing a using System or a System. in front of the Console.

@ScifiDeath That's true - but the end result is still one byte shorter. Sorry for omitting it and causing confusion int i=1;

Also one byte shorter using Linq: void f(string s){s.Select((c,i)=>{Console.Write(new string(c,i+1));return c;});}. The need for a (unused) return value is ugly though. Edit: just found similar snippets in other answers further back.

MATL, 5 bytes
tn:Y"

Try it Online
Explanation
    % Implictly grab input as a string
tn  % Duplicate and compute the length (N)
:   % Create an array from [1...N]
Y"  % Perform run-length decoding to elacticize the string
    % Implicitly display the result

Clojure, 86 bytes
(fn[s](apply str(mapcat #(repeat(+(nth % 1)1)(nth % 0))(map list s(range(count s))))))

Well, nearly beat C. Create a list of pairs (symbol, its position), then repeat each symbol given number of times and flatten the result list and concatenate the list into one string.
See it here: https://ideone.com/uQNar2

Jelly, 2 bytes
xJ

Try it online!

Why non-competing? it's completely okay.

@MatthewRoh J did not exist back then.

Zsh, 38 bytes
for i (${(s::)@});repeat ++n printf $i

Try it online!
-8 bytes thanks to roblogic

41 bytes

Dart, 47 bytes
f(s,[c=0])=>s.split("").map((i)=>i*++c).join();

Try it online!

Knight, 33 32 bytes
;=i!=sP;W<iLsO+*Gs iT=i+1i"\"O""

Try it online!
expanded:
; = i ! = s PROMPT
; WHILE < i LENGTH s
    : OUTPUT
        +
            * (GET s i TRUE) (= i + 1 i)
        "\" # so no trailing newline
: OUTPUT "" # now output the trailing newline

-1 did =i! instead of ;=iF

You forgot to put =i+1i in your expanded version.

Yo that ! thing is actually super smart.

Why do you have to output a trailing newline? No one said you did.

C (clang), 54 bytes
i;c;main(j){for(;j=j-1?:read(0,&c,1)*++i;)putchar(c);}

Try it online!
How it works
i;            // declares a zero initialized int
main(j){      // j := argc (should be 1, program called with no arguments)
 for(;j=j-1?: // if (j > 1) j = j - 1, otherwise...
 read(0,&c,1) // try to read 1 byte, return number of bytes read (0 on EOF or 1)
 *++i;)       // increment i, j = read? * i (stopping on EOF)
  putchar(c); // write to stdout
}

C (clang), 51 bytes

With help from @Steffan and @jdt.

i,j;f(*s){for(i=0;*s;s++)for(j=++i;j--;)printf(s);}

This function takes a wide-character string as input and works in the same way as the full program.
Try it online!

This is pretty interesting, but it's 54 bytes to declare a function and write to stdout: Try it online!

you'd need to reset i=0 if you want the ability to call the function more than once

53 bytes

Japt -m, 3 bytes
+pV

Try it here

Ruby, 29 bytes
Try it online
->s{i=0;s.gsub(/./){$&*i+=1}}

Pyke, 4 bytes
Foh*

Try it here!

Python 2.7 - 47 Bytes
''.join([s[i-1]*i for i in range(1, len(s)+1)])

where 's' is the given string
Output:
welcome: weelllccccooooommmmmmeeeeeee
00004:   000000000044444
Why:     Whhyyy
SKype:   SKKyyyppppeeeee
A and B: A  aaannnnddddd      BBBBBBB

Oracle SQL 11.2, 125 bytes
SELECT LISTAGG(SUBSTR(RPAD(' ',LEVEL+1,SUBSTR(:1,LEVEL,1)),2))WITHIN GROUP(ORDER BY 1)FROM DUAL CONNECT BY LEVEL<=LENGTH(:1);

05AB1E, 6 bytes
vN>Fy?

Explained
v       # for each char in string
 N>F    # index+1 number of times do
    y?  # print current char

Try it online

This one looks like it has a question :D

Retina, 62 bytes
It wasn't as easy or short as I thought it'd be. Note that the code contains no spaces. They are all tabs (which are rendered incorrectly here), and the last line is blank.
.*
$0¶ ¶
{+`^(.)(.*)¶    (.*¶.*)
$1$2    ¶$3$1
(   +)¶
¶   $1
}`^.

    |¶

Try it online

C, 77 bytes
Not much room for golfing here. If only there were a string repeat operator.
i;main(j){char s[999];gets(s);for(;s[i];i++)for(j=0;j<=i;j++)putchar(s[i]);}

Try it online! http://ideone.com/UliJfD

You can do i;main(j){... and save a bye

@cat Good idea; thanks!

C# (Visual C# Interactive Compiler), 53 bytes
a=>string.Concat(a.Select((c,i)=>new@String(c,i+1)));

Try it online!

brev, 42 bytes
(as-list flatten(over(make-list(+ i 1)x)))

Burlesque, 10 bytes
{+..*}wi\[

Try it online!
{
 +. # Increment
 .* # Repeat
}wi # Apply with 0-index
\[  # Concatenate

Kustom, 67 bytes
This makes use of the fact that an undefined global variable works as empty string. The extra byte is for the name of the defined global variable.
$fl(1,tc(len,gv(n)),"i+1","tc(lpad,gv(x),i,tc(cut,gv(n),i-1,1))")$

Sort of ungolfed:
$fl(
  1,
  tc(len, gv(input)),
  "i + 1",
  "tc(
    lpad,
    gv(undefined),
    i,
    tc(
      cut,
      gv(input),
      i - 1,
      1
    )
  )"
)$

Prolog (SWI), 69 bytes
S*O:-append(H,[T],S),maplist([_,Y]>>(Y=T),S,R),H*Y,append(Y,R,O);O=S.

Try it online!
I feel like this should be shorter...

Pip, 14 bytes
Fi,#aOa@iXi+1x

Try It Online!

Arturo, 44 bytes
$[s][i:0join map split s'c[i:i+1repeat c i]]

Try it

Thunno J, \$9\log_{256}(96)\approx\$ 7.41 bytes
DLR1+ZZ.P

Attempt This Online!
Explanation
DLR1+ZZ.P  # Implicit input
D          # Duplicate
 LR        # Push range(0, len(input))
   1+      # Add one to each
     ZZ    # Zip with the input
       .P  # Product of each pair
           # Implicit output, joined by J flag

Brachylog v2, 6 bytes
i₁j₎w⊥

Try it online!
Half-port of Fatalize's v1 answer.
i₁        Choose a pair [element, 1-index] from the input.
  j₎      Replicate the element by its index.
    w     Print the result with no trailing newline.
     ⊥    Backtrack.

Thunno 2 J, 3 bytes
dż×

Attempt This Online!
Explanation
dż×  # Implicit input           ->  "Why"
d    # Split into characters    ->  ["W","h","y"]
 ż   # Length range             ->  ["W","h","y"]  [1,2,3]
  ×  # Multiply together        ->  ["W","hh","yyy"]
     # Implicit output, joined  ->  "Whhyyy"

PHP, 76 bytes
I'm sure this can be improved...
<?php for($i=0;$i<strlen($argv[1]);$i++)echo str_repeat($argv[1]{$i},$i+1);

Run from command line:
$ php [file] "Testing"

Silicon(non-competing), 6 bytes
(This language is exactly the same age as this challenge, but I added some useful commands right after I saw it, so non-competing I think.)
biSÚÿj

Silicon uses CP037, which is a 255-bit codepage.
Explanation:
b        Push a space
i        Input
S        Split
Ú        Enumerate
ÿ        Replicate each list item n times
j        Join

Javascript, 58 bytes
e=a=>(Array.from(a).map((e,i)=>(e).repeat(i+1))).join("");

Java, 136 bytes
enum b{;public static void main(String[]a){int i=0,j=0;for(;i<a[0].length();i++){for(;j<i+1;j++)System.out.print(a[0].charAt(i));j=0;}}}

Takes input as program arguments.
Ungolfed with comments:
enum b {;
    public static void main(String[]a) {
        int i=0, j=0;                               // Init counters
        for (; i<a[0].length(); i++) {              // For each characters in string
            for (; j < i + 1; j++)                  // Loop from 0 to i
                System.out.print(a[0].charAt(i));   // Print character at i
            j=0;                                    // Reset j
        }
    }
}

Jelly, 2 bytes
xJ

Try it online!


text:
Count, Replace, Add Up!
Definition
Define the nth term of the CRAU sequence as follows.

Begin with the singleton array A = [n].
Do the following n times:
For each integer k in A, replace the entry k with k natural numbers, counting from 1 to k.
Compute the sum of all integers in A.

For example, if n = 3, we start with the list [3].
We replace 3 with 1, 2, 3, yielding [1, 2, 3].
We now replace 1, 2, and 3 with 1, 1, 2 and 1, 2, 3 (resp.), yielding [1, 1, 2, 1, 2, 3].
Finally, we perform the same replacements as in the previous step for all six integers in the array, yielding [1, 1, 1, 2, 1, 1, 2, 1, 2, 3].
The sum of the resulting integers is 15, so this is the third CRAU number.
Task
Write a program of a function that, given a strictly positive integer n as input, computes the nth term of the CRAU sequence.
This is code-golf. May the shortest code in bytes win!
Test cases
 1 ->       1
 2 ->       4
 3 ->      15
 4 ->      56
 5 ->     210
 6 ->     792
 7 ->    3003
 8 ->   11440
 9 ->   43758
10 ->  167960
11 ->  646646
12 -> 2496144
13 -> 9657700

Related

Simplicial polytopic numbers
OEIS A001791: Binomial coefficients C(2n,n-1)

Is there a limit on the maximum number the program can handle? i.e. is it acceptable if my program returns a stack overflow for 13?

As long as your algorithm works for arbitrarily large numbers, your implementation may error if the input is too big.

This seems a rather roundabout way to present a challenge to compute choose(2*n,n-1).

@xnor http://chat.stackexchange.com/transcript/message/30500547#30500547

I'm calling it a dupe of a previous (disguised) binomial challenge. Maybe you can instead have the output be the full list without summing?

Welcome to Programming Puzzles and Code Golf! Unfortunately this challenge is too similar to Code Golf: Number of paths! to warrant a separate post. I recommend posting future challenges to the Sandbox where they can get meaningful feedback before being posted to the main site. ;-P

@DigitalTrauma Thank you. I'll keep that in mind.

MATL, 5 bytes
EGqXn

Try it online, or verify all test cases!
Explanation:
E       #Double the input
 Gq     #Push "input - 1"
   Xn   #Calculate "nchoosek" on the two numbers

Python, 65 bytes
def f(k):
 n,p=2*k,1
 for i in range(1,k):p=p*n//i;n-=1
 return p

Explanation: It's a simplified version of n choose k. See this sequence.

Retina, 27 bytes
$
$.`$*
M!&+%`.+(?=1)|^.+
0

Input in unary, using 0 as the unary digit.
Try it online!

J, 5 bytes
<:!+:

Uses the binomial coefficient of (2n, n-1).
For 22 bytes, this is a possible solution based on using the process described in the challenge.
[:+/([:;<@(1+i.)"0)^:]

Usage
Note: Extra commands used to format output for multiple input.
   f =: <:!+:
   (,.f"0) >: i. 13
 1       1
 2       4
 3      15
 4      56
 5     210
 6     792
 7    3003
 8   11440
 9   43758
10  167960
11  646646
12 2496144
13 9657700

Explanation
<:!+:  Input: n
   +:  Double the value of n to get 2*n
<:     Decrement n to get n-1
  !    Calculate the binomial coefficient of (2*n, n-1) and return

[:+/([:;<@(1+i.)"0)^:]  Input: n
                     ]  Identify function, gets the value n
    (     ...     )^:   Repeat the following n times with an initial value [n]
          (    )"0        Means rank 0, or to operate on each atom in the list
             i.           Create a range from 0 to that value, exclusive
           1+             Add 1 to each to make the range from 1 to that value
        <@                Box the value
     [:;                  Combine the boxes and unbox them to make a list and return
[:+/                    Sum the values in the list after n iterations and return