[Question]
  [
Basing on [this SO question](https://stackoverflow.com/questions/37964715/convert-yyyymm-to-mmmyy).
Challenge is rather simple: given a date period in the format `YYYYMM` output it in the format `MMMYY`.
### Rules:
* The input will be a number or a string exactly 6 characters long, consisting only of digits.
* Last two digits will be between `01` and `12`.
* Output must be in the form `MMMYY`, where `MMM` represents uppercase three-letter code for the month (below) and `YY` represents **two** last digits of the `YYYY` part of the input.
List of months with corresponding code:
```
MM    MMM
01    JAN
02    FEB
03    MAR
04    APR
05    MAY
06    JUN
07    JUL
08    AUG
09    SEP
10    OCT
11    NOV
12    DEC
```
### Examples:
```
Input     Output
201604    APR16
200001    JAN00
000112    DEC01
123405    MAY34
```
  
[Answer]
# Python 3, 70 bytes
```
from time import*
lambda s:strftime("%b%y",strptime(s,"%Y%m")).upper()
```
This uses the built-in `strftime` and `strptime` functions.
For 1 byte more, here's a version which parses the string manually:
```
lambda s:" JFMAMJJASONDAEAPAUUUECOENBRRYNLGPTVC"[int(s[4:])::12]+s[2:4]
```
This encodes the month names in an interesting way (thanks to Henry Gomersall for saving a byte).
[Answer]
# MATL, ~~18~~ ~~14~~ 13 bytes
```
4e!Z{Zc12XOXk
```
Input is provided as a string (enclosed in single quotes).
This version only runs in MATL on MATLAB since MATLAB is able to automatically parse `datestr('2016 04')`.
**Explanation**
```
        % Implicitly grab input as a string
4e!     % Reshape input to be 2 x 4 (puts the year in row 1 and month in row 2)
Z{      % Place each row in a separate cell
Zc      % Join them together using a space to create 'yyyy mm' format
12      % Number literal, pre-defined datestring of 'mmmyy'
XO      % Convert from serial date number to string using this format
Xk      % Convert to uppercase
        % Implicitly display
    
```
---
Here is an **18 byte** version which works on Octave (and therefore the online interpreter)
```
'yyyymm'2$YO12XOXk
```
[**Try it Online**](http://matl.tryitonline.net/#code=J3l5eXltbScyJFlPMTJYT1hr&input=JzIwMTYwNCc)
[Modified version for all test cases](http://matl.tryitonline.net/#code=YCd5eXl5bW0nMiRZTzEyWE9Ya0RU&input=JzIwMTYwNCcKJzIwMDAwMScKJzAwMDExMicKJzEyMzQwNSc)
**Explanation**
```
            % Implicitly grab input as a string
'yyyymm'    % Push the format string as a string literal
2$YO        % Convert to a serial date number
12          % Number literal, pre-defined datestring of 'mmmyy'
XO          % Convert from serial date number to string using this format
Xk          % Convert to uppercase
            % Implicitly display
```
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~49~~ ~~46~~ 40 bytes
```
date "$args".insert(4,'-')-U %b%y|% *per
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/PyWxJFVBSSWxKL1YSS8zrzi1qETDREddV11TN1RBNUm1skZVQasgtej////qRgaGZgYm6gA "PowerShell ‚Äì Try It Online")
*Thanks to @Joey for saving 3 bytes!*
Takes input `$args` as an explicit string (e.g., `'201604'`) via command-line input. Uses the `string.Insert()` function to put a `-` in the appropriate space, and that resultant string forms input to the [`Get-Date` cmdlet](https://technet.microsoft.com/en-us/library/hh849887.aspx) with the `-U`format parameter specifying the three-month shorthand plus two-digit year. We then tack on a `.ToUpper()` to make the output string capitalized. That string is left on the pipeline and printing is implicit.
Also, as pointed out, this is locale-sensitive. Here's the locale information that I'm using where this works correctly.
```
PS C:\Tools\Scripts\golfing> get-culture
LCID             Name             DisplayName
----             ----             -----------
1033             en-US            English (United States)
```
[Answer]
# Bash + coreutils, 18
Requires 64-bit version of `date` for the given testcases, [which recognises dates earlier than 14th December 1901](https://unix.stackexchange.com/questions/7688/date-years-prior-to-1901-are-treated-as-invalid).
```
date -d$101 +%^b%y
```
[Answer]
## [Retina](https://github.com/m-ender/retina), ~~71~~ 70 bytes
*Thanks to Sp3000 for saving 1 byte.*
Byte count assumes ISO 8859-1 encoding. The trailing linefeed is significant.
```
(..)(..)$
DECNOVOCTSEPAUGJULJUNMAYAPRMARFEBJANXXX$2$*¬∂$1
+`...¬∂
R-6`.
```
[Try it online!](http://retina.tryitonline.net/#code=JShHYAooLi4pKC4uKSQKREVDTk9WT0NUU0VQQVVHSlVMSlVOTUFZQVBSTUFSRkVCSkFOWFhYJDIkKsK2JDEKK2AuLi7CtgoKUi02YC4&input=MjAxNjA0CjIwMDAwMQowMDAxMTIKMTIzNDA1)
### Explanation
Taking `201604` as an example:
```
(..)(..)$
DECNOVOCTSEPAUGJULJUNMAYAPRMARFEBJANXXX$2$*¬∂$1
```
This swaps the last two digits of the year with the month while also expanding the month in unary using linefeeds, and prepending the list of months in reverse so we'd get:
```
20DECNOVOCTSEPAUGJULJUNMAYAPRMARFEBJANXXX¬∂¬∂¬∂¬∂16
```
Where the `¬∂` represent linefeeds (0x0A).
```
+`...¬∂
```
Now we repeatedly remove three non-linefeed characters followed by a linefeed. That is we eat up the list of months from the end for each linefeed representing a month:
```
20DECNOVOCTSEPAUGJULJUNMAYAPRMARFEBJANXXX¬∂¬∂¬∂¬∂16
20DECNOVOCTSEPAUGJULJUNMAYAPRMARFEBJAN¬∂¬∂¬∂16
20DECNOVOCTSEPAUGJULJUNMAYAPRMARFEB¬∂¬∂16
20DECNOVOCTSEPAUGJULJUNMAYAPRMAR¬∂16
20DECNOVOCTSEPAUGJULJUNMAYAPR16
```
This is why we've inserted that `XXX`: since the months start counting from `1`, we'll always remove at least three characters, even for January.
```
R-6`.
```
Finally, we remove everything up to the 6th character from the end. In other words we only keep the last five characters.
[Answer]
# CJam, ~~50~~ 46 bytes
```
q2/1>~i("4H~0√´~¬≥!√≤¬≤√ó¬∂7√ñ"256b25b'Af+3/=\
```
[Try it online.](http://cjam.aditsu.net/#code=q2%2F1%3E~i%28%224H~0%C3%AB%C2%99~%C2%B3%C2%90!%C3%B2%C2%B2%C3%97%C2%8C%C2%9D%C2%B6%C2%90%1F%1F7%C3%96%22256b25b'Af%2B3%2F%3D%5C&input=201604) Thanks to Martin Ender for compressing the string to save a few bytes.
### Explanation
```
q2/  e# Get input and divide it into groups of 2, like ["20" "16" "04"]
1>~  e# Discard the first item and dump the remaining array to the stack
i(   e# Convert the top value (month) to an integer and decrement it, because
     e# arrays are zero-indexed
"..."256b25b e# Convert this string from base-256 to base-25
'Af+ e# "Add" a capital A to each number to get the letters
3/   e# Divide into groups of 3 to make an array of month names
=\   e# Get the requested month and swap the elements to put the year on
     e# top, so it is printed last
```
[Answer]
# MATLAB / Octave, 42 bytes
```
@(x)upper(datestr(datenum(x,'yyyymm'),12))
```
Creates an anonymous function named `ans` that is called with a string representing the date: `ans('201604')`.
[**Online Demo**](http://ideone.com/a2ND79)
This solution uses `datenum` to convert the input date to a serial date number, and then `datestr` with the predefined output spec of `mmmyy` (`12`) to yield the string representation in the required format. Finally, we use `upper` to change it to `MMMYY` since the uppercase month is not an output option.
[Answer]
## Bash, ~~39~~ 28 bytes
```
date -d$101 +%b%y|tr a-z A-Z
```
Thanks [Digital Trauma](https://codegolf.stackexchange.com/users/11259/digital-trauma)!
[Answer]
# Java 7, 137 characters (161 bytes)
```
String d(String i){return Integer.toString("ÊÜØ‰∑≥ÁÉ£„òøÁÉ™ÊëøÊëΩ„õ®ËøëÁ≠çÁüØ‰èî".charAt(Integer.parseInt(i.substring(4))-1),36).toUpperCase()+i.substring(2,4);}
```
Consider each month name (JAN, FEB etc...) is a number in base 36 and encode it into corresponding Unicode symbol. Then get corresponding symbol from the string encode it back again in base 36 and after that some plain string manipulations.
Slightly ungolfed:
```
String d(String input){
return 
  Integer.toString("ÊÜØ‰∑≥ÁÉ£„òøÁÉ™ÊëøÊëΩ„õ®ËøëÁ≠çÁüØ‰èî" // encoded month names
  .charAt(Integer.parseInt(input.substring(4))-1),36) // get a symbol from encoded names at position input[4:], decode it to base 36 value
  .toUpperCase()+input.substring(2,4); // get it to upper case and add year
}
```
You can see it running here: <https://ideone.com/IKlnPY>
[Answer]
## Python, 83 bytes
```
from datetime import*
lambda x:datetime.strptime(x,'%Y%m').strftime('%b%y').upper()
```
[Answer]
## Kotlin, 100 bytes
```
fun f(d:String)=SimpleDateFormat("MMMyy").format(SimpleDateFormat("yyyyMM").parse(d)).toUpperCase()
```
Pretty straight forward use of Java SimpleDateFormat
[Answer]
## 05AB1E, ~~51~~ ~~42~~ 41 bytes
```
2√¥¬¶`√Ø<‚Ä¢r‚Äì¬∫√æ¬ØB√™‚Ç¨√µaP√π¬£‚Äî^5A¬∫√ºLw√á‚Äì√®‚Ä¢35B3√¥s√®sJ
```
**Explanation**
```
                                           # implicit input, 123405
2√¥                                         # split input into pieces of 2, ['12','34','05']
  ¬¶`                                       # push last 2 elements to stack, '05', '34'
    √Ø<                                     # convert month to its int index, 4
      ‚Ä¢r‚Äì¬∫√æ¬ØB√™‚Ç¨√µaP√π¬£‚Äî^5A¬∫√ºLw√á‚Äì√®‚Ä¢35B        # get compressed string containing 3-letter months, 
                                             JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC
                                   3√¥      # split into pieces of 3
                                             ['JAN', 'FEB', 'MAR', 'APR', 'MAY', 'JUN', 'JUL', 'AUG', 'SEP', 'OCT', 'NOV', 'DEC']
                                     s√®    # get month at index retrieved earlier, MAY
                                       sJ  # join with 2-digit year and implicitly print, MAY34
```
[Try it online](http://05ab1e.tryitonline.net/#code=MsO0wqTDrzzigKJy4oCTwrrDvsKvQsOq4oKsw7VhUMO5wqPigJReNUHCusO8THfDh-KAk8Oo4oCiMzVCM8O0c8OoczHDqEo&input=MTIzNDA1)
9 bytes saved thanks to string compression, courtesy of @Adnan
[Answer]
# JavaScript, ~~87~~ ~~84~~ ~~80~~ 79 bytes
```
x=>(new Date(x.replace(/.{4}/,'$&-'))+'').slice(4,7).toUpperCase()+x.slice(2,4)
```
To get the month, gets the date (which is formed of "YYYYMM" converted to "YYYY-MM") and retrieves the characters 5 to 8, that are exactly the first three letters of the month. But it costs much to convert it to upper case.
Demo:
```
function s(x) {
  return (new Date(x.replace(/.{4}/, '$&-')) + '').slice(4,7)
         .toUpperCase() + x.slice(2, 4)
}
console.log(s('201604'));
console.log(s('200001'));
console.log(s('000112'));
console.log(s('123405'));
```
[Answer]
# Julia, ~~57~~ ~~56~~ 53 bytes
```
s->uppercase(Dates.format(DateTime(s,"yyyym"),"uyy"))
```
This is an anonymous function that accepts a string and returns a string. To call it, assign it to a variable.
First we construct a `DateTime` object using the type constructor and a format string. Note that the single `m` in the format string will get both one- and two-digit months, though the former case is irrelevant here. Since no days are specified, the first of the month is assumed.
We can then format the value as a string using the `Dates.format` function from the `Base.Dates` submodule. The string `uyy` gets the three-letter month name and two-digit year, but the result is in title case, e.g. Apr16 instead of the desired APR16, so we need to `uppercase` it.
[Try it online!](http://julia.tryitonline.net/#code=Zj1zLT51cHBlcmNhc2UoRGF0ZXMuZm9ybWF0KERhdGVUaW1lKHMsInl5eXltIiksInV5eSIpKQoKZm9yIHRlc3QgaW4gWygiMjAxNjA0IiwiQVBSMTYiKSwgKCIyMDAwMDEiLCJKQU4wMCIpLCAoIjAwMDExMiIsIkRFQzAxIiksICgiMTIzNDA1IiwiTUFZMzQiKV0KICAgIHByaW50bG4oZih0ZXN0WzFdKSA9PSB0ZXN0WzJdKQplbmQ&input=) (includes all test cases)
[Answer]
# JavaScript ES6, ~~77~~ 66 bytes
Saved 11 bytes thanks to @B√°lint!
```
a=>(new Date(0,a[4]+a[5]-1)+"").slice(4,7).toUpperCase()+a[2]+a[3]
```
Get's the date by extracting the string returned by the `Date` class. then capitalizes and adds the year.
ES5 version:
```
var a = prompt("Enter YYYYMM: ");
result = (new Date(0,a[4]+a[5]-1)+"").slice(4,7).toUpperCase()+a[2]+a[3]
alert(result);
```
[Answer]
## C, ~~147~~ ~~145~~ 112 bytes
```
main(m){char a[99]="JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC";scanf("%4s%d",a+50,&m);printf("%.3s%s",a+--m*3,a+52);}
```
[Online demo](http://ideone.com/T0JSWL)
Thanks [ugoren](https://codegolf.stackexchange.com/users/3544/ugoren)!
[Answer]
# C#, ~~94~~ 87 bytes
```
string C(string s)=>System.DateTime.Parse(s.Insert(4,"-")).ToString("MMMyy").ToUpper();
```
Saved 7 bytes by using C#6 Syntax.
[Try Online](http://csharppad.com/gist/1bf6575ea6e22e58e3bdcc79e205d905)
[Answer]
# Japt, ~~35~~ 34 bytes
```
√êUr$/..../$,"$&-")+P s4,7 u +Us2,4
```
[Link.](http://ethproductions.github.io/japt/?v=master&code=0FVyJC8uLi4uLyQsIiQmLSIpK1AgczQsNyB1ICtVczIsNA==&input=IjIwMTUwNCI=)
Uses the same technique as my [JavaScript answer](https://codegolf.stackexchange.com/a/83597).
[Answer]
# Java 8, ~~154~~ 113 bytes
```
import java.text.*;s->new SimpleDateFormat("MMMyy").format(new SimpleDateFormat("yyyyMM").parse(s)).toUpperCase()
```
**Explanation:**
[Try it online.](https://tio.run/##jZAxT8MwEIX3/opTJnuolYTCEsFCYXOXigkxHK5L3Sa2ZV9boiq/PTgk6oREbzjdkz7p3Xt7POF8vzn0qsYYQaKxlxmAsaTDFpWG1SAB1hSM/QLFpiNyoF1w5wgv30p7Ms5WCexmaUVCMgpWYOER@jh/svoMa9P4Wi@R9KsLDRLLpJRtm3GxHfXfUJtGykR5DFGzyLkg9@a9Ds@YNO@rwdEfP@vkOBmfnNlAk5JMz75/APIxBoV2PFKiNpJuhDuS8Imi2jIrFMvKvHjIFxnn1b9gmuIGcMCK8gawKO8W@f0V7BSS2rFrwaD5pfstuet/AA)
```
import java.text.*;                 // Required import for SimpleDateFormat
s->                                 // Method with String as both parameter and return-type
  new SimpleDateFormat("MMMyy")     //  Create a formatter with format "MMMyy"
   .format(                         //  Format the following:
     new SimpleDateFormat("yyyyMM") //   Create another formatter with format "yyyyMM"
     .parse(s))                     //   Parse the input with this format
  .toUpperCase()                    //  Convert everything to Uppercase and return
```
[Answer]
# Oracle SQL, 49 Bytes
```
select to_char(to_date(n,'yyyymm'),'MONyy')from t
```
The data must be inserted in a table called `T` with a column `N` of type `VARCHAR2(6)`, `CHAR(6)` or , only if all the years are > 1000, `NUMBER`
Usage:
```
drop table t;
create table t (n VARCHAR2(6));
insert into t values ('201604');
insert into t values ('200001');
insert into t values ('000112');
insert into t values ('123405');    
select to_char(to_date(n,'yyyymm'),'MONyy')from t;
```
[Answer]
# Microsoft SQL Server, 57 Bytes
```
SELECT UPPER(FORMAT(CAST('201601'+'01' AS DATE),'MMMyy'))
```
The `Upper` function is required as format does not produce Upper case months as would be expected with the *MMM* format pattern.
**Usage:**
```
drop table t;
create table t (n VARCHAR(6));
insert into t values ('201604');
insert into t values ('200001');
insert into t values ('000112');
insert into t values ('123405');    
SELECT UPPER(FORMAT(CAST(n+'01' AS DATE),'MMMyy')) FROM t
```
[Answer]
# MediaWiki Template (with ParserFunctions), 29 bytes
```
{{uc:{{#time:My|{{{1}}}01}}}}
```
Only works if English locale is chosen.
[Try Sandbox](https://www.mediawiki.org/w/index.php?title=Project:Sandbox&action=edit)
[Answer]
# Pyth, 45 bytes
```
+:."AYw2√ªD√à√´KH¬ß√à¬ºDY√âx\E¬±o√ã"J*3sgz5+3J:z2 4
```
[Try it online!](https://tio.run/##AUQAu/9weXRo//8rOi4iQVkMdzLDu0TDiMOrS0jCp8OIwrwCRFnDiXhcRcKxb8OLHCJKKjNzZ3o1KzNKOnoyIDT//zIwMTgwNA)
Explanation:
```
+:."AYw2√ªD√à√´KH¬ß√à¬ºDY√âx\E¬±o√ã"J*3sgz5+3J:z2 4
                                z           Take the input
                               g 5          Slice inclusively from index 5 to the end
                              s             Parse as an int
                            *3              Multiply by 3
                           J                Store in variable J, this also returns J
 :                                          Take a slice
  ."AYw2√ªD√à√´KH¬ß√à¬ºDY√âx\E¬±o√ã"                 Of this packed string
                           J*3sgz5          From the J we defined before
                                  +3J       To J+3
+                                           To this string, append
                                     :z     A slice of the index
                                       2 4  From [2,4).
```
The packed string contains `"JANJANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC"`. The two `JAN`s are so that I can index it pseudo-one-indexed.
EDIT: Fixed bug that was messing with TIO
[Answer]
# [R](https://www.r-project.org/), 65 bytes
```
function(A)paste0(toupper(month.abb[el(A:1)%%100]),substr(A,3,4))
```
[Try it online!](https://tio.run/##LchBC8IgFADge78iFoMnSLyntkPQQapLUES3iA5zbBSUk6m/32b4Hb8pDbs0RNuF92hBM9f60COEMTrXT/AdbXitW2Me/Qf0llhdE@KTcR@NDxNoLrliLA1QCaQGVcVWy5m@3qhZ/HdGZU/6gpg3H4myh@MeKS8JqXBT9qzvUqUf "R ‚Äì Try It Online")
Takes input as a string, leverages the constant `month.abb`. Uses modulus and `substr` to extract relevant values.
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 78 bytes
```
i=>'JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC'.match(/.../g)[i[4]+i[5]-1]+i[2]+i[3]
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z@cn1ecn5Oql5OfrqHxP9PWTt3L0c/N1cnXMcgxIMjXMdIr1M8r1Mcx1D3YNcDfOcTPP8zF1VldLzexJDlDQ19PT08/XTM6M9okVjsz2jRW1xBEG4EI49j/mhrqRgZGhgbm6pqa1v8B "JavaScript (Node.js) ‚Äì Try It Online")
[Answer]
# [Headascii](https://esolangs.org/wiki/Headass#Headascii), 331 bytes
```
UUU^U[UOUODOD]ONE.++++[]]]][]]]]+O[---[]]]][]]]][U]^U]OUOUOD++E.+++^^^U[U-()D]^P(]PD++++P:-()+++++]P-P---P:-()D+++]^P(]PD+++++P:-()]PD++++++]P++P:-()D^^^+++]P(]PD---]P:-()D^^]PD^++]PD-----]P:-()D^^]PD++]P(++^^^^^D+]P:-()]PD^^D++]P(++++++]P:D^^D^]P(++++]PD---]P;UPUP!.++^^^^^U[U)D^^++++]P(++]PD-]P:R-)D^^+++]P+PD+]P:+++]P+P--P;UPUP!
```
[Try it here!](https://replit.com/@thejonymyster/HA23) Code will need to be pasted in and executed like this:
```
erun("UUU^U[UOUODOD]ONE.++++[]]]][]]]]+O[---[]]]][]]]][U]^U]OUOUOD++E.+++^^^U[U-()D]^P(]PD++++P:-()+++++]P-P---P:-()D+++]^P(]PD+++++P:-()]PD++++++]P++P:-()D^^^+++]P(]PD---]P:-()D^^]PD^++]PD-----]P:-()D^^]PD++]P(++^^^^^D+]P:-()]PD^^D++]P(++++++]P:D^^D^]P(++++]PD---]P;UPUP!.++^^^^^U[U)D^^++++]P(++]PD-]P:R-)D^^+++]P+PD+]P:+++]P+P--P;UPUP!","your input here")
```
Headass/ascii is not particularly good at strings.
```
UUU^U[UOUODOD]ONE. Block 0
UU                 Discard the first two chars of input lol
  U^U[             Hold onto the last two digits of the year
      UOUODOD]O    ready MMYY for the next code block
               NE  Go to block 1
                 . Block separator
++++[]]]][]]]]+O[---[]]]][]]]][U]^U]OUOUOD++E. Block 1
++++[]]]][]]]]+O                               Save 65 for later ease of access
                [---[]]]][]]]][                -48
                               U]^             Add to first month digit and hold
                                  U]O          Add to second month digit and save
                                     UOUO      Save year digits
                                         D++E  Go to either block 1 or block 2,
                                                depending on whether the first
                                                digit of the month was 0 or 1
                                             . Block separator
+++^^^U[U-()...;UPUP!.      Block 2 (JAN-SEP)
+++^^^                      Store 9 on the accumulator
      U[                    Restore 65 from earlier
        U-()                If the second digit of the month is 1,
D]^P(]PD++++P                 Concatenate "JAN" to the string register
             :-()           Else if it's 2
+++++]P-P---P                 Concatenate "FEB" to the string register
             :-()           Else if it's 3
D+++]^P(]PD+++++P             Concatenate "MAR" to the string register
                 :-()       Else if it's 4
]PD++++++]P++P                Concatenate "APR" to the string register
              :-()          Else if it's 5
D^^^+++]P(]PD---]P            Concatenate "MAY" to the string register
                  :-()      Else if it's 6
D^^]PD^++]PD-----]P           Concatenate "JUN" to the string register
                   :-()     Else if it's 7
D^^]PD++]P(++^^^^^D+]P        Concatenate "JUL" to the string register
                      :-()  Else if it's 8
]PD^^D++]P(++++++]P           Concatenate "AUG" to the string register
                   :        Else
D^^D^]P(++++]PD---]P          Concatenate "SEP" to the string register
               ;UPUP!       Then concatenate the year digits from earlier and print!
                     .      Block separator, end of execution
++^^^^^U[U)D^...;UPUP!  Block 3 (OCT-DEC)
++^^^^^                 Store 10 on the accumulator 
       U[               Restore 65 from earlier
         U)             If the second digit of the month is 0,
D^^++++]P(++]PD-]P        Concatenate "OCT" to the string register
                  :R-)  Else if it's 1
D^^+++]P+PD+]P            Concatenate "NOV" to the string register
              :         Else
+++]P+P--P                Concatenate "DEC" to the string register
          ;UPUP!        Then concatenate the year digits from earlier and print!
```
[Answer]
# Microsoft Excel VBA, 47 Bytes
Anonymous VBE immediate window function that takes input from range `[A1]` and outputs to the VBE immediate window
```
?UCase(MonthName([Right(A1,2)],1))[Mid(A1,3,2)]
```
Current version thanks to [@Engineer Toast](https://codegolf.stackexchange.com/users/38183/engineer-toast), for pointing out the abbreviate option of the `MonthName` function.
### Previous Version
```
?UCase(Format(DateSerial([Left(A1,4)],[Right(A1,2)],1),"MMMYY"))
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-P`](https://codegolf.meta.stackexchange.com/a/14339/), ~~14~~ 13 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
√êU√≤4)√Öu ¬∏o¬§√Ö√´
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LVA&code=0FXyNCnFdSC4b6TF6w&input=IjIwMTYwNCI)
```
√êU√≤4)√Öu ¬∏o¬§√Ö√´     :Implicit input of string U          > "201604"
√ê                 :Create Date object from
 U√≤4              :  Partitions of U of length 4       > ["2016","04"]
    )             :End Date
     √Ö            :To date string                      > "Fri Apr 01 2016"
      u           :Uppercase                           > "FRI APR 01 2016"
        ¬∏         :Split on spaces                     > ["FRI","APR","01","2016"]
         o        :Modify the last element
          ¬§       :  Slice off the first 2 characters  > ["FRI","APR","01","16"]
           √Ö      :Slice off the first element         > ["APR","01","16"]]
            √´     :Get every second element            > ["APR","16"]
                  :Implicitly join and output          > "APR16"
```
[Answer]
# x86-16 machine code, 64 bytes
```
00000000: fcad ad50 ad2d 3030 86e0 d50a be19 0103  ...P.-00........
00000010: f003 f003 f02e a52e a458 abc3 4a41 4e46  .........X..JANF
00000020: 4542 4d41 5241 5052 4d41 594a 554e 4a55  EBMARAPRMAYJUNJU
00000030: 4c41 5547 5345 504f 4354 4e4f 5644 4543  LAUGSEPOCTNOVDEC
```
Callable function, input at `DS:SI`, output buffer at `ES:DI`.
Listing:
```
FC          CLD                         ; string direction forward 
AD          LODSW                       ; skip first two chars 
AD          LODSW                       ; load YY string 
50          PUSH AX                     ; save YY string 
AD          LODSW                       ; load month string 
2D 3030     SUB  AX, '00'               ; ASCII convert month 
86 E0       XCHG AH, AL                 ; endian convert 
D5 0A       AAD                         ; word convert to index (1-12) 
BE 0116     MOV  SI, OFFSET MTBL[-3]    ; month table (1-indexed) 
03 F0       ADD  SI, AX                 ; add month offset * 3 chars 
03 F0       ADD  SI, AX 
03 F0       ADD  SI, AX
2E A5   CS: MOVSW                       ; copy first two bytes of month
2E A4   CS: MOVSB                       ; copy third byte of month to output
58          POP  AX                     ; restore YY string 
AB          STOSW                       ; write YY to output 
C3          RET 
        MTBL: 
4A 41 4E    DB  'JAN' 
46 45 42    DB  'FEB' 
4D 41 52    DB  'MAR' 
41 50 52    DB  'APR' 
4D 41 59    DB  'MAY' 
4A 55 4E    DB  'JUN' 
4A 55 4C    DB  'JUL' 
41 55 47    DB  'AUG' 
53 45 50    DB  'SEP' 
4F 43 54    DB  'OCT'
4E 4F 56    DB  'NOV' 
44 45 43    DB  'DEC' 
```
Sample runs:
[![enter image description here](https://i.stack.imgur.com/g8c2s.png)](https://i.stack.imgur.com/g8c2s.png)
[Answer]
# [Perl 5](https://www.perl.org/) `-p`, 75 bytes
```
$_=(1,JAN,FEB,MAR,APR,MAY,JUN,JUL,AUG,SEP,OCT,NOV,DEC)[/..$/g].substr$`,2,2
```
[Try it online!](https://tio.run/##K0gtyjH9/18l3lbDUMfL0U/HzdVJx9cxSMcxIAhIR@p4hfoBsY@OY6i7TrBrgI6/c4iOn3@Yjours2a0vp6ein56rF5xaVJxSZFKgo6RjtH//4bGBhYGlv/yC0oy8/OK/@sWAAA "Perl 5 ‚Äì Try It Online")
]