text:
Charlie, Oscar, Delta, Echo
A big part of radio communication is the 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.

Related.

Yea I saw that one but thought this was different enough @MartinEnder

@sagiksp No one said it wasn't. :)

@KritixiLithos How is this a duplicate? It's completely different and the only similarity is that they are both kolmogorov complexity.

I'm closing this as a dupe because it doesn't have any exploitable structure that would allow custom compression schemes to perform better than built-in compression, and the target challenge is our de facto standard challenge for built-in compression.

@Mego Is it? The rick roll has so much structure that custom compression probably makes a lot more sense than built-in compression.

Closely related. If anything I'd call it a dupe of this one, but it allowed people to choose their own words which actually made compression a lot more possible.

May I have a leading newline?

shouldn't the first one be A: Alpha ?

@SeanC: According to wikipedia (see link in question), no. That´s ATIS, not NATO. But then, it should be Juliett, not Juliet and X-ray instead of Xray.

@Titus I removed the dash from xray on purpose because I thought that would complicate any compression trying to decode it, I have no idea how juliet lost a t and for your other question, yes, but just one.

I found a kind of related joke language. My favorite example usage is Input: = pants nopants Output: 100%, nopants.

Didn't know about that one :D @mbomb007

Brings back memories.  The answer I had to give in military inspection was always "November-oscar-sierra-romeo-hotel-echo-papa-sierra-romeo-echo-delta-november-alpha-romeo, sir."

See also a related problem with solutions public: http://golf.shinh.org/p.rb?International+Radiotelephony+Spelling+Alphabet

Python 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!

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

Jelly, 76 bytes
“ṭṡl°ẠkWßġȮRẎ+wḋñȥạġ¢ƊḌ¬kạẠ¦WṡỊƒK⁹ç}⁶hm}Kñ£ɦ/lṇẊɠƓ}pƤ°⁸Ụ.g⁹Ġh9ṁ{f»ḲØAżj€⁾: Y

Try it online!
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

(NOTE: I never programmed in Jelly.) When I see your code I'm wondering two things: 1. You currently loop over the alphabet and join them with the words. Is it possible in Jelly to get the first character of a string, so you loop over the words instead of the alphabet, and join them with first_letter_of_word + ": " + word? And 2. You retrieve all words including spaces and then split by space. Is it possible to inclusive-split by the leading capital letters? No idea if these spaces even give extra bytes in their compressed form or not, and if they can be reduced with my description at 2.

@KevinCruijssen (1) yes it's possible to use the first letter of each word, however it wont be as short since the alphabet yield is a two-byte atom. (2) yes it's possible to split on capital letters, but surprisingly the compression of the string with no spaces is actually longer (many words with leading spaces are actually in the dictionary, as are all of these with capitalisation).

The dictionary doesn't contain leading spaces. However, when decompressing multiple words in a row, the default is to separate them by spaces; the first word won't have a leading space, but all following words will.

Retina, 156 bytes
Byte count assumes ISO 8859-1 encoding.

AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu
[A-Z]
¶$&: $&
G`.

Try it online!

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!
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

Get it down to 98 using this compressed string instead: ”AlfaÐ†vo¼¯¤œ®È¨›trotŠˆƒ‹Š™ÈŸt Kilo´àma—……ÍÐ—Žêpa¼°«Äoµ†Çâgo¸šÉµ Whiskey Xrayµ‹nkeeâ¸lu”.

@EriktheOutgolfer: Thanks! I was sure I looked for pa and li in the dictionary but I must have missed them. I didn't consider ya and zu as words though :)

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.
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();
  }
}

Should work with Java 5 and all subsequent versions.

Ruby, 169 characters
(Heavily based on Jonathan Allan's Python 2 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

PHP, 202 227 196 187 bytes
Thanks to 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 and 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 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

Why variable $a? Just move the entire preg_split() call in foreach's parameter. Then none of the spaces around as will be necessary anymore.

Instead of constant PREG_SPLIT_NO_EMPTY, better use its value: 1. But personally I would tweak the regular expression instead: /\B(?=[A-Z])/.

Thanks @insertusernamehere i'll make that edit now :D Still getting used to codegolfing

That would be one byte shorter with a plain array instead of the preg_split.

Errm no it wouldn´t ... Echo needs quotes.

Are methods like gzinflate(), etc forbidden by the standard loopholes? Feels like you could save a dozen bytes or so by compressing the string.

Also consider a regex over LfaRavoHarlie - the first letters can be autogen'd by a loop, saving 26 bytes, but possibly at too high a cost.

10 characters shorter: echo preg_replace('/([A-Z])[a-z]+/',"$1 = $0\n",Alfa...Zulu);

@DewiMorgan nice one, thanks!

Then how's about a 178ish? :D $z=A;foreach([lfa,ravo,...,ulu]as$k)echo"$z: $z$k\n";$z++;

Oops, I'd need the curlies on that foreach, adding 2 chars, so it's just as efficient to do $z=A;foreach([lfa,ravo,...,ulu]as$k)echo"$z: ".$z++."$k\n";

You can take it down into the 160s if you're willing to do something like $z=A;foreach(explode(X,gzinflate('BINARY_GARBAGE'))as$k)echo"$z: ".$z++."$k\n"; where BINARY_GARBAGE is the output of gzdeflate('lfaXravoXharlieXeltaXchoXoxtrotXolfXotelXndiaXulietXiloXimaXikeXovemberXscarXapaXuebecXomeoXierraXangoXniformXictorXhiskeyXrayXankeeXulu') You can even knock a further couple chars off by replacing explode() with split(), but then you drop compatibility with PHP7.

I think technically you should add <?  at the beginning, though, for character count for PHP. Alternatively, as with Titus' solution below, find something that can use <?= to save on characters wasted by echo...

@DewiMorgan, you mean exactly like my solution? I posted that a couple of hours before your comment, by the way.

@aross Yep, looks like many people beat me to my realizations! I didn't realize until I was several comments in that this was not the only PHP post, though, so for a moment there, I thought I was clever :) Your post, at 162b, is impressive... though I confess to having no clue how it works.

@DewiMorgan, thanks. I actually changed my implementation to that foreach, but before that I used the same approach as your comment. New method iterates over the chars in the string (by string index), checks whether it's an uppercase char (less than a), then prints the char lowercased by setting a bit in the char with binary OR. If it was an uppercase char, prefixes that char with "\nA: A"

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!
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' ...

Thanks! This was a bit messier!, and three bytes longer...

Ah, yes, 'split' would be longer here

'split' was shorter: 209 :)

I see! Well done!

You can split on spaces and save 5 more bytes

... or go back to strsplit?

Thanks again Luis, but maybe you should post it yourself since it's quite different...? (I do appreciate the tips though, don't misunderstand me)

No,  it's quite similar to your approach. Post it yourself if you want :-)

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!
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

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!
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!

How would I compile this?

@ItayGrudev, GCC and Clang should both compile that as is. gcc src.c or clang src.c. Here's a sample run with a main function added so the code will actually link and run: http://ideone.com/4Eowlh

@chris Then at the expense of 4 bytes, shouldn't f be replaced with main so the code is valid, or am I missing some golfing convention.

@ItayGrudev, The way I see it, the question only asked for the functionality, not a full, self-contained program.

218 with strtok() and some fiddling with the string 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,":"));} Unclear if it works everywhere: TIO segfaults but works in MinGW at least. Can't see much of a reason why it wouldn't work.

@gastropner Thanks! It works with MinGW on my computer too, and seems to work also on TIO with Clang (but not with gcc or tcc).

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>

This time competitive ? ;)

-13 bytes with gzinflate-ing the result of gzdeflate(Alfa...Zulu).

Unfortunately, no leading newline is allowed, only a (single) trailing newline

@aross: see the OP´s comment from yesterday: and for your other question, yes, but just one.

Python 2, 186 182 bytes
print''.join('\n%s: '%c*('['>c)+c for c in'AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu')

Try it online!

see comments on question: one leading newline is (now) accepted

Welcome to PPCG! Nice stuff.

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

Bash, 224 205 188 180 bytes
Thanks to Digital Trauma for removing 17 bytes, and 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!

Some golfing

Indexing array a is too long. set {A..Z};for i in lfa … ulu;{ echo $1: $1$i;shift;}

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...

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.

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.

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, 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!
Saved 2 bytes thanks to obarakon.

I was wondering how else you could get rid of that leading newline - it would have actually been a byte cheaper than your previous approach to manually prepend A: A to the string. But you can still save another byte by using a literal newline character instead of \n.

Nice answers. You can use a literal newline in Japt as well. Also, replace accepts a string for its second argument and replaces any $&s in it with the match, so you can do e.g "\n$&: $&" for both langs instead of using functions.

You can change @"\n{X}: {X}"} in Japt to just "\n$&: $&" :-)

@ETHproductions Thanks for the help!

Nice answer! You can save a couple bytes by dropping the " x and inserting a -x flag into the input. Note that the flag adds 1 byte to the total bytes.

Python 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!
Not exciting or clever. Just loops through the list and prints the first letter then ': ' then the whole word.

Lua, 278 260 bytes
Thanks again to 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

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.

My question may become boring, but again: Why variable a? ;) You can move the entire array declaration inside the for. And the for..in syntax helps to avoid writing those long array indices: http://pastebin.com/rxck79md Weird Lua thing: if you declare a function and call it 26 times “manually” (I mean, not in a loop) is shorter: http://pastebin.com/FMF9GmLJ

¯\_(ツ)_/¯ for the simple reason that I never used Lua before so I was just following the manual to try make it work, aha. Thanks @manatwork for the info, I didn't know about that.

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!
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 -splitting 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.

Nice. Removing the first character of each word didn't even occur to me. You can chop off 2 bytes doing this: 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')[$_]}

@Matt Oh sure, that makes sense. Thanks!

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.

Golf your original down to 180-1 with for($c=A;$s=[lfa,...,ulu][+$i++];$c++)echo"$c: $c$s\n";. Nice regex though.

@Titus I had in mind there must be a better way but switched to preg. Thanks for the tip !

GNU sed, 165 bytes
This script is based on the Retina answer by Martin Ender.
s/$/AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu/
s/[A-Z]/\n&: &/g
s/.//

Try it online!
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

SOGL, 91 bytes
╗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

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!

+1. The {,} trick in the brace expansion is a very clever way to double up each list member!

Lua, 177 bytes
print(("AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu"):gsub('%u',"\n%1: %1"):sub(2))

Try it online!
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.

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

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!
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 );
    }
}

Welcome to PPCG! Nice first post!

@ceilingcat Not only the char*s but the printf could go in there too. Thus saving another 3 bytes - a semicolon and 2 curly braces as we no longer need them since there is only one instruction in it's body - the other for loop.

C#, 257 242 bytes
Thanks to Kevin Cruijssen for saving 15 bytes!
class P{static void Main(){var c='A';foreach(var t 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())System.Console.WriteLine(c+": "+c+++t);}}

Full program which prints the required text, with one trailing newline.
Ungolfed:
class P
{
    static void Main()
    {
        var c='A';
        foreach(var t 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())
            System.Console.WriteLine(c+": "+c+++t);
    }
}

This is actually 17 bytes longer than the output... :P

@StewieGriffin: It's a full program, and C# didn't win awards for being minimalistic :P

I know, it was just an observation :)

You can golf it to 242 bytes like this.

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"

Using Try it online! it doesn't give the desired result :/

@ʰᵈˑyes that could be, I didn't have enough time to check everything before I had to go to work. I might do it again (and better) after work.

@ʰᵈˑ There are some unprintables in the string which don't show up in the Markdown. Try it online!

@ETHproductions ah thanks for that, I didn't know

Pyke, 89 bytes
.d⻵㡺ᐒଆຳ뼙΋ÒΗ䊊繎ㅨڨǔᯍⰬᐓ❤ᄵ㤉ተ᤬䆰髨⨈性dc Fl5DhRJ":

Do these characters happen to be in a specific single byte character set?

TIO gives a bad eval error and reports 161 bytes in the message. Either Pyke needs pushing there or something went wrong with a copy and paste here. @Adám if it was 1-1 it would be 41 bytes, utf-8 would be 88, but something definitely looks a bit off.

@JonathanAllan it should be UTF-8. TIO runs it in not UTF-8. I think the byte-count might be wrong because it's measured as UTF-8

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

Old BASIC memories… Can't those be stored in a data statement then read inside the for..next loop?

@manatwork, that's a good idea; I hadn't thought of it!

Wouldn't simply ?"A: Alfa" and so on be only 360 bytes?

@oerkelens, you could be right.  I didn't even consider the possibility.  :)

///, 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!
-20 bytes thanks to @ETHproductions.

It's not hard, and it saves 20 bytes: Try it online!

@ETHproductions I get it... for some reason I was overthinking it. I will update the answer.

Bubblegum, 182 bytes
00000000: 05c1 4792 e330 1004 c07b bda2 de51 3779  ..G..0...{...Q7y
00000010: efbd 6e10 b7b5 4210 644f 8026 46bf 9fcc  ..n...B.dO.&F...
00000020: 8138 48ef 80a1 38cc a177 8cc4 d127 e414  .8H...8..w...'..
00000030: 0d63 716c a90d 9888 93e2 e398 8a53 ff6d  .cql.........S.m
00000040: b3b7 9889 334f 6fcc c5b9 b796 b010 17f5  ....3Oo.........
00000050: bf18 b014 975d 8ad6 6225 ae62 72ac c575  .....]..b%.br..u
00000060: ac02 36e2 2696 86ad b8f5 deaa 9765 ecc4  ..6.&........e..
00000070: 5d53 848c bdb8 0f3f 0107 f1d0 d9cb 0a1c  ]S.....?........
00000080: c5a3 57e6 3889 a768 3907 9cc5 73a8 ff3b  ..W.8..h9...s..;
00000090: 2ee2 a58e 6fcf 15ae e235 16ad 67dc c4db  ....o....5..g...
000000a0: 2736 a57d 7117 ef39 7cf1 101f a12e cdf0  '6.}q..9|.......
000000b0: 149f 5dea fe00                           ..]...

Just Zopfli'd the target string for 100 000 iterations.

Japt, 131 bytes
130 bytes +1 for the -R flag.
;B¬®+": "+`AlfaBŸvoC•r¦eDeltaE®oFoxÉ•GolfHÇUI˜iaJªietKiloL‹aMikeNovem¼rOs¯rPapaQue¼cRo´oSi€ŸTÂ
UnifŽmVÅ¡rW–skeyXŸyY„keeZªu`fZ+"%a+

Try it online!
Explanation
;B¬®+": "+`{compressed string}`fZ+"%a+
;B                                     // Alphabet shortcut (ABC...XYZ)
  ¬                                    // Splits the Alphabet, by char, into new lines
   ®                                   // Shortcut for mZ{Z, which maps each item Z to the following:
    +": "+                             //   (Implicit) Z + ": " +
                               fZ+"%a+ //   matches of Z followed by lowercase letters, in
          `{compressed string}`        //   the compressed string "Alfa...Zulu". Backticks are used to decompress the string

The -Rflag is used to seperate each item by newlines.
Japt uses the shoco library for string compression.

Nice one! This reminds me of the original version of your answer on Create an Alphabet Song, unfortunately we can't use the same tricks here that we did there.

Chipmunk BASIC, 191 characters
(Inspired by anonymous2's QBasic solution. Was just too impatient to see a data based variant, so tried it myself.)
data 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=65to 90
read w$
?chr$(i)": "chr$(i)w$
next

Sample run:
Chipmunk BASIC v3.5.8b9
>load "nato.bas"
>run
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

Common Lisp, 219 bytes
(dolist(c'(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))(format t"~C: ~:(~A~)~%"(char(string c)0)c))

Ungolfed
(dolist (c '(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))
  (format t "~C: ~:(~A~)~%" (char (string c) 0) c))

Explaination:
dolist is effectively the CL equivalent of python's for _ in _ loop.
The words themselves are stored as lisp symbols, which are upcased after parsing by default.
format actually handles printing out to screen. The heavily lifting is in the format control string: "~C: ~:(~A~)~%".
~C takes a char and just prints it, ~A does the same with an arbitrary lisp object. ~:( and ~) are 'case control' directives, which upcase the first letter of any word printed between them.
(char (string c) 0) Gets the string for the symbol c and pulls the first char out of it.

Groovy, 191 bytes
Really nothing fancy, but it's Friday and I wanted to go golfing for the first time.
char c=65;"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().any{println("${c}: ${c++}"+it)}

Try it online!

Welcome to the site!

8086 machine code, 187 bytes
00000000  be 4c 01 31 c9 53 89 e5  68 0a 24 8a 8f 32 01 29  |.L.1.S..h.$..2.)|
00000010  cc 89 e7 f3 a4 83 c3 41  b7 20 86 fb 53 b3 3a 86  |.......A. ..S.:.|
00000020  fb 53 89 e2 b4 09 cd 21  89 ec 5b 43 83 fb 1a 75  |.S.....!..[C...u|
00000030  d4 c3 03 04 06 04 03 06  03 04 04 05 03 03 03 07  |................|
00000040  04 03 05 04 05 04 06 05  06 03 05 03 6c 66 61 72  |............lfar|
00000050  61 76 6f 68 61 72 6c 69  65 65 6c 74 61 63 68 6f  |avoharlieeltacho|
00000060  6f 78 74 72 6f 74 6f 6c  66 6f 74 65 6c 6e 64 69  |oxtrotolfotelndi|
00000070  61 75 6c 69 65 74 69 6c  6f 69 6d 61 69 6b 65 6f  |aulietiloimaikeo|
00000080  76 65 6d 62 65 72 73 63  61 72 61 70 61 75 65 62  |vemberscarapaueb|
00000090  65 63 6f 6d 65 6f 69 65  72 72 61 61 6e 67 6f 6e  |ecomeoierraangon|
000000a0  69 66 6f 72 6d 69 63 74  6f 72 68 69 73 6b 65 79  |iformictorhiskey|
000000b0  72 61 79 61 6e 6b 65 65  75 6c 75                 |rayankeeulu|
000000bb

Equivalent assembly code:
org 0x100
use16
    mov si, nato
    xor cx, cx
@@: push bx
    mov bp, sp
    push 0x240a
    mov cl, [len+bx]
    sub sp, cx
    mov di, sp
    rep movsb
    add bx, 'A'
    mov bh, ' '
    xchg bh, bl
    push bx
    mov bl, ':'
    xchg bh, bl
    push bx
    mov dx, sp
    mov ah, 0x09
    int 0x21
    mov sp, bp
    pop bx
    inc bx
    cmp bx, 26
    jne @b
    ret

len db 3,4,6,4,3,6,3,4,4,5,3,3,3,7,4,3,5,4,5,4,6,5,6,3,5,3
nato db "lfaravoharlieeltachooxtrotolfotelndiaulietiloimaikeovemberscarapauebecomeoierraangoniformictorhiskeyrayankeeulu"

Vyxal 3, 78 76 bytes
m':ᵛ+"vD∦C∑:ḋᵉ∑7ðȮ÷m^¹,ṫ₈Cⁿ«⁾hƒu~Φ∑₈DᴳkƓᶤNGġṀ<ϩɠ←⁰øWᵘ₉Πȧƛ₄∦ιqṘᶴ]←Ṭ}₈NḋẠᵃ”ṂZ'

Try it Online!

Batch, 216 bytes
@for %%w 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)do @set l=%%w&call echo %%l:~,1%%: %%l%%

CJam, 160 158 bytes
'A"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"S/{_": "\_)QN@}fQ;

Try it online!
Explanation
'A                         Push the character 'A'
  "..."S/                  Split huge string on spaces
         {           }fQ   For each word Q:
          _                  Duplicate top of stack (the character)
           ": "\             Push ": ", swap top stack elements; results in "A: A"
                _)           Duplicate the char on top and increment it (the next letter)
                  QN         Push Q and a newline
                    @        Bring the third-top element of the stack to the top
                              (brings the next character on top for the next iteration)
                        ;  Delete the top stack element, since at the end there will be a
                            '[' character on top

IBM/Lotus Notes Formula - 195 Bytes
L:=@Explode("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");@Left(L;1)+": "+L

Formula will by default apply a given function to each value in a list in turn so no for loop needed. @Explode (equivalent to split in other  more sensible languages) defaults to " ","," or ";" if no separator is supplied in the function call. As an aside, @Implode also equates to join. I guess formula is a bit too verbose and was not really made for golfing but some of the list operators are still cool and work as well as they did 20 odd years ago.
No TIO available for LN so screenshot shown below:

C (gcc), 393 bytes
#define p printf
long a[]={0x16C,0xf7f13f,0x59c3f18,0x15fc5,0xF83,0x5f0f3f5f9f0f,0x6c0f,0xC55f0f,0x194e,0x5f59c6f,0xfc9,0x1d9,0x5b9,0x3f52d57f0f,0x3f134f,0x11f1,0x35256f,0xf5d0f,0x13f3f59,0xf7e1,0xd3f0f69e,0x3f0f5f39,0xafb4f98,0xaf13f,0x55be1,0x6fc6f};i,j;d(long n){for(;n;n/=16){if(j=n&15){if(j>14)n/=16,j+=n&15;p("%c",96+j);}else n=0;}}r(){for(i=0;i<26;p("\n"))p("%c: %1$c",i+65),d(a[i++]);}

I thought it would be shorter than it is. I was wrong..
Each long int in long a[] represents a word containing the remaining letters of the required mnemonic once the first letter has been removed. Letters are encoded right to left whereby if the 4 lower bits are 0xF then it adds it to the next 4 bits and shifts it all down appropriately, repeating until the variable is empty.
Try it online!

283: main(){puts("A: Alfa\nB: Bravo\nC: Charlie\nD: Delta\nE: Echo\nF: Foxtrot\nG: Golf\nH: Hotel\nI: India\nJ: Juliet\nK: Kilo\nL: Lima\nM: Mike\nN: November\nO: Oscar\nP: Papa\nQ: Quebec\nR: Romeo\nS: Sierra\nT: Tango\nU: Uniform\nV: Victor\nW: Whiskey\nX: Xray\nY: Yankee\nZ: Zulu");}

@jayjay kind of takes the fun out of it, doesn't it?

I will give you that! Yours is much more interesting. :)

352 bytes

C, 199 bytes
f(){char*s=" AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu";while(*++s){printf("\n%c: %c"+*s/96*5,*s,*s);}}

I've been banging my head on this: "\n%c: %c"+*s/96*5 and I can't understand why it works. Care to elaborate? Also isn't it possible to remove the new line in the front? With it the solution is not correct.

BTW, your solution could be rewritten with a for loop and the printf could be changed to printf("\n%c: %1$c"+*s/96*5,*s) and thus save 4 bytes. Though it's still not correct.

And please, explain how this works: "\n%c: %c"+*s/96*5.

@ItayGrudev I’ll look into a fix later. "abc" is a pointer to the start of a constant string, and "abc"+2 adds 2 to that pointer, giving you a pointer to "c", for example.

Perl, 188 bytes

$n=64;$x="LfaRavoHarlieEltaChoOxtrotOlfOtelNdiaUlietIloImaIkeOvemberScarApaUebecOmeoIerraAngoNiformIctorHiskeyRayAnkeeUlu";while($x=~/.[a-z]*/g){$_=chr(++$n)."\l$&
";s/(.).*/$1: $&/;print}

Ungolfed version:

$x="LfaRavoHarlieEltaChoOxtrotOlfOtelNdiaUlietIloImaIkeOvemberScarApaUebecOmeoIerraAngoNiformIctorHiskeyRayAnkeeUlu";
$n=64;
while ($x =~ /([A-Z][a-z]*)/g) {
    $y = chr(++$n) . "\l$1\n";
    $y =~ s/(.)(.*)/$1: $1$2/;
    print $y;
}

Perl, 185 164 163 bytes
Saved 11 12 bytes with help from @manatwork
print$a=chr$i+++65,": $a\l$_\n"for split/(?=[A-Z])/,LfaRavoHarlieEltaChoOxtrotOlfOtelNdiaUlietIloImaIkeOvemberScarApaUebecOmeoIerraAngoNiformIctorHiskeyRayAnkeeUlu

May I suggest to reorder the used instructions/functions? print$a=chr$i+++65,": $a\l$_\n"for split/(?=[A-Z])/,LfaRavoHarlieEltaChoOxtrotOlfOtelNdiaUlietIloImaIkeOvemberScarApaUebecOmeoIerraAngoNiformIctorHiskeyRayAnkeeUlu

Nice! thanks, I'll update my code

REXX, 192 bytes
@='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'
do #=1 to 26
  c=d2c(#+64)
  say c':' c||word(@,#)
  end

Java, 300 275 bytes
interface x{static void main(String[]a){for(int i=0;i<26;i++) System.out.println(String.format("%c: %c%s",'A'+i,'A'+i,"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("_")[i]));}}

Ungolfed version with comments:
interface x {
    static void main(String[] a) {
        for (int i = 0; i < 26; i++)            // For all characters in alphabet
            System.out.println(                 // Print string
                    String.format("%c: %c%s",   // Formatted string(similar to printf)
                            'A'+i,              // Letter
                            'A'+i,              // Letter
                            "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("_")[i])); // Absurdly long string containing all words without first letters, divided into an array by _
    }
}

q, 167 bytes
Link to interpreter download
-1@.Q.A,'": ",/:.Q.A,'" "vs"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";

Japt -R, 108 bytes
I suspect there may be another byte or 2 to be saved here, possibly by interleaving with the uppercase alphabet, but I'm running out the door so it'll have to do for now.
Note the trailing space.
`lfaæ1ÃÉr¦e³ltawÖoxÉwolfÙ*lÙAawªià5¹µ±kewovem¼rws¯r°pawue¼cÙ o±ØÇ¯fmØtØkeyÙ°nkeewªu`qÔËi°Id ²i1":

Test it
`...`qÔËi°Id ²i1":
`...`                   :Compressed string "lfawravowharlieweltawchowoxtrotwolfwotelwndiawulietwilowimawikewovemberwscarwapawuebecwomeowierrawangowniformwictorwhiskeywraywankeewulu"
     q                  :Split on
      Ô                 :  "w"
       Ë                :Map
        i               :  Prepend
         °I             :    Prefix increment I, initially 64
           d            :    Get character at that codepoint
             ²          :    Repeat twice
              i1":      :    Insert ": " at 0-based index 1
                        :Implicit output joined with newlines

Thunno 2 N, 81 bytes
’lfaŒ¥ȷþ<ƭ`Ṃ⁸Ø⁽ÄƝḲƲḤJulietƒḍɲḄẠ[Ḷ⁸Ọ¦ṢĖḞɠṘ»oẹ⁽ẓẇṅ⁼ṡ÷ẏƬ»|»⁸“¶’"[A-Z]"ḄkAZıẸD`: +ƤJƤ

Attempt This Online!
Explanation
’...’"[A-Z]"ḄkAZıẸD`: +ƤJƤ  # Full program
’...’                       # Push compressed string "lfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu"
     "[A-Z]"Ḅ               # Split on uppercase letters
             kAZ            # Zip with the uppercase alphabet
                ı           # Map over this list of pairs:
                 ẸD         #  Dump onto stack and duplicate the letter
                   `: +     #  Append ": " to one copy
                       Ƥ    #  Prepend this to the other copy
                        JƤ  #  Join and prepend this to the string
                            # Implicit output, joined on newlines

Pip -l, 132 124 bytes
_.": "._MAZ.:J(zA*":yE-HFZ[`\0,A-%[z5/gh4!R
c}FNu3GM%uHk{yKs.B/OVMKb XP14DXDT[Em%
.rUog"FD126TD25)^'w

The code contains unprintable characters which do not display correctly on StackExchange. Here's a hexdump:
00000000: 5f2e 223a 2022 2e5f 4d41 5a2e 3a4a 287a  _.": "._MAZ.:J(z
00000010: 412a 2205 3a79 452d 4812 465a 5b60 1b5c  A*".:yE-H.FZ[`.\
00000020: 3006 2c41 2d25 5b7a 352f 6768 1008 1334  0.,A-%[z5/gh...4
00000030: 2152 1215 0a63 7d46 4e75 3305 474d 2575  !R...c}FNu3.GM%u
00000040: 1048 6b7b 794b 732e 1c42 2f4f 5619 4d07  .Hk{yKs..B/OV.M.
00000050: 074b 6220 5850 1131 3444 5844 545b 456d  .Kb XP.14DXDT[Em
00000060: 250a 191b 172e 1b72 0117 5517 6f67 2246  %......r..U.og"F
00000070: 4431 3236 5444 3235 295e 2777            D126TD25)^'w

Attempt This Online!
Explanation
Similar compression approach to another recent kolmo answer:
_.": "._MAZ.:J(zA*"..."FD126TD25)^'w
                  "..."               String of characters
                A*                    Get ASCII code of each
                       FD126          Treat those as base-126 digits and convert
                                      to base 10
                            TD25      Convert to list of base-25 digits
              (z                )     Index into lowercase alphabet
             J                        Join into a single string
                                 ^'w  Split on w's
                                      This gives a list ["lpha";"ravo";...;"ulu"]
         AZ                           Uppercase alphabet
        M                             Map this function to each letter:
_                                      The letter
 .": "                                 Concatenate colon-space
      ._                               Concatenate the letter again
           .:                         Concatenate that list itemwise with the list
                                      from earlier
                                      Print each on a separate line (-l flag)

Base 126 was chosen to avoid having any " characters in the string.


text:
Game of Life arrowslits
Background
This challenge is in honor of apsillers, who won the Not as simple as it looks category in Best of PPCG 2016 with their challenge Can my 4-note music box play that song?
Congratulations!
On their "About Me" page, this user has a really neat simulator for the Game of Life cellular automaton.
(Seriously, go check it out.)
On the other hand, the word aspillera is Spanish for "arrowslit".
In light of these facts, this challenge is about arrowslits in Game of Life.
Game of Life arrowslits
In GoL, we will represent an arrow by a glider, and a wall by a sequence of blocks.
A single glider approaches the wall from above, and tries to fly through a gap in the wall (the arrowslit).
Your task is to check whether the glider passes through the arrowslit or crashes into the wall.
Input
Your input is a grid of bits, which represents a GoL configuration.
You can take it in any reasonable format (multiline string of any two distict printable ASCII characters, list of strings, 2D array of integers, 2D array of booleans etc).
For clarity, I will use multiline strings of the characters .# in the following.
The input is guaranteed to have several properties.
First, its height is 2N for some N ≥ 6, and its width is at least 2N+2.
The input will be all .s, except that somewhere on the top three rows is a glider, and on the two middle rows there is a wall of blocks.
The glider will be heading southwest or southeast, and its position is such that if the walls are removed, it will not pass through a side edge before reaching the bottom edge (but it may reach a corner of the grid).
The glider is initially separated from the left and right edges by at least one step of .s.
It can be in any phase.
The wall consists of blocks, which are separated by one column of .s, except in one place, where they will be separated by at least two columns of .s.
Like the glider, the leftmost and rightmost blocks are also separated from the edges by one step of .s.
There will always be at least one block on the left edge and one block on the right edge.
Here is an example of a valid input grid:
....#......................
..#.#......................
...##......................
...........................
...........................
...........................
.##.##............##.##.##.
.##.##............##.##.##.
...........................
...........................
...........................
...........................
...........................
...........................

Output
As stated, your task is to determine whether the glider crashes into the wall or makes it through to the south edge.
For the purposes of this challenge, a crash occurs if the configuration no longer consists of a single glider and the wall of blocks, regardless of what happens later in the simulation.
The following diagrams show the smallest gaps that a southeast glider can go through without crashing in the two distinct phases (the condition for southwest gliders is symmetric).
...#...........
.#.#...........
..##...........
...............
...............
##...........##
##...........##

...#...........
....#..........
..###..........
...............
...............
##...........##
##...........##

If the glider flies through the wall, you shall output a truthy value, and otherwise a falsy value.
For the example above, the correct output is falsy, since the glider will crash into the left part of the wall.
For the purposes of this challenge, you can assume that if you simulate GoL on the input for 2*(height - 3) steps, the glider is on the bottom row in the expected position and the wall is intact, then the output is truthy.
Rules and scoring
You can write a full program or a function.
The lowest byte count wins.
Test cases
I have collected the test cases into a GitHub repository, since they are quite large.
Here are links to the individual files:

Truthy test cases as 2D arrays of bits
Falsy test cases as 2D arrays of bits
All test cases in human-readable format

Is there any reason for including the empty rows below the wall in the input?

@MartinEnder They make solutions where you actually simulate GoL on the input more feasible (at least I hope so).

The glider will always start on the top row?

@Rod Yes, it will be on the top row heading southwest or southeast.

Another game of life :P

Thanks for the interesting challenge! I'm honored. :)

Python 2, 142 136 135 bytes
-6 bytes thanks to ElPedro
-1 byte thanks to TuukkaX
p=input()
z=p[2].index(1)
m=(p[1][z]-p[1][z+1]<1)*2-1
k=i=0
for b in p[3:]:x=p[2][::m].index(1)+i;k|=1in b[::m][x-2:x+8];i+=1
print 1-k

Try it online! or Verify all test cases
Checking orientation (east/west):

Using z=p[2].index(1) to get the first square on 3rd row (represented by the red square), and then m=(p[1][z]-p[1][z+1]<1)*2-1 to subtract the value on the right (green) from the one on the left (blue), this way all the 4 gliders states that are going to southwest result in 1 (top row in the image), while the ones going to southeast result in 0 or -1.
Then convert : 1 -> -1 and 0,-1 -> 1 to be used on parameter to reverse the lists when dealing with west ones. This way the gliders going southwest are threated the same as the one going southeast.
Glider movement

This is the movement that the glider going southeast do, it has a "ladder" pattern, and the leftmost block on 3rd line is constant to every pattern. Using it as starting point, the surrounding 3 blocks on left and right, and the middle 4 blocks are checked for the presence of 1s (that would be the wall).

I think you can lose 4 bytes by setting a variable i to 0 outside the for loop then adding 1 to it it each pass and so get rid of enumerate. Seems to work when I tried it with your TIO. +1 for a cool answer whether I am right or wrong.

Nice! You can save a byte by removing the whitespace from 1 in. +1.

+1 for "weast"

Retina, 101 93 91 bytes
Byte count assumes ISO 8859-1 encoding.
O$#^`.(?=(.*¶)*(?<=#_.\2.+##.(.*¶)\D+))
$#1
¶(?>_(_)*#+_+¶_+¶(?<1>_+¶)*)(?>(?<-1>.)+)_{11}

Try it online!
Certainly not optimal yet.

Octave , 123 122 108 bytes
Thanks to @LuisMendo saved 2 bytes
B=A=input("");B(1:3,:)=0;do;until nnz((A=A&(s=conv2(A,(m=-1:1)|m','same'))>1&s<4|~A&s==3)-B)-5;any(A(end,:))

Try it online!
Or
Verify all test cases
Thanks to Rod preparing test cases.
B=A=input("");
B(1:3,:)=0;
do
until nnz((A=A&(s=conv2(A,(m=-1:1)|m','same'))>1&s<4|~A&s==3)-B)-5
any(A(end,:))

Previous answer:
B=A=input("");
B(1:3,:)=0;
while nnz(A~=B)==5
    s=conv2(A,(m=-1:1)|m','same');
    x=~A;
    A&=~A|~(s<2|s>3);
    A|=x&s==3;
end;
any(A(end,:))

First extract wall pattern as variable B.
Do GoL simulation until the wall pattern and the simulated pattern have more/less than 5 different cells.
If the glider has received the last row the function returns true.

until the wall pattern and the simulated pattern have more/less than 5 different cells. That's clever!

@LuisMendo Thanks, saved a byted

APL (Dyalog Unicode), 47 bytes
{p←0⍪⍣3⊢3↓⍵⋄1∊⊢⌿({≢⍸⍵}⌺3 3∊¨3+0,¨⊢)⍣{5≠≢⍸p≠⍺}⍵}

Try it online!
Uses the idea from rahnema1's Octave answer:

Do GoL simulation until the wall pattern and the simulated pattern have more/less than 5 different cells. If the glider has received the last row the function returns true.

The GoL simulation part is from the APLcart entry.
How it works
{
  ⍝ ⍵←initial GoL pattern
  p←0⍪⍣3⊢3↓⍵  ⍝ Extract the wall pattern
         3↓⍵  ⍝ Remove first 3 rows
    0⍪⍣3⊢     ⍝ Prepend a zero row three times
  p←          ⍝ Assign to p

  1∊⊢⌿({≢⍸⍵}⌺3 3∊¨3+0,¨⊢)⍣{5≠≢⍸p≠⍺}⍵  ⍝ Run the simulation and check
      ({≢⍸⍵}⌺3 3∊¨3+0,¨⊢)          ⍵  ⍝ Run GoL on the input pattern
                         ⍣{       }   ⍝ until
                             ≢⍸p≠⍺    ⍝ the difference between the pattern and p
                           5≠         ⍝ is not 5
    ⊢⌿  ⍝ Extract the last row
  1∊    ⍝ Check if it has at least one alive cell
}

source: Stack Exchange

license: 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/

sort: votes


text:
What's my question record?
There's a confusing factor in the 'Curious' badge. The "Positive question record".
(total questions - negative questions - closed - deleted)/total questions is the formula of the question record. (negative, closed and deleted 'stack' with each other. that means if a question is negative and closed, it counts as two minus.)
Luckily, you know a list of your questions. Make a program that calculates your question record.
The Input
You will be given an array of question datas. A question data is made of 2 datas.

The votes (integer)
The state (o(open), c(closed), d(deleted), b (closed and deleted) is the default, You may change the type and the characters for each states.)

Examples

[[-1,'o'],[1,'o']] => 0.5 (2 total, 1 minus points)
[[-1,'d'],[2,'c']] => -0.5 (2 total, 3 minus points)
[[-1,'b']] => -2 (1 total, 3 minus points)
[[23,'o'],[7,'c'],[7,'c'],[-1,'o'],[-5,'b'],[-11,'d'],[-3,'d'],[-3,'b'],[-15,'b']] => -0.77778(The precision is 5 digits past decimal point, rounded half-up. fractions are acceptable) (Oh my, my question record is horrible.)
`
('Minus points' is the sum of negative, closed and deleted.)

Rules

Format of input is your choice. You don't necessarily need to use the format in the Examples.

Reference

You should definitely care about that badge! Not for the sake of the badge, but because it means you're contributing with valuable content :)

You say it's part of the input format: Can I take open questions as 0, closed questions and deleted questions as -1 and closed and deleted questions as -2? Where is the limit?

@StewieGriffin I was just in the middle of writing a script using that trick!

What precision is needed for decimal output? Is fractional output acceptable?

Extra test cases, if you want: [[0,'c'],[22,'o'],[-5,'d'],[-16,'b']] and
[[0,'b'],[-2,'o'],[13,'c'],[3,'d']].

Data is plural. Datum is the singular

Usually a liberal input format is a good idea, but if it's too liberal, a code golf competition just turns into a most blatant abuse of the rules contest.

@Dennis That's why we make questions hard when it has a liberal input format, right?

As it is, nothing prevents me from posting a 0 byte answer and putting all my code in the input format. That's sort of what the dc answer does.

dc, 8 bytes
I've been waiting to use dc's feature, that the input is both data and code, for quite some time.
0d?n47Pp

The idea behind the script is that all of the number crunching will be done by the question's state representation, a valid input string. The main script's task is then to initialize the counters, read the input (and execute it as code at the same time), and print the result when done, as a fraction.
Here are the strings I use to represent the state. The OP allows non-char types!

'o' -> "1r[1-]sX0>X0-+r1+r"
'c' -> "1r[1-]sX0>X1-+r1+r"
'd' -> "1r[1-]sX0>X1-+r1+rrr"

The extra "rr" part at the end changes nothing, it is there to differentiate the d state from c.

'b' -> "1r[1-]sX0>X2-+r1+r"

Try it online! The default input there is the last example.
Test run: from the 2nd example. Negative numbers in dc are given with _ as the minus sign. This is allowed by this meta consensus.
dc -f question_record.dc <<< "_1 1r[1-]sX0>X1-+r1+rrr 2 1r[1-]sX0>X1-+r1+r"
-1/2

Explanation of the script:
0d
# push 0 twice. The bottom cell will keep track of the number of questions, and the
#top cell of the sum part of the score.
?
# read input, which in this case is actually pairs of (data, code), that do all the
#number crunching
n47Pp
# print the 2 cells as a fraction: print top, print '/' (ASCII 47), print bottom

Explanation of the state's representation: I take the c state as example code
The stack at the start of this snippet is composed of the two bottom counters, plus the integer data (the votes) that was pushed on top before this. The snippet contains both the integer value of the state (minus points) and the dc code needed to apply it.
1r[1-]sX0>X1-+r1+r

I work with the following iterative algorithm (pseudo-code) to calculate the "positive question record":
result = 0
# main script: `0`
sum = 0
# main script: `d`
for each input question; do
# main script:`?`
    sum += 1
    # snippet: `1`
    sum -= v (0 if total votes are positive, 1 if negative)
    # snippet: `r[1-]sX0>X`
    sum -= minus_points (based on state)
    # snippet: `1-`, or `0-`, or `2-`
    result++
    # snippet: `r1+`
done
result = sum / result
# main script:`n47Pp`

Dear downvoter, I don't mind your vote, but I would prefer an explanation if possible on why is the answer not valid or useful. I'm not the only one that represents the state differently than a char. Some use integers, other use a list/string. What I did is use a language feature that treats the input string and the input integer data the same, as code that is.

Jelly, 7 bytes
F<0S÷LC

Try it online!
Each entry in the input is a list of the vote count (an integer) and the status (a list). The status is a list of two integers, effectively a negated bit-flag:
open:             [ 0, 0]
closed:           [-1, 0]
deleted:          [ 0,-1]
closed & deleted: [-1,-1]

The tally of (negativeQuestions + closed + deleted) is then just the number of negative numbers and the final formula is then rearranged as 1-((negativeQuestions + closed + deleted)/totalQuestions):
F<0S÷LC - Main link: list as described above, d
F       - flatten d into a single list
 <0     - less than 0 (vectorises)
   S    - sum
     L  - length of d
    ÷   - divide
      C - complement (1 minus that)

05AB1E, 9 bytes
˜0‹O¹g/(>

Try it online!
Uses Jonathan Allan's algorithm, so the inputs for the state are as follows:open:             [ 0, 0]
closed:           [-1, 0]
deleted:          [ 0,-1]
closed & deleted: [-1,-1]Explanation:
˜0‹O¹g/(> "The program."\
˜         "Deep-flatten the list."\
 0‹O      "Check how many numbers are negative."\
    ¹g    "Push the original list's length."\
      /   "Float-divide top two stack items."\
       (> "Push the complement of ToS."\

Haskell, 70 57 bytes
13 bytes saved thanks to @Laikoni!
f=fromIntegral.length
v#s=(f v-(f.filter(<0))v+sum s)/f v

Input format
2 lists of same length, the first containing the vote counts, the second containing the question statuses where open is 0, closed/deleted is -1 and closed+deleted ist -2.
Readable
record :: [Int] -> [Int] -> Float
record v s = fromIntegral (length v - (length.filter(<0)) v + sum s)
           / (fromIntegral.length) v

Explanation
Nothing special. Number of votes minus the number of negative questions plus the sum of the statuses, using the input format.
This solution gets inflated quite a bit because Haskell requires the arguments of a real divison to both be real numbers. In this case, they are Integers instead, so we have to call fromIntegral on them.

You could use a shorter function name than record, eg. an infix operator to save some bytes.

Defining f=fromIntegral.length should save some more bytes.

57 bytes: Try it online!

Thanks, @Laikoni! I really forgot to shorten the name... And the new definition of f is a great idea. I edited your suggestions in.

Python 3, 42 bytes
lambda d:sum(1-s-(v<0)for v,s in d)/len(d)

Try it online!

Input: [[votes, status],[votes, status],...]

open : 0
closed : 1
deleted : 1
closed and deleted : 2

Example : [[-1,0],[1,1],[0,2]]

Python 3, 35 bytes
lambda d:1-str(d).count('-')/len(d)

Unnamed function taking a list, d.
Try it online!
Each entry in d is a list of the vote count (an integer) and the status (a list). The status is a list of two integers, effectively a negated bit-flag:
open:             [ 0, 0]
closed:           [-1, 0]
deleted:          [ 0,-1]
closed & deleted: [-1,-1]

The tally of (negativeQuestions + closed + deleted) is then just the number of negative numbers, which is shortest to count by counting the hyphens in d cast to a string. The final formula is then rearranged as 1-((negativeQuestions + closed + deleted)/totalQuestions)

Python 2, 35 bytes
lambda d:1-1.*`d`.count('-')/len(d)

Same approach, but uses the __repr__ shorthand `...` and multiplies by 1. to cast the count to a float.

Röda, 38 bytes
f a{[-#[a()|[0]for i if[i<0]]/#a*3+1]}

Try it online!
It's a function that takes one argument, an array, that has three values per each question: the vote count, close status and delete status. Statuses are either -1 (closed or deleted) or 0 (not closed or not deleted).
Explanation:
f a{[-#[a()|[0]for i if[i<0]]/#a*3+1]}
f a{                                 } /* function f with parameter a */
        a()|                           /* push values in a to the stream */
               for i                   /* for each value in the stream: */
                     if[i<0]           /*   if the value is negative: */
            [0]                        /*     push 0 to the stream */
    [                               ]  /* return: */
      #[                    ]          /*   number of values in the stream */
     -                                 /*   negated */
                             /#a*3     /*   divided by number of questions */
                                  +1   /*   plus 1 */

Example:
main {
    f([
        23, 0, 0,
        7, -1, 0,
        7, -1, 0,
        -1, 0, 0,
        -5, -1, -1,
        -11, 0, -1,
        -3, 0, -1,
        -3, -1, -1,
        -15, -1, -1
    ])
}

By the way, now you can try Röda programs online using the Try it online! interpreter hosted by Dennis.

@KritixiLithos That's really cool!

JavaScript (ES6), 53 46 bytes
a=>a.reduce((r,[v,s])=>r-(v<0)-s,l=a.length)/l

Takes the state as 0 for a closed NOR deleted question, 1 for a closed XOR deleted question, 2 for a closed AND deleted question.

Octave, 45 43 42 37 bytes
OP has just said in a comment that it's OK to take the state of questions on this format:
Open:              0
Closed:           -1
Deleted:          -1
Closed+Deleted:   -2

That makes the challenge quite a bit simpler:
@(v,s)(rows(v)-v<0-sum(s))/rows(v)

Old answer, from when the rules were a bit more strict.
@(v,s)((r=nnz(s))-nnz([v<0,s<100,s<99]))/r

This takes two variables as input, the votes, v and the state s, both as row vectors. It counts the number of rows, subtracts the total amount of negative votes, the number of close votes and the number of delete votes, then finally divides by the number of questions again.

JS: 108 bytes
Note the first slice argument should be 1 if not running from a script. I figured that the scores don't need to be associated with each post since the effect stacks anyway.
Call by script:
node code.js totalQs numOpen numClosed numDeleted score1 score2 ...
The code:
[t,o,c,d,...s]=process.argv.slice(2).map(v=>parseInt(v));console.log((t-c-d-s.reduce((c,v)=>v<0?c+1:c,0))/t)

Explanation needed?
[a, ...b] = [1,2,3] gives a==1, b==[2,3]
process.argv.slice(2) gets all the arguments except the first (path to node and script respectively).
.map(v=>parseInt(v)) converts each element to a number. Hopefully nobody tries NaN inputs ;).
s.reduce((c,v)=>v<0?c+1:c,0) loops over s (scores) with a function taking the counter c and value v. If v (the score of any post) is <0 then we +1 our counter to get the number of negative posts.
(t-c-d-numberNegative) / t is the total, minus closed, minus deleted, minus negative, divided by total.

Mathematica, 32 bytes
1-Count[#,a_/;a<0,∞]/Length@#&

Anonymous function. Takes a list of pairs of integers and states, where the states are translated from the problem output specification as shown below:
o: {0, 0}
c: {-1, 0}
d: {0, -1}
b: {-1, -1}

Returns a rational number as output. The Unicode character is U+221E INFINITY for \[Infinity]. The algorithm used is conceptually similar to those of other answers.

Batch, 99 bytes
@set/ar=n=o=0,c=d=-1,b=-513
@for %%v in (%*)do @set/a"r+=%%v>>9,n+=1
@set/ar+=n/=2
@echo %r%/%n%

Takes input as a single list of votes (limited to ±500 per question) and statuses. Prints an unreduced fraction. 218 bytes to print using decimals:
@set/ar=n=o=0,c=d=-1,b=-513
@for %%v in (%*)do @set/a"r+=%%v>>9,n+=1
@set/a"n/=2,r=r*200000/n+200001,r+=r>>31,r>>=1
@if %r:-=% geq 100000 echo %r:~,-5%.%r:~-5%&exit/b
@set/a"r+=(r>>31|1)*1000000
@echo %r:~,-7%0.%r:~-5%

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