text:
Make an ASCII bat fly around an ASCII moon
Background
Here is a Halloween related challenge.
As you may have seen from my last challenge I quite like what I term as ascii art animations, that is not just draw a pattern but draw a pattern that progresses. This idea came to me after I was asked a couple of years ago to liven up a (rather dull) presentation by making random ascii bats fly across the screen on Halloween. Needless to say I duly obliged (I was being paid for it) but it made me think that there is more to life than random bats. Inspired by this I would like to propose this challenge.
Challenge
Make a bat fly around the moon.
Here is a bat:
^o^

Here is the moon:
     mmm
   mmmmmmm
  mmmmmmmmm
   mmmmmmm
     mmm

You must show every stage of the bats flight (see output).
Input
None
Output
      ^o^
      mmm
    mmmmmmm
   mmmmmmmmm
    mmmmmmm
      mmm

      mmm^o^
    mmmmmmm
   mmmmmmmmm
    mmmmmmm
      mmm

      mmm
    mmmmmmm^o^
   mmmmmmmmm
    mmmmmmm
      mmm

      mmm
    mmmmmmm
   mmmmmmmmm^o^
    mmmmmmm
      mmm

      mmm
    mmmmmmm
   mmmmmmmmm
    mmmmmmm^o^
      mmm

      mmm
    mmmmmmm
   mmmmmmmmm
    mmmmmmm
      mmm^o^

      mmm
    mmmmmmm
   mmmmmmmmm
    mmmmmmm
      mmm
      ^o^

      mmm
    mmmmmmm
   mmmmmmmmm
    mmmmmmm
   ^o^mmm

      mmm
    mmmmmmm
   mmmmmmmmm
 ^o^mmmmmmm
      mmm

      mmm
    mmmmmmm
^o^mmmmmmmmm
    mmmmmmm
      mmm

      mmm
 ^o^mmmmmmm
   mmmmmmmmm
    mmmmmmm
      mmm

   ^o^mmm
    mmmmmmm
   mmmmmmmmm
    mmmmmmm
      mmm

      ^o^
      mmm
    mmmmmmm
   mmmmmmmmm
    mmmmmmm
      mmm

Rules

No reading from external files or websites
You may submit a full program or a function
Extra spaces and/or newlines are fine by me
Standard loopholes banned as usual
The bat must finish back at the top of the moon
Please feel free to clear the screen between frames if you wish however this is not a requirement. Output as shown above is fine
As this is code golf, the winner will be the answer with the lowest byte count although any answer is welcome

Sample
Reference implementation in totally ungolfed Python 2 (620 bytes but just to prove that it can be done. May golf it later).
b='^o^'
m=['                     ',
'         mmm         ',
'       mmmmmmm       ',
'      mmmmmmmmm      ',
'       mmmmmmm       ',
'         mmm         ',
'                     ']
p=[(9,12),(12,15),(14,17),(15,18),(14,17),(12,15),(9,12),(6,9),(4,7),(3,6),(4,7),(6,9),(9,12)]
d=0
for z in range(7):
    x=map(str,m[z])
    c="".join(x[:p[z][0]]) + b + "".join(x[p[z][1]:])+"\n"
    print "\n".join(m[:z]) + "\n" + c+"\n".join(m[z+1:])
for z in range(6)[::-1]:
    x=map(str,m[z])
    c="".join(x[:p[z+6][0]]) + b + "".join(x[p[z+6][1]:])+"\n"
    print "\n".join(m[:z]) + "\n" + c+"\n".join(m[z+1:])

Result
Although @Jonathan obviously wins on byte count with Jelly, I am going to mark the Brainfuck answer from @Oyarsa as the accepted answer purely because I think that anyone who can actually do something like this in such a crazy language deserves +15 rep no matter how many bytes it takes. This is not because I have any problem with golfing languages. See my answer to a question regarding this on meta if you have any doubts. Many thanks and respect to all who contributed in whatever language.

Thanks @Oliver. I forgot to remove it after the Sandbox.

@daHugLenny Thanks for adding the tag. I hadn't thought of that one.

If you think that reference implementation is totally ungolfed, I never want to work with you on any programming project.

Well, maybe a bit golfed then :-)

Brainfuck, 690 Bytes
This is my first time golfing, so I'm sure there's still plenty of room for improvement
-[-[-<]>>+<]>-<<+++[>+++++++<-]>>>+>>-[<-->-------]<->++++++++>+>+++++>+>+++++>+>+++++++>+>+++++>+>+++++>+>++++++++>+>+>+>>+++[<++++++>-]<+>+>-->+>+>+[<]>[[<+>>-[>]+[[<]>+[>]<+[<]>>>-]<<[->>+<<]>-]>-[->>>>+<<<<]>++]>>>[[-]<]>>>>[>]>>+>+++++++<<<<[<]+<+<<+[[<]++++[>++++<-]>[<+[>]>[-<+>]<[<]>>-]>[>]++++++++++[>]>>>-[<]<<[<]<]<[<]>->-<<<[-]++++++<+<+++[>++++++<-]+<++++[>++++++++<-]---<-[>+<-----]++<----[>+<----]--<-[>+<---]<-[>++<-----]++++<-[>+<---]++<-[>+<-------]---<----[>+<----]<--[>+<++++++]<+++++[>+++++<-]++++++>[[[>]>[>]>>[-<<+>>]<<[<]<[<]>-]>[>]>[>]+++++++[>+++++++++<-]>-[->+>+>+<<<]++++[>>++++<<-]>>+<<<<[<]>[.>]>>[.>]<[<]>[-]>[-]>[-]<+[--<---[->]<]<[->+>+>+<<<]<<[[->>+<<]<]<]

Try it online
Ungolfed some for readability:
-[-[-<]>>+<]>-<<+++[>+++++++<-]>>>+>>-[<-->-------]<->++++++++>+>+++++>+>+++++>+>+++++++>+>+++++>+>+++++>+>++++++++>+>+>+>>+++[<++++++>-]<+>+>-->+>+>+
Sets counters for creation of the m's and spaces
[<]>[[<+>>-[>]+[[<]>+[>]<+[<]>>>-]<<[->>+<<]>-]>-[->>>>+<<<<]>++]
Adds the first counter plus two of the character at the second counter to the end of the
current set of cells removes the first two counters on the list then repeats until
it encounters a 254
>>>[[-]<]>>>>[>]>>+>+++++++<<<<[<]
Removes some excess cells then adds a 7 after the end of the set of cells
+<+<<+[[<]++++[>++++<-]>[<+[>]>[-<+>]<[<]>>-]>[>]++++++++++[>]>>>-[<]<<[<]<]
Adds a newline every 16 characters until 7 newlines are added
<[<]>->-<<<[-]++++++<+<+++[>++++++<-]+<++++[>++++++++<-]---<-[>+<-----]++<----[>+<----]--<-[>+<---]<-[>++<-----]++++<-[>+<---]++<-[>+<-------]---<----[>+<----]<--[>+<++++++]<+++++[>+++++<-]++++++
Removes some excess cells then sets indices for the locations of bats
>[[[>]>[>]>>[-<<+>>]<<[<]<[<]>-]>[>]>[>]+++++++[>+++++++++<-]>-[->+>+>+<<<]++++[>>++++<<-]>>+<<<<[<]>[.>]>>[.>]<[<]>[-]>[-]>[-]<+[--<---[->]<]<[->+>+>+<<<]<<[[->>+<<]<]<]
Loops through the indices replacing the spaces at each index with a bat then printing
the set of cells then changing the bat back to spaces

I wanted to use the fact that by adding a newline to the beginning, each stage can be read in both directions to get two different stages, but I couldn't find a good way to do so without generating the full six and a half stages at once.

Very nice! I don't think I'd have the patience to answer a challenge this big in brainfuck, haha.

Added a TIO link, hope you don't mind. Also, I seem to count 693 bytes.

Ungolfed for readability would still win first prize for unreadability :) Total respect for actually doing it in such a crazy language. Very nice and thanks for the answer.  +1. Well worth 690 bytes of anyones time.

@Enigma From me, thanks for the TIO link.

@DJMcMayhem, I must have messed up the copy/paste, there was a duplicated [<] in the ungolfed form that should have only been there once. Should be fixed now.

05AB1E, 69 62 60 bytes
Saved 2 bytes thanks to Adnan.
3ð×…^o^)U13FNV0379730vð5y>;ï-y_+×N(Y-12%_Xè'my×NY-12%_y&XèJ,

Try it online!
Explanation
3ð×…^o^)U stores the list ["   ","^o^"] in X for later use.
13FNV loops over the 13 stages [0 .. 12] and stores the current iteration index in Y.
0379730v loops over the rows of each stage,
where N is the row index and y is the current number of m's.
We start by adding floor(5/(y+1))-(y==0) spaces to each row with ð5y>;ï-y_+×.
We then determine if there should be a bat or 3 spaces before the m's.
If (-N-Y)%12 == 0 is true we add a bat, else 3 spaces.
This expression (N(Y-12%_Xè) will place bats in stages 0,6-12.
Then we place y m's with 'my×.
Now we determine if there should be a bat or 3 spaces after the m's.
The code NY-12%_y&Xè will place a bat if ((N-Y)%12 == 0) and y!=0 is true, else 3 spaces.
This will place the bats on stages 1-5.
Finally we join the whole row into a string and print with a newline: J,.

Does exactly what it says on the tin +1

3ð×…^o^) instead of "   ^o^"2ä should save two bytes.

@Adnan: Thanks! For some reason I just assumed it would be longer and never even tried 3ð×.

JavaScript (ES6), 109 144 140 138 bytes

f=(k=13,b=y=>(y-k)%12?'   ':'^o^')=>k--?[0,3,7,9,7,3,0].map((n,y)=>' '.repeat(5-n/2+!n)+b(y)+'m'.repeat(n)+b(n?-y:.1)).join`
`+`
`+f(k):''

console.log(f());

Animated version

f=(k,b=y=>(y-k)%12?'   ':'^o^')=>[0,3,7,9,7,3,0].map((n,y)=>' '.repeat(5-n/2+!n)+b(-y)+'m'.repeat(n)+b(n?y:.1)).join`
`

var k =0;
setInterval(function() { o.innerHTML = f(k++) }, 150);

nice answer and you are the first as on my last challenge :)

Nice answer. I can't wrap my head around thinking like this.

HTML+JS, 153 149 bytes

n=setInterval(_=>o.innerText=`zzd
zc3e
 b7f
a9g
 l7h
zk3i
zzj`.replace(/\S/g,c=>parseInt(c,36)-n%12-10?`m`.repeat(c)||`   `:`^o^`,n++),1e3)

Edit: Saved a bunch of bytes thanks to @RickHitchcock. The boring version that just returns the 13 multiline strings in an array is 132 131 bytes:
_=>[...Array(13)].map((_,n)=>`zza
zl3b
 k7c
j9d
 i7e
zh3f
zzg`.replace(/\S/g,c=>parseInt(c,36)-n%12-10?`m`.repeat(c)||`   `:`^o^`))

If I was being really strict I would point out that the bat doesn't start at the top :) But then it does the full circle and depending on opinion finishes at the top which was all that I specified in the rules. +1 for the first full animation. Nice job and thanks.

@ElPedro I think the place where the bat starts depends on the result of setInterval, which is always the same on my browser, but may vary for other browsers.

OK, but as I said the start position was not clearly specified so I'm ok to let setInterval decide ;) I'm viewing with Chome on Ubuntu if thet's of any interest. Always starts one position before the top but that doesn't matter. Great solution and thanks again for your answer..

You can save a couple bytes by using innerHTML instead of textContent.  And another byte by changing repeat(+c) to repeat(c).

(And 1000 can become 1e3.)

@RickHitchcock The +c which used to be a +c?...:... was just an oversight, but I can't believe I forgot to use 1e3.

Jelly, 76 69 58 bytes
⁾ mṁ11ż“æ¤¿¬®µ‘ŒḄ¤Œṙs⁴Y
_4¢ḣ;“^o^”;¢ṫ⁸¤
“½œ0CSbp\I7'ð½‘Ç€Y

TryItOnline
How?
⁾ mṁ11ż“æ¤¿¬®µ‘ŒḄ¤Œṙs⁴Y - Link 1, make a moon (niladic)
⁾ m                     - literal " m"
   ṁ                    - reshape like
    11                  - 11 (interpreted as range(11)) -> " m m m m m "
                 ¤      - nilad followed by links as a nilad
       “æ¤¿¬®µ‘         - code page indexes [22,3,11,7,8,9]
               ŒḄ       - bounce -> [22,3,11,7,8,9,8,7,11,3,22]
      ż                 - zip -> [[22,' '],[3,'m'],[11,' '],...]
                  Œṙ    - run length decode -> "                      mmm           mmmmmmm        mmmmmmmmm        mmmmmmm           mmm                      "
                    s   - split into chunks of length
                     ⁴  - l6
                      Y - join with line feeds

_4¢ḣ;“^o^”;¢ṫ⁸¤ - Link 2, a moon with a bat placed: endIndex
_4              - subtract 4 (startIndex)
  ¢              - call last link (1) as a nilad
   ḣ            - ḣead to startIndex
    ;           - concatenate
     “^o^”      - literal "^o^"
          ;     - concatenate
              ¤ - nilad followed by links as a nilad
           ¢    - call last link (1) as a nilad
            ṫ⁸  - tail from endIndex

“½œ0CSbp\I7'ð½‘Ç€Y - Main link (niladic)
“½œ0CSbp\I7'ð½‘    - code page indexes [10,30,48,67,83,98,112,92,73,55,39,24,10]
                   -    indices to the right of each bat in a constructed moon
               Ç€  - call last link (2) as a monad for each
                 Y - join on line feeds

Very nice. Think I'm going to have to look into Jelly a bit closer.

Great explanation. Thanks.

Would be cool to see how you approach this in Python as well if you're interested and have the time. I'm always happy to learn.

Python 2, 146 144 138 bytes
-2 bytes thanks to @Willem (use the variable c rather than looping through a map)
m='\n'.join(int(a)*' '+int(b)*'m'+3*' 'for a,b in zip('6643466','0379730'))
for b in" -;L[hrbQ@2' ":c=ord(b)-23;print(m[:c-3]+'^o^'+m[c:])

repl.it
'6643466' is the number of spaces before the moon (with 6 on the empty first and last lines, since the bat will go there).
'0379730' is the number of 'm's in the moon on each line.
The zip unpacks these characters into a and b and makes the moon in the sky, m, with 3 trailing spaces on each line.
The last line then traverses the positions of the bat within the moon, and is effectively:
for c in(9,22,36,53,68,81,91,75,58,41,27,16,9):print(m[:c-3]+'^o^'+m[c:])

but the tuple of positions is encoded as the ordinals of printable characters, with an added 23 (since 9 is not printable). This comes out as " -;L[hrbQ@2' ", and c=ord(b)-23 is used to extract the values.

Respect +1 and thanks for rising to the challenge :) Now I just have to work out how it works...

Sometimes I wish I could give 2 upvotes.

You can save two chars on the last line by writing it like this: for b in" -;L[hrbQ@2' ":c=ord(b)-23;print(m[:c-3]+'^o^'+m[c:])

PHP, 167 bytes
I made a small program in PHP:
<?php foreach([0,3,7,9,7,3,0]as$l)$b.=str_pad(str_repeat('=',$l),15," ",2)."\n";foreach([6,25,43,60,75,89,102,83,65,48,33,19,6]as$x)echo substr_replace($b,'^o^',$x,3);

Here is a more verbose version:
// width of the moon
$moonsizes = [0,3,7,9,7,3,0];
// position where to place the bat
$positions = [6,25,43,60,75,89,102,83,65,48,33,19,6];
// prepare base moon painting
foreach($moonsizes as $size){
    $basepainting .= str_pad(str_repeat('=',$size),15," ",STR_PAD_BOTH)."\n";
}
// loop frames and place bat
foreach($positions as $position) {
    echo substr_replace($basepainting,'^o^',$position,3);
}

This is my first codegolf, if you have any suggestion i'm happy to hear :)

Welcome to PPCG! Nice first answer. Thanks.

Autovim, 85 81 bytes
No animation, probably still golfable... Still,  not bad for the new kid on the block! (autovim)
ñ9am␛ÿP2xÿP4xyjGpđp2o
%ce 15
®q=8j$p
®z=6␍"_d3hP
ñğyG12PğÿPC^o^␛v^y6@q==o␛6@z==O

To run it:
autovim run ascii-bat.autovim -ni

Explanation
In short, we draw the moon, copy and paste it 12 times, and use two macros: one to append the bat on the first 7 moons, the other to prepend the last 6.
" Draw the moon
ñ                                 " Normal mode
 9am␛                            " Write 9 `m`
      ÿP                          " Duplicate the line
        2x                        " Delete two characters
          ÿP                      " Duplicate the line
            4x                    " Delete 4 characters
              yj                  " Yank two lines
                Gp                " Paste at the end of the file
                  đp              " inverts the current line with the previous
                    2o            " Add two line breaks

%ce 15                            " Center our moon

" Macros
®q=8j$p                           " Macro `q` jumps 8 lines, and pastes
                                  "   at the end
®z=6␍"_d3hP                      " Macro `z` jumps 6 lines and replaces
                                  "   the previous 3 characters by the default

" Draw all 12 moons and add the bats
                                  "   register's content
ñ                                 " Run in normal mode
 ğyG                              " Copy the moon we just drew
    12P                           " Duplicate the moon 12 times
       ğÿP                        " Duplicate the top line (gets 3 centered `m`)
          C^o^␛                  " Change the mmm by a bat
                v^y               " Copy the bat we just drew
                   6@q            " Add the first 6 bats
                      ==          " Center the bat
                        o␛       " Add a line under the bat
                           6@z    " Add the 6 last bats
                              ==  " Align the last bat in the center
                                O " Add a line over the last moon

I followed the download instructions, installed VIM and ended up with the following:
VIM - Vi IMproved 7.4 (2013 Aug 10, compiled Dec  9 2014 17:36:41)
Unknown option argument: "--not-a-term"
More info with: "vim -h"
Not got time to look at it now but will have a play this evening. Looks like an interesting project.

If you have some time to spare, open a GitHub issue - it's working on my phone (Termux, a Linux distribution) as well as on Windows in Git Bash. I'd love to make it work everywhere! My best guess is that VIM compiled in 2013 might really not be the latest version :) (latest version is 8.0)

OK. I just installed from the package manager so maybe I'll try the upgrade option. I'll let you know what happens.

You were right @Christian. Upgrade to v8.0 did the trick and I ran the prog from the examples. Works like a charm.  Thanks for your answer to both questions :)

Issue raised on GitHub as requested. Please feel free to ignore/reject if you don't consider it a problem since the upgrade resolved it.

So that means it works now! Great!

Python 2, 112 bytes
b=['   ','^o^']
for k in range(91):r=k%7;print(b[k/7+r==12]*(r%6>0)+(r*(6-r)*8/5-5)*'m'+b[k/7%12==r]).center(15)

Print the picture. Each line has three parts

A potential bat on the left
Some number of m's for the moon
A potential bat on the right

These parts are concatenated and centered in a box of size 15 for spacing. To avoid the bats shifting the center, a missing bat is three spaces, the same length. For bats on top of or below the moon, the left bar slot is omitted and the right slot is occupied.
There are 91 lines: a 7-line picture for each of 13 pictures. These are counted up via divmod: As k counts from 0 to 91, (k/7, k%7) goes
(0, 0)
(0, 1)
(0, 2)
(0, 3)
(0, 4)
(0, 5)
(0, 6)
(1, 0)
(1, 1)
 ....
(12, 5)
(12, 6)

Taking the first value k/7 to be the picture and the second value r=k%7 as the row number within the picture, this counts up first by picture, then by row number within each picture, both 0-indexed.
The number of m's in the moon changes with row number r=k%7 as [0,3,7,9,7,3,0]. Rather than indexing into this, a formula was shorter. A convenient degree of freedom is that the 0's can be any negative value, as this still gives the empty string when multiplied by m. Fiddling with a parabola and floor-dividing gave a formula r*(6-r)*8/5-5.
Now, we look at selecting whether to draw a bat or empty space on either side. The array b=['   ','^o^'] contains the options.
The bat in row 0 on in picture 0 (on top), in row 1 in picture 1 (on the right), on to in row 6 in picture 6 (on top). So, it's easy to check whether it appears as the row and picture number as being equal, k/7==r. But we also need picture 12 to look like picture 0, so we take the picture number modulo 12 first.
On the left it's similar. The bat appears on the left in rows r=5,4,3,2,1 in pictures 7,8,9,10,11. So, we check whether the  row and picture number sum to 12. We also make sure to draw nothing rather than three spaces on rows 0 and 6 -- the right bat slot will draw the bat, and we must not mess up its centering.

Any chance of a quick explanation @xnor? I've run it and it sure does work so no explanation needed but if you have time and the inclination it would be interesting for educational purposes :)

+1 for "Fiddling with a parabola and floor-dividing..." -- if I had to guess, that's the first time that phrase has been used in PPCG... :-)

Thanks @xnor. Awesome explanation. I am gonna have to spend some time studying this :)

Python 2, 299 300 290 270 bytes
Golfed down to 270 having gained a bit more golfing experience.
Reference implementation golfed down by 321 320 330 bytes. Not pretty or elegant. Just uses brute force string and list slicing. Was fun to get the byte count down though but I think the approach was completely wrong to start with for a serious competitor.
I don't expect this answer to be taken seriously so please no downvotes. I did say in the question that I would try to golf the reference implementation and this is exactly that. Just posted for fun.
c,e,n=' ','m','\n';f,g=c*9+e*3+c*9,c*7+e*7+c*7;h=9,12;i=12,15;j=6,9;k=13,17;l=4,7;m=c*21,f,g,c*6+e*9+c*6,g,f,c*21;p=h,i,k,(15,18),k,i,h,j,l,(3,6),l,j,h;w=0
for z in map(int,'0123456543210'):print n.join(m[:z])+n+m[z][:p[w][0]]+'^o^'+m[z][p[w][1]:]+n+n.join(m[z+1:]);w+=1

Try it online!

C#, 615 582 337 bytes
This is my first (still far too readable) attempt at one of these, so I'll gladly welcome any suggestions to shave off a few hundred bytes! Top of my list right now is a shorter way to create the moon array.
void M(){string[]m={"","      mmm","    mmmmmmm","   mmmmmmmmm","    mmmmmmm","      mmm",""};var b="^o^";for(int x=0;x<13;x++){var a=(string[])m.Clone();int n=x>6?12-x:x;int[] j={0,1,3,6};a[n]=!a[n].Contains("m")?"      "+b:x<=n?a[n]+b:new string(' ',j[Math.Abs(9-x)])+b+a[n].Replace(" ","");foreach(var c in a){Console.WriteLine(c);}}}

Ungolfed (includes loop!)
class Program {
    public static string[] moon = new string[] { "               ", "      mmm      ", "    mmmmmmm    ", "   mmmmmmmmm   ", "    mmmmmmm    ", "      mmm      ", "               " };

    public static string bat = "^o^";

    static void Main(string[] args) {
        while (true) {
            Fly();
        }
    }

    static void Fly() {
        int times = (moon.Length * 2) - 1;
        for (int x = 0; x < times; x++) {
            string[] temp = (string[])moon.Clone(); //create a new array to maintain the original

            int index = x >= moon.Length ? times - x - 1 : x;

            if (!temp[index].Contains("m")) {
                temp[index] = new string(' ', 6) + bat + new string(' ', 6);
            } else if (x <= index) {
                int lastM = temp[index].LastIndexOf('m') + 1;
                temp[index] = temp[index].Insert(lastM, bat);
            } else {
                int firstM = temp[index].IndexOf('m');
                char[] src = temp[index].ToCharArray();
                int i = firstM - bat.Length;
                src[i] = bat[0];
                src[i + 1] = bat[1];
                src[i + 2] = bat[2];

                temp[index] = new string(src);
            }

            for (int y = 0; y < temp.Length; y++) {
                Console.WriteLine(temp[y]);
            }
            Thread.Sleep(100);
            Console.Clear();
        }
    }
}

Edit:
Took out 21 bytes by removing trailing spaces in the array declaration. Instead of a grid 15 characters wide, each row is only wide enough for the bat to fit. Removed another 12 for the unnecessary string[]args in Main() declaration.
Edit 2:
Rewrote most of the logic, taking out 245 bytes! Includes suggested changes from the comments. Thanks!
From the comments, turned this into a function M() instead of the previous Main() method - so now, this needs to be called externally.

Welcome to PPCG! :)

Welcome and nice first effort! Thanks for your answer. Not a c# expert myself so probably can't help you much but I'm sure you'll find many community members who will be happy to help.

Maintenance nightmare seems to be one of the qualifications for this community. Guess that's one of the reasons why I like it. I spend all day trying to write legible code. It's nice to come here sometimes and relax the rules a bit :)

You can save a few bytes by removing the new string[] from m and just putting string[]m={...}.

@Pokechu22 Awesome, I didn't know that - thanks! I've changed this pretty heavily and will be uploading a new try shortly, definitely adding this in.

Can safe a few more byte by using var's  in places such as string[]w=(string[])m.Clone(); -  var w=(strin[])m.Clone();

Since I stated that this can be a function or a complete program, can you lose the static void Main() and just make it a function in which case it could be void M() and state that you call the function from an external program? As I said, I am no C# expert but since it looks like Java I guess this may work and save a few bytes.

@ElPedro Sure, I'll take it! It certainly works as a callable function that produces the desired result. Anecdotally, I tried rewriting this again and found a pretty "clever" solution. Much to my chagrin, I ended up +1 from the current byte count, so I think I'm gonna leave it here - thanks for a really fun challenge! This certainly taught me some new things.

Thanks for your input as well. Convinced me to install Visual Studio today and try out your answer. It worked. If I hadn't already given you +1 I would now. btw, after 5 minutes playing I spotted @Pokechu22 recommendation but was too late posting it. Guess I have learned something as well.

I think you could save 3 bytes defining m by using string[]m="/      mmm/    mmmmmmm/   mmmmmmmmm/    mmmmmmm/      mmm/".Split('/'); (apparently multiple spaces don't render correctly, but they're supposed to be in there)

Ruby, 164 156 bytes
puts Zlib.inflate Base64.decode64 "eNqlkrUVAAEMQvtMcZP9DfLYvzo3qhNSxQ2GVRC1ad29ar1JXaoHbul16Yig+p6BCKqtFBFU+1IE1famoHrX/jZBvN8e8f5tiE94Ib4SBREwNKH5BNJy2QM="

Very simple program. Can be worked on more. Please leave tips in the comments.

Nice answer. I'm currently playing with Ruby at the moment cos it looks much less verbose than Python when it comes to golfing.

@ElPedro This is just the text stripped of trailing whitespace, zlib compressed, and base64 encoded. No magic Ruby action anywhere.

Still think this approach would be a lot more heavy with Python unless someone wants to prove me wrong  (@Jonathan perhaps? :))

Welp, I forgot to include some libraries and SE won't let me do it. Can someone please include the base64 and zlib libraries in the shortest way possible, and add them to the byte count?

Is there any difference between puts and say? I'm not familiar with Ruby.

@RomanGräf Is say even a thing in Ruby?

Got something wrong with Perl

///, 205 bytes
/*/\/\///B/^o^*9/
*M/mmm*N/MM*O/   *0/OO*n/

*1/O Nm0
*2/NM0
*3/0M9*4/1O2*7/13n*5/34/0B9570MB0
473O NmBO
O2731ONMBO
75O NmBO
3n510MB0n
5130B9n51OBM9n5 BNm0
3n31B273 BNm0
O27OBM9470B90M0O
410MO

Try it online!
Only if I didn't need tons of trailing spaces...

Mumps, 223 Bytes
This is using InterSystems Cache Mumps -- it allows braces around loops which make it handy for nested loops in a single line.
S X="09121415141209060403040609",R="097679",L="037973",S=-14 F Y=1:1:13 S S=S+2 F C=1:1:7 S F=$E(X,Y*2-1,Y*2),(M,T)="",$P(T," ",21)="" F A=1:1:$E(L,C){S M=M_"m"} S $E(T,$E(R,C))=M S:C=$S(Y<8:Y,1:Y-S) $E(T,F,F+2)="^o^" W T,!

Could probably be golfed more, and I may play with that when I have more time. Add another 9 bytes, and it'll be animated [[ due to the addition of the 'H 1 W # ' --> that halts for a second and clears the screen:
S X="09121415141209060403040609",R="097679",L="037973",S=-14 F Y=1:1:13 S S=S+2 H 1 W # F C=1:1:7 S F=$E(X,Y*2-1,Y*2),(M,T)="",$P(T," ",21)="" F A=1:1:$E(L,C){S M=M_"m"} S $E(T,$E(R,C))=M S:C=$S(Y<8:Y,1:Y-S) $E(T,F,F+2)="^o^" W T,!

Here's an ungolfed / explained version (of the animation version), with the correct 'do' statements and dot loops:
 S X="09121415141209060403040609"
 S R="097679",L="037973",S=-14              ; Initialize Variablex
 F Y=1:1:13 D                               ; Set up our main loop of 13 cels
 . S S=S+2                                  ; set up secondary counter, for start char.
 . H 1                                      ; halt for 1 second
 . W #                                      ; clear screen
 . F C=1:1:7 D                              ; set up our per-line loop
 . . S F=$E(X,Y*2-1,Y*2)                    ; set F to 2-digit "start of bat"
 . . S (M,T)=""                             ; set our "builder" lines to empty strings
 . . S $P(T," ",21)=""                      ; then reset our main 'line string' to 21 spaces.
 . . F A=1:1:$E(L,C){S M=M_"m"}             ; make our 'moon' text.
 . . S $E(T,$E(R,C))=M                      ; and insert our 'moon' into the empty line
 . . S:C=$S(Y<8:Y,1:Y-S) $E(T,F,F+2)="^o^"  ; find the start character for our 'bat' and insert.
 . . W T,!                                  ; and write the line and a CR/LF.

I tried to do the "compress then Base-64 encode" jazz just to see what would happen, but the encoded string ended up a little longer than the program itself! That, and Cache's system calls for the compression and base64 encoding are quite long... for example, here's the system call to decode base64:
$System.Encryption.Base64Decode(STRING)
That method would 'bloat' the program to over 300 characters, I think...


text:
Play a game of Yahtzee
In the game Yahtzee, players take turns rolling 5 6-sided dice up to three times per turn, possibly saving dice between rolls, and then selecting a category they wish to use for their roll. This continues until there are no more categories (which happens after 13 turns). Then, players' scores are tallied, and the player with the highest score wins.
The categories are as follows ("sum of dice" means adding up the number of pips on the specified dice):

Upper Section

Aces: sum of the dice showing 1 pip
Twos: sum of the dice showing 2 pips
Threes: sum of the dice showing 3 pips
Fours: sum of the dice showing 4 pips
Fives: sum of the dice showing 5 pips
Sixes: sum of the dice showing 6 pips

Lower Section

Three of a Kind: 3 dice with same value, score is sum of all dice
Four of a Kind: 4 dice with same value, score is sum of all dice
Full House: 3 dice with one value and 2 with another, score is 25
Small Straight: 4 sequential dice, score is 30
Large Straight: 5 sequential dice, score is 40
Yahtzee: all 5 dice with same value, score is 50
Chance: any combination of dice, score is sum of all dice

There are a few rules about the category choices:

If a player chooses a category that does not match their roll, they receive a score of 0 for that category.
If a player earns a score of at least 63 in the upper section, they receive 35 bonus points.
If a player has rolled a Yahtzee but the Yahtzee category is already taken (by another Yahtzee - filling in 0 for a miss doesn't count), they receive a bonus of 100 points. This bonus is awarded for every Yahtzee after the first.

Additionally, the player must still choose to fill in a category. They must choose the upper section category corresponding to their roll (e.g. a roll of 5 6's must be placed in the Sixes category). If the corresponding upper section category has already been used, the Yahtzee may be used for a lower section category (in this case, choosing Full House, Small Straight, or Large Straight awards the normal amount of points rather than 0). If all of the lower section categories are taken, then the Yahtzee may be applied to an unused upper section category, with a score of 0.

The Challenge
In this challenge, the competitors will play 1000 games of Yahtzee. At the end of each game, the submission(s) that scored the highest will receive 1 point. After all of the games are finished, the submission with the most points will win. If there is a tie, additional games will be played with only the tied submissions until the tie is broken.
Controller
The complete controller code can be found on this GitHub repository. Here are the public interfaces with which players will be interacting:
public interface ScorecardInterface {

    // returns an array of unused categories
    Category[] getFreeCategories();

    // returns the current total score
    int getScore();

    // returns the current Yahtzee bonus
    int getYahtzeeBonus();

    // returns the current Upper Section bonus
    int getUpperBonus();

    // returns the current Upper Section total
    int getUpperScore();

}

public interface ControllerInterface {

    // returns the player's scorecard (cloned copy, so don't try any funny business)
    ScorecardInterface getScoreCard(Player p);

    // returns the current scores for all players, in no particular order
    // this allows players to compare themselves with the competition,
    //  without allowing them to know exactly who has what score (besides their own score),
    //  which (hopefully) eliminates any avenues for collusion or sabotage
    int[] getScores();

}

public enum Category {
    ACES,
    TWOS,
    THREES,
    FOURS,
    FIVES,
    SIXES,
    THREE_OF_A_KIND,
    FOUR_OF_A_KIND,
    FULL_HOUSE,
    SMALL_STRAIGHT,
    LARGE_STRAIGHT,
    YAHTZEE,
    CHANCE;

    // determines if the category is part of the upper section
    public boolean isUpper() {
        // implementation
    }

    // determines if the category is part of the lower section
    public boolean isLower() {
        // implementation
    }

    // determines if a given set of dice fits for the category
    public boolean matches(int[] dice) {
        // implementation
    }

    // calculates the score of a set of dice for the category
    public int getScore(int[] dice) {
        // implementation
    }

    // returns all categories that fit the given dice
    public static Category[] getMatchingCategories(int[] dice) {
        // implementation
    }
}

public class TurnChoice {

    // save the dice with the specified indexes (0-4 inclusive)
    public TurnChoice(int[] diceIndexes) {
        // implementation
    }

    // use the current dice for specified category
    public TurnChoice(Category categoryChosen) {
        // implementation
    }

}

public abstract class Player {

    protected ControllerInterface game;

    public Player(ControllerInterface game) {
        this.game = game;
    }

    public String getName() {
        return this.getClass().getSimpleName();
    }

    // to be implemented by players
    // dice is the current roll (an array of 5 integers in 1-6 inclusive)
    // stage is the current roll stage in the turn (0-2 inclusive)
    public abstract TurnChoice turn(int[] dice, int stage);

}

Additionally, there are some utility methods in Util.java. They are mainly there to simplify the controller code, but they can be used by players if they desire.
Rules

Players are not allowed to interact in any way except using the Scorecard.getScores method to see the current scores of all players. This includes colluding with other players or sabotaging other players via manipulating parts of the system that are not part of the public interface.
If a player makes an illegal move, they will not be allowed to compete in the tournament. Any issues that cause illegal moves must be resolved prior to the running of the tournament.
If additional submissions are made after the tournament is run, a new tournament will be run with the new submission(s), and the winning submission will be updated accordingly. I make no guarantee of promptness in running the new tournament, however.
Submissions may not exploit any bugs in the controller code that cause it to deviate from the actual game rules. Point out bugs to me (in a comment and/or in a GitHub issue), and I'll fix them.
Use of Java's reflection tools is forbidden.
Any language which runs on the JVM, or can be compiled to Java or JVM bytecode (such as Scala or Jython) can be used, so long as you supply any additional code needed to interface it with Java.

Final Comments
If there is any utility method you would like me to add to the controller, simply ask in the comments and/or make an issue on GitHub, and I'll add it, assuming it doesn't allow for rule breaking or expose information to which players are not privy. If you want to write it yourself and create a pull request on GitHub, even better!

ACES? You mean ONES? These are dice, not cards.

@mbomb007 Yahtzee scorecards call it aces.

I don't recall seeing it called that when I've played it, but okay.

Is there a method to get the score for a given category given a set of dice?

@mbomb007 No, but I certainly can make one :)

Does this challenge support python? If so, how?

@Magenta This challenge is primarily Java, but you are welcome to use Python (by way of Jython) if you write a wrapper to use the Jython from within Java.

@Mego the koth challenges I have competed in are written in java, and can be accessed by native python. However, some use argv[0] as the I/O, and some use the python input(). I was wondering which one this uses, as I do not have the knowledge to write anything in Java.

@Magenta This KotH challenge uses method calls for communication between the controller and the players. As such, you will need to use a language that runs on the JVM.

@Mego are we allowed to write a wrapper submission which implements the player class by calling another process? (That's how non-JVM languages were able to compete in the Wolf KotH.)

@MartinEnder Sure, as long as the interface is callable from Java and doesn't break any of the rules.

@TNT You are absolutely correct. I will fix that now.

Part of the controller code is giving me issues again. I created a chat room for it (Did you get a notification? It's my first time using SE chat) since my description was a little lengthy for a comment. I'm not sure if I'm just confused about something or if it's another bug.

Nice to see a post in PPCG that's not so focused on byte count.

DummyPlayer
package mego.yahtzee;
import java.util.Random;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class DummyPlayer extends Player {

    public DummyPlayer(ControllerInterface game) {
        super(game);
    }

    @Override
    public TurnChoice turn(int[] dice, int stage) {
        Category[] choices = game.getScoreCard(this).getFreeCategories();
        Category choice = choices[new Random().nextInt(choices.length)];
        if(IntStream.of(dice).allMatch(die -> die == dice[0])) {
            if(Stream.of(choices).filter(c -> c == Category.YAHTZEE).count() > 0) {
                choice = Category.YAHTZEE;
            } else if(Stream.of(choices).filter(c -> c == Util.intToUpperCategory(dice[0])).count() > 0) {
                choice = Util.intToUpperCategory(dice[0]);
            } else {
                choices = Stream.of(game.getScoreCard(this).getFreeCategories()).filter(c -> c.isLower()).toArray(Category[]::new);
                if(choices.length > 0) {
                    choice = choices[new Random().nextInt(choices.length)];
                } else {
                    choices = game.getScoreCard(this).getFreeCategories();
                    choice = choices[new Random().nextInt(choices.length)];
                }
            }
        }
        return new TurnChoice(choice);
    }

}

This player is here to serve as a basic outline for how to use the tools present in the Yahtzee controller. It chooses Yahtzee whenever possible, and makes random choices otherwise, while complying with the strict joker rules.

Aces and Eights
Well, this took a lot longer than I would have liked thanks to how busy I've been lately.
package mego.yahtzee;

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import static mego.yahtzee.Category.*;

public class AcesAndEights extends Player {
    private Category[] freeCategories, matchingCategories, usableCategories;

    public AcesAndEights(ControllerInterface game) {
        super(game);
    }

    @Override
    public TurnChoice turn(int[] dice, int stage) {
        List<Integer> holdIndices = new java.util.ArrayList<>();

        freeCategories = game.getScoreCard(this).getFreeCategories();

        matchingCategories = Category.getMatchingCategories(dice);
        Arrays.sort(matchingCategories);

        usableCategories = Arrays.stream(freeCategories)
                                 .filter(this::isMatchingCategory)
                                 .toArray(Category[]::new);
        Arrays.sort(usableCategories);

        if (isMatchingCategory(YAHTZEE))
            return doYahtzeeProcess(dice);

        if (isUsableCategory(FULL_HOUSE))
            return new TurnChoice(FULL_HOUSE);

        if (stage == 0 || stage == 1) {
            if (isMatchingCategory(THREE_OF_A_KIND)) {
                int num = 0;
                for (int i : dice) {
                    if (Util.count(Util.boxIntArray(dice), i) >= 3) {
                        num = i;
                        break;
                    }
                }
                for (int k = 0; k < 5; k++) {
                    if (dice[k] == num)
                        holdIndices.add(k);
                }
                return new TurnChoice(toIntArray(holdIndices.toArray(new Integer[0])));
            }

            if (isFreeCategory(LARGE_STRAIGHT) || isFreeCategory(SMALL_STRAIGHT)) {
                if (isUsableCategory(LARGE_STRAIGHT))
                    return new TurnChoice(LARGE_STRAIGHT);

                if (isMatchingCategory(SMALL_STRAIGHT)) {
                    if (!isFreeCategory(LARGE_STRAIGHT))
                        return new TurnChoice(SMALL_STRAIGHT);

                    int[] arr = Arrays.stream(Arrays.copyOf(dice, 5))
                                      .distinct()
                                      .sorted()
                                      .toArray();
                    List<Integer> l = Arrays.asList(Util.boxIntArray(dice));
                    if (Arrays.binarySearch(arr, 1) >= 0 && Arrays.binarySearch(arr, 2) >= 0) {
                        holdIndices.add(l.indexOf(1));
                        holdIndices.add(l.indexOf(2));
                        holdIndices.add(l.indexOf(3));
                        holdIndices.add(l.indexOf(4));
                    }
                    else if (Arrays.binarySearch(arr, 2) >= 0 && Arrays.binarySearch(arr, 3) >= 0) {
                        holdIndices.add(l.indexOf(2));
                        holdIndices.add(l.indexOf(3));
                        holdIndices.add(l.indexOf(4));
                        holdIndices.add(l.indexOf(5));
                    }
                    else {
                        holdIndices.add(l.indexOf(3));
                        holdIndices.add(l.indexOf(4));
                        holdIndices.add(l.indexOf(5));
                        holdIndices.add(l.indexOf(6));
                    }
                    return new TurnChoice(toIntArray(holdIndices.toArray(new Integer[0])));
                }
            }

            if (isFreeCategory(FULL_HOUSE)) {
                int o = 0, t = o;
                for (int k = 1; k <= 6; k++) {
                    if (Util.count(Util.boxIntArray(dice), k) == 2) {
                        if (o < 1)
                            o = k;
                        else
                            t = k;
                    }
                }

                if (o > 0 && t > 0) {
                    for (int k = 0; k < 5; k++) {
                        if (dice[k] == o || dice[k] == t)
                            holdIndices.add(k);
                    }
                    return new TurnChoice(toIntArray(holdIndices.toArray(new Integer[0])));
                }
            }
        }
        else {
            Arrays.sort(freeCategories, Comparator.comparingInt((Category c) -> c.getScore(dice))
                                                  .thenComparingInt(this::getPriority)
                                                  .reversed());
            return new TurnChoice(freeCategories[0]);
        }

        return new TurnChoice(new int[0]);
    }

    private TurnChoice doYahtzeeProcess(int[] dice) {
        if (isUsableCategory(YAHTZEE))
            return new TurnChoice(YAHTZEE);

        Category c = Util.intToUpperCategory(dice[0]);
        if (isUsableCategory(c))
            return new TurnChoice(c);

        Category[] arr = Arrays.stream(freeCategories)
                               .filter(x -> x.isLower())
                               .sorted(Comparator.comparing(this::getPriority)
                                                 .reversed())
                               .toArray(Category[]::new);
        if (arr.length > 0)
            return new TurnChoice(arr[0]);

        Arrays.sort(freeCategories, Comparator.comparingInt(this::getPriority));
        return new TurnChoice(freeCategories[0]);
    }

    private boolean isFreeCategory(Category c) {
        return Arrays.binarySearch(freeCategories, c) >= 0;
    }

    private boolean isMatchingCategory(Category c) {
        return Arrays.binarySearch(matchingCategories, c) >= 0;
    }

    private boolean isUsableCategory(Category c) {
        return Arrays.binarySearch(usableCategories, c) >= 0;
    }

    private int getPriority(Category c) {
        switch (c) {
            case YAHTZEE: return -3;        // 50 points
            case LARGE_STRAIGHT: return -1; // 40 points
            case SMALL_STRAIGHT: return -2; // 30 points
            case FULL_HOUSE: return 10;     // 25 points
            case FOUR_OF_A_KIND: return 9;  // sum
            case THREE_OF_A_KIND: return 8; // sum
            case SIXES: return 7;
            case FIVES: return 6;
            case FOURS: return 5;
            case THREES: return 4;
            case TWOS: return 3;
            case ACES: return 2;
            case CHANCE: return 1;          // sum
        }
        throw new RuntimeException();
    }

    private int[] toIntArray(Integer[] arr) {
        int[] a = new int[arr.length];
        for (int k = 0; k < a.length; k++)
            a[k] = arr[k];
        return a;
    }
}

The bot looks for patterns in the dice that could match certain categories and holds the necessary ones. It immediately chooses a high-priority matching category if one's found; otherwise it chooses a category that yields the highest score. Scores nearly 200 points per game on average.

source: Stack Exchange

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

sort: votes


text:
Spaced-out numbers
Given a list of N non-negative integers, output those numbers with each left-padded by spaces to a length of N. (Alternatively, return a character/string list.) You may assume that N is greater than or equal to the number of digits of the largest number in the list. Trailing spaces are allowed in the output.
You may also take a string containing these numbers, but N is not the length of the string, but rather the number of elements in the list; also, you may take a list of strings e.g. ["1", "2", "3"].
This is a code-golf, so the shortest program in bytes wins.
Test cases
input => 'output'
0 => '0'
1 => '1'
2 3 => ' 2 3'
2 10 => ' 210'
4 5 6 => '  4  5  6'
17 19 20 => ' 17 19 20'
7 8 9 10 => '   7   8   9  10'
100 200 300 0 => ' 100 200 300   0'
1000 400 30 7 => '1000 400  30   7'
1 33 333 7777 => '   1  33 3337777'
0 0 0 0 0 0 => '     0     0     0     0     0     0'

Can the numbers be printed one on each line (with the proper padding)?

@LuisMendo yes.

05AB1E, 3 bytes
Code:
Dgj

Explanation:
D    # Duplicate the input array
 g   # Get the length
  j  # Left-pad with spaces to the length of the array

Try it online! or Verify all test cases.

Oh. Well that was finished quickly. Nice job!

Python, 32 bytes
lambda l:'%%%ds'%len(l)*len(l)%l

An anonymous function that takes a tuple as input. Either numbers or strings work.
Example:
l=(1,33,333,7777)

'%%%ds'
## A "second-order" format string

'%%%ds'%len(l)           -> '%4s'
## Inserts the length as a number in place of '%d'
## The escaped '%%' becomes '%', ready to take a new format argument
## The result is a format string to pad with that many spaces on the left

'%%%ds'%len(l)*len(l)    -> '%4s%4s%4s%4s'
## Concatenates a copy per element

'%%%ds'%len(l)*len(l)%l  -> '   1  33 3337777'
## Inserts all the tuple elements into the format string
## So, each one is padded with spaces

JavaScript (ES7), 37 bytes
a=>a.map(v=>v.padStart(a.length,' '))

Input: Array of strings
Output: Array of strings

f=
  a=>a.map(v=>v.padStart(a.length,' '))
;
console.log(f(['0']))
console.log(f(['1']))
console.log(f(['2','3']))
console.log(f(['2','10']))
console.log(f(['4','5','6']))
console.log(f(['17','19','20']))
console.log(f(['7','8','9','10']))
console.log(f(['100','200','300','0']))
console.log(f(['1000','400','30','7']))
console.log(f(['1','33','333','7777']))
console.log(f(['0','0','0','0','0','0']))

PowerShell v2+, 36 bytes
param($a)$a|%{"{0,$($a.count)}"-f$_}

Takes input $a as an array of integers. Loops through them with $a|%{...}. Each iteration, uses the -format operator with the optional Alignment Component (based on $a.count) to left-pad the appropriate number of spaces. That resultant string is left on the pipeline. At end of program execution, the resulting strings are all left on the pipeline as an array.

Examples
Output is newline-separated on each run, as that's the default Write-Output at program completion for an array.
PS C:\Tools\Scripts\golfing> @(0),@(1),@(2,3),@(2,10),@(4,5,6),@(17,19,20),@(7,8,9,10),@(100,200,300,0),@(1000,400,30,7),@(1,33,333,7777),@(0,0,0,0,0,0)|%{""+($_-join',')+" -> ";(.\spaced-out-numbers $_)}
0 ->
0
1 ->
1
2,3 ->
 2
 3
2,10 ->
 2
10
4,5,6 ->
  4
  5
  6
17,19,20 ->
 17
 19
 20
7,8,9,10 ->
   7
   8
   9
  10
100,200,300,0 ->
 100
 200
 300
   0
1000,400,30,7 ->
1000
 400
  30
   7
1,33,333,7777 ->
   1
  33
 333
7777
0,0,0,0,0,0 ->
     0
     0
     0
     0
     0
     0

JavaScript, 49 bytes
a=>a.map(n=>" ".repeat(a.length-n.length)+n)

Takes the arguments as a list of strings and also returns a list of strings.
Explanation:
a=>                                                   An unnamed function, which takes one argument, a
   a.map(n=>                               )          Do the following to each element n in a:
            " ".repeat(a.length-n.length)             Generate the spaces needed to justify the number
                                         +n           Append the number

An array of strings is acceptable, so .join("") is not needed.

a=>a.map(n=>(" ".repeat(l=a.length)+n).slice(-l)) is the same length but works on integers as well as strings.

Bash, 14
printf %$#d $@

Input list given at the command line.
Not much to explain here.  Simply uses built-in printf facilities to do the necessary padding, based off the number of passed args:

$# is the number of args passed
%<n>d is a printf format specifier that prints an integer with up to n leading spaces
$@ is the list of all args passed
The format specifier is reused for each member of $@.

Ideone.

Perl, 26 bytes
-4 bytes thanks to @Ton Hospel
25 bytes of code + -a flag.
printf"%*s",~~@F,$_ for@F

Run with :
perl -ae 'printf"%*s",~~@F,$_ for@F' <<< "10 11 12"

(On some older version of Perl, you might need to add -n)

Using the -a option will make your code shorter...

@TonHospel hum, that sounds fairly obvious, silly me.. Thanks for the reminder

Slightly different method avoids the loop and saves a byte: Try it online!

Ruby, 40 36 34 bytes
->m{m.map{|i|$><m{m.map{|i|$><m{                             } # lambda taking array m
    m.map{|i|                   }  # map over array using variable i
             $><<                  # output to $> (stdout)
                 i.rjust(m.size)   # right justify i to m's length

Vim, 19 bytes
YPPG!{<C-F>|R%ri<CR>djVGgJ
Takes a list of numbers one-per-line. Relies on :set expandtab, which is popular, but not universal.
You clearly want to use :right for this. The question is how to get the number of lines onto the command line. The traditional way is :%ri<C-R>=line('$'), but all that text is long.
The shorter, more enterprising approach is to form the command line using the normal mode ! command. It involves some weird workarounds, expanding the file by 2 lines then removing them again, but it comes out 2 bytes shorter. And I'm kinda shocked the garbled command line I get (like :%ri+4!) actually works, but it does.

I don't think you can rely on a feature that is off by default.

@DJMcMayhem I've spent far too many hours of my life fighting bad indent settings in vimgolf. Explicitly setting expandtab adds 7 strokes to this solution. The reason that's a problem is that I have to check for other approaches for avoiding/removing tabs that might now win. It's a lot of time, not at all fun, makes the quality of my solution worse, and doesn't even affect any of the test cases provided (none have 8+ numbers). If that's the rule, that's the rule, but I'd rather mark non-compete than do this without expandtab.

@DJMcMayhem About Ypp!{. It is indeed shorter. It also doesn't work. It would always bring the number 1 into the command line, regardless of the length of the file.

JavaScript (ES6), 47
Anonymous function, input: array of strings, output: array of strings
Using a recursive padding function
a=>a.map(x=>p(x),p=x=>x[a.length-1]?x:p(' '+x))

For an integer/string array as input, 49 bytes:
a=>a.map(x=>p(x),p=x=>(y=' '+x)[a.length]?x:p(y))

Test

f=
a=>a.map(x=>p(x),p=x=>x[a.length-1]?x:p(' '+x))

function update() {
  var l=I.value.match(/\d+/g)||[]
  O.textContent = f(l)
}

update()

<input id=I oninput='update()' value='1000,400,30,7'>

J, 4 bytes
":~#

Try it online!
Unary function taking the list of numbers on the right as an array and returning the padded string.
Here it is in use at the REPL. Note that input lines are indented three spaces.
   f=: ":~#
   f 2 3
 2 3
   f 2 10
 210
   f 1111 222 33 4
1111 222  33   4

Wow. You beat my reference solution in J! Very nice.

Jelly, 7 6 bytes
L⁶xaUU

Input is an array of strings. Try it online! or verify all test cases.
How it works
L⁶xaUU  Main link. Argument: A (array of strings)

L       Yield the l, the length of A.
 ⁶x     Repeat ' ' l times.

    U   Upend; reverse all strings in A.
   a    Perform vectorizing logical AND, replacing spaces with their corresponding
        digits and leaving spaces without corresponding digits untouched.
     U  Upend; reverse the strings in the result to restore the original order of
        its digits, moving the spaces to the left.

PHP, 55 Bytes
<?foreach($a=$_GET[a]as$i)printf("%".count($a)."s",$i);

Pevious Version 59 Bytes
<?foreach($a=$_GET[a]as$i)echo str_pad($i,count($a)," ",0);

Why using str_pad, when printf is enough ? foreach($a=$_GET[a]as$i)printf("%".count($a)."s",$i);

Mathematica, 25 bytes
#~StringPadLeft~Length@#&

Both input and output are lists of strings.
Explanation
Length@#

Get the length of the input (number of element).
#~StringPadLeft~...

Pad left each element in the input so that their lengths match the length of the input.

Java, 83 82 bytes
a->{String s="";for(int i=a.length,j=i;i-->0;)s+="%"+j+"s";return s.format(s,a);};

Constructs a format string designed to pad the given arguments by a number of spaces equal to the length of the array. The format string is used as an argument for String.format, and the result is then returned. The functional interface can accept either a String[] or an Integer[] or similar.
Full class:
public class Test {
    public static void main(String[] args) {
        java.util.function.Function<Integer[], String> f = a -> {
            String s = "";
            for (int i = a.length, j = i; i-- > 0;)
                s += "%" + j + "s";
            return s.format(s, a);
        };

        System.out.println(f.apply(new Integer[] {0}));
        System.out.println(f.apply(new Integer[] {2, 10}));
        System.out.println(f.apply(new Integer[] {7, 8, 9, 10}));
        System.out.println(f.apply(new Integer[] {1, 33, 333, 7777}));
        System.out.println(f.apply(new Integer[] {0, 0, 0, 0, 0, 0}));
    }
}

Try it on Ideone.
-1 byte thanks to @KevinCruijssen.

Nice approach, +1. You can golf it by 1 byte by putting the int ... and s+=... inside the if like this: for(int i=a.length,j=i;i-->0;s+="%"+j+"s");

Haskell, 47 bytes
k=length
f l=map(\s->replicate(k l-k s)' '++s)l

That’s a function from a list of strings to a list of strings, like the JavaScript answers. replicate allows one to get a list (Haskell strings are lists of characters) of a given size, so I use it — and the bolded assumption in the problem — to generate the padding (its length is N − <length of element>, for each element of the input list). I would have preferred to use a printf based solution rather than this one with replicate (it would have been shorter, for one thing) but the import statement kills any savings done on the function itself.

Groovy, 36 Bytes
{a->a.collect{it.padLeft(a.size())}}

Takes in array of strings only, outputs array of padded strings.

CJam, 11 bytes
lS%_,f{Se[}

Try it online! (As a test suite.)
Explanation
l      e# Read input.
S%     e# Split around spaces.
_,     e# Copy and get length.
f{     e# Map this block over the list, passing in the length on each iteration.
  Se[  e#   Left-pad to the given length with spaces.
}

Kotlin, 90 bytes
Golfed:
fun main(a:Array<String>){a.forEach{b->for(i in 1..a.size-b.length){print(" ")};print(b)}}

Ungolfed:
fun main(a: Array<String>) {
    a.forEach { b ->
        for (i in 1..a.size - b.length) {
            print(" ")
        }
        print(b)
    }
}

MATL, 14 bytes
'%%%dd'inYDGYD

Try it out at MATL Online
This uses formatted string creation by first constructing the format string: %(NUM)d and then applies string formatting again using this format string and the input.

K (oK), 11 bytes
Solution:
,/(-#x)$$x:

Try it online!
Explanation:
Interpretted right-to-left. Convert to string, and left-pad with length of list, then flatten:
,/(-#x)$$x: / the solution                      | example:
         x: / save as 'x'                       |
        $   / string                            | $10 20 30 -> "10","20","30"
       $    / pad right by left                 | 5$"abc" -> "abc  "
  (   )     / do the stuff in brackets together |
    #x      / count x                           | #10 20 30 -> 3
   -        / negate                            |
,/          / flatten (concatenate-over)        | ,/" a"," b"," c" -> " a b c"

JavaScript 33 bytes
similar to @Hedi - but the default padding is ' ', so its 4 chars less
a=>a.map(s=>s.padStart(a.length))

f=a=>a.map(s=>s.padStart(a.length))

console.log(f(["0"]))
console.log(f(["1"]))
console.log(f(["2","3"]))
console.log(f(["2","10"]))
console.log(f(["17" ,"19" ,"2"]))
console.log(f(["1000" ,"400" ,"30" ,"7"]))

C#, 39 bytes
s=>s.ConvertAll(c=>c.PadLeft(s.Count));

Takes a List<string> and outputs a List<string>.
Explanation:
/*Func<List<string>, List<string>> Lambda =*/ s =>
    s.ConvertAll(c =>                                // Create a new List<string> by...
        c.PadLeft(s.Count)                           // ...padding each element by 'N'
    )
;

Would've been a few bytes shorter to use LINQ if the import isn't counted and then returning IEnumerable<string> instead of a full blown list:
C#, 35+18 = 53 bytes
using System.Linq;s=>s.Select(c=>c.PadLeft(s.Count));

R, 47 bytes
cat(sprintf("%*.f",length(n<-scan()),n),sep="")

Reads input from stdin and uses C-style formating with sprintf. There should be some way the cat function is not needed but couldn't find a way to suppress the quotes on each element without it. If we only want start and end quotes we could use the slightly longer option:
paste0(sprintf("%*.f",length(n<-scan()),n),collapse="")

Pyth - 7 bytes
Straightforward answer using padding builtin.
sm.[;lQ

Test Suite.

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

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


text:
String Calculator
Assume you're writing in one method, (or whatever you call them) with 3 inputs: the first string, a character that contains a +, - or * symbol, and the second string.
Example in Java:
public String strCalc(String str1, char sym, String str2) {
    //code...
}

What it should return:
str1 sym str2 ans
A     +  A   =  B
A     +  B   =  C
B     +  B   =  D
Z     +  A   =  AA
W     +  B   =  Y
A     -  A   =  ' ' (Space Character)
A     -  B   =  -A
A     -  C   =  -B
B     -  A   =  A
CA    -  A   =  BZ
A     *  A   =  A
B     *  B   =  D

Think of a one-indexed base 26.
Then convert the numbers back to letters based on their position in the alphabet.
0 = ' ' (Space Character)
1 = A
2 = B
3 = C
4 = D
5 = E
6 = F
7 = G
8 = H
9 = I
10 = J
11 = K
and so on...

This is code-golf, so the shortest code in bytes not including the method declaration wins.

Are full programs allowed?

This must be done within one method, if methods don't exist in the language you use, you may use full programs.

I assume this is meant to just be math in one-based base 26, but could you clarify?

I removed division because that would simply be too tedious.

Must the method be able to handle zero (space-character) and negative inputs (such as "-AB")?

Jelly, 64 63 bytes
Aḃ26ịØA
O_64»0ḅ26
e”-NḤ’×Ç
³Ç;“*×-_”y⁴¤;⁵Ç¤V
¢<0”-x;¢1Ŀ¤
¢⁶¢L¤?

Not a particularly clean solution; there are no 3 argument methods in Jelly, so this is a full program.
Accepts negative inputs like "-A", "- A", " -A", ... (note however "--A" is treated as "-A")
Accepts zero inputs like "", " ", "  ", ...
TryItOnline
How?
Aḃ26ịØA           - Link 1, convert integer to absolute value string: i
A                 - absolute value of i
 ḃ26              - convert to bijective base 26 (a list of integers in [1,26])
    ị             - index into (1-based)
     ØA           - alphabet yield -> "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                  - (note: 0 will convert to an empty string here.)

O_64»0ḅ26         - Link 2, convert an input string to a positive integer: s
O                 - cast to ordinal (vectorises)
 _64              - subtract 64 from each (A->[1], B->[2], ..., AZ->[1,26], ...)
    »0            - maximum of that and zero ("-" and space become zeros; vectorises)
      ḅ26         - convert from base-26 to an integer (26 place values still work)

e”-NḤ’×Ç          - Link 3, convert an input string to an integer: s
 ”-               - literal '-'
e                 - exists in s?
   N              - negate
    Ḥ             - double
     ’            - increment (if "-" was in s we have -1, else we have 1)
      ×           - multiply by
       Ç          - call last link (2) as a monad

³Ç;“*×-_”y⁴¤;⁵Ç¤V - Link 4, evaluate the operation: niladic
³                 - first program input
 Ç                - call last link (3) as a monad (value of first input as an integer)
  ;               - concatenate with
           ¤      -     nilad followed by link(s) as a nilad
          ⁴       -     second program input
         y        -     map characters
   “*×-_”         -     literal "*×-_" - change "*" to "×" and "-" to "_"
            ;     - concatenate with
               ¤  -     nilad followed by link(s) as a nilad
             ⁵    -     third program input
              Ç   -     call last link (3) as a monad (value of 3rd input as integer)
                V - evaluate string as Jelly code (something like "-76×5" or "3_2")

¢<0”-x;¢1Ŀ¤       - Link 5, form output for non-zero results: niladic
¢                 - call the last link (4) as a nilad (integer result)
 <0               - less than zero?
   ”-             - literal '-'
     x            - repeat ('-' if negative '' if positive or zero)
      ;           - concatenate with
          ¤       -     nilad followed by link(s) as a nilad
       ¢          -     call the last link (4) as a nilad (integer result)
        1Ŀ        -     call the next link (1) as a monad (as absolute string)

¢⁶¢L¤?            - Main link: niladic (the program arguments expected however)
     ?            - ternary if
    ¤             -     nilad followed by link(s) as a nilad
  ¢               -     call the last link (5) as a nilad
   L              -     length
                  - True case (has length)
¢                 -     call the last link (5) as a nilad
                  - False case (no length)
 ⁶                - literal ' '

CA - A should be BZ
-CA - A should be -BZ

CA - A should be BZ

Should all work now.

Assembler x86 (32-bit) - 142 bytes
The 142 bytes are the compiled size (not the source code size, which is larger). Note that for assembler the size of the compiled code is not dependend on the compiler used but it should always be 142 bytes.
The calling convention is "_cdecl" so you can call the function from C:
const char *strCalc(const char *num1,
    char operation, const char *num2, char *bufferEnd);

The function accepts negative inputs (such as "-AB") and zero (" "). However malformed inputs might crash the program!
The last argument points to the LAST byte of a buffer used to store the sring because C does not support strings without pre-allocated buffers.
The function returns the pointer to the string (somewhere in the buffer). The function may be called the following way:
#include <stdio.h>

const char *strCalc(const char *num1, char operation, const char *num2, char *bufferEnd);

main(int argc,char **argv)
{
    char buf[21];
    puts(strCalc(argv[1],argv[2][0],argv[3],buf+20));
}

Here is the actual function (Linux users: Replace "_strCalc" by "strCalc"):
    .globl _strCalc
    .text
_strCalc:
    push %ebx
    push %esi
    push %edi
    mov 16(%esp), %esi
    call loadNum
    push %ebx
    mov 28(%esp), %esi
    call loadNum
    pop %eax
    # This assumes that the operation is ONLY +, * or -!
    cmpb $0x2B, 20(%esp)
    je isPlus
    jb isMultiply
    sub %ebx, %eax
    jmp calcDone
isPlus:
    add %ebx, %eax
    jmp calcDone
isMultiply:
    xor %edx, %edx
    imul %ebx
calcDone:
    push %eax
    mov 32(%esp), %edi
    std
    xor %al, %al
    stosb
    pop %eax
    call writeOut
    mov %al, (%edi)
    mov %edi, %eax
    inc %eax
    pop %edi
    pop %esi
    pop %ebx
    # Needed due to MSVCRT.DLL bug!
    cld
    ret

    # Write EAX to the buffer
    # EDI points to the last character to be
    # written (the terminating NUL has already been written)
    # Returns: EDI pointer to the first character!
writeOut:
    test %eax, %eax
    jnz notZero
    mov $0x20, %al
    stosb
    ret
notZero:
    jns notNegative
    neg %eax
    call writeOut
    mov $0x2D,%al
    stosb
    ret
notNegative:
    xor %edx, %edx
    dec %eax
    div %ecx
    xchg %al, %dl
    add $0x41, %al
    stosb
    xchg %al, %dl
    test %eax, %eax
    jnz notNegative
    xchg %al, %dl
    ret

    # Load number from string ESI points to to EBX
    # Destroys EAX, ECX, EDX
    # Allows negative and zero inputs!
    # Assumes syntactically correct numbers!
    # Sets ECX to 26 (needed later!)
loadNum:
    xor %ebx, %ebx
    xor %eax, %eax
    mov $26, %al
    mov %eax, %ecx
nextLoad:
    cld
    lodsb
    and $0xDF, %al
    jz endOfLoad
    sub $0x40, %al
    jc negativeInput
    xchg %eax, %ebx
    mul %ecx
    add %eax, %ebx
    jmp nextLoad
negativeInput:
    call loadNum
    neg %ebx
endOfLoad:
    ret