[Question]
  [
A big part of radio communication is the [NATO Phonetic Alphabet](https://en.wikipedia.org/wiki/NATO_phonetic_alphabet), which encodes letters as words to make them easier to understand over comms. Your job, if you wish to accept it, is to print them one by one.
You must print this exact string to stdout:
```
A: Alfa
B: Bravo
C: Charlie
D: Delta
E: Echo
F: Foxtrot
G: Golf
H: Hotel
I: India
J: Juliet
K: Kilo
L: Lima
M: Mike
N: November
O: Oscar
P: Papa
Q: Quebec
R: Romeo
S: Sierra
T: Tango
U: Uniform
V: Victor
W: Whiskey
X: Xray
Y: Yankee
Z: Zulu
```
# Rules:
* Your program takes no input
* Standard loopholes are **Disallowed**.
* If there are any builtins in your language that turn letters to their NATO equivelants, you may not use them (I'm looking at you Mathematica).
* You may have trailing spaces and **one** trailing newline.
  
[Answer]
# [Python 2](https://docs.python.org/2/), ~~189~~ 186 bytes
```
i=65
for w in"lfa ravo harlie elta cho oxtrot olf otel ndia uliet ilo ima ike ovember scar apa uebec omeo ierra ango niform ictor hiskey ray ankee ulu".split():print'%c: %c'%(i,i)+w;i+=1
```
**[Try it online!](https://tio.run/nexus/python2#Dc3BCoMwEIThe59iKIiKpdBDe7D4MGu61sUkK2vU@vQ25/mY/5Tu9bwMatgh8eoHgtGmGMm8MNgnghsV@kumCeoHaGKP@BHCmkmCeIUEgkwM3Tj0bFgcGWjOhHt20MDZsBmB4lcRJRcDxKUcHmWZ@MjZI48Tc75dr/dl9pKqup1NYioL16JwZVHJTepmf0vTPc7zDw)**
---
Previous: (this was cool, but I realised the simpler version could be made shorter by a byte)
```
w=''
i=65
for c in"lfAravOharliEeltAchOoxtroTolFoteLndiAulieTilOimAikEovembeRscaRapAuebeComeOierrAangOniforMictoRhiskeYraYankeEulU":
 w+=c.lower()
 if'_'>c:print'%c: %c'%(i,i)+w;w='';i+=1
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 76 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
“ṭṡl°ẠkWßġȮRẎ+wḋñȥạġ¢ƊḌ¬kạẠ¦WṡỊƒK⁹ç}⁶hm}Kñ£ɦ/lṇẊɠƓ}pƤ°⁸Ụ.g⁹Ġh9ṁ{f»ḲØAżj€⁾: Y
```
**[Try it online!](https://tio.run/nexus/jelly#AZUAav//4oCc4bmt4bmhbMKw4bqga1fDn8ShyK5S4bqOK3fhuIvDscil4bqhxKHCosaK4biMwqxr4bqh4bqgwqZX4bmh4buKxpJL4oG5w6d94oG2aG19S8OxwqPJpi9s4bmH4bqKyaDGk31wxqTCsOKBuOG7pC5n4oG5xKBoOeG5gXtmwrvhuLLDmEHFvGrigqzigb46IFn//w "Jelly – TIO Nexus")**
### How?
Pretty much just dictionary values and compression. The code between `“` and `»` is just a compressed value that will form the string `"Alfa Bravo Charlie Delta Echo Foxtrot Golf Hotel India Juliet Kilo Lima Mike November Oscar Papa Quebec Romeo Sierra Tango Uniform Victor Whiskey Xray Yankee Zulu"` by looking up all the words (with single space prefixes, except for `"Alfa"`) in Jelly's dictionary (except for `" Xray"` which is not in the dictionary, so the direct string value `" X"` and the dictionary entry `"ray"` are used instead).
The rest of the code does the rest:
```
“...»ḲØAżj€⁾: Y - Main link: no arguments
“...»           - the string described above (really a list of characters)
     Ḳ          - split at spaces
      ØA        - alphabet yield - ['A','B','C', ...,'X','Y','Z']
        ż       - zip - makes a list of lists [['A'],['A','l','f','a']],[['B'],['B','r','a','v','o']], ...]
         j€     - join each with
           ⁾:   - the string ": "
              Y - join with line feeds
                - implicit print
```
[Answer]
## [Retina](https://github.com/m-ender/retina), 156 bytes
Byte count assumes ISO 8859-1 encoding.
```
AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu
[A-Z]
¶$&: $&
G`.
```
[Try it online!](https://tio.run/nexus/retina#DcpJDoJAEADAO6/wQLjpA7zhhvu@YkxssJEOM9OmmSHyMR/gx9A6V@OFKoOeQMX9HEQRDlBZGKY5j/hthW3EKhuzRTUxD4Kp@xc7I8Vz0rCgApdcoU5QVmUKsoYXbBwmmG5ZI@8IRWAP5skHQxmLPlJqWU45lQXWZ4H6AqZAjJ1y3jVsxzfv@/GDbssPvOjeaZof "Retina – TIO Nexus")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~102~~ 98 bytes
Saved 4 bytes thanks to *Erik the Outgolfer*
```
”AlfaÐ†vo¼¯¤œ®È¨›trotŠˆƒ‹Š™ÈŸt Kilo´àma—……ÍÐ—Žêpa¼°«Äoµ†Çâgo¸šÉµ Whiskey Xrayµ‹nkeeâ¸lu”#vy¬„: «ì,
```
[Try it online!](https://tio.run/nexus/05ab1e#Fc4xCsJAEIXhqyzYegI7aw@g7RZRQ6IrMQbSbRE0FoJoWmUNIqJBLQwkos0Ma@Mt5iJxA6/74eNVJHdtt89xTVIFAt5wh6Pewg1jOJN8@Z7wtfrNvxuSpVYUpRjrwmcd2xXwRDXiJBOSJzNc1UiiP3iZcAM94IqRgNzAuMB0IKDQB1xCzrpDe@pYIet5PKx7OXYsC1Mo3Jm50whCyEjuW8wAWbOq/g "05AB1E – TIO Nexus")
**Explanation**
Uses dictionary compression for the words in 05AB1E's dictionary.  
Uses partial dictionary compression whenever possible for other words.  
Plain-text words where neither is possible.
```
#          # split on spaces
 v         # for each word
  y        # push the word
   ¬       # get the first letter of the word
    „:     # push the string ": "
       «   # append this to the letter
        ì  # prepend the result to the word
         , # print with newline
```
[Answer]
# Ruby, 169 characters
(Heavily based on [Jonathan Allan](https://codegolf.stackexchange.com/users/53748/jonathan-allan)'s [Python 2](https://codegolf.stackexchange.com/a/112229) solution. If you like the idea, please upvote the original answer.)
```
i=?@
"LfaRavoHarlieEltaChoOxtrotOlfOtelNdiaUlietIloImaIkeOvemberScarApaUebecOmeoIerraAngoNiformIctorHiskeyRayAnkeeUlu".scan(/.[a-z]+/){|w|puts i.succ!+": "+i+w.downcase}
```
Sample run:
```
bash-4.3$ ruby -e 'i=?@;"LfaRavoHarlieEltaChoOxtrotOlfOtelNdiaUlietIloImaIkeOvemberScarApaUebecOmeoIerraAngoNiformIctorHiskeyRayAnkeeUlu".scan(/.[a-z]+/){|w|puts i.succ!+": "+i+w.downcase}' | head
A: Alfa
B: Bravo
C: Charlie
D: Delta
E: Echo
F: Foxtrot
G: Golf
H: Hotel
I: India
J: Juliet
```
[Answer]
# Java 7, ~~242~~ ~~225~~ ~~222~~ 217 bytes
```
void d(){char c=65;for(String s:"lpha ravo harlie elta cho oxtrot olf otel ndia uliet ilo ima ike ovember scar apa uebec omeo ierra ango niform ictor hiskey ray ankee ulu".split(" "))System.out.println(c+": "+c+++s);}
```
**Explanation:**
```
void d(){                          // Method
  char c = 65;                     //  Starting character 'A'
  for(String s : "lpha ravo harlie elta cho oxtrot olf otel ndia uliet ilo ima ike ovember scar apa uebec omeo ierra ango niform ictor hiskey ray ankee ulu"
      .split(" "))                 //  Loop over the word-parts
    System.out.println(            //   Print line with:
      c                            //    The current character
      + ": "                       //    + ": "
      + c++ + s                    //    + the current character + word-part (and raise the character afterwards)
    );                             //   End of print line
                                   //  End of loop (implicit / single-line body)
}                                  // End of method
```
**Test code:**
[Try it here.](https://ideone.com/b0YOtR)
```
class M{
  static void d(){char c=65;for(String s:"lpha ravo harlie elta cho oxtrot olf otel ndia uliet ilo ima ike ovember scar apa uebec omeo ierra ango niform ictor hiskey ray ankee ulu".split(" "))System.out.println(c+": "+c+++s);}
  public static void main(String[] a){
    d();
  }
}
```
[Answer]
# Octave, ~~215~~ ~~210~~ 209 bytes
~~Saved 5 bytes thanks to Luis Mendo.~~ I saved 4 bytes thanks to Luis Mendo, but changing the approach help me save one more
```
fprintf('%s: %s%s\n',[k=num2cell(65:90);k;regexp('lfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu','[A-Z]','split')]{:})
```
[Try it online!](https://tio.run/nexus/octave#DcrJasMwEADQX@nFyIYUSqGFOvTQfd/3pDlM1FE8aKQxIykklH67m9O7vMH1SjG72lSp3apSlb6jGU39YSxh1yJzvb/XHuw0Yz9WXOCqrw07OFZYykkHyoSnyBnObCfnssoq@ULYXUpGvoo/BNdlU/INsdxSgDvyeC9LDHPUh2RBH6GHp4JztM8SUF4IVeEV4kLeIjnR8E42i350lDyuPxXWXxA94qRwMSMzPdqezDamnimbZvbb/jXD8A8)
~~If I got rid of the spaces, I'd save 25 bytes, but then~~ I'd have to use a regex. The regex itself would cost quite a few bytes, and it would also remove the capital letter of all words, leaving me with the words `lfa, ravo` etc. I would therefore have to concatenate the new strings with the leading characters. All this costs bytes.
**Old explanation:**
```
fprintf('%s: %s\n',      % Print a string with the format "str: str\n"
num2cell(65:90)          % Create a cell array with the numbers 65 - 90, one in each cell
strsplit('Alfa ...       % Split the string on the default delimiter: space
[num2cell();strsplit()]  % Concatenate cell arrays, leaving us with
                         % {'A',    'B'
                         %  'Alfa', 'Bravo'}
[...]{:}                 % Convert the cell array to a comma-delimited vector
                         % 'A', 'Alfa', 'B', 'Bravo' ...
```
[Answer]
## PHP, ~~202~~ ~~227~~ ~~196~~ 187 bytes
Thanks to [Dewi Morgan](https://codegolf.stackexchange.com/users/41364/dewi-morgan) for saving 9 bytes
```
echo preg_replace('/([A-Z])[a-z]+/',"$1: $0\n",AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu);
```
<https://repl.it/GMkH/1>
---
**Older versions**
Thanks to [manatwork](https://codegolf.stackexchange.com/users/4198/manatwork) and [insertusernamehere](https://codegolf.stackexchange.com/users/41859/insertusernamehere) for saving 31 bytes!
```
foreach(preg_split('/\B(?=[A-Z])/',AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu)as$k)echo"$k[0]: $k\n";
```
<https://eval.in/749541>
Thanks to [insertusernamehere](https://codegolf.stackexchange.com/users/41859/insertusernamehere) for noticing the output was wrong with the previous version.
```
$a=preg_split('/(?=[A-Z])/',AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu,-1,PREG_SPLIT_NO_EMPTY);foreach($a as $k)echo "$k[0]: $k\n";
```
<https://repl.it/GKS8/3>
```
$a=preg_split('/(?=[A-Z])/',AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu);foreach($a as $k)echo"$k[0]: $k\n";
```
<https://repl.it/GKS8/2>
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 178 bytes
```
"Alfa Bravo Charlie Delta Echo Foxtrot Golf Hotel India Juliet Kilo Lima Mike November Oscar Papa Quebec Romeo Sierra Tango Uniform Victor Whiskey Xray Yankee Zulu"ṇ₁{hw": "w?ẉ}ᵐ
```
[Try it online!](https://tio.run/nexus/brachylog2#DcpLUsJQEAXQrdzKMpxQgAiI/L86a0LHdOUlbXVeAhTFACaUMzfjQHcTNhI941MHTRcRWkaloh2TOWE8svOEThgrnvTgTT266iL01LNDP9sJ4bn4nx4DcYoXSQlDSRgjLTndsmGch2SY0AdhWvCWQ8w0ZcVc2IywoOxdscwkUkuxktCrYR1LnvARG6MjXilLmPFWuCKofm736@UU74MHBPtG9ft5rr6/6voP "Brachylog – TIO Nexus")
### Explanation
```
"…"ṇ₁               Split the string on spaces
     {         }ᵐ   Map on each word:
      hw              Write the first letter
        ": "w         Write ": "
             ?ẉ       Write the word followed by a new line
```
[Answer]
# PHP, ~~188~~ ~~186~~ ~~180~~ 174 bytes
no trailing spaces, one leading newline
```
<?=preg_filter("#[A-Z]#","
$0: $0",AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu);
```
simply replaces all uppercase letters in the compressed string with  
`<newline><letter><colon><space><letter>`
[Answer]
# [Python 2](https://docs.python.org/2/), ~~186~~ 182 bytes
```
print''.join('\n%s: '%c*('['>c)+c for c in'AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu')
```
[Try it online!](https://tio.run/nexus/python2#Dc1JDoJAEADAr3AhI5r4AA8m7vu@L5d2bKRlmCbNQOT1yL2SqlIh65Rqf5lsQz2tn3U85etmQz1UVwct7YUsnvbIqp4JoS9Q8CACMYRDNA5GOuIx/5ywm7AJp@zQzOybYJ7XxC3I8JISWFGMay4weaFsMg2yhRR2Ob5Q7zlBPhCKwBHsh0@W6jI5k3Ysl4iyGMurQHkDGyPec5OroKr@ "Python 2 – TIO Nexus")
[Answer]
# C (MinGW, Clang), 218 bytes
*Thanks to @gastropner!*
```
i;f(){char s[]="lfa:ravo:harlie:elta:cho:oxtrot:olf:otel:ndia:uliet:ilo:ima:ike:ovember:scar:apa:uebec:omeo:ierra:ango:niform:ictor:hiskey:ray:ankee:ulu";for(i=64;++i<91;)printf("%c: %c%s\n",i,i,strtok(i^65?0:s,":"));}
```
[Try it online!](https://tio.run/##Dc/RasMwDAXQ93xFMAQS2sEGW2HXK/2QbgPVUxYRxyq2W1ZKvz2T9CYddFF4CpHS77qKH/vhHibKbTl@7V0cCZmuCptEYXCshDAp9K9mrdA4QitHpB8hXIxUSFTIQpCZoVdeTpxRAmXQ2QifOEAXNsM5EyxWkWTUvEBC1YxJysw3i73Zcma2sxfnDfSy3736zUY@3l/8cM6S6ti7LqDtQlc@k9uKdam56tzL9@7t8IyydXDD4B@r6XYhSf3Q3JvWyj71zWP9Bw)
# C, ~~259~~ 236 bytes
```
i;f(){char*s="lfa\0ravo\0harlie\0elta\0cho\0oxtrot\0olf\0otel\0ndia\0uliet\0ilo\0ima\0ike\0ovember\0scar\0apa\0uebec\0omeo\0ierra\0ango\0niform\0ictor\0hiskey\0ray\0ankee\0ulu";for(i=64;++i<91;s+=strlen(s)+1)printf("%c: %c%s\n",i,i,s);}
```
[Try it online!](https://tio.run/##FY/disMgEEbv8xQhENDNFiwsC1s3b@KNdcdmiD9FbWkpffbsF4URz3dkRne4OLdtrL2QL7fY8lHnIXhrVLH3bBRIYDKKQgNzC1B@tJIbzuBRGgWj0h8jvcEE5wCJIwCveJnvFM9UjKrOotrrbtKZHKJIu0qlgNl0wSWxzyUCupZhL1xXeu7DPHdjJdrb3AYNS/D8/aWniX9/jrpOc20lUBJVTkd5LZyaF8PoTv3oxmrS8MnYVer3hqiPlpOQ3avrsfB33b23fw)
[Answer]
# Gema, 168 characters
```
\A=@subst{?<J>=\?: \$0\\n;AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu}@end
```
Sample run:
```
bash-4.3$ gema '\A=@subst{?<J>=\?: \$0\\n;AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu}@end' | head
A: Alfa
B: Bravo
C: Charlie
D: Delta
E: Echo
F: Foxtrot
G: Golf
H: Hotel
I: India
J: Juliet
```
[Answer]
# x86 Assembly, 512 bytes
Compiled with NASM and tested with QEMU. To boot you need to put a 2 byte boot signature at the end of the bootsector (510 bytes into the file) so I lost 317 bytes filling the compiled code with zeros. This is my first golf so I have to apologize for any gigantic errors. 
```
[org 7c00h]     ;So NASM can change the labels into memory locations correctly.
cld             ;Tells lodsb to look forward in memory
mov bh, 65      ;Moves the ASCII value of A into the BH register
mov si, NATO    ;Moves the first byte of NATO into the si register
call print      ;Call the 'print' subroutine
jmp $            ;Loops forever
print:
    mov ah, 0eh ;Moves the hex value 0E into the AH register. Tells interrupt 10h that we want subfucntion 0E
    lodsb       ;Load a byte of SI into AL and increments a register (DL i think) that tells it the offset to look at
    cmp al, 3   ;Compares the AL register that now has a byte from our string to ASCII value 3 (Enf Of Text)
    je R        ;If AL == 3 then jump to R
    cmp al, 0   ;Comapre AL to ASCII 0 (NULL)
    je newWord  ;If AL == 0 hump to newWord
    int 10h     ;Execute interrupt 10h Subfunction 0Eh (stored in AH register) which prints character value in AL
    jmp print   ;Jump to print
newWord:
    mov al, 10  ;Move ASCII 10 (New Line) into AL
    int 10h     ;Print character
    mov al, 13  ;Move ASCII 13 (Carriage Return) into AL
    int 10h     ;Print character
    mov al, bh  ;Move BH (which has our starting letter) into AL
    int 10h     ;Print Character
    mov al, 58  ;Move ASCII 58 (:) into AL
    int 10h     ;Print Character
    mov al, 32  ;Move ASCII 32 (Space) into AL
    int 10h     ;Print Character
    mov al, bh  ;Move BH into AL
    int 10h     ;Print Character
    inc bh      ;Increments BH by one (BH++)
    jmp print   ;Jump to print
R:
    ret         ;Returns from a subroutine
;Below defines bytes (db) of our string to print. I used 0 as word seperators and 3 to end the string.
NATO: db 0,"lfa",0,"ravo",0,"harlie",0,"elta",0,"cho",0,"oxtrot",0,"olf",0,"otel",0,"ndia",0,"uliet",0,"ilo",0,"ima",0,"ike",0,"ovember",0,"scar",0,"apa",0,"uebec",0,"omeo",0,"ierra",0,"ango",0,"niform",0,"ictor",0,"hiskey",0,"ray",0,"ankee",0,"ulu",3
times 0200h - 2 - ($ - $$) db 0 ;Zerofill the file with upto 510 bytes (This is where all my bytes are)
dw 0AA55H   ;Write the bootsignature
```
## Output
This is what the above code outputs. As you can see *A: Alfa* is missing and that is because the prompt is 25 lines tall...
![Above codes output](https://i.stack.imgur.com/pA47p.png)
To prove I printed *A: Alfa* I replaced `0,"ulu"` with `32,"Z: Zulu"` so that Zulu is one on the same line as Yankee.
![Changed code](https://i.stack.imgur.com/2xaqf.png)
I would appreciate it if someone told me if I would be able to subtract the 317 bytes of zerofill from my code so it would be 195 bytes. Also if this is even valid because the output won't fit on the screen.
[Answer]
# [Bash](https://www.gnu.org/software/bash/), ~~224~~ ~~205~~ ~~188~~ 180 bytes
Thanks to [Digital Trauma](https://codegolf.stackexchange.com/users/11259/digital-trauma) for removing 17 bytes, and [manatwork](https://codegolf.stackexchange.com/users/4198/manatwork) for 8 bytes.
```
set {A..Z}
for i in lfa ravo harlie elta cho oxtrot olf otel ndia uliet ilo ima ike ovember scar apa uebec omeo ierra ango niform ictor hiskey ray ankee ulu;{ echo $1: $1$i;shift;}
```
[Try it online!](https://tio.run/nexus/bash#Fc0xDsIwDIXhnVO8gbkSK524BpsbHGI1iZGTVlRVz17M4Mm/3nc27tgfw/A8LlENAqnIkWC0KhJZFgbnTghJod9u2qE5Qjtn1JcQFk86JCukEGRm6MplYkMLZKCPJzxxgBb2hs0IVN@KKi4WSOgOJ2kzb85u/pyZfXYZd/Cfvd7uflcZW5LYx@M8fw "Bash – TIO Nexus")
[Answer]
# [Python 2](https://docs.python.org/2/), 198 bytes
```
for x in'Alfa Bravo Charlie Delta Echo Foxtrot Golf Hotel India Juliet Kilo Lima Mike November Oscar Papa Quebec Romeo Sierra Tango Uniform Victor Whiskey Xray Yankee Zulu'.split():print x[0]+': '+x
```
[Try it online!](https://tio.run/nexus/python2#Dc67bsJAEAXQX7mdiZAQNV2AQIDwDK@AKAZnjEde71jjNTJfb9yf4jSJGmqIjz5dQhgaPRWjlMwJY8wuEL7iVDHROpgGTNUl@NbADjP/L4R51cqAhTjFj@SEpWSMlT45v7NhXcZk2FBB2FZ85xg7zVnxK2xG2JN/KA5e2kaOo8Sh7ZxSKTN@4Wz0wh/5jBmXylVRryychM7HoDDxAfW1f@tGA0Tdumne "Python 2 – TIO Nexus")
Not exciting or clever. Just loops through the list and prints the first letter then ': ' then the whole word.
[Answer]
# PHP, 184 bytes 179 bytes 178
```
<?=preg_filter('/(.)[a-z]+/',"$1: $0
",AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu);
```
saved a single byte by using preg\_filter instead of preg\_replace.
---
*Original answer* 184 bytes 179 bytes
```
for($c=A;$s=[lfa,ravo,harlie,elta,cho,oxtrot,olf,otel,ndia,uliet,ilo,ima,ike,ovember,scar,apa,uebec,omeo,ierra,ango,niform,ictor,hiskey,ray,ankee,ulu][+$i++];$c++)echo"$c: $c$s
";
```
uses the fact that its sorted to generate the first char on the fly.
5 bytes saved by @Titus.
[Answer]
# [SOGL](https://github.com/dzaima/SOGL), 91 [bytes](https://github.com/dzaima/SOGL/blob/master/chartable.md)
```
╗D↕«∙φā¡75↔TI.½!γΜΧ…¡%<F┼0h╔κy|▓@TņV≈%⁹cr_σy░mgļΕžΕ⅝ »τ{M╔|«▼↔»aΓ²⁹┘′⅓G…└g↔bFΞ‽‘θ{KUtƧ: ooo
```
Explanation:
```
...‘θ{KUtƧ: ooo  that gibberish is a compressed string                 
...‘             push the compressed string of the words
    θ            split on spaces
     {           for each
      K          pop the 1st letter off & push it
       U         uppercase it
        t        output in newline a copy of the letter
         Ƨ: o    append ": "
             o   append the alphabet letter
              o  append the rest of the word
```
[Answer]
## [GNU sed](https://www.gnu.org/software/sed/), 165 bytes
This script is based on the [Retina answer](https://codegolf.stackexchange.com/a/112209/59010) by Martin Ender.
```
s/$/AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu/
s/[A-Z]/\n&: &/g
s/.//
```
**[Try it online!](https://tio.run/nexus/sed#Dcq5EoIwEADQ3q@wcOg0vR3e932iFgsusEOSdZaEka9H2zevKVVHhTqFgUDFwxxEE45QOxgnOU/464TdlHU6Y4d6bt8EC/8vbkmaV2RgTQVuuEITo2zLBGQHH9h7jDE5sEE@EorACWzGZ0spi7lQ4liuOZUF1jeB@g62QIy89qpVqkfYjV7qaYN@O1DZH3pKNc0P)**
**Explanation:**
```
s/$/AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu/
   # generate the alphabet words in concatenated form
s/[A-Z]/\n&: &/g
   # prepend '\nUL: ' before each upper-case letter (UL), getting the needed format
s/.//
   # delete the leading newline, plus implicit printing at the end
```
[Answer]
# [Bash](https://www.gnu.org/software/bash/), 184 bytes
```
printf '%c: %s
' {Alfa,Bravo,Charlie,Delta,Echo,Foxtrot,Golf,Hotel,India,Juliet,Kilo,Lima,Mike,November,Oscar,Papa,Quebec,Romeo,Sierra,Tango,Uniform,Victor,Whiskey,Xray,Yankee,Zulu}{,}
```
[Try it online!](https://tio.run/nexus/bash#DcrLUoNAEAXQvV/BJsXmfoE7ExM1T6N5aHadSRO6GKapZqBCUXw7etZnrExCzJJ04p6TSf2UJv2LzwhTo1Yxy8m8MF7ZR8Lc5YqFPqJpxJv6DO8a2eMj3ISwbP5nxEq8Yi0lYSMFY6stl1c27GpHhk@qCPuGr@zwpSUrvoXNCAcKd8UxSKZW4iQuquGcS11whx@jDr8UCmZcGt8MPYZx/AM "Bash – TIO Nexus")
[Answer]
## Lua, ~~278~~ 260 bytes
Thanks again to [Manatwork](https://codegolf.stackexchange.com/users/4198/manatwork) for saving 18 bytes!
```
function f(w)print(w.sub(w,0,1)..": "..w)end
f"Alfa"f"Bravo"f"Charlie"f"Delta"f"Echo"f"Foxtrot"f"Golf"f"Hotel"f"India"f"Juliet"f"Kilo"f"Lima"f"Mike"f"November"f"Oscar"f"Papa"f"Quebec"f"Romeo"f"Sierra"f"Tango"f"Uniform"f"Victor"f"Whiskey"f"Xray"f"Yankee"f"Zulu"
```
[Try it online](https://tio.run/nexus/lua#FY27bsMwDEX3fkWgyQYCoV27NU3fr7RJ@tpkhaoJy2JAS3Hz9Q45nQNeXnIKJfmMlGahGus9Y8rVaIfSVOP8fH5RW2suZ8basYa0OwvmKgZnglmwO5DwunUcEcSWELMmN77V4Jb@M1MWu6MYBPeUIQof0g5177FIT/MnjFp4xl7HL9jptVc6QN8Ai74N3ilXbq8L7wUa8CIf1IMW1wjMmmxc@tPBNmEg7sU@0WfS7leLQwdHsW92ih@XOtBHvyUWM00n)
---
**Older versions**
```
a={"Alfa","Bravo","Charlie","Delta","Echo","Foxtrot","Golf","Hotel","India","Juliet","Kilo","Lima","Mike","November","Oscar","Papa","Quebec","Romeo","Sierra","Tango","Uniform","Victor","Whiskey","Xray","Yankee","Zulu"}
for i=1,26 do print(a[i].sub(a[i],0,1) .. ": " .. a[i]) end
```
<https://repl.it/GK8J>
First time doing Lua, do probably can golf more, but thought I'd add it as an answer anyways.
[Answer]
# [Lua](https://www.lua.org), 177 bytes
```
print(("AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu"):gsub('%u',"\n%1: %1"):sub(2))
```
[Try it online!](https://tio.run/nexus/lua#Fcq5DoJAEADQXzEkREhstKTzvu/b2Aw4wIRlhwy7RL4esX15TSGkjec5QxXDSKDicQqiCCeoDEyjlGf8NcJmzipesEG11B@ClW2LWZPiDeWwpQx3XGEeouzLCOQABRwthhidOEc@E4rABXTCV00xS36jyLDcUyozrB8C9RN0hviyyjp@kJQ29Lqu7fact3b7Qcftt/rHge83zQ8 "Lua – TIO Nexus")
**Without trailing newline, 180 bytes:**
```
io.write(("AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu"):gsub('%u',"\n%1: %1"):sub(2))
```
**Explanation**
```
str = "AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu"
str = str:gsub('%u',"\n%1: %1") -- returns "\nA: Alfa...". %u matches uppercase letters, %1 returns matched letter in this case.
str = str:sub(2) -- remove added newline in the beginning
print(str) -- native print command
```
It uses Lua's string.gsub substitution function to pattern match the uppercase letters.
The letters are then replaced with the requested format (plus the letters themselves). Newlines are also added on the same pass. 
The sub-function at the end just trims out newline from the beginning and also works nicely to hide the second return value of gsub, which would have been the amount of replacements.
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~187~~ 185 bytes
```
0..25|%{($a=[char]($_+65))+": $a"+(-split'lfa ravo harlie elta cho oxtrot olf otel ndia uliet ilo ima ike ovember scar apa uebec omeo ierra ango niform ictor hiskey ray ankee ulu')[$_]}
```
[Try it online!](https://tio.run/nexus/powershell#Dc3RCoJAEIXhVznERooUEdRF0JNIyLSNObjryLhJUT277fX5OP@y3@0Ox@/6Uzi61L4juxauqU7HsqxWZzhaVcV2GoOkTWgJRrMioyAMDongO4W@kmmChhaaOGC4C@GZSYIEhUSC9AydOd7YMHky0JgJ39hDI2fDZgQaHopBWrUI8UkNnUw9v3P2nceeOd8@N2XtmutvWf4 "PowerShell – TIO Nexus")
Loops from `0` to `25`, each iteration forming `$a` of the corresponding capital `char`. Then string-concatenated with `: $a` (i.e., the colon-space-letter). Then that string is string-concatenated with an string that's formed by indexing into an array created by `-split`ting the phonetic string on spaces. Each of those 26 strings is left on the pipeline, and an implicit `Write-Output` happens at program completion, inserting a newline between elements.
*Saved two bytes thanks to @Matt.*
[Answer]
# C, ~~216~~ ~~215~~ 212 bytes
```
i=64,l;f(){for(char*s="lfAravOharliEeltAchOoxtroTolFoteLndiAulieTilOimAikEovembeRscaRapAuebeComeOierrAangOniforMictoRhiskeYraYankeEulU";++i<91;printf("%c: %c%.*s%c\n",i,i,l,s,s[l]+32),s+=l+1)for(l=0;s[++l]>90;);}
```
[Try it online!](https://tio.run/nexus/c-gcc#FY9RS8MwFEbf@ytKodAuQTYVYcYKQeqTEijzYcw9ZNmtvfQ2GUlahLHfXivf03k655uxenrkJNqivLbOF6bTfhWqjFrp9aQWIqyBojSdcr/Ru52jdxfhw55RjoSwQ1I4SOxrN8FwgiYY3eiLHOEEb24AheC91PZHWVwEn2iiazoMPey93mvbQz3SVyYYw5ftRlw82tgWWW6e09zkd6uQm2@bcVxGPPBwoCN7uC95YBWxTfnfTNVahANjdHzdrkUpbkkyOTyng0ZblOk1SdPlnkhu8/wH "C (gcc) – TIO Nexus")
A detailed, human readable, well commented and perfectly valid (no compiler warnings) version of the program can be found below:
```
#include <stdio.h>
int main() {
    // Uppercase characters designate the last character of a word
    char*s="lfAravOharliEeltAchOoxtroTolFoteLndiAulieTilOimAikEovembeRscaRapAuebeComeOierrAangOniforMictoRhiskeYraYankeEulU";
    int i = 64; // Consecutive character
    int l; // Word length
    // Loop `i` from A to Z; Shift `s` with word length
    // `s` always points to the beginning of a word
    for( ; ++i < 91; s += l + 1 ) {
        // Increment `l` until you reach the next capital letter
        for( l = 0; s[++l] > 90 ;);
        // Print the current character, the word without it's last letter
        // and the last letter lowercased
        printf( "%c: %c%.*s%c\n", i, i, l, s, s[l]+32 );
    }
}
```
[Answer]
# JavaScript ES6, 216 187 184 180 174 bytes
```
"AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu".replace(/[A-Z]/g,`
$&: $&`).trim()
```
Saved a byte thanks to Neil. Saved 5 bytes thanks to ETHproductions.
```
console.log("AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu".replace(/[A-Z]/g,`
$&: $&`).trim());
```
# [Japt](https://github.com/ETHproductions/japt), 127 bytes
```
`AlfaBŸvoC•r¦eDeltaE®oFoxÉ•GolfHÇUI˜iaJªietKiloL‹aMikeNovem¼rOs¯rPapaQue¼cRo´oSi€ŸTÂ
UnifŽmVÅ¡rW–skeyXŸyY„keeZªu`r"%A""
$&: $&
```
[Try it online!](https://tio.run/nexus/japt#AZsAZP//YEFsZmFCwp92b0PClXLCpmVEZWx0YUXCrm9Gb3jDicKVR29sZkjDh1VJwphpYUrCqmlldEtpbG9MwothTWlrZU5vdmVtwrxyT3PCr3JQYXBhUXVlwrxjUm/CtG9TacKAwp9Uw4IKVW5pZsKObVbDhcKhclfClnNrZXlYwp95WcKEa2VlWsKqdWByIiVBIiIKJCY6ICQm//8teA "Japt – TIO Nexus")
Saved 2 bytes thanks to obarakon.
[Answer]
# PHP, ~~175~~ ~~171~~ ~~164~~ 162 bytes
Note: no longer requires compressed file, uses IBM-850 encoding.
```
for($l=A;$c=LfaRavoHarlieEltaChoOxtrotOlfOtelNdiaUlietIloImaIkeOvemberScarApaUebecOmeoIerraAngoNiformIctorHiskeyRayAnkeeUlu[$i++];)echo$c<a?"
$l: ".$l++:"",$c|~▀;
```
Run like this:
```
php -nr 'for($l=A;$c=LfaRavoHarlieEltaChoOxtrotOlfOtelNdiaUlietIloImaIkeOvemberScarApaUebecOmeoIerraAngoNiformIctorHiskeyRayAnkeeUlu[$i++];)echo$c<a?"
$l: ".$l++:"",$c|~▀;';echo
```
# Explanation
Prints every character individually (lowercased by OR with a space). If an uppercase character is encountered, it first prints a string of the form "\nA: A".
# Tweaks
* Saved 4 bytes by using another compression strategy
* Saved 7 bytes by using a different delimiter (to combine assignment of `$l` with explode param), and not preventing a leading newline
* Saved 2 bytes with a new method
[Answer]
# Japt, ~~216~~ 214 bytes
```
`A: Alfa
B: Bvo
C: Cr¦e
D: Delta
E: E®o
F: FoxÉ
G: Golf
H: HÇU
I: Iia
J: Jªiet
K: Kilo
L: La
M: Mike
N: Novem¼r
O: Os¯r
P: Papa
Q: Que¼c
R: Ro´o
S: Si
T: TÂ
U: Unifm
V: VÅ¡r
W: Wskey
X: Xy
Y: Ykee
Z: Zªu
```
Explaination: 
There is most likely a much better way to do it, but since i'm new I don't know it.
I basically compressed the string with Oc" and put that string to be decompressed using Od" 
If someone wants to help me save bytes by using something different from line breaks, I'd be happy to learn!
edit: Saved 2 bytes using ` instead of Od"
[Answer]
## Pyke, 89 bytes
```
.d⻵㡺ᐒଆຳ뼙΋ÒΗ䊊繎ㅨڨǔᯍⰬᐓ❤ᄵ㤉ተ᤬䆰髨⨈性dc Fl5DhRJ": 
```
[Answer]
# Qbasic, 383 bytes
Not impressive, but for what it's worth:
```
dim a(1to 26)as string
a(1)="lfa
a(2)="ravo
a(3)="harlie
a(4)="elta
a(5)="cho
a(6)="oxtrot
a(7)="olf
a(8)="otel
a(9)="ndia
a(10)="uliet
a(11)="ilo
a(12)="ima
a(13)="ike
a(14)="ovember
a(15)="scar
a(16)="apa
a(17)="uebec
a(18)="omeo
a(19)="ierra
a(20)="ango
a(21)="niform
a(22)="ictor
a(23)="hiskey
a(24)="ray
a(25)="ankee
a(26)="ulu
for i=1to 26
?chr$(i+64);": ";chr$(i+64);a(i)
next
```
[Answer]
# [///](https://esolangs.org/wiki////), 220 bytes
```
/;/: /A;Alfa
B;Bravo
C;Charlie
D;Delta
E;Echo
F;Foxtrot
G;Golf
H;Hotel
I;India
J;Juliet
K;Kilo
L;Lima
M;Mike
N;November
O;Oscar
P;Papa
Q;Quebec
R;Romeo
S;Sierra
T;Tango
U;Uniform
V;Victor
W;Whiskey
X;Xray
Y;Yankee
Z;Zulu
```
[Try it online!](https://tio.run/nexus/slashes#Dcs5coNAEAXQ/J/CNyD3j7Tv@66shRszxUC7WoPKOj32y1@XMfv8yHrsxULQZ9/lZRhwUIrHoBhyqDEJRhzlpWHMsf0mt4QJJxYLTDm1pBEzzpqvIJhz3v6/hAUXIRqWXIZasOIqVIo11/bS@qGODTfPXBxbbuVHsOOu1Yfm2HNvtRoOPAR1Fxx5lObbcOKpCYV5jTPPIU/muPBShmelb1x5dXnjxps0lSruvLex7bo/ "/// – TIO Nexus")
-20 bytes thanks to @ETHproductions.
]