APL (Dyalog Unicode), 27 bytes

{(⌽,⊢)⍉↑↑∘'O'¨1,1-1↓+⍳⍵+1}

Try it online!

-2 bytes from kritixilithos at the APL Orchard.

Explanation

{(⌽,⊢)⍉↑↑∘'O'¨1,1-1↓+⍳⍵+1}
                      ⍳⍵+1  range 1 - n+1
                    +      cumulative sum over each element
                  1↓        drop the first value (0)
                1-          subtract 1 from each value
              1,            prepend 1 to it.
             ¨              for each element,
        ↑∘'O'               prepend(element-1) spaces to 'O'.
       ↑                    convert to matrix
      ⍉                     transpose
 (⌽,⊢)                      prepend its reverse (palindromize).

MathGolf, 17 bytes

r{n*íï- *'oï *+_x

Try it online!

Explanation

r                   range(0, n)
 {                  start block or arbitrary length
  n                 newline char, or map array with newlines
   *                pop a, b : push(a*b)
    í               get total number of iterations of for loop
     ï              index of current loop, or length of last loop
      -             pop a, b : push(a-b)
                    space character
        *           pop a, b : push(a*b)
         '          push single character
          o         print TOS without popping
           ï        index of current loop, or length of last loop
                    space character
             *      pop a, b : push(a*b)
              +     pop a, b : push(a+b)
               _    duplicate TOS
                x   reverse int/array/string

Pyth, 26 bytes

VyhQ=+Y+*ZdO=+ZQ=tQ)j_.tY

Try it Online

Explanation

VyhQ=+Y+*ZdO=+ZQ=tQ)j_.tY
                            Implicit Q=input() (speed), Z=0 (position), Y=[].
VyhQ                )       For N in [0,...,2Q+2]...
       +*ZdO               ... prepend Z spaces to 'O'...
    =+Y                     ... add that line to Y...
             =+ZQ=tQ        ... then update position and speed.
                     j_.tY  Combine the lines to form the parabola.

Perl 5, 48 bytes

47 bytes code + 1 for -n.

$_++;print$/x$-,$"x$_,O,$"x($-++*2),O while$_--

Try it online!

Python 2, 59 bytes

f=lambda n,r='O':(r*n and f(n-1,' '+r))+'n'*n+r+'  '*n+'O'

Try it online!

Röda, 53 52 bytes

f n{seq 0,n|{|i|["
"*i," "*(n-i),"O"," "*i*2,"O"]}_}

Try it online!

Usage: main { f(5) }

Ungolfed version:

function f(n) {
    seq(0, n) | for i do
        push("n"*i, " "*(n-i), "O", " "*i*2, "O")
    done
}

Haskell, 69 bytes

r=replicate
f n=[0..n]>>= a->r a 'n'++r(n-a)' '++'O':r(2*a)' '++"O"

Usage example: f 3 -> " OOn O Onn O OnnnO O". Try it online!.

Haskell, 77 bytes

n!x=[1..n]>>x
-1#i=[]
x#i=(x-1)#(i+1)++x!"n"++i!" "++'O':(2*x)!" "++"O"
(#0)

Try it online! Usage: (#0) 5

VBA, 124 112 85 88 66 63 59 bytes

For i=0To[A1]:?Space([A1]-i)"O"Space(2*i)"O"String(i,vbCr):Next

_{^{Saved 29 bytes in total thanks to Taylor Scott}}

This must be run the in VBA Immediate window and print the result in the same.

Expanded / Formatted, it becomes:

For i=0 To [A1]
   Debug.Print Space([A1]-i) & "O" & Space(2*i) & "O" & String(i,vbCr)
Next

_{(It turns out that concatenation in a print command is automatic without an operator.)}

AHK, 93 bytes

m=0
n=1
f=%1%-1
Loop,%1%{
r=%r%{VK20 %f%}O{VK20 %m%}O{`n %n%}
m+=2
n++
f--
}
FileAppend,%r%,*

If I could figure out how to do math inside of repeating keystrokes, that'd be great.
- VK20 equates to a space
- FileAppend outputs to stdout if the filename is *

05AB1E, 18 13 bytes

ÝηRO«ð×'O«ζ»

Try it online!

Ý                # [0..n]
 €LRO            # [0.sum(), 0..1.sum(), ..., 0..n-1.sum(), 0..n.sum()]
     «          # Mirror image the array [0, 0..n.sum(), 0]
       ð×'O«     # Push that many spaces with an O appended to it.
            .B   # Pad small elements with spaces to equal largest element length.
              ø» # Transpose and print.

Java 8, 129 124 109 bytes

Golfed:

v->{String s="",t="";for(int j,y=0;y<=v;++y){for(j=0;j<v;++j)s+=j<y?"n":" ";s+="o"+t+"o";t+="  ";}return s;}

Try it online!

Ungolfed:

public class DrawTheArcOfABall {

  public static void main(String[] args) {
    for (int i = 1; i < 6; ++i) {
      System.out.println(f(v -> {
        String s = "", t = "";
        for (int j, y = 0; y <= v; ++y) {
          for (j = 0; j < v; ++j) {
            s += (j < y ? "n" : " ");
          }
          s += "o" + t + "o";
          t += "  ";
        }
        return s;
      } , i));
      System.out.println();
      System.out.println();
    }
  }

  private static String f(java.util.function.IntFunction<String> f, int v) {
    return f.apply(v);
  }
}

R, 89 bytes

a=2*v+3
x=matrix(" ",a,v^2+1)
for(k in 0:v)x[c(1-k,k+2)+v,k^2+1]="o"
x[a,]="n"
cat(x,sep="")

• Create a matrix of spaces (the variable a is the width of this matrix, saving a couple of bytes)
• Fill in "o"s at the required locations, working from the top of the arc downwards and outwards
• Add a newline at the end of each matrix row
• Collapse the matrix down to a single string and print

This is my first attempt at golfing, comments welcome...

V, 23 19 bytes

2éoÀñYço/^2á O
HPJ>

Try it online!

Explain

2éo            " Insert two 'o's
   Àñ          " <Arg> times repeat
     Y         " Yank the current (top) line.  This is always 's*oo'
      ço/      " On every line that matches 'o'
         ^     " Go to the first non-whitespace character (the 'o')
          2á   " Append two spaces (between the two 'o's
             O " Add a blank line on top of the current one
H              " Go to the first line
 P             " Paste in front ('s*oo')
  J            " Join this line with the blank line immediately after it
   >           " Indent once

Bash, 76 bytes

for((n=$1+1;--n;));{
yes ''|head -$n
r=$r›${n}AO
t=›${n}BO$t
}
echo O${r}O$t

Only works in a terminal since it uses ANSI escape sequences. › represents the CSI byte (0x9b).

Test run

$ # The terminal's encoding must be set to ISO-8859-1.
$
$ xxd -g 1 arc.sh
0000000: 66 6f 72 28 28 6e 3d 24 31 2b 31 3b 2d 2d 6e 3b  for((n=$1+1;--n;
0000010: 29 29 3b 7b 0a 79 65 73 20 27 27 7c 68 65 61 64  ));{.yes ''|head
0000020: 20 2d 24 6e 0a 72 3d 24 72 9b 24 7b 6e 7d 41 4f   -$n.r=$r.${n}AO
0000030: 0a 74 3d 9b 24 7b 6e 7d 42 4f 24 74 0a 7d 0a 65  .t=.${n}BO$t.}.e
0000040: 63 68 6f 20 4f 24 7b 72 7d 4f 24 74              cho O${r}O$t
$
$ bash arc.sh 1
 OO
O  O
$ bash arc.sh 2
  OO
 O  O

O    O
$ bash arc.sh 3
   OO
  O  O

 O    O


O      O
$ bash arc.sh 4
    OO
   O  O

  O    O


 O      O



O        O

PHP, 76 bytes

for(;$argn>=0;$s.="  ")echo($r=str_repeat)("
",$i++),$r(" ",$argn--),o,$s,o;

Run with echo <v> | php -nR '<code>' or test it online.

loops $argn down from input to 0 and $i up from 0;
prints - in that order - in each iteration

• $i newlines (none in the first iteration)
• left padding: $argn spaces
• left ball: o
• inner padding: 2*$i spaces
• right ball: o

Befunge, 75 73 bytes

<vp00:&
1<-1_:v#+55:g01-g01g00" O"1*2g01" O"1p0
#@_:v>$$:!
1,:_^#:-

Try it online!

The first line reads in the velocity, v, and saves a copy in memory. The second line then counts down from v to zero, with the index i, and on each iteration pushes a sequence of character/length pairs onto the stack.

Length  Character
-----------------
1       'O'
i*2     ' '
1       'O'
v-i     ' '
i       LINEFEED

This sequence represents a kind of run-length encoding of the required output in reverse. The last two lines then simply pop these character/length pairs off the stack, outputting length occurrences of each character, until the stack is empty.

Python 2, 65 bytes

f=lambda n,x=0:(n and f(n-1,x+1)or'')+'n'*n+' '*x+'O'+'  '*n+'O'

Try it online!

Retina, 29 19 bytes

 ?
$.`$*¶$&$'O$`$`O

Try it online!

Takes input in unary as a run of spaces. Port of my JavaScript answer. Edit: Saved 10 bytes thanks to @MartinEnder♦.

JavaScript (ES6), 87 bytes

f=
n=>' '.repeat(n+1).replace(/./g,"$`#$'O$`$`O").replace(/ *#/g,s=>[...s].fill``.join`
`)

<input type=number min=0 oninput=o.textContent=f(+this.value)><pre id=o>

Nonrecursive solution. Indexing requirement was annoying, both in the above and the following 62-byte (I don't know whether it would result in a shorter Retina port) recursive solution:

f=n=>~n?` `.repeat(n)+`OO`+f(n-1).replace(/^ *O/gm,`
$&  `):``

Ruby, 52 bytes

->x{(0..x).map{|a|$><<$/*a+' '*(x-a)+?O+' '*a*2+?O}}

No trailing newline (allowed by the rules: "at most one trailing newline")

Jelly, 17 16 bytes

‘Ḷ+Ṛ⁶ẋ;€”Om0z⁶Y

Try it online!

How?

‘Ḷ+Ṛ⁶ẋ;€”Om0z⁶Y - Main link: v         e.g. 3
‘                - increment: v+1            4
 Ḷ               - lowered range             [0,1,2,3]
  +             - reduce with addition      [0,1,3,6]
    Ṛ            - reverse                   [6,3,1,0]
     ⁶           - a space                   ' '
      ẋ          - repeat (vectorises)       ['      ','   ',' ','']
       ;€        - concatenate each with
         ”O      -     an 'O'                ['      O','   O',' O','O']
           m0    - concatenate reflection    ['      O','   O',' O','O','O','O ','O   ','O      ']
             z⁶  - transpose with space fill ['   OO   ','  O  O  ','        ',' O    O ','        ','        ','O      O']
               Y - join with line feeds      ['   OO   n  O  O  n        n O    O n        n        nO      O']
                 - implicit print

JavaScript (ES6), 98 92 89 84 78 bytes

(-20 bytes thanks to Arnauld!)

f=(v,i=0)=>i>v?"":" "[r="repeat"](v-i)+0+" "[r](2*i)+0+`
`[r](i++<v&&i)+f(v,i)

A recursive solution. This is also my first ever answer in JavaScript, so please be gentle! I am still learning all this neat language has to offer, so golfing tips are very much appreciated. :)

Test Snippet

You may need to scroll to see the entire output.

f=(v,i=0)=>i>v?"":" "[r="repeat"](v-i)+0+" "[r](2*i)+0+`
`[r](i++<v&&i)+f(v,i)

<input id=i min=1 type=number><button onclick=alert(f(document.getElementById("i").value))>Submit</button>

Batch, 163 bytes

@set l=@for /l %%i in (1,1,%1)do @call
@set s=
%l% set s= %%s%%
@set t=
%l%:c&for /l %%j in (2,1,%%i)do @echo(
:c
@echo %s%O%t%O
@set s=%s:~1%
@set t=  %t%

05AB1E, 18 14 bytes

Saved 4 bytes thanks to Adnan

ƒ¶N×'ONúRÂJ}.c

Try it online!

Explanation

ƒ                   # for N in [0 ... input]
 ¶N×                # push N newlines
    'O              # push "O"
      Nú            # pad with N spaces in front
        RÂ          # reverese and create a reversed copy
          J         # join everything to a string
           }        # end loop
            .c      # pad lines until centered 

MATL, 19 17 bytes

Q:tqYsQ79Z?PtPv!c

Try it at MATL Online! Or verify all test cases.

Explanation

Q        % Implicitly input v. Add 1
:        % Push [1 2 ... v+1]
tq       % Duplicate and subtract 1: pushes [0 1 ... v]]
Ys       % Cumulative sum: gives [0 1 3 6 ...]
Q        % Add 1: gives [1 2 4 7 ...]
79       % Push 79 (ASCII for 'O')
Z?       % Create sparse matrix from column indices [1 2 3 4 ...],
         % row indices [1 2 4 7 ...], and data 79
P        % Flip vertically
tP       % Duplicate, flip vertically
v        % Concatenate the two matrices vertically
!        % Transpose
c        % Convert to char. Implicitly display. Char 0 is shown as space

Retina, 35

• 2 bytes saved thanks to @MartinEnder

Port of my sed answer:

.+
$* OO
+`(s*) (O *)O$
$&¶$1O $2 O

Try it online.

Stacked, 67 63 bytes

args 0#1+:@x:>{!n x-1-' '*'O'+n 2*' '*+'O'+x 1-n!=n*LF*+out}"!

Initial attempt, 67 bytes

args 0# :@v 1+2*:>[:v:+1+-2/*' '*'O'+''split]"!fixshape tr rev out

Full program. Generates something like:

('O'
 ' ' 'O'
 ' ' 'O'
 'O')

Which is the padded, transposed, reversed, and outputted.

GNU sed, 41

• Score includes +1 from -r flags to sed.

s/$/OO/
:
s/(s*) O( *)O$/&n1O 2 O/
t

Input is in unary, as a string of spaces - the length of string is the input.

Try it online.

Charcoal, 18 16 13 bytes

-3 bytes thanks to @Neil!

Ｆ⊕Ｎ«←OＭ⊕ι↓»‖Ｃ

Explanation

Ｆ⊕Ｎ«        »    For ι (implicitly from 0) to (1 + input as number)
       ←O          Print O, with print direction rotated 180 degrees
         Ｍ⊕ι↓     Move 1+ ι units down
               
                ‖Ｃ Reflect (in the default direction, right), leaving original intact

Try it online! Link is to verbose code.

RProgN 2, 37 bytes

x=0xR{y@xy-` *`o` y2**`o...2y{[` };};

Getting in with my kind-of-golfy language before the proper golfy langauges jump in.

Explained

x=              # Set 'x' to the input
0xR{            # For everything between the input and 0
    y@          # Set the iteration value to y, for this function only.
    xy-` *      # Subtract y from x, repeat the string " " that many times.
    `o          # Push an "o" to the stack.
    ` y2**      # Push 2*y " "'s to the stack
    `o          # Push another "o" to the stack
    ...         # Concatenate the parts of this string together, giving us the two balls.
    2y{[` };    # For all numbers between 2 and y, add a newline.
};              #

Try it online!

Python 2, 76 bytes

x=input()
for i in range(x):print' '*(x-i),'O'+' '*i*2+'O'+'n'*(i-x+1and i)

Pretty simple. The i-x+1and i is to prevent a bunch of trailing newlines.

C, 93 92

(Note, someone got to 87 in the comments)

y,n;f(s){for(y=0;y<=s;){printf("%*c%*c",s-y+1,79,y*2+1,79);for(n=++y;s+1-n&&n--;)puts("");}}

Try it online!

Readable:

y,n;f(s){
    for(y=0;y<=s;){
        printf("%*c%*c",s-y+1,79,y*2+1,79);
        for(n=++y;s+1-n&&n--;)puts("");
    }
}

Notes:

I can collapse both for loops into just one for loop by iterating the total number of lines outputted, which is given by the formula: n*-~n/2+1

y,n,r;f(s){
    for(r=s,y=n=0;r<s*-~s/2+1;)
        y==n?printf("%*c%*c",s-y+1,79,y*2+1,79),y=0,++n:r++,y++,puts("");
}

But it ends up being even more bytes than just using two seperate for-loops