text:
This question has its ups and downs
Input will consist of the following characters:

^: Go up one
v: Go down one
▲ or k: Go up two
▼ or j: Go down two

For example, the following input:
^^▲^v▼▲^^v

would produce the following output:
        ^
   ^   ^ v
  ▲ v ▲

 ^   ▼
^

Escape sequences that move the cursor such as \e[B are not allowed. You must produce the output using spaces and newlines.
Here are a few more test cases.
▲v^v^v^v^v^v^v^v▲

                ▲
▲ ^ ^ ^ ^ ^ ^ ^
 v v v v v v v v

^^^^^^^▲▲▲▼▼▼vvvvvv

         ▲

        ▲ ▼

       ▲   ▼

      ^     ▼
     ^       v
    ^         v
   ^           v
  ^             v
 ^               v
^                 v

v^^vv^^vvv^v^v^^^vvvv^^v^^vv

  ^   ^         ^
 ^ v ^ v       ^ v       ^
v   v   v ^ ^ ^   v   ^ ^ v
         v v v     v ^ v   v
                    v

Are trailing space allowed? Empty lines?

What about languages that don't support Unicode? Can alternative characters be used?

@xnor You are allowed trailing spaces and/or empty lines.

@Doorknob I'll allow j for going down twice and k for going up twice as well.

@Pyrrha Your comment and rules give opposite directions for j and k.

@xnor My bad :/ The comment is correct and I edited the rules wrong. Will fix now.

@Timwi Yes, trailing spaces are allowed.

Is the title of the question related with Van Damme's Volvo stunt?

While the examples show it already, it could be made a bit clearer that each input character is to be printed after moving the cursor as indicated.

Pyth, 27 bytes
jCm.<.[*5lzd\ =+Ztx"v ^k"dz

Try it online: Demonstration or Test Suite
I use k and j instead of ▲ and ▼. There are lots of leading and trailing empty lines. You have to search quite a bit to find the image. Here's a 34 byte version, that removes all leading and trailing empty lines.
j.sCm.<.[*5lzd\ =+Ztx"v ^k"dz]*lzd

Try it online: Demonstration or Test Suite
Explanation:
jCm.<.[*5lzd\ =+Ztx"v ^k"dz  implicit: Z = 0
  m                       z  map each char d from input string z to:
                  x"v ^k"d     find d in the string "v ^k", -1 if not found
                 t             -1, that gives -2 for j, -1 for v, 1 for ^ and 2 for k
              =+Z              add this number to Z
     .[*5lzd\                  append spaces on the left and on the right of d,
                               creating a 5*len(input_string) long string
   .<           Z              rotate this string to the left by Z chars
jC                           transpose and print on lines

Unreadable, 2199 2145 2134 2104 2087 2084 bytes
Supports both k/j as well as ▲/▼ syntax.
In good Unreadable tradition, here is the program formatted in proportional font, to obfuscate the distinction between apostrophes and double-quotes:

'""""""'""""""""'"""'""'""'""'""'"""'"""""'""""""'""'""'""'""'"""'""'""""""'""""""'""""""""'"""'""'""'"""""""'""""""""'"""'""""""""""'""""'""""'""""'""""'""""'""""""'""'""'""'""'""'"""'""'"""'""""""'""'""'""'""'"""'"""""""""'"""""'""""""'""'""'""'""'"""'""""""""'"""""""'""'""'""'""'"""'""""'""""""'""'""'""'""'""'"""'"""""""""'"""""""'""'""'""'""'""'"""'""""""""'"""""""'""'""'""'""'""'"""'""'""'"""'""""""'"""'"""""""""'"""""""'"""'""'"""""""'"""'""""""""'""""""""'""""""""'""""""""'""""""""'"""'"""""""""'""'"""""""'"""'"""""""""'""'""'""'"""""""'"""'"""'""'""'"""'""'"""'"""""""""'"""""""'""'""'""'""'""'"""'"""'""'""'"""'""""""'"""'"""""""""'"""""""'"""'"""""""""'""'""'"""""""'"""'"""""""""'""'""'""'""'"""""""'"""'"""'""'""'"""'""'"""'"""""""""'"""""""'""'""'""'""'""'"""'""'""'"""'"""'"""""'""""""'""'""'""'""'"""'""""""""'"""""""'""'""'""'""'"""'""""'""""'"""""""""'"""""""'""'""'""'"""'""""""'""'""'""'"""'""'"""""""'""'""'""'"""'"""'""""""'""'""'"""'""'"""""""'""'""'"""'""""""'""'"""'""""""""'"""""""'""'"""'"""""'""""""'"""'""""""""'"""""""'"""'""""'""""'""""""'""'""'""'"""'""""""""'"""""""'""'""'""'"""'"""""""""'"""""""'""'""'"""'""""""'""'""'"""'""""""""'"""""""'""'""'"""'"""'""""""'""'"""'""'"""""""'""'"""'""""""'""'"""""""'""""""""'"""'""'"""""""'""'"""'"""""'""""""""'""""""'""'""'""'"""'""'"""""""'""'""'""'"""'""""'""""""'""'"""'""""""""'"""""""'""'"""'""""""'""'""'"""'""'"""""""'""'""'"""'"""""'""""""""'""""""'""'"""'""'"""""""'""'"""'""""'""""""'"""'""'"""""""'""""""""'"""'"""""'""""""""'""""""""'""""""'"""'""""""""'""""""""'"""""""'"""'""""""'"""""""'"""'""'"""""""'"""""""'"""'"""""'""'""'""""""'""'""'"""'""""""""'"""""""'""'""'"""'""""'""""'""""'""""""'""'"""'""'""'""'""'""'""""""'"""'""'""'""'""'"""'"""""'""""""""'""""""""'""""""""'""""""""'""""""""'""""""'""""""""'"""'""""""""'""""""""'"""""""'""""""""'"""'"'"""""""""'""""""'""'""""""'"""'""'""'"""""""'"""'""""""""'"""""""'""'"""""""'"""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'""'"""""""'""'"""'"""""""'"""""""'"""'""""""'""""""""'"""'""'""'"""""""'"""'"'"""""""'""'"""

This was an amazing challenge. Thank you for posting!
Explanation
To get a feel for what Unreadable can and can’t do, imagine Brainfuck with an infinite tape in both directions, but instead of a memory pointer moving one cell at a time, you can access any memory cell by dereferencing a pointer. This comes in quite handy in this solution, although other arithmetic operations — including modulo — have to be done by hand.
Here is the program as pseudocode with director’s commentary:
// Initialize memory pointer. Why 5 will be explained at the very end!
ptr = 5

// FIRST PASS:
// Read all characters from stdin, store them in memory, and also keep track of the
// current line number at each character.

// We need the +1 here so that EOF, which is -1, ends the loop. We increment ptr by 2
// because we use two memory cells for each input character: one contains the actual
// character (which we store here); the other will contain the line number at which the
// character occurs (updated at the end of this loop body).
while ch = (*(ptr += 2) = read) + 1:

    // At this point, ch will be one more than the actual value.
    // However, the most code-economical way for the following loop is to
    // decrement inside the while condition. This way we get one fewer
    // iteration than the value of ch. Thus, the +1 comes in handy.

    // We are now going to calculate modulo 4 and 5. Why? Because
    // the mod 4 and 5 values of the desired input characters are:
    //
    //  ch  %5  %4
    //  ^   1
    //  v   2
    //  k   3
    //  j   4
    //  ▲   0   2
    //  ▼   0   0
    //
    // As you can see, %5 allows us to differentiate all of them except ▲/▼,
    // so we use %4 to differentiate between those two.

    mod4 = 0      // read Update 2 to find out why mod5 = 0 is missing
    while --ch:
        mod5 = mod5 ? mod5 + 1 : -4
        mod4 = mod4 ? mod4 + 1 : -3

    // At the end of this loop, the value of mod5 is ch % 5, except that it
    // uses negative numbers: -4 instead of 1, -3 instead of 2, etc. up to 0.
    // Similarly, mod4 is ch % 4 with negative numbers.

    // How many lines do we need to go up or down?
    // We deliberately store a value 1 higher here, which serves two purposes.
    // One, as already stated, while loops are shorter in code if the decrement
    // happens inside the while condition. Secondly, the number 1 ('""") is
    // much shorter than 0 ('""""""""'""").
    up = (mod5 ? mod5+1 ? mod5+3 ? 1 : 3 : 2 : mod4 ? 3 : 1)
    dn = (mod5 ? mod5+2 ? mod5+4 ? 1 : 3 : 2 : mod4 ? 1 : 3)

    // As an aside, here’s the reason I made the modulos negative. The -1 instruction
    // is much longer than the +1 instruction. In the above while loop, we only have
    // two negative numbers (-3 and -4). If they were positive, then the conditions in
    // the above ternaries, such as mod5+3, would have to be mod5-3 etc. instead. There
    // are many more of those, so the code would be longer.

    // Update the line numbers. The variables updated here are:
    // curLine = current line number (initially 0)
    // minLine = smallest linenum so far, relative to curLine (always non-positive)
    // maxLine = highest linenum so far, relative to curLine (always non-negative)
    // This way, we will know the vertical extent of our foray at the end.

    while --up:
        curLine--
        minLine ? minLine++ : no-op
        maxLine++

    while --dn:
        curLine++
        minLine--
        maxLine ? maxLine-- : no-op

    // Store the current line number in memory, but +1 (for a later while loop)
    *(ptr + 1) = curLine + 1

// At the end of this, minLine and maxLine are still relative to curLine.
// The real minimum line number is curLine + minLine.
// The real maximum line number is curLine + maxLine.
// The total number of lines to output is maxLine - minLine.

// Calculate the number of lines (into maxLine) and the real minimum
// line number (into curLine) in a single loop. Note that maxLine is
// now off by 1 because it started at 0 and thus the very line in which
// everything began was never counted.
while (++minLine) - 1:
  curLine--
  maxLine++

// Make all the row numbers in memory positive by adding curLine to all of them.
while (++curLine) - 1:
  ptr2 = ptr + 1
  while (ptr2 -= 2) - 2:    // Why -2? Read until end!
    *ptr2++

// Finally, output line by line. At each line, we go through the memory, output the
// characters whose the line number is 0, and decrement that line number. This way,
// characters “come into view” in each line by passing across the line number 0.
while (--maxLine) + 2:    // +2 because maxLine is off by 1
  ptr3 = 5
  while (ptr -= 2) - 5:
    print (*((ptr3 += 2) + 1) = *(ptr3 + 1) - 1) ? 32 : *ptr3   // 32 = space
  ptr = ptr3 + 2
  print 10  // newline

So much for the program logic. Now we need to translate this to Unreadable and use a few more interesting golfing tricks.
Variables are always dereferenced numerically in Unreadable (e.g. a = 1 becomes something like *(1) = 1). Some numerical literals are longer than others; the shortest is 1, followed by 2, etc. To show just how much longer negative numbers are, here are the numbers from -1 to 7:
-1  '""""""""'""""""""'"""  22
 0  '""""""""'"""           13
 1  '"""                     4
 2  '""'"""                  7
 3  '""'""'"""              10
 4  '""'""'""'"""           13
 5  '""'""'""'""'"""        16
 6  '""'""'""'""'""'"""     19
 7  '""'""'""'""'""'""'"""  22

Clearly, we want to allocate variable #1 to the one that occurs most frequently in the code. In the first while loop, this is definitely mod5, which comes up 10 times. But we don’t need mod5 anymore after the first while loop, so we can re-allocate the same memory location to other variables we use later on. These are ptr2 and ptr3. Now the variable is referenced 21 times in total. (If you’re trying to count the number of occurrences yourself, remember to count something like a++ twice, once for getting the value and once for setting it.)
There’s only one other variable that we can re-use; after we calculated the modulo values, ch is no longer needed. up and dn come up the same number of times, so either is fine. Let’s merge ch with up.
This leaves a total of 8 unique variables. We could allocate variables 0 to 7 and then start the memory block (containing the characters and line numbers) at 8. But! Since 7 is the same length in code as −1, we could as well use variables −1 to 6 and start the memory block at 7. This way, every reference to the start position of the memory block is slightly shorter in code! This leaves us with the following assignments:
-1    dn
 0                      ← ptr or minLine?
 1    mod5, ptr2, ptr3
 2    curLine
 3    maxLine
 4                      ← ptr or minLine?
 5    ch, up
 6    mod4
 7... [data block]

Now this explains the initialization at the very top: it’s 5 because it’s 7 (the beginning of the memory block) minus 2 (the obligatory increment in the first while condition). The same goes for the other two occurrences of 5 in the last loop.
Note that, since 0 and 4 are the same length in code, ptr and minLine could be allocated either way around. ... Or could they?
What about the mysterious 2 in the second-last while loop? Shouldn’t this be a 6? We only want to decrement the numbers in the data block, right? Once we reach 6, we’re outside the data block and we should stop! It would be a buffer overflow bug error failure security vulnerability!
Well, think about what happens if we don’t stop. We decrement variables 6 and 4. Variable 6 is mod4. That’s only used in the first while loop and no longer needed here, so no harm done. What about variable 4? What do you think, should variable 4 be ptr or should it be minLine? That’s right, minLine is no longer used at this point either! Thus, variable #4 is minLine and we can safely decrement it and do no damage!
UPDATE 1! Golfed from 2199 to 2145 bytes by realizing that dn can also be merged with mod5, even though mod5 is still used in the calculation of the value for dn! New variable assignment is now:
 0    ptr
 1    mod5, dn, ptr2, ptr3
 2    curLine
 3    maxLine
 4    minLine
 5    ch, up
 6    mod4
 7... [data block]

UPDATE 2! Golfed from 2145 to 2134 bytes by realizing that, since mod5 is now in the same variable as dn, which is counted to 0 in a while loop, mod5 no longer needs to be explicitly initialized to 0.
UPDATE 3! Golfed from 2134 to 2104 bytes by realizing two things. First, although the “negative modulo” idea was worth it for mod5, the same reasoning does not apply to mod4 because we never test against mod4+2 etc. Therefore, changing mod4 ? mod4+1 : -3 to mod4 ? mod4-1 : 3 takes us to 2110 bytes. Second, since mod4 is always 0 or 2, we can initialize mod4 to 2 instead of 0 and reverse the two ternaries (mod4 ? 3 : 1 instead of mod4 ? 1 : 3).
UPDATE 4! Golfed from 2104 to 2087 bytes by realizing that the while loop that calculates the modulo values always runs at least once, and in such a case, Unreadable allows you to re-use the last statement’s value in another expression. Thus, instead of while --ch: [...]; up = (mod5 ? mod5+1 ? [...] we now have up = ((while --ch: [...]) ? mod5+1 ? [...] (and inside that while loop, we calculate mod4 first, so that mod5 is the last statement).
UPDATE 5! Golfed from 2087 to 2084 bytes by realizing that instead of writing out the constants 32 and 10 (space and newline), I can store the number 10 in the (now unused) variable #2 (let’s call it ten). Instead of ptr3 = 5 we write ten = (ptr3 = 5) + 5, then 32 becomes ten+22 and print 10 becomes print ten.

This is...awful... +1

CJam, 37 bytes
r_,2*:L3*S*f{\_iImd8-g\8>)*L+:L\t}zN*

This prints empty lines before and after the desired output, which has been allowed by the OP.
Try it online in the CJam interpreter.
How it works
r_     e# Read a token from STDIN and push a copy.
,2*:L  e# Compute its length, double it and save it in L.
3*S*   e# Push a string of 6L spaces.
f{     e# For each character C in the input, push C and the string of spaces; then
  \    e#   Swap C with the string of spaces.
  _i   e#   Push a copy of C and cast it to integer.
  Imd  e#   Push quotient and remainder of its division by 18.
  8-g  e#   Push the sign((C%18) - 8). Gives -1 for ^ and ▲, 1 for v and ▼.
  \    e#   Swap the result with the quotient.
  8>)  e#   Push ((C/18) > 1) + 1. Gives 2 for ▲ and ▼, 1 for ^ and v.
  *    e#   Multiply both results. This pushes the correct step value.
  L+:L e#   Add the product to L, updating L.
  \t   e#   Replace the space at index L with C.
}      e# We've built the columns of the output.
z      e# Zip; transpose rows with columns.
N*     e# Join the rows, separating by linefeeds.

I think it would only be fair to explicitly state as a caveat that your solution produces copious amounts of extra newlines before and after the desired output...

Added. (I didn't think it was necessary since the OP explicitly allowed empty lines.)

Python 2, 102
s=input()
j=3*len(s)
exec"w='';i=j=j-1\nfor c in s:i-='kv_^j'.find(c)-2;w+=i and' 'or c\nprint w;"*2*j

Prints line by line.
Loops through characters in the input and tracks the current height. The height is updated by one of +2, +1, -1, -2 as computed by 'kv_^j'.find(c)-2. There's probably a mod chain that's shorter
When the current height equals the line number (which can be negative), we append the current character to the line, and otherwise append a space. Then, we print the line. Actually, it's shorter to start the height at the current line number and subtract the height changes, appending the character when the value hits 0.
The line numbers encompass a large enough range that a sequence of up-two or down-two will stay within it. Actually, there's a good amount of excess. If we had an upper bound on the input length, it would be shorter to write, say j=999.
Surprisingly, i and' 'or c was shorter than the usual [' ',c][i==0]. Note that i can be negative, which cuts out some usual tricks.

MATLAB, 116
function o=u(a)
x=0;y=1;o='';for c=a b=find(c=='j^ vk')-3;y=y+b;if y<1 o=[zeros(1-y,x);o];y=1;end
x=x+1;o(y,x)=c;end

It's a start. The j and k make it a pain in the neck as I can't find a way to mathematically map from j^vk to [-2 -1 1 2] and with MATLAB not recognising the Unicode (apparently both up and down have a value of 26 in MATLAB. Go figure!), there are a lot of bytes wasted doing the mapping.
By drawing inspiration from @xnors solution, the code can be reduced by another 14 characters by mapping the control character inside the for loop.
There are also many bytes wasted trying to account for if the input string sends the pattern back below the index at which it started (maybe if there was a limit on the string length I could simplify that bit).
And in its readable form:
function o=u(a)
%We start in the top left corner.
x=0; %Although the x coordinate is 1 less than it should be as we add one before storing the character
y=1;
o=''; %Start with a blank array
for c=a
    %Map the current character to [-2 -1 1 2] for 'j^vk' respectively.
    b=find(c=='j^ vk')-3;
    y=y+b; %Offset y by our character
    if y<1 %If it goes out of range of the array
        o=[zeros(1-y,x); o]; %Add enough extra lines to the array. This is a bit of a hack as 0 prints as a space in MATLAB.
        y=1; %Reset the y index as we have now rearranged the array
    end
    x=x+1; %Move to the next x coordinate (this is why we start at x=0
    o(y,x)=c; %Store the control character in the x'th position at the correct height.
end

Would b=[-2 -1 1 2](a==[106 107 94 118]) work? It works in Octave. Or even b=[-2 -1 1 2](a-94==[12 13 0 24]) if you want to shave off one more byte!

@WChargin doesn't work in MATLAB. Unfortunately the behaviour of the == stops that working, and also in MATLAB you can't put a () after a [].

Hmm…you could change the language to Octave! :) (Octave also has +=, fwiw.)

@WChargin That is cheating=P But I agree, Octave has a lot of shortcuts that Matlab does not have.

JavaScript (ES6), 140
Test running the snippet below in a EcmaScript 6 compliant browser (tested on Firefox)
.

f=s=>[...s].map(c=>{for(t=r[y+=c>'▲'?2:c>'v'?-2:c>'^'?1:-1]||x;y<0;y++)r=[,...r];r[y]=t+x.slice(t.length)+c,x+=' '},y=0,r=[x=''])&&r.join`
`

// Less golfed

f=s=>(
  y=0,
  x='',
  r=[],
  [...s].forEach( c =>
    {
      y += c > '▲' ? 2 : c > 'v' ? -2 : c > '^' ? 1 : -1;
      t = r[y] || x;
      while (y < 0)
      {
        y++;
        r = [,...r]
      }
      r[y] = t + x.slice(t.length) + c;
      x += ' '
    }
  ),
  r.join`\n`
)

//Test

;[
  '^^▲^v▼▲^^v'
, '▲v^v^v^v^v^v^v^v▲'
, '^^^^^^^▲▲▲▼▼▼vvvvvv'
, 'v^^vv^^vvv^v^v^^^vvvv^^v^^vv'
].forEach(t=>document.write(`${t}<pre>${f(t)}</pre>`))
pre { border:1px solid #777 }

GS2, 34 bytes
This one correctly calculates the output bounds so no excess whitespace is produced.  Here's my solution in hex
5e 20 76 6a 05 3e 26 ea 30 e0 6d 40 28 26 cf d3
31 e9 d0 4d 42 5e e2 b1 40 2e e8 29 cf d3 5c e9
9a 54

A little explanation is in order. On the stack we have user input as an array of ascii codes.  The program starts in a string literal because of the 05.  Here we go.
  5e 20 76 6a      # ascii for "^ vj"
  05               # finish string literal and push to stack
  3e               # index - find index in array or -1 if not found
  26               # decrement
ea                 # map array using block of 3 instructions (indented)

  30               # add
e0                 # create a block of 1 instruction
6d                 # scan (create running total array of array using block)
40                 # duplicate top of stack
28                 # get minimum of array
26                 # decrement
cf                 # pop from stack into register D (this is the "highest" the path goes)

  d3               # push onto stack from register D
  31               # subtract
e9                 # map array using block of 2 instructions

d0                 # push onto stack from register A (unitialized, so it contains stdin)

  4d               # itemize - make singleton array (also is single char string)
  42               # swap top two elements in stack
  5e               # rjust - right justify string
e2                 # make block from 3 instructions
b1                 # zipwith - evaluate block using parallel inputs from two arrays
40                 # duplicate top of stack

  2e               # get length of array/string
e8                 # map array using block of 1 instruction
29                 # get maximum of array
cf                 # pop from stack into register D (this is the "lowest" the path goes)

  d3               # push from register D onto stack
  5c               # ljust - left justify string
e9                 # map array using block of two instructions
9a                 # transpose array of arrays
54                 # show-lines - add a newline to end of each element in array

GS2, 24 bytes
I also have a 24 byte solution that doesn't take as much care calculating output size, and ends up with extra whitespace.  I prefer the one with the whitespace kept to a minimum though.
5e 20 76 6a 05 3e 26 ea 30 e0 6d d0 08 4d 42 d1
30 5e d1 5c 09 b1 9a 54

Crayon, 13 bytes (non-competing)
O"^ vj"\CynIq

Try it online! Uses the real arrows because why not.
Non-competing because Crayon is way newer than this challenge.
How it works
Crayon is a stack-based language designed to be killer at ASCII-art challenges. It is built around the basis of a 2-dimensional output "canvas", and a "crayon", a cursor that travels around this canvas. Anything that is sent to output is drawn on the canvas at the position of the crayon, and in the direction the crayon is facing. By default, the crayon points East (to the right).
O"^ v▼"\CynIq   Implicit: input string is on top of the stack
O               For each char I in the input string:
 "^ v▼"          Push this string.
       \         Swap the top two items (so I is on top).
        C        Take the index of I in the string.
                 This returns 3 for ▼, 2 for v, 0 for ^, and -1 for ▲.
         y       Move the crayon by this number of spaces on the Y-axis (south).
          n      Move the crayon one position north.
                 The crayon has now been translated 2 positions south for ▼,
                 1 south for v, 1 north for ^, and 2 north for ▲.
           Iq    Draw I at the crayon. This automatically moves the crayon forward
                 by the length of I, which is 1 in this case.

Husk, 30 bytes
↔T' z:mR' λm+a▼¹)∫m-2m€"v ^▲"¹

Try it online! or Verify all tests
Uses a few ideas from the Pyth answer, and the lambda can be shortened.
Since ▲ and ▼ are in Husk's codepage, you can see the testcases in their full glory!
Explanation
↔T' z:mR' λm+a▼¹)∫m-2m€"v ^▲"¹
                     m€"v ^▲"  get the indices of each char in the string
                  m-2          subtract 2 from each
                 ∫             cumulative sum
          λm+a▼¹)              add abs(minimum) to each
      mR'                      map each n to n spaces
    z:                         join the spaces with the input
 T'                            Transpose. padding with spaces
↔                              reverse

pb - 136 bytes
^w[B!0]{>}v[3*X]<[X]<b[1]^[Y]^>w[B!0]{t[B]<vw[B=0]{v}>w[T=107]{^^b[T]t[0]}w[T=94]{^b[T]t[0]}w[T=118]{vb[T]t[0]}w[T!0]{vvb[T]t[0]}^[Y]^>}

Uses k and j instead of ▲ and ▼.
A couple of notes:

Escape sequences that move the cursor such as \e[B are not allowed. You must produce the output using spaces and newlines. I do follow this rule! pb uses the concept of a "brush" to output characters. The brush moves around the "canvas" and can print a character immediately below it. However, the actual implementation prints the character using spaces and newlines.
I wasn't going to bother with this challenge even though I thought it would be fun with pb until I saw the ruling that You are allowed trailing spaces and/or empty lines. This is for a couple of reasons:

pb can't not have trailing spaces. It always produces rectangular output, padding with spaces if necessary.
This program produces a lot of empty lines. It doesn't know how tall the output is going to be when it starts making it, so for an input of length n it starts at Y=3n+1. The -1 is because it's going down 3n from Y=-1, and starting at Y=2n-1 fails for an input of all k.

You can watch this program in action on YouTube! This version is slightly modified in that it only goes down to n-1. It works for this input, but will fail for others. It does, however, capture a lot nicer.
With comments:
^w[B!0]{>}             # Go to the end of the input
v[3*X]                 # Go down 3 times the current X value
<[X]<                  # Go to X=-1 (off screen, won't be printed)
b[1]                   # Leave a non-zero value to find later
^[Y]^>                 # Back to the beginning of the input
w[B!0]{                # For every byte of input:
    t[B]                 # Copy it to T
    <vw[B=0]{v}>         # Go 1 to the right of the character to the left
                         # (either the last one printed or the value at X=-1)
                         # Move the correct amount for each character and print it:
    w[T=107]{^^b[T]t[0]} # k
    w[T=94]{^b[T]t[0]}   # ^
    w[T=118]{vb[T]t[0]}  # v
    w[T!0]{vvb[T]t[0]}   # j (Every other possibility sets T to 0, so if T is not 0
                         #    it must be j. T!0 is shorter than T=106)
    ^[Y]^>               # To the next byte of input to restart the loop
}

Ceylon, 447 bytes
import ceylon.language{o=null,v=variable,s=shared}s void y(){v L c;v L f;v L l;v Integer i=0;class L(v L?p,v L?n){s v String t="";s L u=>p else(f=p=L(o,this));s L d=>n else(l=n=L(this,o));s void a(Character c)=>t=t+" ".repeat(i-t.size)+c.string;}f=l=c=L(o,o);for(x in process.readLine()else""){switch(x)case('^'){c=c.u;}case('v'){c=c.d;}case('▲'|'k'){c=c.u.u;}case('▼'|'j'){c=c.d.d;}else{}c.a(x);i++;}print(f.t);while(f!=l){f=f.d;print(f.t);}}

Or with line breaks for "readability":
import ceylon.language{o=null,v=variable,s=shared}s void y(){v L c;v L f;v L l;v Integer i=0;class L(v L?p,v L?n){s v String t="";s L u=>p else(f=p=L(o,this));s L d=>n else(l=n=L(this,o));s void a(Character c)=>t=t+" ".repeat(i-t.size)+c.string;}f=l=c=L(o,o);for(x in process.readLine()else""){switch(x)case('^'){c=c.u;}case('v'){c=c.d;}case('▲'|'k'){c=c.u.u;}case('▼'|'j'){c=c.d.d;}else{}c.a(x);i++;}print(f.t);while(f!=l){f=f.d;print(f.t);}}
This works with both the ▲/▼ and the j/k input (If we had to support just one of them, the program would be 8 bytes shorter). The last output line is empty when the starting position was on it (i.e. the first input was a ▲ or ^ and we never got below that again later).
Input which is not one of the specified characters will simply be printed as-is, without switching the line:
v^^vv^^vvv^v^v^^^Hellovvvv^^v^^vv

→
  ^   ^         ^Hello
 ^ v ^ v       ^      v       ^
v   v   v ^ ^ ^        v   ^ ^ v
         v v v          v ^ v   v
                         v

Here is a formatted version (753 bytes):
shared void y() {
    variable L c;
    variable L f;
    variable L l;
    variable Integer i = 0;
    class L(variable L? p, variable L? n) {
        shared variable String t = "";
        shared L u => p else (f = p = L(null, this));
        shared L d => n else (l = n = L(this, null));
        shared void a(Character c) => t = t + " ".repeat(i - t.size) + c.string;
    }
    f = l = c = L(null, null);
    for (x in process.readLine() else "") {
        switch (x)
        case ('^') { c = c.u; }
        case ('v') { c = c.d; }
        case ('▲' | 'k') { c = c.u.u; }
        case ('▼' | 'j') { c = c.d.d; }
        else {}
        c.a(x);
        i++;
    }
    print(f.t);
    while (f != l) {
        f = f.d;
        print(f.t);
    }
}

This is an almost straight-forward "object-oriented" program ... the (local) class L (line buffer) stores a line of text (in t), as well as (nullable) pointers to the next (n) and previous (p) line. The (not nullable) attributes u (for up) and d (for down) initialize those if needed (with a reverse pointer to itself), and in this case also keep track of the first and last line overall (in the f and l variables).
The a (append) method appends a character to this line, including some spaces eventually necessary.
c is the current line. We parse the input string (using readLine as the input should be on one line) using a switch statement which updates the current line, and then calls the append method.
After parsing is done, we iterate over the lines from the first to the last, printing each of them. (This destroys the f pointer, if it were needed afterwards, we should have used a separate variable for this.)
Some used tricks for golfing:

Some stuff which in other languages would be keywords are actually just identifiers in the ceylon.language package, and can be renamed with an alias import – we used this for the annotations shared (used 5×) and variable (used 6×), as well as for the object null (used 4×):
import ceylon.language{o=null,v=variable,s=shared}

(Trivia: The Formatter in the Ceylon IDE formats some built-in language annotations, between them variable and shared, by putting them in the same line as the annotated declaration, contrasted to custom annotations, which are put on a separate line above the declaration. This makes the formatted version of the golfed program unreadable, therefore I changed the alias-imports back for this version.)
this, void, case, else are actual keywords and cannot be renamed this way, and Integer, String and Character appear just once each, so there is nothing to be gained by importing.
Originally I also had a separate ScreenBuffer class (which kept track of the linked list of line buffers, the current index, and so on), but as there was only ever one object of it, it was optimized away.
That Screenbuffer class also had up and down methods, which were called from the parser (and just did currentLine = currentLine.up respectively currentLine = currentLine.down). It showed that directly doing this in the parser's switch is shorter. It also allowed to write currentLine = currentLine.up.up (which later became c = c.u.u) instead of currentLine = currentLine.up;currentLine = currentLine.up.
Originally we did pass the current index as an argument into the append method (and even to the parser from the loop) – having it a variable in the containing function is shorter.
Originally my printAll method used the current pointer and moved it first up until the current line was empty, and then down while printing each line. This broke when using ▲ and ▼ to jump over lines, so we had to explicitly append something in those jumped lines instead. Keeping track of first/last line proved easier (though it made it necessary to use two print statements, because there is no do-while-loop in Ceylon).
Originally I had something like this:
  String? input = process.readLine();
  if(exists input) {
     for(x in input) {
         ...
     }
  }

process.readLine returns null if there is no line which can be read (because the input has been closed), and the Ceylon compiler requires me to checkfor that before I access input. As in this case I want to do nothing, I can equivalently use the else operator which returns its first argument if not null, and otherwise its second argument, saving the variable and the if-statement. (This also would allow us to encode a default input for testing: for (x in process.readLine() else "^^▲^v▼▲^^v") {)

JavaScript (ES6), 228 bytes
E=(r,p=(' '[M='repeat'](Z=r.length)+',')[M](Z*4),i=Z*2,k=0)=>Z>k?E(r,(p.split(',').map((o,q)=>q==i?o.slice(0,k)+r[k]+o.slice(k++):o)).join`,`,i+(H={'^':-1,k:-2,j:2,v:1})[r[k]],k):p.split(',').join`
`.replace(/\s+\n$|^\s+\n/g,'')

Well, here is a (rather long) recursive solution that passes all of the test cases given. It was a nice challenge. This uses k and j in place of ▼ and ▲.
Test Snippet
Although the submission itself can only handle k,j, the following snippet can handle both k,j and ▼,▲.

E=(r,p=(' '[M='repeat'](Z=r.length)+',')[M](Z*4),i=Z*2,k=0)=>Z>k?E(r,(p.split(',').map((o,q)=>q==i?o.slice(0,k)+r[k]+o.slice(k++):o)).join`,`,i+(H={'^':-1,k:-2,j:2,v:1})[r[k]],k):p.split(',').join`
`.replace(/\s+\n$|^\s+\n/g,'')
Input: <input type="text" oninput=o.textContent=E(this.value.replace(/▲/g,'k').replace(/▼/g,'j'))></input>
<pre id='o'></pre>

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


text:
Download all StackExchange git repos
Introduction
We all love StackExchange, therefore it would be essential to download all gems hidden on Stack Overflow repositories in the simplest possible way.
Challenge/Task
Your task is to write a script or program which would:

Fetch the list of all (within current page) repositories under Stack Overflow GitHub account. This can be achieved either by using direct link, or by using API callback (in JSON format). Example URLs for public access:
https://github.com/StackExchange
https://api.github.com/users/StackExchange/repos

Parse the list either from HTML, JSON or whatever format you would have into standard git URL format (recognised by git), such as:
https://github.com/StackExchange/foo.git
https://github.com/StackExchange/foo
git@github.com:StackExchange/foo.git

The last one assumes that your public key is already added.
For each repository, git clone needs to be executed/invoked, for example:
git clone URL_to_1st_repo
git clone URL_to_2nd_repo
...

All repositories are cloned (destination doesn't matter) and should be present (not just echoed or silently processed).

Assumptions

We're assuming all necessary standard tools are installed (e.g. git command) and it's in your PATH..
Assume that github.com fingerprint is already added into your system, e.g.
ssh-keyscan -H github.com >> ~/.ssh/known_hosts

Assume that your public key to access the remote repository has been added to the system (this is only required when accessing via git@).
We are not assuming any page or API rate limits.

Rules & Requirements

Smallest working/reproducible code with positive score wins.
After execution, all repositories should be cloned and the script/program must exit without crashing.
You can import libraries, but they must be made before the challenge.  However, you're not allowed to alias libraries to make them shorter to use in your code.
All libraries/tools which are provided by ubuntu/vivid64 sandbox (specified below) are not necessary to mention.
All used languages or tools needs to be at least 1 year old to prevent too narrow submissions.

Examples
You can find some useful examples at: How to clone all repos at once from Git.
Sandboxes

if you've got Vagrant installed, try running:
vagrant init ubuntu/vivid64 && vagrant up --provider virtualbox && vagrant ssh

OpenRISC OR1K Javascript Emulator - Running Linux With Network Support
However the curl doesn't always seems to work there (e.g. curl -v ifconfig.co).

Is there a reason to make the winner have to have at least 5 upvotes to win? Also, why does the language have to be a year old to compete?

@muddyfish For the reason of potential cheating. If somebody finds some loophole which hasn't been mentioned yet and people won't like the solution, the downvotes should sort that out. So there is not possibility of the winner with 1-2 byte of code (claiming that it magically works somehow) and having negative number of votes at the same time. In other words, the winner should be approved by the community in some way.

Have you looked at the standard loopholes?

@muddyfish I'm fairly new into writing some challenges, so thanks for pointing that out. But still applies if somebody will use some 1-5 byte of code by installing some magic libraries, so it won't be a standard loophole. So I think the score should be at some point an important factor, otherwise there is no point of voting the answers. Sorry if I'm introducing something new, this can be taken off if this rule is not well received. I believe the answer should be matured enough at some point to be accepted.

I'm pretty sure you're not allowed to use libraries written after the challenge either.

If you trust the community to upvote only valid answers, you can also trust it to downvote and delete cheating answers. The score and age requirements seem unnecessary to me.

@Dennis Changed to positive score if that's better.

That is better. Personally, I'd eliminate the extra requirements (score, age of language) altogether, but it's your challenge...

@Dennis Thanks. I wouldn't like to see the solution to work on some languages which were created a month ago, as it wouldn't be useful in some real life usage. So I'm expecting to see the solutions by using already matured tools/commands/languages. Just securing challenge for any ambiguity which I could think of which would be not expected.

Usability should be a minor concern in code golf. The shortest solution is almost never the most useful one. Take my answer, for example: It tries to clone every whitespace-delimited string in the JSON-file, so it makes a lot of unnecessary network requests and takes a lot longer than it should.

@Dennis When testing, I'm usually dumping curl request into file and trying to parse the static file and checking for the right output, so the requests are only done twice on initial and final testing. GitHub has necessary API limitations, so it won't allow you to abuse their server much. So as you can see, I forgot on another loopholes, which is preventing fetching invalid repos:) So not good practical usage, but at least your example works:)

Dennis is right about the extraneous requirements. What you gain in loophole haters you'll lose in TL;DRers.

Bash, 81 bytes
curl https://api.github.com/users/StackExchange/repos|tr -d ,|xargs -n1 git clone

Git will be fed a lot of invalid repos, but it will happily clone the valid ones.

sh (92 characters)
Example using Linux shell:
curl https://api.github.com/orgs/StackExchange/repos|grep -o 'git@[^"]*'|xargs -L1 git clone

And alternative version sh, but 94 characters:
grep -o 'git@[^"]*'|xargs -L1 git clone<(curl https://api.github.com/orgs/StackExchange/repos)

Explanation
Downloads API page via curl, extracts URLs which starts with git@, then execute git clone for each match.

source: Stack Exchange

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

sort: votes


text:
Perform a Pluto flyby
Congratulations! You've just been hired by NASA to work on the new Horizons 2 project.
Sadly, there have been huge budget cuts recently, so the top management has decided to fake the whole planned Pluto flyby (as they did for the moon landings in the 70s).
Your task is to write a program that will accept as input a date in the format yyyymmdd, and will provide a fake photograph of Pluto for this date. You can assume the entered date will be in the year 2015 or 2016.
The photograph is a 15x15 grid of ASCII characters. The characters on the grid have their x- and y-coordinates within the range [-7, 7] - the top-left character is at (-7, -7) while the bottom-right character is at (7, 7).
The photograph will be computed with the following rules:

The probe will be the nearest to Pluto on 25/12/2015
The distance d to Pluto is given by this formula : square root of ((difference in days to christmas) ^ 2 + 10)
The radius r of Pluto's image on the photo is given by : 22 / d
A character with coordinates (x, y) on the grid must be set to # if x^2 + y^2 <= r^2 ; it must be set to space otherwise.
There are stars at positions (-3, -5), (6, 2), (-5, 6), (2, 1), (7, -2). Stars are represented by a dot ., and they are of course hidden by Pluto.

One more thing: The NASA board has come to the conclusion that the discovery of life on Pluto would likely result in a substantial budget increase. Your program should then add clues of life on Pluto:

When the distance to Pluto is <= 4, add a plutonian at coordinates (-3,-1) : (^_^)

Example photograph for input 20151215: (Your code should have all the newlines as this code does)

    .

       #      .
      ###
     #####
      ###.
       #     .

  .

Photograph for input 20151225:

    #######
   #########
  ###########
 #############
 #############.
 ###(^_^)#####
 #############
 #############
 #############
 #############
  ###########
   #########
  . #######

As a comparison, here's a photo of Pluto's satellite Hydra as taken by New Horizons. Differences are hardly noticeable with our ASCII art.

This is code golf, so the shortest code in bytes wins!

This would've been a perfect challenge for the ASCII-art-drawing language I'm working on. Perhaps I'll post an answer with it after it's finished. :)

@SuperChafouin I removed the \``s in favour of `; feel free to roll back if you don't like it.

You can assume the entered date will be in the year 2015 or 2016. But then why specify a year at all?

Can I take dates in the form 2015/12/25?

JavaScript (ES6), 237 bytes
f=(n)=>(t=new Date('201'+n[3],n[4]+n[5],n[6]+n[7])/864e5-403805/24,r=484/(t*t+10),(g=(i)=>(++i<8?(h=(j)=>(i*i+j*j<=r?r>30.25&!~i&&'(^_^)'[j+3]||'#':~'p-3-5p62p-56p21p7-2'.indexOf('p'+j+i)?'.':' ')+(++j<8?h(j):''))(-7)+'\n'+g(i):''))(-8))

Live demo. Run in Firefox.
Original version
f=function(n) {
    t = (new Date('201'+n[3],''+n[4]+n[5],''+n[6]+n[7]) // Find the time difference in milliseconds,
    - new Date(2015,12,25)) / 864e5;                    // then divide by 86400000 to convert to days.

    r=22 / Math.sqrt(t*t+10);                           // Calculate the radius.

    s=[]; // s is the array that contains each line as a string.

    for(i=-7;i<8;i++)               // Loop through rows.
        for(j=-7,s[i+7]='';j<8;j++) // Loop through columns, appending one character per column.
                                    // s is zero based, so add 7 to the row.
            s[i+7]+=i*i+j*j<=r*r ?  // Choose which character to add to s.
            (r>5.5&i==-1&&'(^_^)'[j+3]||'#') :  // Add a '#' if the position is inside the radius.
                                                // If distance < 4, then the radius > 5.5
                                                // Then add the face at the right position.
            {'-3-5':1,'62':1,'-56':1,'21':1,'7-2':1} // Add the stars if outside. Create an associative array.
            [j+''+i]?'.':' ';                        // If i concat j is in the array, the expression will be 1,
                                                     // which is truthy, else it will be undefined, which is falsey.
    return s.join`\n` // Join all the rows with a new-line.
}

Golfing
This was fun to golf.
I don't need to create a Date object, so I hardcoded the value in milliseconds to save 13 bytes:
t=(new Date('201'+n[3],n[4]+n[5],n[6]+n[7])-new Date(2015,12,25))/864e5 // Before
t=new Date('201'+n[3],n[4]+n[5],n[6]+n[7])/864e5-403805/24 // After

Replace the associative array with a delimited string to eliminate 9 bytes:
{'-3-5':1,'62':1,'-56':1,'21':1,'7-2':1}[j+''+i]?'.':' ' // Before
~'p-3-5p62p-56p21p7-2'.indexOf('p'+j+i)?'.':' ' // After

The biggest refactor was replacing the for loops with nested, recursive IIFEs to knock off 10 bytes:
s=[];for(i=-7;i<8;i++)for(j=-7,s[i+7]='';j<8;j++)s[i+7]+= /* Chooses char at i,j */ ;return s.join`\n` // Before
(g=(i)=>(++i<8?(h=(j)=>( /* Chooses char at i,j */ )+(++j<8?h(j):''))(-7)+'\n'+g(i):''))(-8) // After

I also got rid of Math.sqrt for 8 more bytes.
r=22/Math.sqrt(t*t+10),(g=(i)=>(++i<8?(h=(j)=>(i*i+j*j<=r*r?r>5.5 // Before
r=484/(t*t+10),(g=(i)=>(++i<8?(h=(j)=>(i*i+j*j<=r?r>30.25 // After

Issues
I could only get the correct photograph for the test cases by changing the closest date to 2015/12/24, and I don't know if the problem lies in my code or the question. Please clarify and I will update my answer.
Here is my output using the differences from 2015/12/25.
Edit: Updated answer to use Christmas as the closest date.
Photograph for "20151215":

        .

           #      .
          ###
         #####
          ###.
           #     .

      .

Photograph for "20151225":

        #######
       #########
      ###########
     #############
     #############.
     ###(^_^)#####
     #############
     #############
     #############
     #############
      ###########
       #########
      . #######

My two examples were wrong (there was a one day shift), I have corrected them in the question. Thanks for pointing that!

C# 4.0, 393 bytes
string p(string s){int i=Convert.ToInt32(s),Y=i/10000,m,x,y;s="";i-=Y*10000;m=i/100;i-=m*100;double d=Math.Sqrt(Math.Pow((new DateTime(2015,12,25)-new DateTime(Y,m,i)).Days,2)+10);string o,k=".-3-5.62.-56.21.7-2";for(y=-7;y<8;y++){for(x=-7;x<8;x++){o="#";if(d<=4&&x==-3&&y==-1){o="(^_^)";x+=4;}s+=Math.Pow(x,2)+Math.Pow(y,2)<=Math.Pow(22/d,2)?o:k.Contains("."+x+y)?".":" ";}s+="\n";}return s;}

Example:
string userInput = Console.ReadLine();
Console.WriteLine(p(userInput));

Output:
20151216

    .

      ###     .
     #####
     #####
     #####
      ###    .

  .

20151224

     #####
   #########
  ###########
  ###########
 #############.
 ###(^_^)#####
 #############
 #############
 #############
  ###########
  ###########
   #########
  .  #####

CJam, 165 bytes
q'-%:i~\0\({X1=29W$2%-X7<X+2%30+?+}fX+\2%-359 6?+:DD*A+mq:Z22Z/_*:R-7:Y];F{-7:X;F{XX*YY*+R>XYF*+[-78II+85H-23]#)'.S?Z4<Y-1=X-4>X2<&&&X-3="(^_^)"L?'#??X):X;}*NY):Y;}*

The first part computes the day difference and stores it in the D variable.
The rest is a double loop that iterates through X and Y.
Test it here

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


text:
Implement a Moore State Machine
This challenge is a slightly different kind of Code Golf challenge. Rather than coding to match IO, you code to match an interface.
Background
Finite state machines are very useful design models for modeling event-based programming. A state machine is defined by a set of states and tranitions between them. The machine can be in one and only one state at any given time: the current state. Naturally, the machine has an initial state. When an event occurs, it may change it's state to another state; this is called a transition. A Moore machine is simply a FSM which can produce output; each state can produce an output.
For example, consider the following state machine which models a turnstile:

The Locked state is the initial state of the machine. Whenever the turnstile is Pushed from this state, we do nothing (go back to the Locked state). However, if we receive a Coin, we transition to the Un-locked state. Extra Coins do nothing, but a Push puts us back into the Locked state. It's not explicitly stated, but this FSM does have output: the Locked state has an output that tells the turnstile to lock it's arms, wheras the Un-locked state has an output that allows the turnstile to turn.
Task
You must implement a state machine class. This means that only languages with objects can compete. If there is an accepted alternative to objects in your language, that is valid (e.g. C can use structs with member functions). You must be able to access the functions of the object via obj.function or obj->function or whatever the accessor character for your language is. You are allowed to use a state machine library if it exists for your language, but you aren't allowed to use a class from the library "as your own" (don't just point at a premade class and say that that's your solution).
You must implement the following methods with exactly the specified names and signatures. However, you may capitalize the first letter or switch to snake_case (e.g. mapOutput, MapOutput, or map_output are all valid). Additionally, you may take an explicit this parameter as the first parameter:

map(State from, Event event, State to) Defines a transition from from to to on the event event. If from and event have both been previously passed to this method before, you may do anything at all.
mapOutput(State state, Output output) Assigns the given output to the given state. If state has been previously passed to this method before, you may do anything at all.
processEvent(Event event) Advances the state machine according to the transitions defined via map. Basically, if the current state of the state machine is from, then event sets the current state to the state defined by a previously called map(from, event, to). Throws an exception or fails violently if there is no mapping for the current state and given event.
getOutput() Gets the output for the current state, as defined via mapOutput. Returns null or equivalent if there is no output defined for the given state. This may be an Optional type or similar if your language has one.
Some sort of initial-state setting. This may be done in the constructor for your class, you may require State to have a default constructor, or you may provide some other way of setting the initial state.

The idea of State, Event, and Output is that they are generic types. You don't have to support generics per se, but this means that the user of your state machine will only pass in the type State for states, the type Event for events, and the type Output for outputs. However, the state machine is expected to be "generic" in that it should be possible to use any type as a State, any type as an Event, and any type as an Output.
Additionally, you map implement the map and mapOutput methods in a separate builder class, but I don't foresee that saving any bytes.
Test cases
Note: don't trust my code. It's untested. It's intended mostly to give an idea of what you state machine will be used like
Java, classname StateMachine, initial-state passed via constructor:
// States are ints, Events are chars, Outputs are ints
StateMachine machine = new StateMachine(0);
machine.map(0, '0', 1);
machine.map(0, '1', 2);
machine.map(0, '2', 3);
machine.map(1, '3', 0);
machine.map(1, '4', 2);
machine.map(2, '5', 0);
machine.map(2, '6', 1);
machine.map(2, '7', 2);
machine.mapOutput(1, 1);
machine.mapOutput(2, 10);
machine.mapOutput(3, 0);

// At this point, there should be absolutely no errors at all.
System.out.println(machine.getOutput()); // Should output `null`
machine.processEvent('0'); // Don't count on reference equality here...
System.out.println(machine.getOutput()); // Should output `1`
machine.processEvent('4');
System.out.println(machine.getOutput()); // Should output `10`
machine.processEvent('7');
System.out.println(machine.getOutput()); // Should output `10`
machine.processEvent('6');
System.out.println(machine.getOutput()); // Should output `1`
machine.processEvent('3');
System.out.println(machine.getOutput()); // Should output `null`
machine.processEvent('1');
System.out.println(machine.getOutput()); // Should output `10`
machine.processEvent('5');
System.out.println(machine.getOutput()); // Should output `null`
machine.processEvent('2');
System.out.println(machine.getOutput()); // Should output `0`
// Now any calls to processEvent should cause an exception to be thrown.
machine.processEvent('0'); // Throws an exception or crashes the program.

Ruby, classname SM, initial-state through attr_writer on i:
sm = SM.new
sm.i = :init # All states will be symbols in this case.
[
  [:init, [], :init],
  [:init, [1], :state1],
  [:init, [2, 3], :state2],
  [:state1, [], :init],
  [:state1, [1], :state1],
  [:state1, [2, 3], :state2],
  [:state2, [], :init],
  [:state2, [1], :state1],
  [:state2, [2, 3], :state2]
].each { |from, trigger, to| sm.map(from, trigger, to) }
sm.mapOutput(:state1, [1])
sm.mapOutput(:state2, [[2, 3], 4, 5])

p sm.getOutput # => nil
sm.processEvent []
p sm.getOutput # => nil
sm.processEvent [1]
p sm.getOutput # => [1]
sm.processEvent [1]
p sm.getOutput # => [1]
sm.processEvent [2, 3]
p sm.getOutput # => [[2, 3], 4, 5]
sm.processEvent [2, 3]
p sm.getOutput # => [[2, 3], 4, 5]
sm.processEvent []
p sm.getOutput # => nil
sm.processEvent [2, 3]
p sm.getOutput # => [[2, 3], 4, 5]
sm.processEvent [1]
p sm.getOutput # => [1]
sm.processEvent []
p sm.getOutput # => nil

Note that even though there are only a few test cases, you must support arbitrary input to these functions.

JavaScript (ES6), 132 125 121 109
M=c=>(s={},r={},{map:(f,e,t)=>s[f+e]=t,mapOutput:(s,o)=>r[s]=o,processEvent:e=>c=s[c+e],getOutput:x=>r[c]})

Thanks to edc65 for his suggestion of avoiding the full-fledged constructor approach!
Here's a test snippet that works in Chrome and Firefox:

M=c=>(s={},r={},{map:(f,e,t)=>s[f+e]=t,mapOutput:(s,o)=>r[s]=o,processEvent:e=>c=s[c+e],getOutput:x=>r[c]})

var sm = M('Locked');

var output = '';
var print = t => { output += t + "\n"; }

print(sm.getOutput() || 'not defined (there are no outputs currently defined)');

sm.map('Locked', 'Coin', 'Unlocked');
sm.map('Unlocked', 'Coin', 'Unlocked');
sm.map('Unlocked', 'Push', 'Locked');
sm.map('Locked', 'Push', 'Locked');

sm.mapOutput('Locked', 'Insert coin!');
sm.mapOutput('Unlocked', 'You can pass now.');

function event(name){
  print(' >> ' + name);
  sm.processEvent(name);
}

print(sm.getOutput());
event('Push');
print(sm.getOutput());
event('Coin');
print(sm.getOutput());
event('Coin');
print(sm.getOutput());
event('Push');
print(sm.getOutput());

alert(output);

Do you really need a full fledged constructor here? M=c=>(s={},r={},{map:(f,e,t)=>s[f+e]=t,mapOutput:(s,o)=>r[s]=o,processEvent:e=>c=s[c+e],getOutput:x=>r[c]}) (score 107) then var sm = M('Locked'); (without new) and all seems to work like a charm

@edc65 I have edited the code and the snippet. Thanks!

C# (LinqPad) 318 Bytes
Golfed Version
class S<T,K> where K:Hashtable,new(){public T c;K m=new K(),o=new K();public void Map(T f,char e,T t){if(!m.Contains(f))m.Add(f,new K());((K)m[f]).Add(e,t);}public void MapOutput(int t,object r){o.Add(t,r);}public void ProcessEvent(char e){c=(T)((K)m[c])[e];}public object GetOutput(){return o.Contains(c)?o[c]:null;}}

Ungolfed Version
class S<T,K> where K:Hashtable,new()
{
    public T c;
    K m=new K(),o=new K();
    public void Map(T f,char e,T t){if(!m.Contains(f))m.Add(f,new K());((K)m[f]).Add(e,t);}
    public void MapOutput(int t,object r){o.Add(t,r);}
    public void ProcessEvent(char e){c=(T)((K)m[c])[e];}
    public object GetOutput(){return o.Contains(c)?o[c]:null;}
}

Initialization:
var m = new S<int,Hashtable>();

Setting initial State:
m.c = 0 // or whatever

If you don't use it in LinqPad you've got to add another "using System.Collections;" in front (+25 Bytes)

OCaml, 217
This is an anonymous function which takes the initial state as its sole parameter and returns a newly constructed object. The function/object are polymorphic in the state, event, and output types.
fun i->Hashtbl.(object
val o=create 9
val t=create 9
val mutable s=i
method map a b c=add t(a,b)c
method mapOutput a b=add o a b
method getOutput=try Some(find o s)with _->None
method processEvent e=s<-find t(s,e)end)

For a 200+-byte program, there seemed to be remarkably few opportunities for golfing.
Example usage:
let k =
fun i->Hashtbl.(object
val o=create 9
val t=create 9
val mutable s=i
method map a b c=add t(a,b)c
method mapOutput a b=add o a b
method getOutput=try Some(find o s)with _->None
method processEvent e=s<-find t(s,e)end)
;;

let pr optint = match optint with
    | Some x -> Printf.printf "%d\n" x
    | None -> Printf.printf "None\n" ;;

let machine = k 0;;

machine#map 0  '0'  1 ;;
machine#map 0  '1'  2 ;;
machine#map 0  '2'  3 ;;
machine#map 1  '3'  0 ;;
machine#map 1  '4'  2 ;;
machine#map 2  '5'  0 ;;
machine#map 2  '6'  1 ;;
machine#map 2  '7'  2 ;;
machine#mapOutput 1 1 ;;
machine#mapOutput 2 10 ;;
machine#mapOutput 3 0 ;;
pr machine#getOutput ;;
machine#processEvent '0' ;;
pr machine#getOutput ;;
machine#processEvent '4' ;;
pr machine#getOutput ;;
machine#processEvent '7' ;;
pr machine#getOutput ;;
machine#processEvent '6' ;;
pr machine#getOutput ;;
machine#processEvent '3' ;;
pr machine#getOutput ;;
machine#processEvent '1' ;;
pr machine#getOutput ;;
machine#processEvent '5' ;;
pr machine#getOutput ;;
machine#processEvent '2' ;;
pr machine#getOutput ;;
(* causes exception *)
machine#processEvent '0'

Ruby, 174 bytes
class M
def initialize i
@c=@i=i
@s={}
@o={}
end
def map f,e,t
@s[[f,e]]=t
end
def mapOutput s,o
@o[s]=o
end
def processEvent e
@c=@s[[@c,e]]
end
def getOutput
@o[@c]
end
end

I think the code is pretty self-explanatory. This challenge is not challenging in Ruby.


text:
Ode Golf - Letter Deletions
Given a dictionary file (a text file containing a word or phrase on each line, with possible punctuation but no numbers; lines are alphabetized), you must output each combination of words where one letter can be removed from a word to make another; the removed letter should be encased in parentheses.
For example, the input
cat
cart
code
golf
ode
verify
versify

should give an output of
ca(r)t
(c)ode
ver(s)ify

Multiple ways to get the same pair must only be displayed once. You can output scra(p)ped or scrap(p)ed, but not both.
The output should be ordered alphabetically by the longer entry;
mart
mar
mat
ma

should have an output of
ma(r)
ma(t)
ma(r)t
mar(t)

and the latter two could be in either order.
The dictionary file may include capitalizations, spaces, hyphens, or apostrophes; these should be ignored. For instance,
inlay
in-play

should produce in(p)lay. Your output should all be in the same case. Extra whitespace is allowed.
Input can be STDIN or from a file; it is separated by newlines.
Output can be return value of a function or STDOUT (or written to a file if you wanted).
This is code-golf, so the shortest code in bytes wins.
(This is my first challenge on PPCG - let me know if I've done anything wrong and I'll fix it.)

What should be the output for mart mar mat ma? Would it be mar(t) ma(r)t ma(r) ma(t)?

@Sp: Forgot to specify the order - edited to clarify.

In the first example the word golf isn't in the output. Is that because it's a word that doesn't have other combinations?

@Luk: Yep! For most dictionary files, there will be a lot of words that don't make other words at all - those shouldn't appear anywhere in the output.

Since this is a dictionairy, can we assume the list is already sorted?

@Luk: Yes - I said that in the parentheses at the start, but it was worded in a weird way. Edited to clarify.

What about allowing a function with a (big) string parameter, returning the requested output as a string array? This put the focus on the algorithm, avoiding the need to manage file I/O.

@edc65 The Ruby answers already take an Array as input

@zozo: That title was completely intentional.

Perl -an0, 101+3 bytes
@F=sort{length$a<=>length$b}map{s/\W//g;lc}@F;map{$`.$'~~@F?print"$`($1)$'\n":$\while/(.)(?!\1)/g}@F;

where

@F is the dictionary, stored in an array, provided by runtime flag magic. (b-oost, BoO#@%@#$%$#@T)
map{s/\W//g;lc}@F removes all symbols from the words and turns everything lowercase. (boost, boot)
sort{length$b<=>length$a} sorts on length. (boot, boost)
map{ (...) while/(.)(?!\1)/g}@F matches all characters that aren't followed up by the same character ([b]oot, bo[o]t,boo[t],...)
print"$`($1)$'\n" prints the parts that precede, parenthesize, and succeed a match... (boo(s)t)
if $`.$'~~@F ...if the concatenation of everything before and after the match is in the dictionary. ([boo]s[t])

JavaScript (ES6), 225
A function with a string parameter, no input from file. I asked OP if this could be valid.
Test running the snippet in an EcmaScript 6 compliant browser (implementing arrow functions, template string, spread operator - Firefox, maybe Safari or MS Edge, not Chrome)

f=t=>t.split`
`.map(w=>(d[k=w.replace(/\W/g,'').toLowerCase()]={},k),d={},r=[]).map(w=>[...w].map((c,i,v)=>(d[v[i]='',x=v.join``]&&!d[x][w]&&r.push(d[x][w]=(v[i]=`(${c})`,v.join``)),v[i]=c)))&&r.sort((a,b)=>a.length-b.length)

// LESS GOLFED

Q=t=>{
  // convert to canonical form and put in a dictionary
  // each value in the dictionary is an hashtable tha will store the list
  // of words that can generate the current word, removing a letter
  d={},
  t=t.split`\n`.map(w=>(k=w.replace(/\W/g,'').toLowerCase(),d[k]={},k))
  r=[], // result array
  t.forEach(w =>
    [...w].forEach((c,i,v)=>( // for each letter in word, try to remove
      v[i]='', x=v.join``, // build string with missing letter
      v[i]='('+c+')', y=v.join``, // and build string with brackets
      v[i]=c, // restore the current letter
      d[x] && // if the word with removed letter is present in the dictionary
      !d[x][w] && // and not already from the same generating word
         r.push(d[x][w]=y) // update dictionary and add word to result array
    ))
  )
  return r.sort((a,b)=>a.length-b.length) // sort result by length
}

// TEST
function test() { R.innerHTML=f(I.value) }
textarea { height: 20em }
Test <button onclick="test()">-></button>

<textarea id=I>cat
cart
code
golf
node
scraped
scrapped
verify
versify
mart
mar
mat
ma</textarea>

@ETHproductions right, thx

Ruby, 173
->d{o=[]
c={}
d=d.sort_by{|w|[w.size,w]}.map{|w|w=w.upcase.gsub /[^A-Z]/,''
c[w]=l=1
w.size.times{|i|p,x,s=w[0...i],w[i],w[i+1..-1]
c[p+s]&&l!=x&&o<<p+"(#{w[i]})"+s
l=x}}
o}

Test it here: http://ideone.com/86avbe
Readable version here: http://ideone.com/ynFItB

On mobile so I can't test right now - could you add a test case for the SCRAPPED/SCRAPED one?

@Deusovi That case does not work correctly. I'm fixing it now...

@Deusovi Updated!

This answer does not provide correct output for e.g. the ['jacklantern','jackslantern','jack-o-lantern'] dict.

@14mRh4X0r I think the program returns the correct result for that test case (["JACK(S)LANTERN", "JACK(O)LANTERN"]). What do you think?

@w0lf According to the question, it has to be ordered alphabetically after length

@14mRh4X0r can't find that request in the question ... The output should be ordered by the longer entry; ... and the latter two could be in either order.

@edc65 the latter two exactly, so not the first two, which are in alphabetical order.

@14mRh4X0r then again: I can't find that request in the question. The order of the first two is not explicitly specified. I'll wait for a specification by OP

@edc65 Fair enough; let's wait for clarification.
To lighten the mood a bit: @w0lf You can shorten your answer by using [-' ] instead of [^A-Z], the question states that you should (only) ignore those characters, beside the capitalisation

Ruby, 211
I decided I'd take a different approach to solve this, using regex.
->d{o=[]
d.map{|x|x.upcase!.gsub! /[-' ]/,''}
d.map{|x|(x.size+1).times{|i|o+=d.map{|w|w.b.sub! /(#{x[0...i]})(.)(#{x[i..-1]})/,'\1(\2)\3'if w[i]!=w[i+1]}}}
o.compact.sort_by{|w|[w.size,w.gsub(/[()]/,'')]}.uniq}

Perl 5, 210
The code loads the input in an sorted array, and checks for each value against all values in the array that are 1 byte longer.
map{@W=split//,$w=$_;map{@X=split//,$x=$_;if(@W+1==@X){$i=0;while($W[$i]eq$X[$i]&&$i<@W){$i++}$c=$X[$i];$e=substr($w,$i);print substr($w,0,$i)."($c)$e\n",if substr($x,$i+1)eq$e}}@D}@D=sort(map{s/[^\w]//g;lc}<>)

Test
$ perl dictionairy_same_words.pl dictionairywords.txt
ca(r)t
in(p)lay
ma(r)
ma(t)
mar(t)
ma(r)t
(c)ode
ver(s)ify

Haskell, 201 bytes
import Data.List
import Data.Char
a#(b:c)=(a,b,c)
g a=[l++'(':m:')':n|x<-a,((l,m,n):_)<-[[o|o@(i,j,k)<-zipWith(#)(inits x)$init$tails x,elem(i++k)a]]]
f=sortOn length.g.map(filter isLetter.map toLower)

I'm not sure what input format is allowed. f takes a list of strings. If only a single string (with nl separated words) is allowed, add .lines to f (+6 bytes).
Usage example:
f ["cat","cart","code","golf","od-e","verify","versify","on","s-o-n","Scrapped","scraped"]

["(s)on","ca(r)t","(c)ode","ver(s)ify","scra(p)ped"]

How it works: turn every word to lowercase and keep only the letters. Split every word x into two parts at every possible position and make triples (i,j,k) where i is the first part, j is the first character of the second part and k is the tail of the second part. Keep the triples where i++k also appears in the word list. If this list is non-empty, take the first element, call it (l,m,n). Turn all those list heads into the required output format by surrounding m with () and putting it between l and n.


text:
EOC Vault Password Rank 3 Puzzle - Vault Password
The shortest reliable password testing code
Introduction
I started playing Empire of Code recently, and there was some challenge. The player is supposed to write a piece of Python or Javascript code to detect if the string passed to it is reliable password, that is, it contains at least one lowercase Latin letter, one uppercase Latin letter and one digit and has at least 10 characters.
It was quite easy for me to fit within the 130 characters limit for rank 3 using Javascript, however, I spent a lot of time trying to fit within the 100 characters limit for rank 3 using Python. Some guy said that he has managed to fit in 71 characters for Python. I tried hard but still couldn't reduce the code to less than 90 characters. Is it possible to use even less than 71 characters?
Winning condition:
The shortest Python code (or Javascript), which solves given problem, wins. You may assume whatever was assumed in the original problem description in the game, given below.
Remark: The solution should define a function or method called "golf" which takes the password as the first parameter and returns a boolean value indicating whether the given password satisfies the criterion.

Challenge Vault Password
[The following description is merged from two versions of the problem description (for Python and
  for Javascript), copied from the game site
  https://empireofcode.com/ ]
We've installed a new vault to contain our valuable resources and
  treasures, but before we can put anything into it, we need a suitable
  password for our new vault. One that should be as safe as possible.
The password will be considered strong enough if its length is greater
  than or equal to 10 characters, it contains at least one digit, as
  well as at least one uppercase letter and one lowercase letter. The
  password may only contain ASCII latin letters or digits, no
  punctuation symbols.
You are given a password. We need your code to verify if it meets the
  conditions for a secure password.
In this mission the main goal to make your code as short as possible.
  The shorter your code, the more points you earn. Your score for this
  mission is dynamic and directly related to the length of your code.
Input: A password as a string.
Output: A determination if the password safe or not as a boolean, or any data type that can be converted and processed as a boolean.
  When the results process, you will see the converted results.
Example:
golf('A1213pokl') === false
golf('bAse730onE') === true
golf('asasasasasasasaas') === false
golf('QWERTYqwerty') === false
golf('123456123456') === false
golf('QwErTy911poqqqq') === true
Precondition:
0 < |password| ≤ 64
The password matches the regexp expression "[a-zA-Z0-9]+"
Scoring:
Scoring in this mission is based on the number of characters used in
  your code (comment lines are not counted).
Rank1:
Any code length.
Rank2:
Your code should be shorter than 230 characters for Javascript code or
  shorter than 200 characters for Python code.
Rank3:
Your code should be shorter than 130 characters for Javascript code or
  shorter than 100 characters for Python code.

Python, 59 bytes
golf=lambda s:(9<len(s))*(s.lower()>s>s.upper())*'?'>min(s)

(Still) probably not optimal.

I think the first part can just be (min(s)<'A')*.

I think you can use > instead of !=.

Both versions work.
Can anyone explain why this work?
golf=lambda s:(min(s)<'A')(s.lower()!=s!=s.upper())(9<len(s))
ok! Got it! If we convert string to lowercase and there are uppercase characters, string wouldn't match itself, and if we convert string to uppercase which has lowercase characters, it wouldn't match itself.

Thanks @xnor and @Maltysen. I have shaved off 10 bytes now.`

JavaScript ES6, 67 - ES5, 88
Slightly longer than necessary as it has to return a proper true/false value (not truthy/falsy)

// MORE COMMON JAVASCRIPT - ECMASCRIPT 5 - 88 byte
function golf(p){return!(!~(p.search(/\d/)|p.search("[a-z]")|p.search("[A-Z]"))||!p[9])}

// NEWEST JAVASCRIPT - ECMASCRIPT 6 - 67 byte
/*
golf=p=>!(!~(p.search`\\d`|p.search`[a-z]`|p.search`[A-Z]`)||!p[9])
*/

// Explanation
// search gives -1 if not found, if any of search results is -1 then ORing we have a result of -1
// ~ operator is 0 if and only if operand is -1
// !p[9] is true if the string has less than 10 characters

// TEST
function out(x) {
  O.innerHTML += x + '\n'
};

;[['A1213pokl',0],['bAse730onE',1],['asasasasasasasaas',0],['QWERTYqwerty',0],['123456123456',0],['QwErTy911poqqqq',1]]
.forEach(function(pwd){out(pwd[0]+' '+!!pwd[1]+' '+golf(pwd[0]))})

JavaScript – 83 bytes
function golf(x){return!!(/\d/.test(x)&/[a-z]/.test(x)&/[A-Z]/.test(x)&x.length>9)}

How about /(?=.*\d)(?=.*[a-z])(?=.[A-Z]).{10}/.test(x)

function golf(x){return!!(/\d/.test(x)&/[a-z]/.test(x)&/[A-Z]/.test(x)&&x[9])} (my personal battle against the lengthy length) (+1 anyway)

@MartinBüttner - can't get yours to work on PHP online. I think your regex skills are too advanced!

@edc65 - I tried that, it always seems to return 0/false?

Did you tried exaclty as I wrote it? It works! x[9] returns a 1 character string (=truthy) if the length is > 9 and an empty string (=falsy) if the length is <= 9. Must be checked with && to avoid conversion to number, as '0' converted to number is falsy.

Python, 83 bytes
Alternatively, you can try this (93 bytes):
import re
def golf(p):
    return bool(re.findall(r'(?=.*[a-z])(?=.*[A-Z])(?=.*\d).{10,}',p))

or (83 bytes)
import re
golf=lambda p:bool(re.findall(r'(?=.*[a-z])(?=.*[A-Z])(?=.*\d).{10,}',p))

Try it online!

Hi, welcome to PPCG! I took the liberty to format your answer a bit (make sure to look at the edit so you can do this yourself next time). I've added #Python, 83 bytes which is standard for code-golf answers on this site. I've also used four spaces as code instead of the back-ticks. As for your answer, you can golf it to import re golf=lambda p:[p]==re.findall('(?=.*[a-z])(?=.*[A-Z])(?=.*\d).{10,}',p) (81 bytes)

The solution on Python I could implement, 90 bytes
import re
golf=lambda p:re.compile(r'(?=.{10,})(?=.*\d)(?=.*[a-z])(?=.*[A-Z])').search(p)

From what I can tell, this answer doesn't check for non-alphanumeric characters which should fail the test?

it checks: (?=.\d) checks for presence of digits, (?=.[a-z]) checks for presence of lower latin letters and (?=.*[A-Z]) checks for presence of upper latin letters. Anyway, this solution is too lengthy

@Dendrobium - Precondition is the password matches the regexp expression "[a-zA-Z0-9]+".

Slightly improved regex-based solution:
golf=re.compile('(?=.*[a-z])(?=.*[A-Z])(?=.*\d).{10,}').search


text:
Lisp Extraction Mission
In Lisp style languages, a list is usually defined like this:
(list 1 2 3)

For the purposes of this challenge, all lists will only contain positive integers or other lists. We will also leave out the list keyword at the start, so the list will now look like this:
(1 2 3)

We can get the first element of a list by using car. For example:
(car (1 2 3))
==> 1

And we can get the original list with the first element removed with cdr:
(cdr (1 2 3))
==> (2 3)

Important: cdr will always return a list, even if that list would have a single element:
(cdr (1 2))
==> (2)
(car (cdr (1 2)))
==> 2

Lists can also be inside other lists:
(cdr (1 2 3 (4 5 6)))
==> (2 3 (4 5 6))

Write a program that returns code that uses car and cdr to return a certain integer in a list. In the code that your program returns, you can assume that the list is stored in l, the target integer is in l somewhere, and that all the integers are unique.
Examples:
Input: (6 1 3) 3
Output: (car (cdr (cdr l)))
Input: (4 5 (1 2 (7) 9 (10 8 14))) 8
Output: (car (cdr (car (cdr (cdr (cdr (cdr (car (cdr (cdr l))))))))))
Input: (1 12 1992) 1
Output: (car l)

Can we take input with the integer first and the list second?

@MartinBüttner Sure.

What about (1 2 3) 16, shall we return ()?

@coredump Good question. You can assume that the target integer will always be in the expression, so a case like (1 2 3) 16 will never show up.

Can we receive two inputs, one for the list and one for the integer?

Is the list always a list (and not just a number)? Can any of the sublists be empty? Can I use square brackets for the input?

May we assume that the list is properly formatted just like in the question (so always one space between elements, no spaces between ), etc.

Similarly, can we assume a different whitespace format? E.g. spaces around parentheses, or one space after each list element (e.g. (1 (2 3 ) ))?

@Blackhole No, it goes in on one input.

@orlp Yes, you can assume the lisp will always be properly formatted.

@MartinBüttner No, the only format that will be present is the one used in the examples -- that is, one space between each element, and no spaces between parentheses.

@aditsu The list is always a list. The sublists won't be empty. You cannot use square brackets for the input.

This invalidates a lot of answers, then. I don't think you can maintain that this way.

@Blackhole Ah, does it? I'm not familiar with most of the languages used in the answers. I'll retract my previous statement then.

CJam, 59
q"()""[]"er~{:AL>{0jA1<e_-_A(?j'l/"(car l)"@{2'dt}&*}"l"?}j

Try it online
Explanation:
q                 read the input
"()""[]"er        replace parentheses with square brackets
~                 evaluate the string, pushing an array and a number
{…}j              calculate with memoized recursion using the array as the argument
                   and the number as the memozied value for argument 0
  :A              store the argument in A
  L>              practically, check if A is an array
                   if A is a (non-empty) array, compare with an empty array
                   (result 1, true)
                   if A is a number, slice the empty array from that position
                   (result [], false)
    {…}           if A is an array
      0j          get the memoized value for 0 (the number to search)
      A1<         slice A keeping only its first element
      e_          flatten array
      -           set difference - true iff the number was not in the array
      _           duplicate the result (this is the car/cdr indicator)
      A(          uncons A from left, resulting in the "cdr" followed by the "car"
      ?           choose the cdr if the number was not in the flattened first item,
                   else choose the car
      j           call the block recursively with the chosen value as the argument
      'l/         split the result around the 'l' character
      "(car l)"   push this string
      @           bring up the car/cdr indicator
      {…}&        if true (indicating cdr)
        2'dt      set the character in position 2 to 'd'
      *           join the split pieces using the resulting string as a separator
    "l"           else (if A is not an array) just push "l"
                   (we know that when we get to a number, it is the right number)
    ?             end if

Common Lisp, 99
The following 99 bytes solution is a CL version of the nice Scheme answer.
(defun g(l n &optional(o'l))(if(eql n l)o(and(consp l)(or(g(car l)n`(car,o))(g(cdr l)n`(cdr,o))))))

I originally tried to make use of position and position-if, but it turned out to be not as compact as I would have liked (209 bytes):
(lambda(L x &aux(p'l))(labels((f(S &aux e)(cons(or(position x S)(position-if(lambda(y)(if(consp y)(setf e(f y))))S)(return-from f()))e)))(dolist(o(print(f L))p)(dotimes(i o)(setf p`(cdr,p)))(setf p`(car,p)))))

Expanded
(lambda
  (l x &aux (p 'l))
  (labels ((f (s &aux e)
             (cons
              (or (position x s)
                  (position-if
                   (lambda (y)
                     (if (consp y)
                         (setf e (f y))))
                   s)
                  (return-from f nil))
              e)))
    (dolist (o (print (f l)) p)
      (dotimes (i o) (setf p `(cdr ,p)))
      (setf p `(car ,p)))))

Example
(funcall *fun* '(4 5 (1 2 (7) 9 (10 8 14))) 14)

The list is quoted, but if you really want, I can use a macro.
The returned value is[1]:
(CAR (CDR (CDR (CAR (CDR (CDR (CDR (CDR (CAR (CDR (CDR L)))))))))))

For tests, I used to generate a lambda form where l was a variable:
(LAMBDA (#:G854) (CAR (CDR (CDR (CAR (CDR (CDR (CDR (CDR (CAR (CDR (CDR #:G854))))))))))))

Calling this with the original list returns 14.

[1] (caddar (cddddr (caddr l))) would be nice too

You answered a question about Lisp with Lisp! It's Lisp-ception!

@DanTheMan Lisp-ception is pretty much what defines Lisp ;-)

Retina, 170 142 125 115 114 87 84 83 75 73 70 69 68 67 bytes
Yay, less than 50% of more than 100 bytes off my first attempt. :)
\b(.+)\b.* \1$
(
^.
l
\(
a
+`a *\)|\d

d
+`(.*[l)])(\w)
(c$2r $1)

To run the code from a single file, use the -s flag.
I'm still not convinced this is optimal... I won't have a lot of time over the next few days, I will add an explanation eventually.

Pyth, 62 bytes
JvXz"() ,][")u?qJQG&=J?K}Quu+GHNY<J1)hJtJ++XWK"(cdr "\d\aG\)\l

Try it online: Demonstration or Test Suite
Explanation:
The first bit JvXz"() ,][") replaces the chars "() " with the chars "[]," in the input string, which ends up in a representation of a Python-style list. I evaluate it and store it in J.
Then I reduce the string G = "l" with u...\l. I apply the inner function ... repeatedly to G, until the value of G doesn't change anymore and then print G.
The inner function does the following: If J is already equal to the input number, than don't modify G (?qJQG). Otherwise I'll flatten the the list J[:1] and check if the input number is in that list and save this to the variable K (K}Quu+GHNY<J1)). Notice that Pyth doesn't have a flatten operator, so this is takes quite a few bytes. If K is true, than I update J with J[0], otherwise with J[1:] (=J?KhJtJ). And then I replace G with "(cdr G)" and replace the d the a, if K is true (++XWK"(cdr "\d\aG\)).

Scheme (R5RS), 102 bytes
(let g((l(read))(n(read))(o'l))(if(pair? l)(or(g(car l)n`(car,o))(g(cdr l)n`(cdr,o)))(and(eq? n l)o)))

PHP - 177 bytes
I've added some newlines for readability:
function f($a,$o,$n){foreach($a as$v){if($n===$v||$s=f($v,$o,$n))return
'(car '.($s?:$o).')';$o="(cdr $o)";}}function l($s,$n){echo f(eval(strtr
("return$s;",'() ','[],')),l,$n);}

Here is the ungolfed version:
function extractPhp($list, $output, $number)
{
    foreach ($list as $value)
    {
        if (is_int($value))
        {
            if ($value === $number) {
                return '(car '. $output .')';
            }
        }
        else
        {
            $subOutput = extractPhp($value, $output, $number);
            if ($subOutput !== null) {
                return '(car '. $subOutput .')';
            }
        }

        $output = '(cdr '. $output .')';
    }
}

function extractLisp($stringList, $number)
{
    $phpCode = 'return '. strtr($stringList, '() ','[],') .';';
    $list = eval($phpCode);
    echo extractPhp($list, 'l', $number);
}

Haskell, 190 188 bytes
l "(4 5 (1 2 (7) 9 (10 8 14)))" 8
evaluates to
"(car (cdr (car (cdr (cdr (cdr (cdr (car (cdr (cdr l))))))))))"
l(h:s)n=c$i(show n)s""""
i n(h:s)t l|h>'/'&&h<':'=i n s(t++[h])l|t==n='a':l|h=='('=j$'a':l|h==')'=j$tail$dropWhile(=='d')l|0<1=j$'d':l where j=i n s""
c[]="l"
c(h:s)="(c"++h:"r "++c s++")"

You can turn (and c in function c into a string: c(h:s)="(c"++h:...

Wow, didn't think that would work with h being a Char!

Common Lisp, 168 155 bytes
Some stupid recursion thing, it could probably be condensed a bit more:
(lambda(l e)(labels((r(l o)(setf a(car l)d(cdr l)x`(car,o)y`(cdr,o))(if(equal e a)x(if(atom a)(r d y)(if(find e l)(r d y)(if d(r d y)(r a x)))))))(r l'l)))

Pretty printed:
(lambda (l e)
  (labels ((r (l o)
             (setf a (car l) d (cdr l)
                   x `(car ,o) y `(cdr ,o))
             (if (equal e a) x
                 (if (atom a)
                     (r d y)
                     (if (find e l)
                         (r d y)
                         (if d
                             (r d y)
                             (r a x)))))))
    (r l 'l)))


text:
Hidden Power Calculator
One of the reasons I've always loved Pokemon is because for such a simple-seeming game, it has so many layers of complexity. Let's consider the move Hidden Power. In game, the type and power (at least before Generation VI) of Hidden Power is different for every Pokemon that uses it! That's pretty cool, right? Now, would you be surprised if I told you that the type and power of Hidden Power isn't generated randomly?
In all Pokemon games, all Pokemon (not just ones in your party, ALL POKEMON) have six internally-stored integers (one for the HP stat, one for the attack stat, one for the defense stat, one for the special attack stat, one for the special defense stat and one for the speed stat) called their individual values, or IVs. These values range between 0 and 31, and they essentially are one of a few factors that influence a Pokemon's overall stats. HOWEVER, they also determine the type and power of Hidden Power!
In Generation III to V (the generations whose algorithm we'll be implementing), the type of Hidden Power is determined by the following formula (note the floor brackets, that means you need to round down the result):

where a, b, c, d, e and f are the least significant bits of  the HP, Attack, Defense, Speed, Sp. Attack, and Sp. Defense IVs respectively. (Least significant bit is IV mod 2.) The number produced here then can be converted to the actual type using this chart:
0 Fighting
1 Flying
2 Poison
3 Ground
4 Rock
5 Bug
6 Ghost
7 Steel
8 Fire
9 Water
10 Grass
11 Electric
12 Psychic
13 Ice
14 Dragon
15 Dark

For power, a similar formula is used:

Here, however, u, v, w, x, y and z represent the second least significant bit of the HP, Attack, Defense, Speed, Sp. Attack and Sp. Defense IVs (in that order again). (Second least significant bit is more complicated then least significant bit. If IV mod 4 is 2 or 3, then the bit is 1, otherwise it is 0. If your language has some sort of built-in or at least a more clever way to do this, you should probably use it.)

So, as you probably figured out already, the challenge here is to write a program that takes in six integers separated by spaces via STDIN that represent the HP, Attack, Defense, Speed, Sp. Attack and Sp. Defense IVs of a Pokemon (in that order) and output the type and power of that Pokemon's Hidden Power.
Sample input:
30 31 31 31 30 31

Sample output:
Grass 70

Sample input:
16 18 25 13 30 22

Sample output:
Poison 61

This is code-golf, so shortest code wins. Good luck!
(And before people ask, I used the Generation V algorithm here because Generation VI gets rid of the power randomization and makes it always 60. Not only do I think this is incredibly lame, I think it makes the challenge a LOT LESS INTERESTING. So for the purposes of the challenge, we're running a Gen V game.)

Sorry, I left out the sample input and output by mistake. Here you go.

Some additional test samples would be nice :).

Yes, my bad. Fixed.

I'd like to see a challenge about MissingNo.

That might happen next ;)

Added another example.

Pyth, 110 bytes
J+dGA.b/*iN2CY63Cm_+0jd2_Q"("r@cs@LJjC"!�W��Zm�����A�zB0i��ȏ\"���?wC�ǀ�-#ך
?ЫܦO@�J/m���#"26)G3+30H

This contains unprintable chars. So here's a hexdump:
00000000: 4a 2b 64 47 41 2e 62 2f 2a 69 4e 32 43 59 36 33  J+dGA.b/*iN2CY63
00000010: 43 6d 5f 2b 30 6a 64 32 5f 51 22 0f 28 22 72 40  Cm_+0jd2_Q".("r@
00000020: 63 73 40 4c 4a 6a 43 22 10 21 de 57 ad c8 5a 1c  cs@LJjC".!.W..Z.
00000030: 10 6d e0 d6 12 f6 80 bc 41 85 7a 42 30 69 ae 80  .m......A.zB0i..
00000040: c8 8f 5c 22 a0 84 ab 3f 77 43 01 ca c7 80 d0 1d  ..\"...?wC......
00000050: 2d 23 d7 9a 0a 3f d0 ab dc a6 4f 40 b9 4a 2f 6d  -#...?....O@.J/m
00000060: d2 ca c6 23 22 32 36 29 47 33 2b 33 30 48        ...#"26)G3+30H

You can also download the file pokemon.pyth and run it with python3 pyth.py pokemon.pyth
The input 30, 31, 31, 31, 30, 31 prints
Grass
70

Explanation:
J+dGA.b/*iN2CY63Cm_+0jd2_Q".("
J+dG                            store the string " abc...xyz" in J
                 m      _Q      map each number d in reverse(input list) to:
                     jd2          convert d to base 2
                   +0             add a zero (list must have >= 2 items)
                  _               reverse the list
                C               zip
                          ".("  string with the ascii values 15 and 40
     .b                         map each N of ^^ and Y of ^ to:
         iN2                       convert N from base 2 to base 10
        *   CY                     multiply with the ascii value of Y
       /      63                   and divide by 63
    A                           G, H = ^

r@cs@LJjC"longstring"26)G3+30H
        C"longstring"           interpret the string as bytes and convert
                                from base 256 to base 10
       j             26         convert to base 26
   s@LJ                         lookup their value in J and create a string
                                this gives "fighting flying ... dark"
  c                    )        split by spaces
 @                      G       take the Gth element
r                        3      make the first letter upper-case and print
                          +30H  print 30 + H

I find it rather amusing that your file extension for pyth files is more verbose than python's file extension :^)

Ruby, 210
a=$*.map.with_index{|a,i|[a.to_i%2<<i,a.to_i[1]<<i]}.transpose.map{|a|a.inject &:+}
$><<"#{%w(Fighting
Flying
Poison
Ground
Rock
Bug
Ghost
Steel
Fire
Water
Grass
Electric
Psychic
Ice
Dragon
Dark)[a[0]*15/63]} #{a[1]*40/63+30}"

First time golfing, so I guess this is pretty obvious solution.

CJam, 140 115 bytes
q~]W%_1f&2bF*63/"GMÿD>BÙl½}YÛöí6P¶;óKs¯¿/·dÇ¯ã®Å[YÑÌÞ%HJ9¹G4Àv"256b25b'af+'j/=(euooSo2f/1f&2b40*63/30+

Note that the code contains unprintable characters.
Try it online in the CJam interpreter: Chrome | Firefox

Wow, that was fast. Nice job!

Javascript (ES6), 251 bytes
Kinda long, at least for now. The list of types and the complex maths take up about the same amount of space. I'm looking for ways to shorten either/both of them.
x=>([a,b,c,d,e,f]=x.split` `,`Fighting
Flying
Poison
Ground
Rock
Bug
Ghost
Steel
Fire
Water
Grass
Electric
Psychic
Ice
Dragon
Dark`.split`
`[(a%2+b%2*2+c%2*4+d%2*8+e%2*16+f%2*32)*5/21|0]+' '+((a/2%2+(b&2)+(c&2)*2+(d&2)*4+(e&2)*8+(f&2)*16)*40/63+30|0))

As usual, suggestions welcome!

Javascript (ES6), 203 bytes
f=(...l)=>(q=(b,m)=>~~(l.reduce((p,c,x)=>p+(!!(c&b)<<x),0)*m/63),'Fighting0Flying0Poison0Ground0Rock0Bug0Ghost0Steel0Fire0Water0Grass0Electric0Psychic0Ice0Dragon0Dark'.split(0)[q(1,15)]+' '+(q(2,40)+30))

Example runs:
f(30,31,31,31,30,31)
> "Grass 70"

f(16,18,25,13,30,22)
> "Poison 61"