[Question]
  [
It is in my humble opinion that standard text is boring. Therefore I propose a new writing standard, walking words!
### Walking words
Walking words are words which will respond to certain characters. For the purpose of this challenge the trigger characters are `[u, d, r, l]` from `up down right left`.
Whenever you encounter such a character when printing text, you will move the direction of the text.  
For example, the text `abcdef` will result in: 
```
abcd
   e
   f
```
### Rules
* Both uppercase `UDRL` and lowercase `udrl` should change the direction, but case should be preserved in the output
* Input will only contain printable characters `(0-9, A-Z, a-z, !@#%^&*() etc...)`, no newlines!
* Whenever the text will collide, it will overwrite the old character at that position
* Output should be presented to the user in any fashionable matter, but it should be a single output (no array of lines)
* Trailing and leading newlines are allowed
* Trailing spaces are allowed
* Standard loopholes apply
### Test cases
```
empty input => empty output or a newline
u =>
u
abc =>
abc
abcd =>
abcd
abcde =>
abcd
   e
abcdde =>
abcd
   d
   e
codegolf and programming puzzles =>
   cod
     e
     g
     o
dna fl    sel
            z
p           z
rogramming pu
ABCDELFUGHI =>
 I
AHCD
 G E
 UFL
It is in my humble opinion that standard text is boring. Therefore I propose a new writing standard, walking words! =>
dnats taht noinipo el
a                   b
rd                  m
       It is in my hu
 t
 e
 x
 t
 i
 s
 b
 o
 ring. Therefore I propose a new writing stand
                                             a
                                             rd
                                              ,
                                              w
                                              a
                                      rdw gnikl
                                       s
                                       !
```
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), shortest code in bytes wins!
  
[Answer]
# [Dyalog APL](http://goo.gl/9KrKoM), 63 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319)
`s@(n+11 9∘○¨+\0j1*⊃¨,⍨\(8∘≠⍴¨⊢)0,'rdluRDLU'⍳¯1↓s)⍴∘'',⍨2×n←≢s←⍞`
uses `⎕IO←0` and features from v16 (`@`)
`n←≢s←⍞` raw input `s` and its length `n`
`⍴∘'',⍨2×n` create a 2n by 2n matrix of spaces
`s@(...)` amend the matrix with the characters of `s` at the specified (pairs of) indices
how the indices are computed:
`¯1↓s` drop the last char of `s`
`'rdluRDLU'⍳'` encode `'r'` as 0, `'d'` as 1, etc; other chars as 8
`0,` prepend a 0
`(8∘≠⍴¨⊢)` turn every 8 into an empty list, all others into a 1-element list
`,⍨\` cumulative swapped concatenations (`abcd` -> `a ba cba dcba`)
`⊃¨` first from each
`0j1*` imaginary constant i to the power of
`+\` cumulative sums
`11 9∘○¨` real and imaginary part from each; get coords in the range `-n`...`n`
`n+` centre them on the big matrix
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~29~~ ~~27~~ ~~20~~ 19 bytes
```
ＦＳ«Ｆ№rdlu↧ι≔ιω✳∨ωrι
```
[Try it online!](https://tio.run/##HY1BCsIwEADP7SuWnDYQX@BJKoggWPAFIU3rQpqVTWKh4ttj8DrMMO5pxbENtc4sgNf4KvmRheKCWsOn7/544BIzKplCUQZuvHlxNnkk3aRTSrREJAObPvbd2OKMZxLvMnHEu@BmQInS2gA141vrKLyIXde2gbHse/AJbJxg4MnDhcPc18M7/AA "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
ＦＳ«
```
Loop over the input characters.
```
Ｆ№rdlu↧ι
```
If the current letter is a direction...
```
≔ιω
```
then update the current walking direction.
```
✳∨ωrι
```
Print the character in the current walking direction, defaulting to right if no direction has been set yet.
[Answer]
# Pyth, ~~68~~ 65 bytes
```
KUJ,00ImXH~+VJ=@as_BM_MBU2Kx"rdlu"rd0dzjcsm.x@Hd;*Fm=Z}hdedSMCHlZ
```
[Test suite](https://pyth.herokuapp.com/?code=KUJ%2C00ImXH~%2BVJ%3D%40as_BM_MBU2Kx%22rdlu%22rd0dzjcsm.x%40Hd%3B%2aFm%3DZ%7DhdedSMCHlZ&test_suite=1&test_suite_input=%0Au%0Aabc%0Aabcd%0Aabcde%0Aabcdde%0Acodegolf+and+programming+puzzles%0AABCDELFUGHI%0AIt+is+in+my+humble+opinion+that+standard+text+is+boring.+Therefore+I+propose+a+new+writing+standard%2C+walking+words%21&debug=0)
This uses a dictionary, indexed by a pair of coordinates, that is updated as the input read, then printed at the end. It also uses a ton of clever golfing tricks.
Here's how I wrote it, using the interpreter's `-m` flag to strip the whitespace and comments before running:
```
KUJ,00                 ; Initialize J to [0, 0] and K to [0, 1].
                       ; J is the current location, K is the current direction.
I                      ; If the following is truthy, which will be when the input
                       ; is nonempty,
  m                    ; Map d over z, the input.
  XH                   ; Assign to H (a hash table, initially empty)
    ~+VJ               ; At location J, then update J by adding elementwise
      =@               ; K (Next variable is implicit), which is set to
        as_BM_MBU2K    ; [0, 1], bifurcated on mapped negation, then mapped on
                       ; reversal bifuraction with the old value of K appended.
                       ; e.g. [[0, 1], [1, 0], [0, -1], [-1, 0], K]
        x"rdlu"rd0     ; indexed at location equal to the index of the lowercase
                       ; of the current character into "rdlu", -1 if missing.
    d                  ; Insert the current character with that key.
  z                    ; map over z.
jc                     ; Join on newlines the result of chopping into a rectangle
  sm                   ; the concatenation of the map
    .x@Hd;             ; Lookup the character at the given location,
                       ; if none then ' '
    *Fm                ; Locations are the cartesian product of the map
      =Z}hded          ; Inclusive range from the head of each list to 
                       ; the end of each list
                       ; Saved in Z for later
      SMCH             ; Transpose the list of keys, and sort the x and y values
                       ; separately.
  lZ                   ; Width of the rectangle should equal the number of
                       ; x values, which is the length of the last entry.
```
[Answer]
# C#, 525 474 Bytes
*Edit: Saved 51 Bytes thanks to @steenbergh*
*It's not pretty, but it does work...*
Golfed:
```
string W(string s){var l=s.Length;var a=new char[2*l+1,2*l+1];int x=2*l/2;int y=2*l/2;int d=0;for(int i=0;i<l;i++){switch(char.ToUpper(s[i])){case'U':d=3;break;case'D':d=1;break;case'L':d=2;break;case'R':d=0;break;}a[y,x]=s[i];switch(d){case 0:x+=1;break;case 1:y+=1;break;case 2:x-=1;break;case 3:y-=1;break;}}string o="";for(int i=0;i<2*l+1;i++){string t="";for(int j=0;j<2*l+1;j++)t+=a[i,j]+"";o+=t==string.Join("",Enumerable.Repeat('\0',2*l+1))?"":(t+"\r\n");}return o;}
```
Ungolfed:
```
public string W(string s)
{
  var l = s.Length;
  var a = new char[2 * l + 1, 2 * l + 1];
  int x = 2 * l / 2;
  int y = 2 * l / 2;
  int d = 0;
  for (int i = 0; i < l; i++)
  {
    switch (char.ToUpper(s[i]))
    {
      case 'U':
        d = 3;
        break;
      case 'D':
        d = 1;
        break;
      case 'L':
        d = 2;
        break;
      case 'R':
        d = 0;
        break;
    }
    a[y, x] = s[i];
    switch (d)
    {
      case 0:
        x += 1;
        break;
      case 1:
        y += 1;
        break;
      case 2:
        x -= 1;
        break;
      case 3:
        y -= 1;
        break;
    }
  }
  string o = "";
  for (int i = 0; i < 2 * l + 1; i++)
  {
    string t = "";
    for (int j = 0; j < 2 * l + 1; j++)
      t += a[i, j] + "";
    o += t == string.Join("", Enumerable.Repeat('\0', 2 * l + 1)) ? "" : (t + "\r\n");
  }
  return o;
}
```
Explanation:
Uses a two-dimensional array and the `d` value to increment the position of the array in the correction direction, where d values are:
```
0 => RIGHT
1 => DOWN
2 => LEFT
3 => UP
```
Test:
```
var walkTheWords = new WalkTheWords();
Console.WriteLine(walkTheWords.W("codegolf and programming puzzles"));
                            cod                              
                              e                              
                              g                              
                              o                              
                         dna fl    sel                       
                                     z                       
                         p           z                       
                         rogramming pu  
```
[Answer]
# JavaScript (ES6), 218 ~~220 232~~
**Edit** I was using `u` and `t` to keep track of the top and leftmost position, but I realized that `t` is not needed at all
```
w=>[...w].map(c=>u=(((g[y]=g[y]||[])[x]=c,n=parseInt(c,36)|0)-21&&n-27?a=n-13?n-30?a:!(b=-1):!(b=1):(b=0,a=n/3-8),y+=b,x+=a)<u?x:u,a=1,b=0,x=y=u=w.length,g=[])+g.map(r=>[...r.slice(u)].map(c=>z+=c||' ',z+=`
`),z='')&&z
```
*Less golfed*
```
w=>{
  a = 1, b = 0;
  x = y = u = w.length;
  g = [];
  [...w].map(c => (
    r = g[y]||[],
    r[x] = c,
    g[y] = r,
    n = parseInt(c,36)|0,
    n-21 && n-27 ? n-13 && n-30?0 : (a=0, b=n-13?-1:1) : (b=0, a=n/3-8),
    x += a, u = x<u? x : u,
    y += b
  ))
  z=''
  g.map(r=>[...r.slice(u)].map(c=>z += c||' ', z += '\n'))
  return z
}             
```
**Test**
```
F=
w=>[...w].map(c=>u=(((g[y]=g[y]||[])[x]=c,n=parseInt(c,36)|0)-21&&n-27?a=n-13?n-30?a:!(b=-1):!(b=1):(b=0,a=n/3-8),y+=b,x+=a)<u?x:u,a=1,b=0,x=y=u=w.length,g=[])+g.map(r=>[...r.slice(u)].map(c=>z+=c||' ',z+=`
`),z='')&&z
function update() {
  w=I.value
  O.textContent=F(w)
}
update()
```
```
#I {width:90%}
```
```
<input id=I value='It is in my humble opinion that standard text is boring. Therefore I propose a new writing standard, walking words!' oninput='update()'>
<pre id=O></pre>
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~27 26 25 23~~ 22 bytes
Saved 3 bytes thanks to *Grimy*
```
ā¤‹>Šε’uÏ‡’slkDÈiV}Y}Λ
```
[Try it online!](https://tio.run/##PYsxDoJAFAWv8uyNR7CyoTcmlkv4wg@wn@wuWS1IsLOzNjaaeAULW9GWQ3CRFS3sJpMZsSpmCuG1f96G9jF/X/r70J7q7ji01xFskS@6A6@addOfQ4gc2II1yh2yuowLglSsWTRcphysUzpRJoGj7S@NxbBOZ1hmZGgjhhChMlKJJSho8vCG3Zj81ym8KvKv8WISO/kA "05AB1E – Try It Online")
**Explanation**
```
ā                        # push [1 ... len(input)]
 ¤‹                      # check each number if its less than the max
   >                     # increment
                         # results in a list as long as the input where each number is 2 
                         # apart from the last one, this is the lengths to draw
    Š                    # move 2 copies of the input to the top of the stack
                         # the first one is the string to draw
     ε              }    # for each char in the second copy
      ’uÏ‡’slk           # get the chars index in "ubridal"
              D          # duplicate
               Èi }      # if the index is even
                 V       # store it in Y
                   Y     # push Y (initially 2)
                         # this gives us the list of directions
                     Λ   # draw everything on the canvas
```
[Answer]
## Javascript, 4̶6̶6̶, ~~455~~, 433 Bytes
Edits:
11 Bytes saved, thanks to user 1000000000
10 or so saved, thanks to user2428118
Also removed some unnecessary semi-colons. 
I'm pretty sure this can be golfed further, but i couldn't quite manage it.
I'm still new whole thing, so any advice is much appreciated :)
```
z=a=>{b=c=0;j=[[]];d='';a.split``.forEach(g=>{h=g.toLowerCase();if('ruld'.includes(h)){d=h}f=x=>new Array(x[0].length).fill` `;switch(d){case 'l':if(!b){j.forEach(e => e.unshift` `);++b}j[c][b--]=g;break;case 'u':if(!c){j.unshift(f(j));++c}j[c--][b]=g;break;case 'd':if(c == j.length-1){j.push(f(j))}j[c++][b]=g;break;default:if(b==(j[0].length-1)){j.forEach(row=>row.push` `)}j[c][b++] = g;break}});j.forEach(x=>console.log(x.join``))}
```
```
<input id="a"> </input>
<input type="submit" onclick="z(document.getElementById('a').value);"/>
```
Ungolfed:
```
z=a=>{
b=c=0;
j=[[]];
d='';
a.split``.forEach(g=>{
    h=g.toLowerCase();
    if('ruld'.includes(h)){d=h;}
    f=x=>new Array(x[0].length).fill` `;
    switch(d){
        case 'l':
            if(!b){
                j.forEach(e => e.unshift` `);
                ++b;
            }
            j[c][b--] = g;
            break;
        case 'u':
            if(!c){
                j.unshift(f(j));
                ++c;
            }
            j[c--][b] = g;
            break;
        case 'd':
            if(c == j.length-1){
                j.push(f(j));
            }
            j[c++][b] = g;
            break;
        default:
            if(b == (j[0].length-1)){
                j.forEach(row=>row.push` `);
            }
            j[c][b++] = g;
            break;
    }
});
j.forEach(x => console.log(x.join``));
```
}
I more or less took the approach of:
* Have an array to store output
* Calculate the x and y position of next character in the array
* If the co-ordinates were about to be outside of the array, extend the array in that direction. Either by pushing and extra space onto the end of that row or adding another row entirely.
* Make array[y][x] = current character
* print the resulting array
[Answer]
# Python 3, 314 309 290 268 Bytes
```
x=y=0
d,m=(1,0),{}
q={'u':(0,-1),'d':(0,1),'l':(-1,0),'r':d}
for c in input():m[x,y]=c;d=q.get(c.lower(),d);x,y=x+d[0],y+d[1]
X,Y=zip(*m)
O,P=min(X),min(Y)
r,p=0,print
exec("t=~~O;exec(\"p(m.get((t,r+P),' '),end='');t+=1;\"*-~abs(max(X)-O));r+=1;p();"*-~abs(max(Y)-P))
```
I tried running my program as input to my program with some interesting results. Hah, try interpreting that, Python!
Shaved 5 bytes - compliments to Jack Bates.
23 bytes whisked away by kundor
Note: I think there was some error of measurement with my bytes because of using different editors. However, I'm fairly certain the latest one is correct.
[Answer]
# PHP, ~~238 223 205~~ 204 bytes
12 bytes saved by Jörg (`stripos` instead of `preg_match`), 1 byte +braces by leading instead of trailing newline, 16+braces golfed from the direction change, 1 more with ternary instead of `if`.
```
for($m=$d=1;$o=ord($c=$argn[$i++]);$m=min($m,$x),$n=max($n,$x))stripos(_ulrd,$r[$y+=$e][$x+=$d]=$c)?$d=($e=[1,-1][$o&11])?0:$o%4-1:0;ksort($r);foreach($r as$s)for($i=$m-print"\n";$i++<$n;)echo$s[$i]??" ";
```
Run as pipe with `php -nR '<code>'` or [try it online](http://sandbox.onlinephpfunctions.com/code/0cf5686ca09dbd714cfbdc40109a4dd8a91af78d).
**breakdown**
```
for($m=$d=1;                    # init max index and x-offset to 1
    $o=ord($c=$argn[$i++]);     # loop through characters
    $m=min($m,$x),$n=max($n,$x))    # 3. adjust min and max x offset
    stripos(_ulrd,
        $r[$y+=$e][$x+=$d]=$c       # 1. move cursor; add character to grid
    )?                              # 2. if direction change
        $d=(
            $e=[1,-1][$o&11]            # set y direction
        )
        ?0:$o%4-1                       # set x direction
    :0;
ksort($r);              # sort rows by index
foreach($r as$s)        # loop through rows
    for($i=$m-print"\n";    # print newline, reset $i
        $i++<$n;)           # loop $i from min index to max index
        echo$s[$i]??" ";        # print character, space if empty
```
[Answer]
# Java 10, ~~288~~ ~~286~~ ~~280~~ 263 bytes
```
s->{int l=s.length(),x=l,y=l,d=82,A=x,B=y;var r=new char[l+=l][l];for(var c:s.toCharArray()){A=x<A?x:A;B=y<B?y:B;r[x][y]=c;c&=~32;d="DLRU".contains(""+c)?c:d;x+=5-d/14;y+=3-(d^16)/23;}s="";for(x=A;x<l;x++,s+="\n")for(y=B;y<l;y++)s+=r[x][y]<1?32:r[x][y];return s;}
```
-17 bytes thanks to *@Grimy*.
**Explanation:**
[Try it here.](https://tio.run/##bVNbb9MwFH7frzhYCCVKmq0tINTUVOkuMNgG7MKtK8i13TabYwfbaZNN5a8XpwsPozw48vnO1d/5ckMWpHXDbtdUEGPglKTyfgcglZbrKaEczmoT4MLqVM6Aes3F@LHDVzvuYyyxKYUzkIDXpvX63iWDwCYSXM7s3PPDEouwcofhV50wwWU4xFW8IBo0lnwJdE70SARYjEdiHE@V9mof7ZnIqn3nS7Qmlef79y61nwzKXhK7Av3hoOoNYz0qx6NqjGlMn@Hf3U7MMDo4Ob9CEVXSuucYD6GA@gPaY3EZ4Bctttt@HlcB7rY89qP90t/tdOOVwQhtWpc4icu@cKFBaAKMriXya7zCw7hyeBUEvsObtv32oNvpNUasuS20BBOv1jU7eTERjpiGn4VKGWRuoIbC0RiI/0Cu5cZ6iEwo49PZPL25FZlU@S9tbLFYltVdMtw/ODx68/b43fuT07MPHz@dX1xeff7y9dt3tFnD3wrFY9MV3ALYNsK3oX8xqhifKTEFIhnkWs00ybJaBnlxdye4eRy9Gffk6MoN/NhxbCE1TluQVTAvsongoPJUpkqCnRNbMyUZ0cyFl5vQiaqZiuByzjV3W@BwXLfPleFAoNbOUqd2o8cmNYQlEbc1slSamSdoS6ebPWzmaaScyrywzSYuKmN5FqnCRrlzWiE9GVHvISTSPBfun0iE8JCXDfzraxM8RSFCfvPM/6Sjn6jO48R67b09vxlntf4D) (NOTE: I remove all trailing spaces/newlines to make the output a bit more compact. Feel free to remove the `.replaceAll("(m?)\\s+$","")` in the `test`-method to see the actual result.)
```
s->{                              // Method with String as both parameter and return-type
  int l=s.length(),               //  Length of input String
      x=l,y=l,                    //  x,y coordinates, starting at `l`,`l`
      d=82,                       //  Direction, starting towards the right
      A=x,B=y;                    //  Min x & y values to remove leading spaces at the end
  var r=new char[l+=l][l];        //  character-matrix, with size `l`+`l` by `l`+`l`
  for(var c:s.toCharArray()){     //  Loop over the characters of the input String:
    A=x<A?x:A;                    //   Adjust minimum x `A` if necessary
    B=y<B?y:B;                    //   Adjust minimum y `B` if necessary
    r[x][y]=c;                    //   Fill x,y with the current character
    c&=~32;                       //   Make character uppercase if it isn't yet
    d="DLRU".contains(""+c)?c:d;  //   Change the direction if necessary
    x+=5-d/14;                    //   Set the next x coordinate based on the direction
    y+=3-(d^16)/23;}              //   Set the next y coordinate based on the direction
  s="";                           //  After the loop: create an empty result-String
  for(x=A;x<l;x++,                //  Loop `x` in the range [`A`, `l`):
      s+="\n")                    //    And append a new-line after every iteration
    for(y=B;y<l;y++)              //   Inner loop `y` in the range [`B`, `l`):
      s+=r[x][y]<1?               //    If the cell at x,y is empty:
          32                      //     Append a space to the result-String
         :r[x][y];                //    Else: append the character to the result-String
  return s;}                      //  After the nested loop: teturn result-String
```
[Answer]
# Perl, 204 + 3 = 207 bytes
+3 for `-F` 
Whitespace is not part of the code and is provided for legibility.
```
%p=(d,1,l,2,u,3,r,$x=$y=0);
for(@F){
    $m{"$x,$y"}=$_;
    $g=$p{lc$_}if/[dlur]/i;
    $g%2?($y+=2-$g):($x+=1-$g);
    ($a>$x?$a:$b<$x?$b:$x)=$x;
    ($c>$y?$c:$d<$y?$d:$y)=$y
}
for$k($c..$d){
    print($m{"$_,$k"}||$")for$a..$b;
    say""
}
```
Similar to my solution to the Fizz Buzz challenge, I create a hash with x,y coordinates for every step along the way, keeping the maximums and minimums of the x- and y- coordinates stored, then loop through and print everything out.
If I'm *desperate* I might be able to turn the last three lines of the first `for` loop into a single disgusting statement that may save a byte or two, but I'm not looking forward to the completely unreadable result.
[Answer]
## Excel VBA, 205 bytes
```
Sub t(a)
Z=1:x=70:y=x:For i=1 To Len(a)
s=Mid(a,i,1):Cells(y,x).Value=s:Select Case LCase(s)
Case "l":Z=-1:w=0
Case "d":Z=0:w=1
Case "r":Z=1:w=0
Case "u":Z=0:w=-1
End Select:x=x+Z:y=y+w:Next:End Sub
```
I'm kinda surprised at Excel's ability to compete with existing answers. It works because `w` and `z` keep track of the direction.
[Answer]
# SmileBASIC, ~~148~~ 146 bytes
```
DEF W M,S,T
WHILE""<M
A=INSTR(@DLURdlur,M[0])*PI()/2IF A>0THEN S=COS(A)T=SIN(A)
X=CSRX+S
Y=CSRY+T?SHIFT(M);
SCROLL-!X,-!Y
LOCATE!X+X,Y+!Y
WEND
END
```
Call the function with `W "text",vx,vy`, where vx and vy is the direction at the start (default is 1,0)
[Answer]
# Swift 3, 283 bytes
```
func w(a:String){var t=a.characters,d=t.count,c=Array(repeating:Array(repeating:" ",count:d*2),count:d*2),i=d,j=d,l=["d":(1,0),"u":(-1,0),"l":(0,-1),"r":(0,1)],e=(0,1)
t.map{c[i][j]="\($0)"
e=l["\($0)".lowercased()] ?? e
i+=e.0
j+=e.1}
c.map{$0.map{print($0,terminator:"")};print()}}
```
**Ungolfed**
```
func w(a:String){
    var t=a.characters,d=t.count,c=Array(repeating:Array(repeating:" ",count:d*2),count:d*2),i=d,j=d,l=["d":(1,0),"u":(-1,0),"l":(0,-1),"r":(0,1)],e=(0,1)
    t.map{
        c[i][j]="\($0)"
        e=l["\($0)".lowercased()] ?? e
        i+=e.0
        j+=e.1
    }
    c.map{
        $0.map{
            print($0,terminator:"")
        };
        print()
    }
}
```
**Warning**
Longer input will requires bigger screen. Output has no treatment for "empty" row/columns as I understood that is acceptable by the rules of the challenge.
**Rant**
* Newline being the default terminator for `print` sux
* No simple way of creating an array of known length destroyed the score.
]