text:
Verify the birth number
A Norwegian Birth Number consists of 11 digits, composed the following way:
DDMMYYiiikk

DD is the day (from 01-31)
MM is the month (from 01-12)
YY is the year (from 00-99). It's not differentiated between 1900 and 2000
iii is the "individual number"
kk are two control digits

iii is determined by birthyear and gender the following way

0000-1900: Disregard, there is some inconsistency and special cases
1900-1999: Range = 000-499
2000-2039: Range = 500-999
Female: Even numbers (and 000)
Male: Odd numbers

The control numbers are determined the following way:
Let's call the 11 digits:
d1 d2 m1 m2 y1 y2 i1 i2 i3 k1 k2

Then the control digits can be calculated using the equations:
k1 = 11 - ((3 * d1 + 7 * d2 + 6 * m1 + 1 * m2 + 8 * y1 + 9 * y2 + 4 * i1 + 5 * i2 + 2 * i3) mod 11)

k2 = 11 - ((5 * d1 + 4 * d2 + 3 * m1 + 2 * m2 + 7 * y1 + 6 * y2 + 5 * i1 + 4 * i2 + 3 * i3 + 2 * k1) mod 11).

For some combinations, the control numbers k1 or k2 can become 10. If that's the case, the number will be invalid.
If the sum modulus 11 for k1 or k2 is 11, i.e. k1 = 11 - (11 mod 11), then the control digit will be 0, not 11.
Challenge
Take a letter, M or F (male or female), and an eleven digit number as input, and check if the Birth Number is valid according to the rules above.

Input format and order is optional
The 11 numbers must be a single number or a consecutive string (you can't take the input as DD, MM, YY, iii, kk).
You can assume the date is valid (310699xxxxx will not be given as input)
Output is a truthy/falsy value (1/0, true/false etc.)
Program or function
All standard rules apply

You can find all valid numbers on this page (in Norwegian) by choosing a date.
Examples:
M, 01010099931
True

F, 01029042620
True

M, 0101009841
False

F, 01010051866
True

F, 08021690849
True

M, 01029040105
True

M, 01029037473
False

Shortest code in bytes win.

Do we need to handle genders other than M and F? (Is it against the rules if ["Q", "01010099931"] returns true?)

@Chiru, assume only M or F is given as input. Undefined behavior for invalid input is OK.

Python 3, 227 221 bytes
Function that takes two arguments, the gender 'm', and the birthnumber 'n', both as strings. There may be some more golfing to be done, especially in the last line. I'll keep working on it.
def a(m,n):
 o=[3,7,6,1,8,9,4,5,2];t=[5,4,3,2,7,6,5,4,3,2];n=list(map(int,n));y=z=b=0;q=11
 for i in n[:9]:z+=o[b]*i;y+=t[b]*i;b+=1
 print((q-z%q)%q==n[9] and (q-(y-z-z)%q)%q==n[-1] and len(n)<12 and ord(m)%2==n[8]%2)

JavaScript (ES2016), 275 259 255 254 252 Bytes
Golfed:

f=(g,I)=>{[,d,m,y,i,k]=/(..)(..)(..)(...)(..)/.exec(I.padEnd(12)),v=g.charCodeAt()%2!=i%2|y<=39&i<500,s=k=>11-([...I].slice(0,-2).map((e,i)=>e*[..."376189452543276543"][i+!k|9]).reduce((a,b)=>a+b)+2*k)%11,[s(0),s(s(0))].map((s,i)=>v&=k[i]!=s);return!v}

Tests:

for (let args of [
    ["M", "01010099931"], // true
    ["F", "01029042620"], // true
    ["M", "0101009841"],  // false
    ["F", "01010051866"], // true
    ["F", "08021690849"], // true
    ["M", "01029040105"], // true
    ["M", "01029037473"]  // false
]) {
    console.log(f(...args));
}

Ungolfed:
let f = (g, input) => {

    /* Sanitize input, destructure arguments via RegExp */
    let [, d, m, y, i, k] = /(..)(..)(..)(...)(..)/.exec(input.padRight(12));

    /* Validate gender and year */
    let violation = g.charCodeAt() % 2 != i % 2 | y <= 39 & i < 500;

    let n = [..."376189452543276543"];
    /* This function computes k1 if given no arguments, k2 if given one argument */
    let s = k => 11 - ([...input].slice(0, -2).map((e, i) => e * n[i + !k | 9]).reduce((a, b) => a + b) + 2 * k) % 11;

    /* Validate the control numbers k */
    [s(0), s(s(0))].map((s, i) => violation &= k[i] != s);

    return !violation;
}

JS, 343 Bytes
x=prompt().replace(/F/,1).replace(/M/,2).match(/\d{1}/g);v=Math.abs((x[0]-x[9])%2);v++;t=x[5]*10+x[6]*1;i=x[7]*1;if(t>39&&i>4){v--}if((11-(3*x[1]+7*x[2]+6*x[3]+1*x[4]+8*x[5]+9*x[6]+4*x[7]+5*x[8]+2*x[9])%11)%11===x[10]*1&&(11-(5*x[1]+4*x[2]+3*x[3]+2*x[4]+7*x[5]+6*x[6]+5*x[7]+4*x[8]+3*x[9]+2*x[10])%11)%11===x[11]*1){v++}alert(Math.floor(v/3))


text:
Determine the depth of an array
A simple challenge for your Monday evening (well, or Tuesday morning in the other half of the world...)
You're given as input a nested, potentially ragged array of positive integers:
[1, [[2, 3, [[4], 5], 6, [7, 8]], 9, [10, [[[11]]]], 12, 13], 14]

Your task is to determine its depth, which is the greatest nesting-depth of any integer in the list. In this case, the depth of 11 is 6, which is largest.
You may assume that none of the arrays will be empty.
You may write a program or function, taking input via STDIN (or closest alternative), command-line argument or function argument and outputting the result via STDOUT (or closest alternative), function return value or function (out) parameter.
Input may be taken in any convenient list or string format that supports non-rectangular arrays (with nested arrays of different depths), as long as the actual information isn't preprocessed.
You must not use any built-ins related to the shape of arrays (including built-ins that solve this challenge, that get you the dimensions of a nested array). The only exception to this is getting the length of an array.
Standard code-golf rules apply.
Test Cases
[1]                                                               -> 1
[1, 2, 3]                                                         -> 1
[[1, 2, 3]]                                                       -> 2
[3, [3, [3], 3], 3]                                               -> 3
[[[[1], 2], [3, [4]]]]                                            -> 4
[1, [[3]], [5, 6], [[[[8]]]], 1]                                  -> 5
[1, [[2, 3, [[4], 5], 6, [7, 8]], 9, [10, [[[11]]]], 12, 13], 14] -> 6
[[[[[[[3]]]]]]]                                                   -> 7

After discussion in chat I've decided to allow length built-ins, because some languages require them to iterate over an array cleanly.

Just for general education: ≡ is APL's built-in primitive for exactly this.

@MartinBüttner I've run into a tiny problem. I started doing this in java, unfourtunetly when testing inputs the commas are causing it to split the inputs into multiple command line arguments rather then one. Can I use the escape character \  in the inputs? EDIT: nevermind just tried it like that. That doesn't even work either. Darn can I not use CMD args?

@AshwinGupta can't you wrap the command line argument in quotes? You can also read input from STDIN or submit a function that takes an actual array object as a parameter.

@MartinBüttner oh I didn't know that quotes thing I'll try it out. Currently just using Scanner. (System.in). I believe that is a form of STDIN?

K, 4 bytes
#,/\

In K, ,/ will join all the elements of a list. The common idiom ,// iterates to a fixed point, flattening an arbitrarily nested list completely. ,/\ will iterate to a fixed point in a similar way, but gather a list of intermediate results. By counting how many intermediate results we visit before reaching the fixed point (#), we get the answer we want: the maximum nesting depth.
"Count of join over fixed-point scan".
In action:
 (#,/\)'(,1
        1 2 3
        ,1 2 3
        (3;(3;,3;3);3)
        ,((,1;2);(3;,4)))
1 1 2 3 4

Retina, 10

Saved 1 byte thanks to @ӍѲꝆΛҐӍΛПҒЦꝆ
Saved 14 extra bytes thanks to @MartinBüttner

+`\w|}{

{

Here the input format is a bit contrived - _ characters are used for list separators, so an input would look like this {1_{{2_3_{{4}_5}_6_{7_8}}_9_{10_{{{11}}}}_12_13}_14}

Stage 1 - repeatedly remove }{ and all other \w characters.  This has the effect of a) making all lists at all levels consist of only one element and b) removing all non-list-structural characters.
Stage 2 - count remaining {.  This gives the deepest level of nesting.

Try it online.

If that's too much of a stretch, then the previous answer was:
Retina, 13
Assumes lists are contained in curly braces {}.

+`[^}{]|}{

{

Try it online.

Your code can be shortened to 13 bytes (11 if you stretch the input format a bit). Let me know if you want a hint. :) (I don't really want to post it myself, since it's virtually the same solution.)

It's two things. a) You can save a byte or so by slightly tweaking the input format. b) You can save a lot of bytes regardless of that... can you find a shorter (and much simpler) solution if you try not to handle multiple test cases in a single run?

I didn't even think of that. That's amount byte saved then. My change to the input format would have been even weaker. Regarding b) remember what Retina's very first and simplest mode of operation was?

yep. My a) was referring to removing spaces from the input though. And you can then save two more bytes by using _ instead of , but that might be a bit of a stretch.

@MartinBüttner Nice idea!  Agreed - _ separators might be too contrived.  So I'm leaving both versions in the answer

Python 2, 33 bytes
f=lambda l:l>{}and-~max(map(f,l))

Recursively defines the depth by saying the depth of a number is 0, and the depth of a list is one more than the maximum depth of its elements. Number vs list is checked by comparing to the empty dictionary {}, which falls above numbers but below lists on Python 2's arbitrary ordering of built-in types.

Length built-ins are now allowed if it helps.

Pyth - 11 10 7 bytes
1 bytes saved thanks to @Dennis
4 bytes saved thanks to @Thomas Kwa
eU.usNQ

Try it online here.
Keeps on summing the array till it stops changing, which means its just a number, does this cumulatively to save all the intermediate results and gets length by making a urange with the same length as list and taking the last element.

m!!d can become &R1.

@Dennis cool, that's smart

@ThomasKwa l isn't allowed in OP.

@ThomasKwa that is really smart, thanks!

Length built-ins are now allowed if it helps.

Haskell, 43 bytes
'['#x=x-1
']'#x=x+1
_#x=x
maximum.scanr(#)0

Usage example: maximum.scanr(#)0 $ "[1, [[3]], [5, 6], [[[[8]]]], 1]" -> 5.
Haskell doesn't have mixed lists (Integer mixed with List of Integer), so I cannot exploit some list detection functions and I have to parse the string.
Im starting at the right with 0 and add 1 for every ], subtract 1 for every [ and keep the value otherwise. scanr keeps all intermediate results, so maximum can do it's work.

Julia, 55 26 bytes
f(a)=0a!=0&&maximum(f,a)+1

This is a recursive function that accepts a one-dimensional array with contents of type Any and returns an integer. When passing an array to the function, prefix all brackets with Any, i.e. f(Any[1,Any[2,3]]).
The approach is pretty simple. For an input a, we multiply a by 0 and check whether the result is the scalar 0. If not, we know that a is an array, so we apply the function to each element of a, take the maximum and add 1.
Saved 29 bytes thanks to Dennis!

Dat golf.

JavaScript (ES6), 35 bytes
f=a=>a[0]?Math.max(...a.map(f))+1:0

Explanation
Recursive function that returns the maximum depth of an array, or 0 if passed a number.

var solution =

f=a=>
  a[0]?                   // if a is an array
    Math.max(...a.map(f)) // return the maximum depth of each element in the array
    +1                    // add 1 to increase the depth
  :0                      // if a is a number, return 0

// Test cases
result.textContent =
`[1]                                                              -> 1
[1, 2, 3]                                                         -> 1
[[1, 2, 3]]                                                       -> 2
[3, [3, [3], 3], 3]                                               -> 3
[[[[1], 2], [3, [4]]]]                                            -> 4
[1, [[3]], [5, 6], [[[[8]]]], 1]                                  -> 5
[1, [[2, 3, [[4], 5], 6, [7, 8]], 9, [10, [[[11]]]], 12, 13], 14] -> 6
[[[[[[[3]]]]]]]                                                   -> 7`
.split`\n`.map(t=>(c=t.split`->`.map(p=>p.trim()),c[0]+" == "+c[1]+": "+(solution(eval(c[0]))==c[1]?"Passed":"Failed"))).join`\n`
<input type="text" id="input" value="[1, [[2, 3, [[4], 5], 6, [7, 8]], 9, [10, [[[11]]]], 12, 13], 14]" />
<button onclick="result.textContent=solution(eval(input.value))">Go</button>

Length built-ins are now allowed if it helps.

MATL, 11 14 15 bytes
'}{'!=dYsX>

Curly braces are used in MATL for this type of arrays. Anyway, the input is taken and processed as a string, so square brackets could equally be used, modifying the two characters in the code.
Try it online!
          % implicitly take input as a string (row array of chars)
'}{'!     % 2x1 (column) char array with the two curly brace symbols
=         % 2-row array. First / second row contains 1 where '}' / '{' is found
d         % second row minus first row
Ys        % cumulative sum of the array
X>        % maximum of the array
          % implicitly display result

Length built-ins are now allowed if it helps.

Jelly, 10 7 bytes
¬;/SÐ¿L

Try it online! or verify all test cases.
How it works
¬;/SÐ¿L  Main link. Input: A (list)

¬        Negate all integers in A. This replaces them with zeroes.
    Ð¿   Cumulative while loop.
   S       Condition: Compute the sum of all lists in A.
                      If the sum is an integer, it will be zero (hence falsy).
 ;/        Body:      Concatenate all lists in A.
      L  Count the number of iterations.

Update
While writing this answer, I noticed that Jelly behaves rather weirdly for ragged lists, because I calculated the depth of a list as the incremented minimum of depths of its items.
This has been addressed in the latest version, so the following code (6 bytes) would work now.
¬SSÐ¿L

This sums the rows of the array instead of concatenating them.

Presumably, ŒḊ is newer than the challenge?

You must not use any built-ins related to the shape of arrays (including built-ins that solve this challenge, that get you the dimensions of a nested array).

Octave, 29 bytes
@(a)max(cumsum(92-(a(a>90))))

Maps [ to 1 and ] to -1, then takes the max of the cumulative sum.
Input is a string of the form
S6 = '[1, [[3]], [5, 6], [[[[8]]]], 1]';

Sample run on ideone.

Should you use {, }? The Octave equivalent to the arrays in the OP are cell arrays, I think

@LuisMendo No, because that's 2 extra bytes :) Plus, since I never actually create the array, simply parse the input string, I don't think it matters. But you've reminded me to add the expected input to my answer.

True! Longer ASCII code

@LuisMendo Actually, 1 byte longer. That second comparison only needs to be greater than '9'. But you get the idea :D

Ruby, 53 bytes
i=0;p gets.chars.map{|c|i+=('] ['.index(c)||1)-1}.max

Input from STDIN, output to STDOUT.
i=0;                 initialize counter variable
p                    output to STDOUT...
gets                 get line of input
.chars               enumerator of each character in the input
.map{|c|             map each character to...
i+=                  increment i (and return the new value) by...
('] ['.index(c)||1)  returns 0 for ], 2 for [, 1 for anything else
-1                   now it's -1 for ], 1 for [, 0 for anything else
                     therefore: increment i on increase in nesting, decrement i
                       on decrease, do nothing otherwise
}.max                find the highest nesting level that we've seen

Length built-ins are now allowed if it helps.

Mathematica, 27 20 bytes
Max[#0/@#]+1&[0#]-1&

Simple recursive function.

It's possible to void the If, saving 7 bytes. (Let me know if you want a hint.)

@MartinBüttner I give up... A Replace-based solution is at least as long as this one...

Mapping over an integer is a no-op: Max[#0/@#]+1&[0#]-1&. The -1 can also go inside the inner call like ...&[0#-1]&.

Mathematica, 18 bytes
Max@#+1&//@(0#-1)&

Could you explain it, please?

PHP, 84 72 64 63 60 bytes
Note: requires PHP 7 for the combined comparison operator. Also uses IBM-850 encoding
for(;$c=$argv[1][$i++];)$c>A&&$t=max($t,$z+=~ú<=>$c);echo$t;

Run like this:
php -r 'for(;$c=$argv[1][$i++];)$c>A&&$t=max($t,$z+=~ú<=>$c);echo$t;' "[1, [[3]], [5, 6], [[[[8]]]], 1]"

Saved 12 bytes by just counting braces of the string representation instead
Saved 8 bytes by simplifying string comparisons and using ordinal number of the char in case of [ and ]
Saved a byte by not casting $i to an int. String offsets are casted to an int implicitly
Saved 3 bytes by using combined comparison operator instead of ordinal number

Nice idea, great golfing! Check out mine.

PHP, 61 bytes
function d($a){return is_array($a)?1+max(array_map(d,$a)):0;}

recursive function that uses itself as a mapping function to replace each element with its depth.

I just noticed: The same thing in JS has only 35 bytes. Still pretty in php.

Nice, you beat me. But I updated mine and beat you back :)

Haskell + free, 29 bytes
Haskell doesn't have a built in ragged list type so we need to build one out of free monads from the free package.
iter((+1).maximum).fmap(*0)

Try it online!

C, 98 69 bytes
29 bytes off thanks @DigitalTrauma !!
r,m;f(char*s){for(r=m=0;*s;r-=*s++==93)r+=*s==91,m=r>m?r:m;return m;}

Takes an string as input and return the result as integer.
Live example in: http://ideone.com/IC23Bc

Raku, 53 48 bytes
The closure:
{my $d;/[\[{$d++;$!=max $!,$d}|\]{$d--}|.]*/;$!}

Needs an argument, eg:
> {my $d;/[\[{$d++;$!=max $!,$d}|\]{$d--}|.]*/;$!}("[[[3]][2]]")
3

Explanation:
{                 # start outer IIFE closure;

  my $d;            # declare depth variable `$d`;

  /                 # start IIFE regex match;

    [                 # start (non-capturing) group;

                      # EITHER:

      \[                # match `[` in input; if successful then:

      {                 # start inner (within regex) IIFE closure;

        $d++;             # increment depth variable; and then:

        $! = max $!, $d   # (ab)use `$!` variable to track MAX depth;

      }                 # end inner IIFE closure;

    |                 # OR:

      \]                # match `[` in input; if successful then:

      {$d--}            # decrement depth variable in IIFE closure;

    |                 # OR:

      .                 # match one character;

    ]*                # end capture group; match zero or more times;

  /;                # end regex;

  $!                # max depth as last value in closure;

}                 # end outer closure, returning last value (max depth);

("[[[3]][2]]")    # pass string "[[[3]][2]]" as outer closure argument.

Python 3, 42 39 bytes
-3 bytes thanks to Sp3000
This is essentially a port of xnor's Python 2 solution:
f=lambda l:"A"<str(l)and-~max(map(f,l))

Unfortunately, [] > {} returns an unorderable types error, so that particular clever trick of xnor's cannot be used. In its place, -0123456789 are lower in ASCII value than A, which is lower than [], hence the string comparison works.

CJam (15 bytes)
q~{__e_-M*}h],(

Online demo
Dissection
q~      e# Read line and parse to array
{       e# Loop...
  _     e#   Leave a copy of the array on the stack to count it later
  _e_-  e#   Remove a flattened version of the array; this removes non-array elements from
        e#   the top-level array.
  M*    e#   Remove one level from each array directly in the top-level array
}h      e# ...until we get to an empty array
],(     e# Collect everything together, count and decrement to account for the extra []

For the same length but rather more in ugly hack territory,
q'[,-{:~_}h],2-

s/ugly/beautiful/

@Dennis, I was referring specifically to the use of '[,- to strip the string down to [], which relies on the contents being limited. The approach which flattens works regardless of the contents of the array.

The second one is prettier. The first one has two types of mismatched braces

Sed, 40 characters
(39 characters code + 1 character command line option.)
s/[^][]+//g
:;s/]\[//;t
s/]//g
s/\[/1/g

Input: string, output: unary number.
Sample run:
bash-4.3$ sed -r 's/[^][]+//g;:;s/]\[//;t;s/]//g;s/\[/1/g' <<< '[1, [[2, 3, [[4], 5], 6, [7, 8]], 9, [10, [[[11]]]], 12, 13], 14]'
111111

Sed, 33 characters
(32 characters code + 1 character command line option.)
If trailing spaces are allowed in the output.
s/[^][]+//g
:;s/]\[//;t
y/[]/1 /

Input: string, output: unary number.
Sample run:
bash-4.3$ sed -r 's/[^][]+//g;:;s/]\[//;t;y/[]/1 /' <<< '[1, [[2, 3, [[4], 5], 6, [7, 8]], 9, [10, [[[11]]]], 12, 13], 14]'
111111

Hexagony, 61 bytes
Edit: Thanks @Martin Ender♦ for saving me 1 byte from the marvelous -1 trick!
|/'Z{>"-\..(.."/'&<'..{>-&,=+<$.{\$._{..><.Z=/...({=Z&"&@!-"

Try it online to verify test cases!
The images below are not modified but the flow is basically the same.  Also note that this will return -1 if the input is not an array (i.e. without []).
I have lots of no-ops inside the Hexagon... I guess it can definitely be golfed more.
Explanation
In brief, it adds -1 when encounters a [ and adds 1 when encounters a ].  Finally it prints the max it has got.
Let's run along Test Case 5 to see its behaviour when it runs along the String [1, [[3]], [5, 6], [[[[8]]]], 1]:
It starts at the beginning and takes its input at the W corner:

Since there is still input (not the null character \0 or EOL), it wraps to the top and starts the crimson path.
Here is what happens when from there till cute ><:
, reads [ into Buffer, and { and Z sets the constant Z to be 90. ' moves to Diff and - calculates the difference.  For [ and ] the difference will be 1 and 3 respectively.  For numbers and spaces and commas it'll be negative.

Then we run ( twice (once at the end of crimson path, one at the start after wrapping at the green path) to get -1 and 1 resp for [ and ].  Here we change the naming of Diff to Value.  Add this Value to Depth. (I used Z& to ensure that it copies the right neighbor).  Then we calculate lastMin - Depth and got a number on the Memory edge minLR.
Then we apply & (at the end of green path) to minLR: If the number is <=0, it copies the left value (i.e. lastMin - Depth <= 0 => lastMin <= Depth), otherwise it takes the right value.
We wraps to the horizontal blue path and we see Z& again which copies the minLR.  Then we "& and made a copy of the calculated min.  The brackets are assumed to be balanced, so the min must be <=0.  After wrapping, the blue path go left and hit (, making the copy 1 less than the real min.  Reusing the -, we created one more 1-off copy as a neighbor of Buffer:

Note: copy is renamed as 1-off
When blue path hits \ and got a nice " and < catches it back to the main loop.
When the loop hits 1, , or  or other numbers as input:

The Diff will become negative and it got reflected back to the main loop for next input.
When everything has gone through the main loop, we reach EOL which makes Buffer -1 and it finally goes to the bottom edge:

' moves the MP to the 1-off copy and ) increments it, and with ~ negation it got the correct Max Depth value which is printed with !
And the story ends with a @.
I guess I must have over complicating things a little bit.  If I have had to only "move back" and "print" without incrementing and negation, I would have well saved 2 bytes without using the full Hexagon.
Great thanks to Timwi for Esoteric IDE and Hexagony Colorer!

You can save a byte by making use of the -1 from , by changing the last row to: @!-". (although I agree that it is probably possible to shave off a lot more or even fit this into side-length 4 with some restructuring).

Haven't thought of making use of the -1! Will edit once I got my computer. If the temp is on left neighbor, I would have saved quite a few Z from using Z&. And there should be better ways to start the program with the implicit if.

brainfuck, 48 bytes
,[<++[>-<------]>++[+[<]>>[-]]+<,]-[<[>+<-]>>]<.

Formatted:
,
[
  <++[>-<------]>++
  [
    not close paren
    +
    [
      not open paren
      <
    ]
    >>[-]
  ]
  +<,
]
-[<[>+<-]>>]
<.

Takes input formatted like (1, ((3)), (5, 6), ((((8)))), 1) and outputs a byte value.
Try it online.
This stores the depth by memory location, moving the pointer right for ( and left for ) and ignoring other characters. Visited cells are marked with a 1 flag, so at the end of the main loop there will be depth + 1 flags to the right of the current cell. These are then added to print the final result.

A previous 69-byte solution using a different approach:
,
[
  >>++[<<->>------]<-<++
  [
    not close paren
    >++<+
    [
      not open paren
      >-<[-]
    ]
  ]
  <
  [
    [>+>]
    <[<-<]
    >
  ]
  >>[<+> >+<-]
  ,
]
<.

In this version, the depth and max depth are stored explicitly in cells.

Io, 53 bytes
Port of the JavaScript (ES6) answer.
f :=method(x,if(x type=="List",x map(i,f(i))max+1,0))

Try it online!

C (gcc), 64 bytes
d,l;f(char*s){return*s?l=d?d>l?d:l:0,d+=*s>90?92-*s:0,f(s+1):l;}

Try it online!

Jelly, 3 bytes
ẎƬL

Try it online!
This is a translation of JohnE's K answer.
Ẏ is the "tighten" command. When applied to a list, it "unwraps" each list in it, essentially reducing the depth by one. Ƭ repeated applies Ẏ to the input until it reaches a fixed point. We then count the number of iterations with L.

05AB1E, 7 bytes
dΔ€`}N>

Try it online or verify all test cases.
Explanation:
d     # Convert each integer in the (implicit) input-list to 1 (with a >=0 check)
 Δ    # Loop until the result no longer changes:
  €   #  Map over each inner item:
   `  #   Pop and dump its contents to the stack
 }N   # After the loop, push the last 0-based index
   >  # Increase it by 1 to make it a 1-based index
      # (which is output implicitly as result)

The €` basically flattens a list one level down, but will push its items in reversed order. E.g. list [[1,[2,3],4]] will become [4,[2,3],1]. In addition, it will do the same for multi-digit numbers, hence the need for the leading d to convert every integer to a single digit first. E.g. list [12,345,67] will become [2,1,5,4,3,7,6].

Whython, 28 bytes
f=lambda l:1+max(map(f,l))?0

Attempt This Online!
Explanation
The depth of a list is the maximum depth of its elements; the depth of an integer is 0.
f=lambda l:1+max(map(f,l))?0
f=                            # Define f as
  lambda l:                   # a function of one argument, l:
                 map(f,l)     #  Call f recursively on each element of l
             max(        )    #  Take the maximum
           1+                 #  Add 1
                              #  If l is an integer, map raises an exception
                          ?0  #  Catch that exception and return 0

Brachylog, 8 bytes
>0|↰ᵐ⌉+₁

Try it online!
 0|         Output 0
>           if the input is a positive integer;
  |↰ᵐ       else map this over the elements of the input
      +₁    and add 1 to
     ⌉      the largest result.

Pyth, 15 13 bytes
-2 bytes by @Maltysen
eSm-F/Ld`Y._z

Counts the difference between the cumulative counts of [ and ], and takes the maximum. Y is the empty array, and its string representation (`) is conveniently [].
Try it here.

Length built-ins are now allowed if it helps.

CJam, 19 22 23 bytes
0l{_91=\93=-+_}%:e>

Similar idea to my MATL answer.
Thanks to Peter Taylor for removing 3 bytes
Try it here
0                            push a 0
l                            read line as string
{            }%              map this block on the string
  _91=\93=-                  1 if it's an opening bracket, -1 if closing
           +_                cumulative sum
               :e>           fold maximum function

Minkolang 0.15, 31 29 24 bytes
Overhauled my algorithm upon inspiration by Luis Mendo's CJam answer and saved 5 bytes!
od5&j$ZN.d"["=$r"]"=~++d

Try it here!
Explanation
Essentially, what this code does is keep a running total with +1 for each [ and -1 for each ], keeping track of the maximum value reached, outputting that maximum at the end. Looping is handled by the toroidal nature of Minkolang's codebox.
od           Take character from input and duplicate it (0 if input is empty)
  5&         Pop top of stack and skip the following five spaces if 0
    j$Z      Push the maximum value of the stack
       N.    Output as number and stop.

  d                  Duplicate top of stack for character tests
   "["=              +1 if the character is [
       $r            Swap top two items of stack
         "]"=~       -1 if the character is ]
              ++     Add twice
                d    Duplicate top of stack for the running total

Perl 5, 34 bytes
32, plus two for -p
{s&]\[|[^][]&&g&&redo}$_=@a=/]/g

Stolen from Digital Trauma's Retina answer… which is 26% shorter than this. :-)
Or, equally:
{s&]\[|[^][]&&g&&redo}$_=y///c/2

@Cyoce, why? ] doesn't need escaping, except in brackets.

@Cyoce, s&...&...&g is the substitution operator. See http://perldoc.perl.org/perlop.html

Ruby, 51 characters
(Started as improvement suggestion for Doorknob's Ruby answer but ended differently. So I posted it as separate answer. Upvotes for the depth counting idea (?\\<=>$&, descending from '] ['.index(c)) should go to the original answer.)
m=i=0
gets.gsub(/\[|\]/){m=[m,i+=?\\<=>$&].max}
p m

Input: string, output: number.
Sample run:
bash-4.3$ ruby -e 'm=i=0;gets.gsub(/\[|\]/){m=[m,i+=?\\<=>$&].max};p m' <<< '[1, [[2, 3, [[4], 5], 6, [7, 8]], 9, [10, [[[11]]]], 12, 13], 14]'
6

Java 8, 95
This is a lambda expression for a ToIntFunction<String>. Input is taken as a String in the OP's examples format.
s->{int d=e=-1;for(String t:s.split("[")){d=++e>d?e:d;e-=t.split("]",-1).length()-1;}return d;}

fairly straightfoward. Split the string using [ as the delimiter. For each of them, increment the counter e and compare it with the counter d, keeping the larger of them in d. Then split the current iteration's string using ] as the delimiter this time and subtract the number of extra splits from e.

Ruby, 41 characters
f=->a,d=1{a.map{|e|f[e,d+1]rescue d}.max}

Parameter: array, return: number.
Sample run:
2.1.5 :001 > f=->a,d=1{a.map{|e|f[e,d+1]rescue d}.max}
 => #<Proc:0x0000000214d258@(irb):1 (lambda)>

2.1.5 :002 > f[[1, [[2, 3, [[4], 5], 6, [7, 8]], 9, [10, [[[11]]]], 12, 13], 14]]
 => 6

Oracle SQL 11.2, 133 bytes
SELECT MAX(d)FROM(SELECT SUM(DECODE(SUBSTR(:1,LEVEL,1),'[',1,']',-1,0))OVER(ORDER BY LEVEL)d FROM DUAL CONNECT BY LEVEL<=LENGTH(:1));

Un-golfed
SELECT MAX(d)
FROM   (
         SELECT SUM(DECODE(SUBSTR(:1,LEVEL,1),'[',1,']',-1,0))OVER(ORDER BY LEVEL) d
         FROM   DUAL
         CONNECT BY LEVEL<=LENGTH(:1)
       );

The CONNECT BY creates one row per character in the input string.
The SUBSTR isolates the character corresponding to the row number.
The DECODE translates each '[' to 1, each ']' to -1 and every other character to 0.
The analytic SUM sums each 1, -1 and 0 from the preceding rows, including the current row;
The MAX sums is the depth.

Ruby, 42 characters
f=->a{a==a.flatten(1)?1:f[a.flatten(1)]+1}

Example:
irb(main):001:0> f.call([[[1,2],[2,3]],[[3,4],[5]]])
=> 3

And it's actually readable. :)

Welcome to the site!

Lua, 101 100 bytes
d,c=0,0 print((...):gsub(".",function(s)c=s=='['and c+1 or s==']'and c-1 or c d=c>d and c or d end))

Try it online!
How it works
-- Passed To Command Line: "[1, [[2, 3, [[4], 5], 6, [7, 8]], 9, [10, [[[11]]]], 12, 13], 14]"

-- Deepest Sub-Array Count, Current Depth
deepest, current = 0, 0

-- We abuse gsub() to iterate over every character in the input string and run a function for it
(...):gsub(".", function(s)
    -- The current depth is incremented if s (the current character) is equal to [, OR decremented if s is equal to ], OR left alone
    current = (s == '[' and current+1) or (s == ']'and current-1) or current
    -- If current is > deepest then deepest = current else deepest = current, we're using boolean logic like a ternary operator
    deepest = current > deepest and current or deepest
end)

print(deepest)
```

How are you taking input?  Based on your example it seems like you might be expecting it to be stored in a specific variable?  There has been a long standing consensus that this sort of input is only permitted in certain very specific contexts.  For a list of ways to take input see this meta thread.

Didn't realize that wasn't allowed, updated to reflect that.

You can save one byte by replacing arg[1] with (...)

I've heard that ... works in place of the args table, but it doesn't seem to work with 5.3. Is is a 5.4 feature?

Swift - 76 bytes
func d(_ a:[Any])->Int{return 1+(a.map{$0 is Int ?0:d($0 as![Any])}).max()!}

A recursive function that returns one plus the max of all non ints in the array using map.

Haskell + hgl, 20 bytes
y=dPF(p 0)$P1<mx<m y

Takes input as a free monad of lists (Free List a).
Explanation
A ragged list can contain either a terminal element or a list of more ragged lists.
dPF is a function which takes a function to convert terminal elements and a function to convert lists of ragged lists and uses them to convert a ragged list.   This is captured in the type signature:
dPF :: (a -> b) -> ([Free [] a] -> b) -> Free [] a -> b

We give it two functions, for terminal elements it is very simple, terminal elements always have depth 0, so we give it p 0, meaning always return zero.
For lists we get the maximum depth of each element and add 1 using the function we are defining recursively.  P1<mx<m y.
Reflections

We spend 6 bytes to envoke dpF properly dPF()$.  This should have an infix function.  Even if the operator precedence was bad it would have saved a byte.
It's not an issue here because the lists can't be empty, but we should have a maximum with default function.
Max with map also seems common enough to implement.
Might have not saved bytes here, but this is the second time I have wanted a fix function.  Should probably add that before I hit a place where I really need it.

tinylisp, 48 bytes
(load library
(d f(q((x)(i(v x)0(+ 1(max(map f x

Try it online!
-11 from Dlosc
gets depth of a quoted list.

Since arrays are guaranteed nonempty and integers are guaranteed positive, you can replace the type check with (v x). Evaling an int returns it unchanged; evaling a list of ints returns nil + error message because the head of the list should be a function or macro. Try it online!

(Also, for future reference, there's a type? function that is a little shorter than using type with e.)

@DLosc i was skeptical about whether errors halted execution because i never really got where the error were coming from.  anyway, thanks.

Wolfram Language (Mathematica), 16 bytes
Max[#0/@-1^#]+1&

Try it online!
The relatively low precedence of prefix - means -1^# is evaluated before the high-precedence /@.

Perl 6, 70 bytes
Whole program that reads the given examples terminated with newline or EOF from STDIN.
# perl6 % <<< '[1, [[2, 3, [[4], 5], 6, [7, 8]], 9, [10, [[[11]]]], 12, 13], 14]'

my $i;dd [max] lines.comb.map:{$i++when '[';$i--when ']'}

lines takes text line by line from STDIN and returns a list of Str. Calling .comb on a list will convert that into a Str and then split it into graphenes. Any block in Perl 6 is born with one positional argument that ends up in $_. map called with any callable expect it to have one positional argument. What is nice because when ']' is short for when $_ ~~ ']'. The returned list is fed to [max] and reduced to it's biggest value.

C#, 99 Bytes
int f(string s){int m=0,w=0;foreach(char c in s){if(c=='[')w++;if(c==']')w--;if(w>m)m=w;}return m;}

Does int m=w=0 work in C# ?

Axiom 106 bytes
RL(a:Union(List(Any),Any)):INT==(a case List(Any)=>(g:List(Any):=a;r:=1;for i in g repeat r:=r+RL(i);r);0)

ungolf
RL(a:Union(List(Any),Any)):INT==
  a case List(Any)=>
          g:List(Any):=a
          r:=1
          for i in g repeat r:=r+RL(i)
          r
  0

results
(3) -> for i in[[1],[1,2,3], [[1,2,3]], [3,[3,[3],3],3]]repeat output[i, RL(i)]
   [[1],1]
   [[1,2,3],1]
   [[[1,2,3]],2]
   [[3,[3,[3],3],3],3]

C++14, 72 70 67 bytes
-2 bytes for removing the curly brackets at for and -3 bytes for replacing m=l>m?l:m with m+=l>m.
As unnamed lambda returning via reference parameter:
[](auto&s,int&m){int l=m=0;for(auto c:s)l+=(c==91)-(c==93),m+=l>m;}

s can be std::string or char[]
Ungolfed and usage:
#include<string>
#include<iostream>

auto f=
[](auto&s,int&m){
 int l=m=0;
 for(auto c:s)
  l+=(c==91)-(c==93),
  m+=l>m;
}
;

int main(){
 std::string S[] = {
  "[1]",
  "[1, 2, 3]",
  "[[1, 2, 3]]",
  "[3, [3, [3], 3], 3]",
  "[[[[1], 2], [3, [4]]]]",
  "[1, [[3]], [5, 6], [[[[8]]]], 1]",
  "[1, [[2, 3, [[4], 5], 6, [7, 8]], 9, [10, [[[11]]]], 12, 13], 14]",
  "[[[[[[[3]]]]]]]"
 };

 for (auto s:S){
  int m;
  g(s,m);
  std::cout << m << std::endl;
 }

}

Clojure, 57 bytes
(fn[s](apply max(reductions +(map #({\[ 1 \] -1}% 0)s))))

Also based on parsing a string:
(f "[3, [3, [3], 3], 3]")

R: 53 bytes.
d=function(L) ifelse(is.list(L),max(sapply(L,d))+1,0)

Recursive function, it adds one point everytime it finds an inner list. It chooses only the element with the maximum depth...

Scala, 56 bytes
val f:Any=>Int={case l:Seq[_]=>l.map(f).max+1 case _=>0}

Make sure the inputs are Seqs and not Lists (I used Seq to save a byte).
Try it online!

Pip, 14 bytes
{a*0&1+MX:fMa}

Try it online!
Explanation
A recursive function that takes the list as its argument.
{            }  Anonymous function:
 a               The first argument
  *0             Times 0
                 (This gives 0 if the argument is a number, or a [possibly nested]
                  list of 0s if the argument is a list)
    &            Logical AND (short-circuiting)
                 (Since 0 is falsey and non-empty lists are truthy in Pip, this
                  halts the recursion and returns 0 if we've reached the inside of
                  the innermost lists; otherwise...)
          fMa    Map this function recursively to each element of a
       MX:       Get the max (: is a no-op to manipulate operator precedence)
     1+          Add 1

C (gcc), 62 bytes
n;m;f(char* s){for(;*s;s++)*s^91?*s^93?0:n--:++n>m?m=n:0;m=m;}

Try it online!

Nekomata, 2 bytes
ˡ∑

Attempt This Online!
ˡ∑
ˡ   Loop until failure and return the number of iterations:
 ∑      Sum

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:
principal square root without resorting to built‑ins
Write a square root function taking a single input – positive, negative or sign‑less (zero is sign‑less) – that outputs its approximate principal square root, correct up to six decimal places past the decimal point (truncate after the sixth decimal place).
Employing scientific notation (1E3 = 1 × 10³ = 100) or similar is not allowed.
You are forbidden from using any built‑in power‑related functions, including but not limited to

Math.pow(n, 0.5)
sqrt(2)
root(n, 2)
n ** 0.5
exp(ln(n) ∕ 2) (the exponentiation function is forbidden, logarithms and division are allowed)

This means that you have to implement your own method for finding the principal square root.
Two common methods are the Babylonian/bisector method and Newton’s method, but feel free to create your own!
Output can be either printed to the console or returned, your choice.
Examples:

input
output

4
2

7
2.645751

5.0625
2.25

−15
3.872983 i

−9
3 i

Is e^x allowed? (I'm guessing not)

While this challenge doesn't ban power functions, there are enough answers there that don't use them to call this one a dupe, IMO.

There's also http://codegolf.stackexchange.com/questions/30253/calculate-the-square-root-only-using

Is an xth root function power-related?

Also, 6 decimal places is somewhat ambiguous, do you mean six significant figures? Otherwise this becomes dramatically more complicated given a 50 digit input.

"Do X without Y" challenges are generally a bad idea, and this one hits the usual pitfalls.

@quartata - no, that is not allowed as that is power (^)

@ThomasKwa - wouldn't xth root be equivalent to n^(1/x), which is power

@FryAmTheEggman - I'm not sure exactly what you mean. How is six decimal places ambiguous? If you have 1.2345678901, then you would truncate to 1.234567

Try, for example 500000000000000000 as input, the output should be 707106781.18654752 ish, is the result then 707106000? Can it be in scientific notation? These general floating point issues make a good case for using the sandbox.

With this definition, even division would be disallowed, as x/y is equal to xy^(-1).

I voted to close this as unclear and the other one as a dupe. The old challenge was broken (all of the answers were just **.5), whereas this has a better chance of being a good challenge. I am concerned, like @xnor, about the viability of a challenge of this type, however.

@FryAmTheEggman - the output cannot be in scientific notation. Your example would have an output of 707106781.186547

@LegionMammal978 - I don't mean to be so restrictive. I just want to find an objective way to ensure that nobody uses trivial answers that let them not write or not implement an algorithm to find the square root. This challenge is essentially to write the shortest code to find the square root of a number like the system would, in that a system cannot use built ins because it is the built in. Does that make more sense?

@Dopapp I think this is an interesting idea for a challenge, although there are some parts to it that are unclear. Would you mind if I were to post the same challenge but with clearer rules? (I won't do it if you'd like to do it yourself)

Go for it @DrGreenEggsandIronMan! I'll be looking out for your version :)

c (function), 166
Now with complex numbers.  Uses the GCC complex number extension.
Straightforward golfing of the famous Fast inverse square root method.  This method gives 1/sqrt(n), so we simply multiply this by n to give sqrt(n):
#include <complex.h>
#define M y*=1.5-n*y*y/2
i;_Complex float f(float m){float y,n;n=m>0?m:-m;y=n;i=0x5f3759df-*(int*)&y/2;y=*(float*)&i;M;M;M;return m>0?y*n:y*n*I;}

The famous snippet of Quake code only does one iteration of Newton's method, which gives a fairly inaccurate answer.  Three iterations here seems to be enough for 6 decimal places, at least for the testcases.
Try it online.

Isn't this not-your-IP and should thus be CW? Or could you at least link to the source file (there are github repos of Quake source)?

@cat OK - CWed and github URL added.

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

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


text:
Cyclic prime number program generator
Challenge
Your submission should consist of 2 or more programs each written in distinct languages. They can be arbitrarily numbered from 1 to k.
Each program p, given a natural number n should print the next n prime numbers (initially, the next prime is the 0-th prime, 2) on a single line, followed by a single blank newline, followed by a program fragment, which, when appended to the p+1 mod kth program, produces the program which does precisely the same thing, but with the next prime being the n+1th prime number.
Details

Your programs may accept its input as a function argument, or from standard input, or the closest equivalent in your languages.
Your programs may not read data from any external source other than to read n from standard input. If this data is required by your program, it must be included in the source code fragment generated by the previous program.
Your programs may not compute any prime numbers less than the next prime number.
The prime numbers may be separated by any delimiter other than a newline.
You may not use any language primitives or libraries for prime number generation - you must write the algorithm yourself.
You may use standard libraries for things other than prime generation.
Two languages which differ only in their versions are not said to be distinct languages.
Two languages whose semantics largely overlap (for example, C and C++) are not said to be distinct.
Your programs may do whatever they like for undefined inputs.
Your programs are required to support generating prime numbers up to 2^32-1. You may assume whatever you need about the runtime environment to ensure this is the case (i.e. you can assume your C program will be run on a machine where int has at least 32 bits). If this assumptions is non-trivial it should be stated explicitly.
If running your program involves a non-trivial compilation step it should be stated how to do it, so others can reproduce it.

Input/Output
next    in    out
0       10    2,3,5,7,11,13,17,19,23,29
25      13    101,103,107,109,113,127,131,137,139,149,151,157,163
7       4     19,23,29,31

Scoring
Because disk space is very expensive, your programs should be as small as possible. Because more is obviously better, your submission should consist of as many programs as possible. The score of your submission is the average byte count of your programs divided by the number of distinct languages used. Lowest score wins.

Java + Python 2, Score = (302 + 218) / 2 / 2 = 130
Here is a brief explanation on how this works:

Choose a program and pick a positive integer, n; for Java, pass n as a command line argument; for Python, pass n through stdin.

The program will then print a list of n primes followed by 2 newlines and then a snippet.

Append this to a fresh copy of the program which was not chosen.
Choose a new n and pass it to this modified program

The program will then print a list of n primes followed by 2 newlines and then a snippet.

Append this to a fresh copy of the program which was originally chosen.
Rinse, repeat.

Golfed
Java, 302 bytes
Netbeans is able to compile this even with the A class missing, I haven't been able to figure out how. But once I do, I will add the flags to the byte count.
public class P{static int i=2;public static void main(String[]a){int l=2,n=Integer.parseInt(a[0]),x;String s="";try{new A().a();}catch(Exception e){}while(n>0){if(i>1){boolean b=false;for(x=2;x<i;x++){if(i%x==0 && i!=2)b=true;}if(!b){s+=s==""?i:","+i;l=i;n--;}i++;}}System.out.print(s+"\n\n+"+(l-1));}}

Python 2, 218 bytes
n=int(input())
s=[]
i=-1
while n:
 if i>1:
  for x in range(2,i):
   if i%x==0and i!=2:break
  else:s+=[i];n-=1
  i+=1
 if n==0:print",".join(str(y)for y in s)+"\n\nclass A{void a(){P.i="+str(s[-1]+1)+";}}"
 if i<0:i=2

Un-Golfed
Java
public class PPCG {

   public static int i = 2;

   public static void main(String[] args){
       int n = Integer.parseInt(args[0]);
       int last = 2;
       String s = "";
       try{
           new A().a();
       }catch(Exception e){}
       while(n>0){
           if(i>1){
               boolean broken=false;
               for(int x=2;x<i;x++){
                   if(i%x==0 && i!=2){
                       broken=true;
                   }
               }
               if(!broken){
                   s += s==""?i:","+i;
                   last = i;
                   n-=1;
               }
               i+=1;
           }
       }
       System.out.println(s+"\n\n+"+(last-1));
   }
}

Python 2
n=int(input())
s=[]
i=-1
while n:
  if i>1:
    for x in range(2,i):
      if i%x==0 and i!=2:
        break
    else:
      s+=[i]
      n -= 1
    i+=1
  if n==0:
    print ",".join(str(y) for y in s)+"\n\nclass A{public static void a(){PPCG.i="+str(s[-1]-1)+";}}"
  if i<0:
    i = 2

Update

-17 [16-12-13] Misc golfing


text:
Sort by Multiplying
You should write a program or function that given a list of positive integers multiplies each element with the smallest positive integer possible to create a strictly increasing list.
For example if the input is
5 4 12 1 3

the multiplications will be
5*1=5 4*2=8 12*1=12 1*13=13 3*5=15

and the output will be the increasing list
5 8 12 13 15

Input

A list of positive integers containing at least 1 element

Output

A list of positive integers

Examples
9 => 9
1 2 => 1 2
2 1 => 2 3
7 3 => 7 9
1 1 1 1 => 1 2 3 4
5 4 12 1 3 => 5 8 12 13 15
3 3 3 8 16 => 3 6 9 16 32
6 5 4 3 2 1 => 6 10 12 15 16 17
9 4 6 6 5 78 12 88 => 9 12 18 24 25 78 84 88
8 9 41 5 12 3 5 6 => 8 9 41 45 48 51 55 60
15 8 12 47 22 15 4 66 72 15 3 4 => 15 16 24 47 66 75 76 132 144 150 153 156

This is code golf so the shortest program or function wins.
Fun fact: the last element of the output for the input N, N-1, ... ,1 seems to be the (N+1)th element of the sequence A007952. If you find a proof, you are welcomed to include it in your golf answer or post it as a comment.

has anyone made ground on that proof yet?

Jelly, 6 5 bytes
:‘×µ\

First Jelly answer before @Dennis wakes up and beats me. Try it online!
Explanation
:          Integer division, m//n
 ‘         Increment, (m//n+1)
  ×        Multiply, (m//n+1)*n
   µ       Turn the previous links into a new monadic chain
    \      Accumulate on the array

Thanks to @Dennis for -1 byte.

:‘×µ\ saves a byte.

@Dennis Oh shit he woke up

JavaScript (ES6), 28
Edit As suggested by @Patrick Roberts, p can be a uninitialized parameter. Same byte count but avoid using a global variable
(a,p)=>a.map(n=>p=n*-~(p/n))

TEST

f=(a,p)=>a.map(n=>p=n*-~(p/n))

console.log=x=>O.textContent+=x+'\n'

;[
[[9], [ 9]],
[[1, 2], [ 1, 2]],
[[2, 1], [ 2, 3]],
[[7, 3], [ 7, 9]],
[[1, 1, 1, 1], [ 1, 2, 3, 4]],
[[5, 4, 12, 1, 3], [ 5, 8, 12, 13, 15]],
[[3, 3, 3, 8, 16], [ 3, 6, 9, 16, 32]],
[[6, 5, 4, 3, 2, 1], [ 6, 10, 12, 15, 16, 17]],
[[9, 4, 6, 6, 5, 78, 12, 88], [ 9, 12, 18, 24, 25, 78, 84, 88]],
[[8, 9, 41, 5, 12, 3, 5, 6], [ 8, 9, 41, 45, 48, 51, 55, 60]],
[[15, 8, 12, 47, 22, 15, 4, 66, 72, 15, 3, 4], [ 15, 16, 24, 47, 66, 75, 76, 132, 144, 150, 153, 156]]
].forEach(t=>{
  var i=t[0],k=t[1],r=f(i),ok=(k+'')==(r+'')
  console.log(i + ' => ' + r + (ok?' OK':'FAIL expecting '+x))
})

I think you can save a few bytes by using modulo, just like I did in my answer.

Can't you skip the p=0?  You need it to run it multiple on multiple lists but the question is just for a single list

@CharlieWynn if you don't initialize a variable you get the error for undefined variable. If by chance the variable already exists (that could easily happen in the environment of a web page), it could have any wrong value.

@edc65 sure enough, p is already defined on this page!

A neat way to do this using ES7 generator comprehensions is (a,p)=>[for(n of a)p=n*-~(p/n)]

@PatrickRoberts can be neat but is longer. The p as a parameter is a nice idea, I'm using it

@edc65 glad you liked my parameter format. Just pointing out that by "neat" I did not mean shorter.

@edc65 I hate to make you revert to a global variable, but you can save 3 bytes by changing your function to a=>a.map(n=>p+=n-p%n,p=0) as @aross suggested.

@PatrickRoberts thinking again, I could still avoid globals: f=a=>a.map(n=>a+=n-a%n,a=0). But it's not my algorithm (silly me) so I'll keep mine as is and upvote aross

@edc65 if you want to keep your algorithm and save 4 bytes, then use a=>a.map(n=>a=n*-~(a/n))!

@PatrickRoberts sorry for the late answer ... that fails for an array with just 1 element

Can you a=>a.map(p=n=>p=n*-~(p/n)) instead?

Python 2, 67 64 bytes
First try at code-golfing, so tips are appreciated.
def m(l):
 for x in range(1,len(l)):l[x]*=l[x-1]/l[x]+1
 print l

Hi, I think you're counting the line returns as 2 bytes each (using Windows?), but on this site you count each line return as a single byte.  So your score is actually 65 bytes. (You can copy and paste your code into https://mothereff.in/byte-counter if you're not sure.) Also, you can do print l instead of return l to save another byte. Nice job!

Thanks, I didn't know about the line returns. That explains why I've always got different byte counts. And I didn't even consider, that printing is sufficient and it doesn't have to return the list.

No problem! BTW, since you mentioned that "tips are appreciated", you might be interested in browsing through http://codegolf.stackexchange.com/questions/54/tips-for-golfing-in-python . Enjoy!

PHP, 55 46 42 41 bytes
Uses ISO 8859-1 encoding.
for(;$a=$argv[++$i];)echo$l+=$a-$l%$a,~ß;

Run like this (-d added for aesthetics only):
php -d error_reporting=30709 -r 'for(;$a=$argv[++$i];)echo$l+=$a-$l%$a,~ß;' 10 10 8

Saved 1 byte thx to Ismael Miguel.
Saved 8 bytes by using modulo instead of floor
Saved 4 bytes thx to Ismael Miguel (for instead of foreach)
Saved a byte by using ~ß to yield a space.

I think that you can replace $a+0 with +$a. Also, you can assume that the input will never have a 0, so, you can replace your $a+0&&print with simply +$a&print. In fact, you could even do $a&print, since in PHP "0" == 0 == 0.0 == false. But it may not be needed if you just use an echo, I think.

Binary and won't work (as opposed to logical), nor will echo work in this way. Since I'm taking input from CLI, the first argument is -, which I wanna catch instead of printing a zero. Try php -r 'print_r($argv);' foo. Saved 1 byte with your first suggestion though, thx.

How about for(;$a=$argv[++$i];)echo$l+=$a-$l%$a,' ';? It is 42 bytes long and skips the first element.

Nice one, thx @IsmaelMiguel

You're welcome. If you want to be really kinky, you can replace the space with a^A, but that would spill too many warnings (warnings are ignorable). It won't change the bytecount in any way, but surelly looks different.

I know warnings are ignorable, hence I don't initiate $l. But how would I print a linebreak in less than 3 characters exactly? Without resorting to non-standard constants of course

Let us continue this discussion in chat.

Thx for your suggestion. Your solution is probably the best for this problem and I don't want to steal it. +1

Haskell (30 28 25 bytes)
scanl1(\x y->y*div x y+y)

Expanded version
f :: Integral n => [n] -> [n]
f xs = scanl1 increaseOnDemand xs
 where
   increaseOnDemand :: Integral n => n -> n -> n
   increaseOnDemand acc next = next * (1 + acc `div` next)

Explanation
scanl1 enables you to fold a list and accumulate all intermediate values into another list. It's a specialization of scanl, which has the following type:
scanl  :: (acc  -> elem -> acc)  -> acc -> [elem] -> [acc]
scanl1 :: (elem -> elem -> elem) ->        [elem] -> [elem]

scanl1 f (x:xs) = scanl f x xs

Therefore, all we need is a suitable function that takes two the last element of our list (acc in the expanded version) and the one we wish to process (next in the expanded version) and return a suitable number.
We can easily derive this number by dividing the accumulator through the next one and flooring the result. div takes care of that. Afterwards, we simply have to add 1 to ensure that the list is actually increasing (and that we don't end up with 0).

No need to give your function a name. You can also replace the ( ... ) with $ ... and I think you've counted a final newline which can be omitted: scanl1$\x y->y*div x y+y, 24 bytes.

@nimi: Really? Expressions count? That being said, I don't save any bytes with (...) vs $, since $\  gets parsed as operator and I would need a single space after $.

unnamed function are allowed by default an scanl1(...) is an unnamed function. Regarding $vs. (): you're right, my mistake.

C++, 63 60 57 bytes
void s(int*f,int*e){for(int c=*f;++f!=e;c=*f+=c/ *f**f);}

Works inplace given a range [first, last). Originally written as template variant, but that was longer:
template<class T>void s(T f,T e){for(auto c=*f;++f!=e;c=*f+=c/ *f**f);}

Extended version
template <class ForwardIterator>
void sort(ForwardIterator first, ForwardIterator last){
    auto previous = *first;

    for(++first; first != last; ++first){
        auto & current = *first;
        current += current * (current / previous);
        previous = current;
    }
}

Mathematica, 36 32 bytes
 #2(Floor[#1/#2]+1)&~FoldList~#&

Test
#2(Floor[#1/#2]+1)&~FoldList~#& /@ {{5, 4, 12, 1, 3},
   {15, 8, 12, 47, 22, 15, 4, 66, 72, 15, 3, 4}}
(* {{5, 8, 12, 13, 15}, {15, 16, 24, 47, 66, 75, 76, 132, 144,
  150, 153, 156}} *)

Brachylog, 12 bytes
{≤.;?%0∧}ᵐ<₁

Weird enough trying to multiply each variable by a number will start at trying to multiply by 2 and not 0 or 1. This seems to work though and beats both other Brachylog implementations
Explanation
{       }ᵐ          --  Map each number
 ≤.                 --      to a number greater or equal to the original
  .;?%0             --      and a multiple of the original
       ∧            --      no more constraints
          <₁        --  so that the list is strictly increasing

Try it online!

CJam, 13 bytes
q~{\_p1$/)*}*

Input as a CJam-style list. Output is linefeed separated.
Test it here.
Explanation
q~    e# Read and evaluate input.
{     e# Fold this block over the list (i.e. "foreach except first")...
  \   e#   Swap with previous value.
  _p  e#   Duplicate and print previous value.
  1$  e#   Copy current value.
  /   e#   Integer division.
  )*  e#   Increment and multiply current value by the result.
}*

The final value is left on the stack and printed automatically at the end.

Python (3.5), 63 62 bytes
def f(a):
 r=[0]
 for i in a:r+=i*(r[-1]//i+1),
 return r[1:]

Test
>>> print('\n'.join([str(i)+' => '+str(f(i)) for i in [[9],[1,2],[2,1],[7,3],[1,1,1,1],[5,4,12,1,3],[3,3,3,8,16],[6,5,4,3,2,1],[9,4,6,6,5,78,12,88],[8,9,41,5,12,3,5,6],[15,8,12,47,22,15,4,66,72,15,3,4]]]))
[9] => [9]
[1, 2] => [1, 2]
[2, 1] => [2, 3]
[7, 3] => [7, 9]
[1, 1, 1, 1] => [1, 2, 3, 4]
[5, 4, 12, 1, 3] => [5, 8, 12, 13, 15]
[3, 3, 3, 8, 16] => [3, 6, 9, 16, 32]
[6, 5, 4, 3, 2, 1] => [6, 10, 12, 15, 16, 17]
[9, 4, 6, 6, 5, 78, 12, 88] => [9, 12, 18, 24, 25, 78, 84, 88]
[8, 9, 41, 5, 12, 3, 5, 6] => [8, 9, 41, 45, 48, 51, 55, 60]
[15, 8, 12, 47, 22, 15, 4, 66, 72, 15, 3, 4] => [15, 16, 24, 47, 66, 75, 76, 132, 144, 150, 153, 156]

Previous solution
some recursive solutions but larger
(68 bytes) f=lambda a,i=0:[i,*f(a[1:],a[0]*(i//a[0]+1))][i==0:]if a!=[]else[i]
(64 bytes) f=lambda a,i=0:a>[]and[i,*f(a[1:],a[0]*(i//a[0]+1))][i<1:]or[i]

Also instead of r+=[…], you can use r+=…,

@Cyoce i make changes but when i defined r=[0] in default parameter r become nonlocal

you're right, I forgot how Python handled default params. The other tip should work though

@Cyoce yes it works thanks for tips

Perl, 17 + 3 = 20 bytes
$p=$_*=$==1+$p/$_

Requires -p and -l flags:
$ perl -ple'$p=$_*=$==1+$p/$_' <<< $'15\n8\n12\n47\n22\n15\n4\n66\n72\n15\n3\n4'
15
16
24
47
66
75
76
132
144
150
153
156

Explanation:
# '-p' reads each line into $_ and auto print
# '-l' chomp off newline on input and also inserts a new line when printing
# When assigning a number to `$=` it will automatic be truncated to an integer
# * Added newlines for each assignment
$p=
  $_*=
    $==
      1+$p/$_

C (gcc), 37 bytes
o(int*_){for(;*++_;)*_*=_[~0]/ *_+1;}

Try it online!

38 bytes, recursive approach.

TI-Basic, 43 40 37 bytes
Prompt A
For(I,1,dim(ʟA
ʟA(I)(1+int(Ans/ʟA(I→ʟA(I
End
ʟA

-6 bytes thanks to MarcMush.

37 bytes with a fresh calculator or Ans = 0

Brachylog, 54 bytes
:_{h_.|[L:T],LhH,(T_,IH;0:$Ie*H=:T>I),Lb:I:1&:[I]rc.}.

Explanation
:_{...}.                § Call sub-predicate 1 with [Input, []] as input. Unify its output
                        § with the output of the main predicate

§ Sub-predicate 1

h_.                     § If the first element of the input is an empty list, unify the
                        § output with the empty list
|                       § Else
[L:T],LhH,              § Input = [L,T], first element of L is H
    (T_,IH              §     If T is the empty list, I = H
    ;                   §     Else
    0:$Ie*H=:T>I),      §     Enumerate integers between 0 and +inf, stop and unify the
                        §     enumerated integer with I only if I*H > T
Lb:I:1&                 § Call sub-predicate 1 with input [L minus its first element, I]
:[I]rc.                 § Unify the output of the sub-predicate with
                        § [I|Output of the recursive call]

Pyth, 11
t.u*Yh/NYQ0

Test Suite
Does a cumulative reduce, a reduce that returns all intermediate values, starting with 0. Since the input is guaranteed to contain only positive integers, this is ok. In each step, we take the old value, divide it by the new value and add 1, then we multiply by the new value.

C, 79 bytes
p;main(x,v)char**v;{for(;*++v;printf("%d ",p=((x+p-1)/x+!(p%x))*x))x=atoi(*v);}

Ungolfed
p; /* previous value */

main(x,v) char**v;
{
    /* While arguments, print out x such that x[i] > x[i-1] */
    for(;*++v; printf("%d ", p = ((x+p-1)/x + !(p%x)) * x))
        x = atoi(*v);
}

Wouldn't p=p/x*x+x work?

@Neil Yeah, that would work. Definitely overthought this one :)

PowerShell, 26 bytes
$args[0]|%{($l+=$_-$l%$_)}

Takes input as an explicit array, e.g., > .\sort-by-multiplying.ps1 @(6,5,4,3,2,1) via $args[0].
We then for-loop over that with |%{...} and each iteration perform magic. Nah, just kidding, we use the same modulo trick as other answers (props to @aross because I spotted it there first).
The encapsulating parens (...) ensure that the result of the math operation is placed on the pipeline, and thus output. If we left those off, nothing would be output since the $l variable is garbage-collected after execution finishes.
Example
PS C:\Tools\Scripts\golfing> .\sort-by-multiplying.ps1 @(8,9,1,5,4)
8
9
10
15
16

Rust, 59 bytes
|mut l:Vec<u8>|{for i in 1..l.len(){l[i]*=l[i-1]/l[i]+1};l}

Try it online!
I am still learning rust, but I am sure there is a better solution using iter(). Also I am using u8 because the examples don't have output value  greater than 512.

Factor, 35 bytes
[ 0 [ tuck /i 1 + * ] accumulate* ]

Attempt This Online!

PARI/GP, 25 bytes
a->i=0;[i=c*(i\c+1)|c<-a]
Attempt This Online!

Desmos, 78 bytes
n->min(n,i.length)+1,o->join(o,i[n]floor(o[n-1]/i[n]+1))
i=\ans_0
n=2
o=[i[1]]

Try It On Desmos!
Try It On Desmos! - Prettified

Julia 1.0, 27 bytes
!L=(x=0;L.|>i->x=(x÷i+1)i)

Try it online!

Uiua, 9 bytes
\(×+1⌊÷,)

Try it!
\(×+1⌊÷,)
\(      )  # scan by
       ,   # over
      ÷    # divide
     ⌊     # floor
   +1      # increment
  ×        # multiply

Uiua, 8 bytes
\(-⊃◿+∶)

Try it online!
Given the previous value x and the next value y, the transformed y is the same as (x+y) - (x+y)%y == (x+y) - x%y.
\(-⊃◿+∶)    input: a vector of positive integers
\(      )    scan by: (input: [x y])
       :       swap [y x]
   ⊃◿+        fork (mod, add) [x%y x+y]
  -            subtract [x+y-x%y]

05AB1E, 11 bytes
Code:
R`[=sŽDŠ/ò*

Try it online!
Explanation:
R            # Reverse input
 `           # Flatten the list
  [          # While loop
   =         # Print the last item
    s        # Swap the last two items
     Ž       # If the stack is empty, break
      D      # Duplicate top of the stack
       Š     # Pop a,b,c and push c,a,b
        /    # Divide a / b
         ò   # Inclusive round up
          *  # Multiply the last two items

Uses CP-1252 encoding.

Japt, 11 bytes
Uå@Y*-~(X/Y

Test it online!
How it works
          // Implicit: U = input array of integers
Uå@       // Cumulative reduce: map each previous value X and current value Y to:
-~(X/Y    //  floor(X/Y+1).
          // Implicit: output last expression

Minkolang 0.15, 17 bytes
nd1+?.z0c:1+*d$zN

Try it here!
Explanation
nd                   Take number from input and duplicate it
  1+                 Add 1
    ?.               Stop if top of stack is 0 (i.e., when n => -1 because input is empty).
      z              Push value from register
       0c            Copy first item on stack
         :           Pop b,a and push a//b
          1+         Add 1
            *        Multiply
             d$z     Duplicate and store in register
                N    Output as number

Essentially, the register keeps the latest member of the ascending list and this is divided by the input and incremented to get the multiplier for the next member. The toroidal feature of Minkolang's code field means that it loops horizontally without the need for () or [] loops.

Brachylog, 21 bytes
l~lCℕ₁ᵐ≤ᵛ~+?&;Cz≜×ᵐ<₁

Try it online!
Uses the sum of input values as the upper bound for coefficients C. Pretty slow, times out on TIO for input list lengths beyond 5 or 6 (also depending on the sum of the values). But not as slow as my original version, which requires tiny lists of upto 3 elements, with tiny values, to not time out:
21 bytes
l~l.&+^₂⟦₁⊇.;?z/ᵐℕ₁ᵐ∧

Try it online!

Python 2, 53 bytes
lambda a:reduce(lambda b,v:b+[b[-1]/v*v+v],a,[0])[1:]

Try it online!
k*x>y implies k>y/x; so the smallest k can be is k=floor(y/x)+1. Since in Python 2.7, integer division is already taken as floor, we want k=y/x+1, and k*x = (y/x+1)*x = y/x*x+x.

K (oK), 11 bytes
{y*1+_x%y}\

Try it online!

J, 21 bytes
(],[*1+{:@]<.@%[)/@|.

Try it online!

x86-64 machine code, 13 bytes
99 F7 3E F7 2E 01 06 AD FF CF 75 F4 C3

Try it online!
Following the standard calling convention for Unix-like systems (from the System V AMD64 ABI), this takes the length of an array of 32-bit integers in RDI and its address in RSI. The starting point is after the first 7 bytes.
In assembly:
                            # Here, EAX holds the modified previous number.
r:  cdq                     # Sign-extend it, preparing for the next instruction.
    idiv DWORD PTR [rsi]    # Divide by the current number, putting the quotient in EAX
                            #  and the remainder in EDX.
    imul DWORD PTR [rsi]    # Multiply the quotient by the current number; the net effect
                            #  is to round EAX down to a multiple of the current number.
    add [rsi], eax          # Add EAX to the current number, producing the first multiple
                            #  greater than the modified previous number.
f:  lodsd       # (Start here.) Load the current number into EAX, advancing the pointer.
    dec edi     # Count down from the length.
    jnz r       # Jump if it hasn't reached 0.
    ret         # Return.

Vyxal, 5 bytes
≬ḭ›*r

Try it Online!
Port of Jelly answer.
How?
≬ḭ›*r
≬     # Next three elements as a lambda:
 ḭ    # Floor divide: a/b
  ›   # Increment: a/b+1
   *  # Multiply: (a/b+1)*b
    r # Cumulative reduce the (implicit) input by this lambda

MathGolf, 7 bytes
æ`/)*]ç

Try it online.
Explanation:
æ        # Loop over the (implicit) input-list,
         # using 4 characters as inner code-block:
         #  (implicitly push the current value)
 `       #  Duplicate the top two values
         #  (which will push a 0 as first item in the first iteration)
  /      #  Integer-divide those two duplicated values
   )     #  Increase it by 1
    *    #  Multiply the top two values together
     ]   # After the loop: wrap all values on the stack into a list
      ç  # Remove the leading 0 with a falsey filter
         # (after which the result is output implicitly)

Oracle SQL 11.2, 210 bytes
WITH v AS(SELECT TO_NUMBER(COLUMN_VALUE)a,rownum i FROM XMLTABLE(('"'||REPLACE(:1,' ','","')||'"'))),c(p,n)AS(SELECT a,2 FROM v WHERE i=1UNION ALL SELECT a*CEIL((p+.1)/a),n+1 FROM c,v WHERE i=n)SELECT p FROM c;

Un-golfed
WITH v AS
(
  SELECT TO_NUMBER(COLUMN_VALUE)a, rownum i            -- Convert the input string into rows
  FROM   XMLTABLE(('"'||REPLACE(:1,' ','","')||'"'))   -- using space as the separator between elements
)
, c(p,n) AS
(
  SELECT a, 2 FROM v WHERE i=1                         -- Initialize the recursive view
  UNION ALL
  SELECT a*CEIL((p+.1)/a),n+1 FROM c,v WHERE i=n       -- Compute the value for the nth element
)
SELECT p FROM c;

Chez Scheme (140 Bytes)
Golfed Version:
(define(f l)(define(g l p m)(cond((null? l)l)((<(*(car l)m)(+ p 1))(g l p(+ m 1)))(else(cons(*(car l)m)(g(cdr l)(* m(car l))1)))))(g l 0 1))

Ungolfed Version:
(define(f l)
  (define(g l p m)
    (cond
      ((null? l) l)
      ((< (* (car l) m) (+ p 1)) (g l p (+ m 1)))
      (else (cons (* (car l) m) (g (cdr l) (* m (car l)) 1)))
    )
  )
  (g l 0 1)
)

Try it Online!

* m(car l) can be *(car l)m.


text:
Output the van der Corput sequence
The van der Corput sequence is one of the simplest example of low-discrepancy sequence. Its n-th term is just 0.(n written in base 10 and mirrored), so its first terms are :
0.1, 0.2,0.3,0.4, 0.5,0.6,0.7, 0.8,0.9,
0.01, 0.11,0.21,0.31, 0.41,0.51,0.61, 0.71,0.81,0.91,
0.02, 0.12,0.22,0.32, 0.42,0.52,0.62, 0.72,0.82,0.92, ...
The challenge
Write a program or a function in any programming language that takes as input a positive integer n less than 10^6 and returns or print the first n terms of the van der Corput sequence. The output format can be a list of floating point numbers, a list of strings of the form 0.digits, or a unique string where the terms are separated by commas and/or whitespaces, newlines.
Standard loopholes are forbidden. The shortest source code wins.

05AB1E, 6 bytes
Code:
>GNÞR,

Try it online!
Explanation:
>       # Increment, pushes input + 1
 G      # For N in range(1, input + 1):
  N     # Push N
   Þ    # Convert to double, which appends `.0` at the end of an integer
    R   # Reverse top of the stack
     ,  # Pop and print with a newline

Uses CP-1252 encoding.

You mean, windows-1252?

@IsmaelMiguel That is the same

I know, but it usually isn't recognized by the name CP-1252

Did you have to modify your language for the purpose of this challenge?

@AndrewSavinykh No, that is considered cheating and is not allowed on this site. It works with version 7.3, which was released before this challenge was posted.

Oracle SQL 11.2, 64 62 58 bytes
SELECT REVERSE(LEVEL||'.0')FROM DUAL CONNECT BY LEVEL<=:1;

Old version
SELECT '0.'||REVERSE(TRIM(LEVEL))FROM DUAL CONNECT BY LEVEL<=:1;

Concatenating '' to a number casts it to a string. It is 2 bytes shorter than using TRIM(), which is shorter than TO_CHAR().
Since concatenating a string to a NUMBER results in a string, it is possible to use that string to manage the '0.' part of the result.

CJam, 14 11 bytes
Thanks to Sp3000 for saving 3 bytes.
ri{)d`W%S}/

Test it here.
Explanation
ri     e# Read input and convert to integer N.
{      e# For each i from 0 to N-1...
  )    e#   Increment.
  d    e#   Convert to double.
  `    e#   Get string representation (which ends in ".0").
  W%   e#   Reverse.
  S    e#   Push a space.
}/

Perl 6, 24 22 20 bytes
{"0."X~(^$_)».flip}

Thanks Aleks-Daniel Jakimenko-A. for yet another two bytes
old version
{("0."~.flip for ^$_)}
# Alternate below, same byte count
{map ^$_: "0."~*.flip}

EDIT: Thanks raiph for extra 2 bytes
usage
> my &f = {"0."X~(^$_)».flip}
-> ;; $_? is raw { #`(Block|333498568) ... }
> f(25)
(0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 0.01 0.11 0.21 0.31 0.41 0.51 0.61 0.71 0.81 0.91 0.02 0.12 0.22 0.32 0.42)

{("0."~.flip for ^$_)} saves 2 bytes

Mathematica, 40 bytes
"0."<>StringReverse@ToString@#&~Array~#&

Test case
%[20]
(* {0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,0.01,0.11,0.21,0.31,0.41,0.51,0.61,0.71,0.81,0.91,0.02} *)

JavaScript (ES6), 58
An anonymous function returning a string with comma separated values
n=>[...[...Array(n)].map(_=>n--+'.0')+''].reverse().join``

TEST

f=n=>[...[...Array(n)].map(_=>n--+'.0')+''].reverse().join``

function test() { R.textContent = f(+I.value) }

test()
N:<input id=I type=number value=20 oninput="test()">

Pyth, 8 bytes
m_`cd1SQ

Try it online.
This is really just a combination of this and this answer. Therefore I'm making it a community wiki.

Brachylog, 23 bytes
:0re:""rcr:"0."rcw,@Sw\

This takes a number as input and outputs the result to STDOUT, separated by spaces.
Fairly straightforward. Unfortunately we have to concatenate the number with an empty string to convert this number to a string (:""rc), because there is no built-in conversion predicate yet.
The conversion to string is necessary, because if we reverse the digits of the number, then the leading zeros (e.g. 10 becomes 01) would be lost.

Python 3, 47 44 bytes
lambda n:[f'{i+1}.0'[::-1]for i in range(n)]

a shorter solution with Python 2
lambda n:['0.'+`i+1`[::-1]for i in range(n)]

Edit: gain 3 bytes using f-string interpolation from python 3.6, now we are even with python 2 solution.
Test case
>>> f(25)
['0.1', '0.2', '0.3', '0.4', '0.5', '0.6', '0.7', '0.8', '0.9', '0.01', '0.11', '0.21', '0.31', '0.41', '0.51', '0.61', '0.71', '0.81', '0.91', '0.02', '0.12', '0.22', '0.32', '0.42', '0.52']

My Python solution was the same, but I think that f= is not required, so it is 47 bytes long.

@Bob ok i removed it

This outputs the first n-1 terms.

@Seeq you are right i change the solution, it doesn't change the bytes count

lambda n:['0.'+`i+1`[::-1]for i in range(n)] is shorter if you use Python 2. Also, you shouldn't say "Python 3.5" unless it requires 3.5, which it doesn't. This version requires Python 2.

@mbomb007 unfortunately i know python 2 solutions is shorter in most of cases.

Pyth, 11 bytes
m+"0."_`dSQ

Try it here!
Explanation

m+"0."_`dSQ  # Q = input

m        SQ  # Map the range(1,Q) to...
 +           # ...the concatenation of:
  "0."_`d    # "0." and the reversed element

Pyth - 10 bytes
_M+R".0"SQ

Try it online here.

One byte smaller if you do VSQ...

MATL, 10 bytes
:"'0.'@VPh

Try it online!
:          % implicit input. Generate vector [1,2,...,input]
"          % for each
  '0.'     %   push string '0.'
  @        %   push loop variable (that is, 1,2,3,... in each iteration)
  V        %   convert to string
  P        %   reverse
  h        %   concatenate horizontally
           % implicit end of loop
           % implicit display of all stack contents

Haskell, 36, 27 bytes
f n=reverse.show<$>[1.0..n]

Two bytes saved by nimi and an additional 7 by Lynn.

f n=reverse.show<$>[1.0..n]

Gol><>, 22, 16 bytes
4 bytes saved by JoKing
IFS" 0."LPWaSDn|

Try it online!

16 bytes through the increment and divmod operators. Kinda conrused about how it terminates though

@JoKing I think it terminates because I can't properly read the input.

Nah, IIh totally works, with I pushing -1 on EOF. I think it's some parsing error with the for loop.

PowerShell, 52 bytes
while($a++-$args[0]){"0."+-join"$a"["$a".Length..0]}

A little longer than I'd like, but uses a couple of neat tricks.
The while loop is obvious, but the conditional is a little tricky - we have $a (which starts as $null when first referenced) and then subtract our input number $args[0]. In PowerShell, math operations on $null treat it as zero, so for input 20 for example this will result in -20. Since any non-zero number is $true, the loop conditional will be $true right up until $a equals our input number (at which point the subtraction will equal 0 or $false). The trick comes from the post-increment ++, which doesn't execute until after the subtraction is calculated, so handling input of 1 will correctly output 0.1 and then stop the loop on the next iteration.
Each time in the loop, we just create a string literal which gets left on the pipeline and output accordingly. We construct this from "0." concatenated with the result of the unary -join operator that has acted on the char-array created from taking the string "$a" backwards (by indexing via the range "$a".length..0).
Test Runs
PS C:\Tools\Scripts\golfing> .\van-der-corput-sequence.ps1 1
0.1

PS C:\Tools\Scripts\golfing> .\van-der-corput-sequence.ps1 20
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
0.01
0.11
0.21
0.31
0.41
0.51
0.61
0.71
0.81
0.91
0.02

Bash, 36 bytes
for i in `seq $1`;do rev<<<$i.0;done

Takes a number as a command line argument, and outputs each term on a separate line. For example:
$ ./vdc.sh 12
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
0.01
0.11
0.21

If not pure Bash anyway: seq -f%g.0 $1|rev.

@manatwork Cool. I didn't know seq could do formatted output.

Japt, 12 bytes
Uò1 ®+".0" w

Test it online!
How it works
           // Implicit: U = input integer
Uò1 ®      // Create the inclusive range [1..U], and map each item Z to:
+".0" w    //  Z + ".0", reversed.
           // Implicit: output last expression

beeswax, 57 53 bytes
Working on the binary digit output problem for rosettacode I noticed that I could use the same short division algorithm for the van der Corput sequence, just using division and modulo by 10 instead of 2. The output is reversed in both cases.
Golfed down by 4 bytes, by mirroring the code:
`.0` XfE@~@L#;
 { %X<#dP@T~P9_
   q<#   N
    >:'bg?b

Hexagonal prettyprint, for easier orientation:
` . 0 `   X f E @ ~ @ L # ;
 {   % X < # d P @ T ~ P 9 _
    q < #       N
     > : ' b g ? b

Explanation of one cycle through the program, using the original code:
;#L@~@EfX `0.`
_9P~T@Pb#>X% {
      N   #>p
      d?gd':<

                                                  lstack   gstack
                                _9P              [0,0,10]•         create bee, set top to 10
                                   ~T            [0,10,n]•         flip top and 2nd, enter n
                                     @P          [n,10,1]•         flip top and 3rd, increment top
                                       b                           redirect to upper left
                     [n,10,1]•        E          [n,10,1]•      (2)clone bee in horizontal direction
flip lstack 1st/3rd  [1,10,n]•       @ f         [n,10,1]•  [1]•   push lstack top on gstack
flip lstack 1st/2nd  [1,n,10]•       ~   X                         clone bee in all directions
flip 1st/3rd         [10,n,1]•      @     `0.`                     print "0." to STDOUT
skip if 1st>2nd      [10,n,1]•     L      >                     (1)redirect
if 1st<2nd, del. bee              #        X                       clone bee in all directions
(if 1st>2nd, terminate program)  ;          % {  [n,10,1]•         1st=1st%2nd, output lstack 1st to STDOUT
                                            >p                     redirect
                                             <                     redirect
                                            :    [n,10,0]•         1st=1st/2nd
                                           '                       skip next instr. if 1st=0
                                          d                        redirect to upper right, loop back to (1)
                                         g       [n,10,1]   [1]•   push gstack top on lstack 1st
                                       d?                   []•    pop gstack, redirect to upper right
                                       N                           print newline to STDOUT
                                       P         [n,10,2]          increment lstack 1st
                                       E                           looped back to (2)

Example:
julia> beeswax("vandercorput.bswx",0,0.0,Int(20000))
i300
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
0.01
0.11
0.21
0.31
0.41
  .
  .
  .
0.492
0.592
0.692
0.792
0.892
0.992
0.003

Program finished!

R, 59 Bytes
example(strsplit);cat(strReverse(sprintf('%s.0',1:scan())))

explanation
example(strsplit) creates the function strReverse (then it should be obvious)
Using IRanges::reverse, this could be golfed to 47 bytes
cat(IRanges::reverse(sprintf('%s.0',1:scan())))

PHP, 45 41 bytes
for(;$i++<$argv[1];)echo strrev(",$i.0");

Takes the input argument from CLI. Run like this:
php -r 'for(;$i++<$argv[1];)echo strrev(",$i.0");' 100

Saved 3 bytes by concatenating the string before reversing

Julia, 50 38 33 31 bytes
I went for a different output format to shorten the code by 12 bytes. The function returns an array of strings now.
Shortened by 5 more bytes. Thanks to Alex A. for reminding me of string interpolation and using an anonymous function (getting rid of 2 more bytes).
n->["0."reverse("$i")for i=1:n]

or alternatively
n->[reverse("$(i/1)")for i=1:n]

Test
julia> @time f(10000)
  0.002260 seconds (60.01 k allocations: 2.823 MB)
10000-element Array{ASCIIString,1}:
 "0.1"
 "0.2"
 "0.3"
 "0.4"
 "0.5"
 "0.6"
 "0.7"
 "0.8"
 "0.9"
 "0.01"
 "0.11"
 "0.21"
 "0.31"
 "0.41"
 "0.51"
 "0.61"
 "0.71"
 "0.81"
 "0.91"
 "0.02"
 "0.12"
 "0.22"
 "0.32"
 ⋮
 "0.8799"
 "0.9799"
 "0.0899"
 "0.1899"
 "0.2899"
 "0.3899"
 "0.4899"
 "0.5899"
 "0.6899"
 "0.7899"
 "0.8899"
 "0.9899"
 "0.0999"
 "0.1999"
 "0.2999"
 "0.3999"
 "0.4999"
 "0.5999"
 "0.6999"
 "0.7999"
 "0.8999"
 "0.9999"
 "0.00001"

31 bytes: n->["0."reverse("$i")for i=1:n]

By the way, you can request that your profile be merged with the old one here.

Very cool, didn’t know that. Thanks!

@AlexA. the anonymous function itself does not output anything. Wouldn’t a longer version like map(n->["0."reverse("$i")for i=1:n],3) (for n=3) be necessary to produce any output? That would make it (at least) as long as my solution.

For an anonymous function, you just add the stipulation that to call it, one must assign it to a variable. Saves two bytes over a named function and is in compliance with our rules.

, 12 chars / 15 bytes
⩤⁽1ï⒨ß)Ė⍞.0ᴙ

Try it here (Firefox only).
It's... okay.
Explanation
⩤⁽1ï⒨ creates a range [1,ï] to map over, ß) converts mapitem (number) to string, Ė⍞.0 concats .0 to the end, and ᴙ reverses the whole string.

Python 2, 54 Bytes
def f(i):
    for i in range(1,i):print("."+str(i)[::-1])

Explanation:
Iterate through the set [1,input) and appends the reversed i to ..
Still an be golfed more.

Use \i`instead ofstr(i)`. Also, I think you need to print the leading zero.

Dyalog APL, 12 bytes
{'0.',⌽⍕⍵}¨⍳

Try it online!
Straight-forward: the function { string '0.' before , the reversed ⌽ string-representation ⍕ of the argument ⍵ to the function } for each ¨ of the numbers 1 through n ⍳.

Retina, 39 bytes
1
1$`0.
(1)+
$#1
+`(\d)0\.(\d*)
0.$2$1

Takes input in unary.
Try it online here.

Gema, 45 characters
*=@set{i;0}@repeat{*;@incr{i}0.@reverse{$i} }

Sample run:
bash-4.3$ gema '*=@set{i;0}@repeat{*;@incr{i}0.@reverse{$i} }' <<< 12
0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 0.01 0.11 0.21

APL, 7
⌽⍎⌽1⍕⍳⎕

Explanation:
⍳⎕    creates a vector of numbers from 1 to user input
1⍕⍳⎕  formats these numbers like ##.0
⌽     inverts the whole string
⌽⍎   transforms back to numbers and inverts order

jq 1.5, 40 35 characters
(34 characters code + 1 character command line option.)
range(.)|"\(.+1).0"/""|reverse|add

Sample run:
bash-4.3$ jq -r 'range(.)|"\(.+1).0"/""|reverse|add' <<< 12
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
0.01
0.11
0.21

On-line test (Passing -r through URL is not supported – check Raw Output yourself.)
The same with links to documentation:

range(.) | "\(. + 1).0" / "" | reverse | add

As a more readable alternative, the above could be also written like this (on-line):
range(.) | . + 1 | tostring | . + ".0" | split("") | reverse | join("")

jq is really cool. Mind explaining how "\(.+1).0"/"" works?

There is nothing special, just a string interpolation \(…) and a division /, which in case of strings is split.

Python 2, 40 bytes
lambda n:[`i+1.`[::-1]for i in range(n)]

Example:
>>> f=lambda n:[`i+1.`[::-1]for i in range(n)]
>>> f(30)
['0.1', '0.2', '0.3', '0.4', '0.5', '0.6', '0.7', '0.8', '0.9', '0.01', '0.11', '0.21', '0.31', '0.41', '0.51', '0.61', '0.71', '0.81', '0.91', '0.02', '0.12', '0.22', '0.32', '0.42', '0.52', '0.62', '0.72', '0.82', '0.92', '0.03']

Algebraic solving:
corput(x) = reversed(str(float(x+1)))
          = reversed(str(x+1.))
          = str(x+1.)[::-1]
          = `x+1.`[::-1]

BBC BASIC, 89 88 87 bytes
0T=1:REP.P."0."FNR(STR$T):T=T+1:U.0
1DEFFNR(S$)IFS$="":=""EL.=FNR(MI.S$,2))+LE.S$,1)

Used abbreviations to shorten things as much as possible. Compatible with both Brandy Basic and BASIC 2 on the original machine.
For modern BBC BASICs you could also leave off the line numbers to save two more bytes.

Dyalog APL, 6
⌽¨1⍕¨⍳

This is an anonymous function that takes one argument, i.e.:
      ⌽¨1⍕¨⍳ 20
 0.1   0.2   0.3   0.4   0.5   0.6   0.7   0.8   0.9   0.01   0.11   0.21   0.31   0.41   0.51   0.61   0.71   0.81   0.91
         0.02
      f←⌽¨1⍕¨⍳
      f 20
 0.1   0.2   0.3   0.4   0.5   0.6   0.7   0.8   0.9   0.01   0.11   0.21   0.31   0.41   0.51   0.61   0.71   0.81   0.91
         0.02

Explanation:
     ⍳    ⍝ get the integers from 1..n
  1⍕¨     ⍝ format each with 1 decimal
⌽¨        ⍝ reverse each string

Lua, 53 bytes
for i=1,io.read()do print("0."..(i..""):reverse())end

Try it online!

Stax, 5 bytes
Öå┴I←

Run and debug it

Factor, 39 bytes
[ [1,b] [ "%d.0"sprintf reverse ] map ]

Try it online!

[1,b] [ ... ] map Map over the range 1..input.
"%d.0"sprintf reverse String interpolate and reverse.

Vyxal, 4 bytes
ƛ²√Ṙ

Try it Online!
Outputs as a list of what I think are strings.
ƛ    # 1..n mapped to...
 ²√  # Cast to float with √(x^2)
   Ṙ # Reverse

Those aren't strings, those are actual floats in the return list

@exedraj Oh ok. Reverse is weird.

It's intentional: you reverse a number and it remains a number. It's more helpful than having to do ṘI (assuming it returned a string instead)

@exedraj But with floats... Oh well.

ɾ²√R also works for 4 bytes

Japt, 6 bytes
Outputs an array of strings
õx1 mw

Try it
õx1 mw     :Implicit input of integer U
õ          :Range [1,U]
 x1        :  Force each to 1 decimal place, converting to a string
    m      :Map
     w     :  Reverse

Perl 5, 25 bytes
say'0.'.reverse for 1..<>

JS, 66
T=101; // set T to the number of iterations wanted
for(o=[],i=0;i<T;i++)o[i]="0."+(""+i).split("").reverse().join("") // 66b

Output is the array called "o"

Ruby, 46 45 40 bytes
->n{(1..n).map{|i|puts"#{i}.0".reverse}}

I'm new to golfing so any tips would be helpful :)

String interpolation implicitly converts your integer to string. Use it to get rid of explicit .to_s: "#{i}.0".reverse. Wondering why was this downvoted…

Ah thanks I hadn't thought about that.

(Much later...) You could save one byte by using n.times and i+1 instead of (1..n).map.

Groovy, 36 characters
{(1..it).collect{"$it.0".reverse()}}

Sample run:
groovy:000> ({(1..it).collect{"$it.0".reverse()}})(12)
===> [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 0.01, 0.11, 0.21]

Seriously, 8 bytes
,R`K$R`M

Try it online!
Explanation:
,R`K$R`M
,R        range(1, input()+1)
  `   `M  map:
   K        ceil (cast int to float; L would also work for floor)
    $R      stringify and reverse

J-uby, 20 bytes
:+|:*&(S|:~|:+&"0.")

Attempt This Online!
Explanation
:+ | :* & (S | :~ | :+ & "0.")

:+ |                            # Get range 1..n, then
     :* & (                  )  # Map with...
           S | :~ |             #   Convert to string then reverse, then
                    :+ & "0."   #   Append to "0."

TI-Basic, 35 bytes
For(I,1,Ans
Disp sum(seq(fPart(.1int(I/₁₀^(J)))/₁₀^(J),J,0,int(log(I
End

Takes input in Ans.

Thunno 2, 4 bytes
ı1/r

Try it online!
Explanation
ı1/r  # Implicit input
ı     # Map over [1..input]:
 1/   #   Divide by 1 (convert to float)
      #     (1     ->     1.0)
      #     (10    ->    10.0)
      #     (1234  ->  1234.0)
   r  #   Reverse this number
      #     (1.0     ->     0.1)
      #     (10.0    ->    0.01)
      #     (1234.0  ->  0.4321)
      # Implicit output


text:
Recursive 2x2 determinant
The determinant of a 2 by 2 matrix
a b
c d

is given by ad - bc.
Given a matrix of digits with dimensions 2n by 2n, n ≥ 1, output the result obtained by recursively computing the determinant of each 2 by 2 sub-block until we reach a single number.
For example, given the input
3 1 4 1
5 9 2 6
5 3 5 8
9 7 9 3

After one step, we obtain:
(3*9 - 1*5)    (4*6 - 1*2)    =    22  22
(5*7 - 3*9)    (5*3 - 8*9)         8  -57

And iterating once more, we get:
(22*-57 - 22*8) = -1430

Hence, the output should be -1430.
Rules

The elements of the matrix will always be single digit integers, i.e. 0 to 9.
You may take input in any convenient list or string format, as long as no preprocessing of data is done. Since the matrix is always square, you may take input as a single 1D list instead of a 2D list if you wish.
Input can be via function input, STDIN, command-line argument or closest alternative.
Output should be a single integer to function output, STDOUT or closest alternative. You may not output the single integer in a list or matrix.
You may use builtin determinant and matrix manipulation methods if your language happens to support them.
Your algorithm must work in theory for any valid input.
Standard code-golf rules apply.

Test cases
The following test cases are given as Python-style lists:
[[1,0],[0,1]] -> 1
[[1,9],[8,4]] -> -68
[[0,1,2,3],[4,5,6,7],[8,9,0,1],[2,3,4,5]] -> 40
[[3,1,4,1],[5,9,2,6],[5,3,5,8],[9,7,9,3]] -> -1430
[[9,0,0,9],[0,9,9,0],[9,0,9,0],[0,9,0,9]] -> 13122
[[1,0,0,0,0,0,0,0],[2,1,0,0,0,0,0,0],[3,2,1,0,0,0,0,0],[4,3,2,1,0,0,0,0],[5,4,3,2,1,0,0,0],[6,5,4,3,2,1,0,0],[7,6,5,4,3,2,1,0],[8,7,6,5,4,3,2,1]] -> 1
[[7,1,0,5,8,0,1,5],[9,9,6,6,1,2,4,8],[4,8,7,3,8,7,4,7],[4,6,1,9,7,0,1,7],[7,6,7,1,9,4,1,6],[8,0,0,8,5,5,9,9],[4,6,4,8,9,4,8,6],[9,0,8,7,6,2,1,5]] -> 2937504
[[1,2,3,4,5,6,7,8],[2,3,4,5,6,7,8,1],[3,4,5,6,7,8,1,2],[4,5,6,7,8,1,2,3],[5,6,7,8,1,2,3,4],[6,7,8,1,2,3,4,5],[7,8,1,2,3,4,5,6],[8,1,2,3,4,5,6,7]] -> -10549504
[[1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,0],[0,1,1,1,1,0,0,1,0,1,1,1,1,1,1,0],[1,1,0,1,1,0,1,1,1,1,1,1,1,1,1,0],[0,1,1,1,1,0,0,0,0,1,1,1,1,1,0,1],[1,0,1,0,1,1,1,0,0,1,1,1,1,0,1,0],[0,0,1,1,1,0,1,1,1,1,1,1,1,0,0,0],[1,1,1,1,1,0,1,0,1,1,1,1,1,1,1,1],[1,1,0,1,1,1,1,1,1,1,1,1,0,1,0,1],[1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1],[0,1,1,1,1,1,1,1,1,0,0,1,0,1,0,1],[1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[1,1,0,1,1,0,1,1,1,1,1,0,0,1,1,0],[1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,0],[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[1,0,1,0,0,1,0,1,0,1,1,1,1,1,0,1],[1,1,1,1,1,1,1,1,1,0,0,1,1,1,0,1]] -> -8

(Thanks to @MartinBüttner for help with this challenge)

Fun fact: I ran some experiments on this and there is a surprisingly large number of binary matrices with non-zero recursive determinant. For sizes 2x2, 4x4, 8x8, 16x16, we get 6, 16488, 2229617029168687104, 3349795881591711813037585032680117995553655026185547430764970842694019448832 matrices with non-zero determinant which corresponds to 37.5%, 25.1587%, 12.0868%, 2.89294%, respectively.

@MartinBüttner: I get 6, 22560, 10160459763342013440, ... which matches A055165.

@Charles odd, I'll check my code

@MartinBüttner: Possibly we're just computing two different things?

@Charles Consider the matrix [1,0,1,0;1,1,1,1;1,1,1,1;0,0,0,1]. The full determinant of it is zero since it has two identical rows. This one is therefore a singular (meaning non-invertible) 4×4 matrix, so it is not counted by A055165. However, the "recursive" determinant discussed here is 1*1-1*0==1. In the opposite direction, the matrix [0,0,0,1;1,0,0,0;0,1,0,0;0,0,1,0] has "recursive" determinant 0*0-0*0==0. However, its full determinant must be non-zero because its rows is just the rows of the identity matrix in another order; and it is counted by A055165.

J, 21 25 bytes
0{0{(_2(_2-/ .*\|:)\])^:_

Usage:
   ]input=.(3,1,4,1),(5,9,2,6),(5,3,5,8),:(9,7,9,3)
3 1 4 1
5 9 2 6
5 3 5 8
9 7 9 3
   (0{0{(_2(_2-/ .*\|:)\])^:_) input
_1430

At every step we cut up the matrix to 2-by-2's and compute each ones determinant resulting in the next step's input matrix. We repeat this process until the result doesn't change (the final element is the determinant itself). We convert the final result to a scalar with 0{0{.
Try it online here.

Tried using Cut's tiling function to do this, but wasn't able to golf it as far as your version.  29 bytes: (2 2$2)&(-/ .*;._3^:(2^.#@])) Try it online!

Mathematica, 52 40 bytes
Thanks to Martin Büttner for saving 12 bytes.
Tr[#//.l:{_,__}:>BlockMap[Det,l,{2,2}]]&

Explanation
BlockMap[f,expr,n] split expr into sublists of size n and map f on every sublists. BlockMap[Det,#,{2,2}]& split the input array into 2*2 blocks and calculate their determinants.

Test case
%[{{3,1,4,1},{5,9,2,6},{5,3,5,8},{9,7,9,3}}]
(* -1430 *)

I wrote a reference implementation in Mathematica while discussing the challenge idea with Sp3000 and it's 40 bytes. It's pretty similar to yours though, so I'll give you some time to find it yourself if you like. :)

@MartinBüttner I failed. :(

You can avoid the [[1,1]] with Tr and the Nest with //.: Tr[#//.l:{_,__}:>BlockMap[Det,l,{2,2}]]&

@MartinBüttner Actually, I came up with //. idea when reading the answer in J, but stuck in finding a good way to match the array. :P

feel free to use my solution to update your answer

Jelly, 20 17 bytes
s€2s2U×¥/€ḅ-µL¡SS

Try it online! or verify all test cases at once.
How it works
s€2s2U×¥/€ḅ-µL¡SS  Main link. Input: M (matrix)

s€2                Split each row of M into pairs.
   s2              Split the result into pairs of rows.
        /€         Reduce each pair...
       ¥             by applying the following, dyadic chain:
     U                 Reverse each pair of the left argument (1st row).
      ×                Multiply element-wise with the right argument (2nd row).
          ḅ-       Convert each resulting pair from base -1 to integer.
                   This maps [a, b] -> b - a.
            µ      Turn the previous links into a monadic chain. Begin a new one.
             L     Yield the length of the input.
              ¡    Execute the previous chain L times.
                   log2(L) times would do, but who's counting?
               SS  Sum twice to turn the resulting 1x1 matrix into a scalar.

MATL, 30 26 bytes
`tnX^teHHhZC2Ih2#Y)pwp-tnq

Input is a 2D array with rows separated by ;, that is,
[3 1 4 1; 5 9 2 6; 5 3 5 8; 9 7 9 3]

Try it online!
`             % do...while loop
  tnX^te      %   reshape into square matrix. Implicitly asks for input the first time
  HHhZC       %   transform each 2x2 block into a column
  2Ih2#Y)     %   push matrix with rows 2,3, and also matrix with remaining rows (1,4)
  pwp-        %   multiplications and subtraction to compute the 2x2 determinants
  tnq         %   condition of do...while loop: is number of elements greater than 1?
              % implicitly end loop
              % implicitly display

Haskell, 93 86 bytes
EDIT: Thanks to @Laikoni for shortening this a whole 7 bytes!
f[[a,b],[c,d]]=a*d-b*c
f m|let l=[take,drop]<*>[div(length m)2]=f[f.($b<$>m)<$>l|b<-l]

I didn't know you could put a let statement before the = and I've never gotten used to those monad operators. Thanks again @Laikoni
Old version:
f[[a,b],[c,d]]=a*d-b*c
f m=f[[f$a$map b m|a<-l]|b<-l]where h=length m`div`2;l=[take h,drop h]

Try it online!
This is a function that recurs on itself in two different ways. First the pattern matching catches the the base case: a 2x2 matrix and it does the calculation. I use this to do the calculation in the recursive case by calling the function with a 2x2 matrix I generate that has the recursive solutions in it. That matrix is generated by iterating twice over an array of functions that each chop a list in half. I apply it to rows with a simple call and apply it to columns using map.

Instead of where h=length m`div`2;l=[take h,drop h], you can use f m|let l=[take,drop]<*>[length m`div`2]=. map b m can be b<$>m, and [f$a$b<$>m|a<-l] can be further shortened to f.($b<$>m)<$>l.  Altogether 86 bytes: [https://tio.run/##DY07DoMwEAX7nMIFBaAlSshfwlxktYWN7YBYE0SsVNzd2eZpNFO80Xxnz5xzQDRgCXAAR6RN7RpbD4eg4s4@KdaYzOzBbZ@VurpHN/1K9ss7jSpWLemA4VgWtiv6WMnwbruGKUczLXrdpiWpQgWFeIIztHCRoyvc4A4PoSe8QLyQFBBPlP8 Try it online!]

Python, 166 bytes
def f(m):l=len(m)/2;g=lambda x,y:[(s[:l],s[l:])[x]for s in(m[:l],m[l:])[y]];return f(g(0,0))*f(g(1,1))-f(g(0,1))*f(g(1,0)) if l>1 else m[0][0]*m[1][1]-m[1][0]*m[0][1]

This passes all the test cases provided. m has to be a 2D array (like in the test cases), g selects the sub matrix.

Pyth, 26
M-F*VG_HhhumgMCcR2dcG2llQQ

Test Suite
This has two parts: M-F*VG_H redefines the function g to calculate the determinant of a two by two matrix. This saves bytes even though we only use it once because it unpacks the two rows.
The other part is a large reduce statement that we call log_2( len( input() ) ) times. Unfortunately, performing a step in the reduction on a 1 by 1 matrix causes the result to be wrapped in a list, so we don't get a fixed point. The reduce is mostly just splitting up the matrix to get 2 by 2 matrices and then applying g.

Perl 5, 120 + 1 (-a) = 121 bytes
while($#F){@r=();for$i(@o=0..($l=sqrt@F)/2-1){push@r,$F[$k=$i*$l*2+2*$_]*$F[$k+$l+1]-$F[$k+$l]*$F[$k+1]for@o}@F=@r}say@F

Try it online!
Takes the input as a list of space separated numbers.

ES6, 91 bytes
(a,x=0,y=0,w=a.length)=>(w>>=1)?f(a,x,y,w)*f(a,x+w,y+w,w)-f(a,x,y+w,w)*f(a,x+w,y,w):a[x][y]

Straightforward recursive solution.

Groovy, 221 189 bytes (At this point, could've used Java)
f={x->b=x.size();c=b/2-1;a=(0..c).collect{i->(0..c).collect{j->z=x.toList().subList(i*2,i*2+2).collect{it.toList().subList(j*2,j*2+2)};z[0][0]*z[1][1]-z[0][1]*z[1][0];}};a.size()==1?a:f(a)}

Old crappy version, which might as well be Java (221 bytes):
f={x->b=x.size();a=new int[b/2][b/2];for(i=0;i<b-1;i+=2){for(j=0;j<b-1;j+=2){z=x.toList().subList(i,i+2).collect{it.toList().subList(j,j+2)};a[(int)(i/2)][(int)(j/2)]=z[0][0]*z[1][1]-z[0][1]*z[1][0];}};a.size()==1?a:f(a)}

Ungolfed code:
f=
{x->
  b=x.size();
  int[][]a=new int[b/2][b/2];
  for(i=0;i<b-1;i+=2) {
    for(j=0;j<b-1;j+=2) {
      z=x.toList().subList(i,i+2).collect{
        it.toList().subList(j,j+2)
      };
      a[(int)(i/2)][(int)(j/2)]=z[0][0]*z[1][1]-z[0][1]*z[1][0];
    }
  }
  a.size()==1
    ?
      a:f(a)
}

R, 111 bytes
f=function(m)"if"((n=nrow(m))-2,f(matrix(c(f(m[x<-1:(n/2),x]),f(m[y<-x+n/2,x]),f(m[x,y]),f(m[y,y])),2)),det(m))

Try it online!
Takes input as an R matrix (which is converted by the function in the header).

Husk, 25 bytes
ω(m(moF`-Fz*C2z*:1İ_)TmC2

Try it online!
The testcases in this one are great.