[Question]
  [
A sculptor is tasked to creating icicle sculptures for the new museum in Greenland. He has been given specifications by his boss, which consists of two numbers: [s, m] or size and melt. Size *must* be an odd number. He was given some photos of real icicles:
```
vvvvv [5, 0]
 vvv 
  v
vvvvvvv [7, 0]
 vvvvv 
  vvv
   v
vvvvvvv [7, 2]
 vvvvv 
vvvvvvv [7, 3]
vvv [3, 1]
```
He needs a program to help draw. Any language allowed. The program needs to take in S and M, any method of input acceptable. You must then print out an ascii art representation of it.
S is how many `v`s are on the first layer. M is how many layers are cut out from the bottom.
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so as usual this competition is **byte based**. White space does count for byte counting. Least bytes wins.
*Edit:*
You will never get a set of numbers that draws nothing, for example [5, 3]. Checking code is *not* required however.
  
[Answer]
# [V](http://github.com/DJMcMayhem/V), 15 bytes
```
Àévò^lYp2x>òÀñd
```
[Try it online!](http://v.tryitonline.net/#code=w4DDqXbDsl5sWXAyeD7DssOAw7Fk&input=&args=Nw+Mg)
Fairly straightforward.
```
À               " Arg1 times:
 év             "   Insert a 'v'
   ò       ò    " Recursively:
    ^l          "   Break if there is only one character on this line
      Y         "   Yank this line
       p        "   Paste it below us
        2x      "   Delete two characters
          >     "   Indent this line
            À   " Arg2 times:
             ñd "   Delete a line
```
[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), 12 bytes
Code:
```
ÅÉ'v×R²F¨}.c
```
Explanation:
```
ÅÉ             # List of uneven numbers: [1, 3, 5, ..., input]
  'v×          # String multiply by 'v', giving ['v', 'vvv', 'vvvvv', ...]
     R         # Reverse the array
      ²F }     # Second input times, do...
        ¨      #   Remove the first element of the array
          .c   # Centralize the array
```
Uses the **CP-1252** encoding. [Try it online!](http://05ab1e.tryitonline.net/#code=w4XDiSd2w5dSwrJGwqh9LmM&input=Nwoy)
[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), 11 bytes
```
;-Ý·¹+'v×.c
;-          Compute x = Input[1]-Input[0]/2  (e.g. 7,2 -> -1.5)
  Ý         Push [0, ..., x]                 (e.g. 7,2 -> [0, -1])
   ·        Multiply each value by 2         (e.g. 7,2 -> [0, -2])
    ¹+      Add Input[0] to each value       (e.g. 7,2 -> [7, 5])
      'v×   String multiply by 'v'
         .c Center all strings and implicitly display them  
```
[Try it online!](http://05ab1e.tryitonline.net/#code=Oy3DncK3wrkrJ3bDly5j&input=Nwoy)
[Answer]
# [MATL](http://github.com/lmendo/MATL), 22 bytes
```
'v'itQ2/i-wX"R2&PRZ{Zv
```
[Try it online!](http://matl.tryitonline.net/#code=J3YnaXRRMi9pLXdYIlIyJlBSWntadg&input=Nwoy)
### Explanation
```
'v'   % Push character 'v'
it    % Input first number. Duplicate
Q2/   % Add 1 and divide by 2
i-    % Input second number. Subtract
w     % Swap
X"    % Char matrix of 'v' repeated those many times along each dim
R     % Upper triangular part
2&P   % Flip horizontally
R     % Upper triangular part
Z{    % Split char matrix along first dimension into a cell array of strings 
Zv    % Remove trailing spaces from each string. Implicitly display
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 19 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
Rm-2”vẋµLḶ⁶ẋżðḣL_¥Y
```
**[TryItOnline!](http://jelly.tryitonline.net/#code=Um0tMuKAnXbhuovCtUzhuLbigbbhuovFvMOw4bijTF_CpVk&input=&args=Nw+MA)**
### How?
```
Rm-2”vẋµLḶ⁶ẋżðḣL_¥Y - Main link: s, m
       µ            - monadic chain separation
R                   - range(s)  [1,2,3,...s]
 m-2                - mod -2    [s,s-2,s-4,...,1]
    ”v              - 'v'
      ẋ             - repeat    ['v'*s,...,'vvv','v']  (call this y)
             ð      - dyadic chain separation
        L           - length, effectively (s+1)/2
         Ḷ          - lowered range [0,1,2,...length-1]
          ⁶         - ' '
           ẋ        - repeat ['', ' ', ... ' '*(length-1)]
            ż       - zip with y
                 ¥  - last two links as a dyad
               L    -     length
                _   -     subtract m
              ḣ     - head
                  Y - join with line feeds
                    - implicit print
```
[Answer]
## Batch, 142 bytes
```
@set/ah=%1-%2-%2
@set s=v
@for /l %%i in (3,2,%1)do @call set s=%%s%%vv
@for /l %%i in (1,2,%h%)do @call echo %%s%%&call set s= %%s:~0,-2%%
```
[Answer]
# Ruby, ~~46~~ 44 bytes
```
->s,m{0.upto(s/2-m){|i|puts' '*i+?v*s;s-=2}}
```
2 bytes saved thanks to G B
[Answer]
# Python, ~~76~~ 73 bytes
```
def f(s,m):print"\n".join([' '*(s/2-i/2)+'V'*i for i in range(s,m*2,-2)])
```
**Edit:** Saved 3 bytes thanks to @TuukkaX and @Challenger5 (Thanks!)
[Answer]
## JavaScript (ES6), 57 bytes
```
f=(s,m,p=``)=>s<m+m?``:p+`v`.repeat(s)+`
`+f(s-2,m,p+` `)
```
Outputs a trailing newline. If a leading newline is acceptable, then for 54 bytes:
```
f=(s,m,p=`
`)=>s<m+m?``:p+`v`.repeat(s)+f(s-2,m,p+` `)
```
[Answer]
## Python 2, 63 bytes
```
lambda s,m:'\n'.join((s-x)/2*' '+x*'v'for x in range(s,m*2,-2))
```
[Answer]
# [Turtlèd](https://github.com/Destructible-Watermelon/Turtl-d), 53 bytes
```
@v?,:l[v,l][ [ l]rr[ d,ur]ld' l]?<:d[ [ u]d[ ' d]luu]
```
### [Try it online!](http://turtled.tryitonline.net/#code=QHY_LDpsW3YsbF1bIFsgbF1yclsgZCx1cl1sZCcgbF0_PDpkWyBbIHVdZFsgJyBkXWx1dV0&input=Nwox)
## Explanation:
```
@v,           set char var to v, write it to cell
   ?:l        take positive int input, move that many character right, move 1 left
      [v,l]   move left back to the v, writing v on all the cells it goes on
           [                   ]                      until the current cell is a space
             [ l]    move left until finding a space
                 rr  move two right
                   [     ]  until cell is a space
                     d,ur   move down, write v, move up and right
                          ld' l    move left, down, write space
                                [end of big loop]
                                  [that part made the "icicle", the next melts some]
                                ?<:    
           Take integer input again,
           rotate counterclockwise, move that number right (now up the icicle)
                                    d      move down
                                     [               ] until cell is space
                                       [ u]d   up until space is found, down 1
                                            [ ' d]  until space is found, write space to cell and move down
                                                  luu    move left, up, up
                                                   [end loop]
```
[Answer]
## Java, ~~138~~ 137 bytes
```
void m(int l,int r){int f=l;do{String v="";for(int i=0;i++<l;v+="v");if(l/2<r)break;System.out.printf("%"+f--+"s%n",v);l-=2;}while(l>0);}
```
Ungolfed:
```
void m(int l, int r) {
    int f = l;
    do {
        String v = "";
        for (int i = 0; i++ < l; v += "v");
        if (l / 2 < r) break;
        System.out.printf("%" + f-- + "s%n", v);
        l -= 2;
    } while (l > 0);
}
```
Update: One byte and loop body gone thanks to @ClaytonRamsey.
[Answer]
# C, 83 bytes
```
i,j;f(s,m){for(i=-1;i++<s/2-m;)for(j=-1;++j<=s;)putchar(j<s?j>=i&&s-j>i?86:32:10);}
```
Ungolfed and usage:
```
i,j;
f(s,m){
  for(i=-1;i++<s/2-m;)
    for(j=-1;++j<=s;)
      putchar(j<s ?
                j>=i&&s-j>i ? 86 : 32
                : 10);
}
main() {
  f(5,0);
  f(7,0);
  f(7,2);
  f(7,3);
  f(3,1);
}
```
[Answer]
# Pyth, 21 bytes
```
j<E.e+*kd*hyb\v_Uh/Q2
```
A program that takes input of `S` followed by `M`, newline-separated, and prints the result.
[Test suite](https://pyth.herokuapp.com/?code=j%3CE.e%2B%2akd%2ahyb%5Cv_Uh%2FQ2&test_suite=1&test_suite_input=5%0A0%0A7%0A0%0A7%0A2%0A7%0A3%0A3%0A1&debug=0&input_size=2)
**How it works**
```
j<E.e+*kd*hyb\v_Uh/Q2  Program. Inputs: Q, E
                  /Q2  Yield Q // 2
                 h      + 1
                U      Yield [0, 1, 2, ..., Q //2 +1]
               _       Reverse
   .e                  Map over with elements as b and zero-indexed indices as k:
           yb           2 * b
          h              + 1
         *   \v          "v" characters
     +                  prepended with
       k                k
      * d                spaces
 <E                    All but the last E elements
j                      Join on newlines
                       Implicitly print
```
]