Escriba un programa que tome una cadena y deletree esa palabra usando el alfabeto fonético de la OTAN.

El mapeo es el siguiente:

'A' -> 'Alfa'
'B' -> 'Bravo'
'C' -> 'Charlie'
'D' -> 'Delta'
'E' -> 'Echo'
'F' -> 'Foxtrot'
'G' -> 'Golf'
'H' -> 'Hotel'
'I' -> 'India'
'J' -> 'Juliett'
'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'

Ejemplo:

'Hello World' -> ['Hotel', 'Echo', 'Lima', 'Lima', 'Oscar', 'Whiskey', 'Oscar', 'Romeo', 'Lima', 'Delta']

La entrada puede ser cualquier cadena, pero siempre estará compuesta solo por letras y espacios. El caso es irrelevante en la salida, pero la entrada puede contener letras en mayúsculas, minúsculas o ambas. Los espacios deben ignorarse en la salida.

Puede imprimir en cualquier formato razonable, pero debe ser un conjunto delimitado de indicativos de la OTAN.

sfk , 78 59 57 bytes

+filt
+spell -nato
+xed _ph_f_ _et_ett_ _-__ "*: [keep]""

Pruébalo en línea!

Solo usa la herramienta correcta.

La salida es la fonética separada por uno o más espacios.

Ensamblaje IBM PC DOS 8088, 208 204 204 197 194 192 bytes

be80 00ad 8ac8 ac51 24df 8ad0 2c40 3c1b 7321 8af0 b024 b18b 9090 bf37 01f2 aefe
ce75 fab4 02cd 218b d7b4 09cd 21b2 20b4 02cd 2159 e2d0 c324 6c66 6124 7261 766f
2468 6172 6c69 6524 656c 7461 2463 686f 246f 7874 726f 7424 6f6c 6624 6f74 656c
246e 6469 6124 756c 6965 7474 2469 6c6f 2469 6d61 2469 6b65 246f 7665 6d62 6572
2473 6361 7224 6170 6124 7565 6265 6324 6f6d 656f 2469 6572 7261 2461 6e67 6f24
6e69 666f 726d 2469 6374 6f72 2468 6973 6b65 7924 7261 7924 616e 6b65 6524 756c
7524

Descargue el ejecutable DOS NATO.COM:

¡Pruébalo sin conexión! (en DOSBox, etc.)

        TITLE NATO3
_TEXT   SEGMENT
        ASSUME CS:_TEXT,DS:_TEXT,ES:_TEXT,SS:_TEXT
        ORG     100H

START:
    MOV  SI, 80H            ; point SI to DOS PSP
    LODSW                   ; load arg length into AL, advance SI to 82H
    MOV  CL, AL             ; set up loop counter
SEARCH:
    LODSB                   ; load next char from DS:SI into AL, advance SI 
    PUSH CX                 ; save outer loop position
    AND  AL, 0DFH           ; uppercase the input letter
    MOV  DL, AL             ; save for output
    SUB  AL, 'A'-1          ; convert letter to one-based index (A=1, Z=26, etc)
    CMP  AL, 27             ; if greater than 26, not a valid char
    JNC  NOTFOUND           ; if not, move to next
    MOV  DH, AL             ; DH is loop counter
    MOV  AL, '$'            ; search for string delimiter
    MOV  CL, LNATO          ; repeat search through length of word data
    MOV  DI, OFFSET NATO    ; re-point SCASB to beginning of word data
SCANLOOP:
    REPNZ SCASB             ; search until delimiter in AL is found ES:DI, advance DI
    DEC  DH                 ; delimiter found, decrement counter
    JNZ  SCANLOOP           ; if counter reached 0, index has been found
    MOV  AH, 02H            ; display first char
    INT  21H
    MOV  DX, DI             ; put found string memory location to DX for display
    MOV  AH, 09H            ; display string function
    INT  21H
    MOV  DL, ' '            ; display a space between words
    MOV  AH, 02H
    INT  21H
NOTFOUND:
    POP  CX                 ; restore outer loop counter
    LOOP SEARCH             ; move to next char in input
    RET
NATO    DB  '$lfa$ravo$harlie$elta$cho$oxtrot$olf$otel$ndia$'
        DB  'uliett$ilo$ima$ike$ovember$scar$apa$uebec$omeo$'
        DB  'ierra$ango$niform$ictor$hiskey$ray$ankee$ulu$'
LNATO   EQU $-NATO

_TEXT ENDS
END START

Prueba de salida:

A>NATO abc aaa
Alfa Bravo Charlie Alfa Alfa Alfa 
A>NATO abc DefG1HIJ
Alfa Bravo Charlie Delta Echo Foxtrot Golf Hotel India Juliett 
A>NATO Alfa Bravo!
Alfa Lima Foxtrot Alfa Bravo Romeo Alfa Victor Oscar 

Actualizado para eliminar el primer carácter de la matriz de la lista de palabras (aunque solo guarda 11 bytes debido al código adicional requerido).

05AB1E , 102 96 95 bytes

álSA”AlfaІvo¼¯¤œ®È¨›trotŠˆƒ‹Š™ÈŸtt Kilo´àma—……ÍЗŽêpa¼°«Äoµ†Çâgo¸šÉµ Whiskey Xrayµ‹nkeeâ¸lu”#‡

La salida es una lista de palabras de la OTAN con título.

Pruébalo en línea.

Explicación:

á              # Only leave the letters of the (implicit) input
 l             # Convert it to lowercase
  S            # Split it to a list of characters
   A           # Push the alphabet
    ”...”      # Push all the NATO words in titlecase and space-delimited
         #     # Split the string by spaces
          ‡    # Transliterate; map all letters in the lowercase input with this
               # list at the same indices (and output the resulting list implicitly)

Ver este consejo 05AB1E mío (sección Cómo usar el diccionario? ) Para entender por qué ”AlfaІvo¼¯¤œ®È¨›trotŠˆƒ‹Š™ÈŸtt Kilo´àma—……ÍЗŽêpa¼°«Äoµ†Çâgo¸šÉµ Whiskey Xrayµ‹nkeeâ¸lu”es "Alfa Bravo Charlie Delta Echo Foxtrot Golf Hotel India Juliett Kilo Lima Mike November Oscar Papa Quebec Romeo Sierra Tango Uniform Victor Whiskey Xray Yankee Zulu". El crédito de esta cadena de diccionario comprimido va a @ErikTheGolfer en este comentario (con un agregado tpara en Juliettlugar de Juliet).

Jalea ,  80  77 bytes

ḟ⁶O%32ị“¡µQỤ(cɠṘwlṁ;Ɗœ<NẸ½ṗN¬ṙẋxḶb¤*O~ƃ¹.ß8Ḋ¡tJ|Ḷ<İİḂ^1eȷjċbY9TYƭ¹Ẉ¥¤K0¹f»Ḳ¤

Pruébalo en línea! (El pie de página formatea la lista uniéndose con espacios para evitar la impresión aplastante implícita cuando se ejecuta como un programa completo)

JavaScript (ES6), 181 189 bytes

s=>s.match(/\w/g).map(c=>'IndiAlfABravOscaRomeOQuebeCharliEchODeltAGolFoxtroTangOHoteLimAJulietTKilOZulUniforMikENovembeRPapASierrAVictoRWhiskeYankeEXraY'.match(c.toUpperCase()+'.*?[A-Z]'))

Como el caso de salida no importa, podemos guardar bytes ejecutando palabras juntas:

... GolFoxtroTangO ...

Pruébalo en línea!

Python 3 , 250 191 bytes

-47 bytes gracias a @Jo King, -2 más gracias a @Jonathan Allen

Pasa por todos los caracteres que no son espacios de la entrada, y para cada uno de ellos selecciona la frase relevante para la letra, que puede reducirse un poco porque la primera letra de cada frase es el propio carácter. Divide una cadena en lugar de almacenar las frases como una matriz para guardar los bytes desde innecesarios 's y ,s.

lambda s:[c+"lfa ravo harlie elta cho oxtrot olf otel ndia uliett ilo ima ike ovember scar apa uebec omeo ierra ango niform ictor hiskey ray ankee ulu".split()[ord(c)%32-1]for c in s if' '<c]

Pruébalo en línea!

Solución original

lambda s:[c+['lfa','ravo','harlie','elta','cho','oxtrot','olf','otel','ndia','uliett','ilo','ima','ike','ovember','scar','apa','uebec','omeo','ierra','ango','niform','ictor','hiskey','ray','ankee','ulu'][ord(c)-65]for c in s.replace(" ", "").upper()]

Pruébalo en línea!

Rojas , 210 193 bytes

func[s][foreach c trim/all s[prin c print pick[:lfa:ravo:harlie:elta:cho:oxtrot:olf:otel:ndia:uliett:ilo:ima:ike:ovember:scar:apa:uebec:omeo:ierra:ango:niform:ictor:hiskey:ray:ankee:ulu]c% 32]]

Pruébalo en línea!

Explicación:

foreachitera sobre la cadena después de eliminar todos los espacios en blanco trim/all. prinimprime el carácter (sin nueva línea). printimprime un símbolo, pickeditado de la lista de get-word! s (símbolos) usando el carácter asignado al rango 1..26 como índice.

Limpio , 218 bytes

import StdEnv
$s=[takeWhile((<=)c)(dropWhile((<)c)['ZuluYankeeXrayWhiskeyVictorUniformTangoSierraRomeoQuebecPapaOscarNovemberMikeLimaKiloJuliettIndiaHotelGolfFoxtrotEchoDeltaCharlieBravoAlfa'])\\c<-map toUpper s|c>' ']

Pruébalo en línea!

C # (compilador interactivo de Visual C #) , 218 bytes

n=>n.ToUpper().Select(x=>"AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJuliettKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu".SkipWhile(k=>x!=k).TakeWhile((k,l)=>l<1|k>96&k<123))

Pruébalo en línea!

Versión alternativa con Split (), 194 bytes.

n=>n.ToUpper().Select(x=>x>64?x+"lfa,ravo,harlie,elta,cho,oxtrot,olf,otel,ndia,uliett,ilo,ima,ike,ovember,scar,apa,uebec,omeo,ierra,ango,niform,ictor,hiskey,ray,ankee,ulu".Split(',')[x%65]:x+"")

Pruébalo en línea!

C ++, 229 228 bytes

[](auto s){for(;auto t=*s?"LfaRavoHarlieEltaChoOxtrotOlfOtelNdiaUliettIloImaIkeOvemberScarApaUebecOmeoIerraAngoNiformIctorHiskeyRayAnkeeUlu":0;s++)if(int c=*s&31){for(cout<<*s;*t>96||--c;t++);for(;cout<<*t,*++t>96;);cout<<' ';}}

Pruébalo en línea!

Sin golf:

[](const char *s)
{
    const char *table = "LfaRavoHarlieEltaChoOxtrotOlfOtelNdiaUliettIloImaIkeOvemberScarApaUebecOmeoIerraAngoNiformIctorHiskeyRayAnkeeUlu";
    for (; *s; s++)
    {
        char c = *s & 0x1F;
        if (c != 0)
        {
            cout << *s;
            const char *w = table;
            while (*w >= 'a' || --c)
                w++;
            do
                cout << *w;
            while (*++w >= 'a');
            cout << ' ';
        }
    }
}

Salida:

TAngo hOtel eCho qUebec uNiform iNdia cHarlie kIlo bRavo rOmeo oScar wHiskey nOvember fOxtrot oScar xRay jUliett uNiform mIke pApa eCho dElta oScar vIctor eCho rOmeo tAngo hOtel eCho lIma aLfa zUlu yAnkee dElta oScar gOlf 
JUliett aLfa cHarlie kIlo dElta aLfa wHiskey sIerra lIma oScar vIctor eCho mIke yAnkee bRavo iNdia gOlf sIerra pApa hOtel iNdia nOvember xRay oScar fOxtrot qUebec uNiform aLfa rOmeo tAngo zUlu 

Versión de capitalización limpia ( 234 bytes ):

[](auto s){for(;auto t=*s?"LfaRavoHarlieEltaChoOxtrotOlfOtelNdiaUliettIloImaIkeOvemberScarApaUebecOmeoIerraAngoNiformIctorHiskeyRayAnkeeUlu":0;s++)if(int c=*s&31){for(cout<<*s;*t>96||--c;t++);for(;putchar(*t|32),*++t>96;);cout<<' ';}}

Pruébalo en línea!

Salida:

Tango hotel echo quebec uniform india charlie kilo bravo romeo oscar whiskey november foxtrot oscar xray juliett uniform mike papa echo delta oscar victor echo romeo tango hotel echo lima alfa zulu yankee delta oscar golf 
Juliett alfa charlie kilo delta alfa whiskey sierra lima oscar victor echo mike yankee bravo india golf sierra papa hotel india november xray oscar foxtrot quebec uniform alfa romeo tango zulu 

Lenguaje de máquina IBM PC DOS 8088, 165 bytes

Esto se basa directamente en la respuesta de gwaugh , pero me afeitó 26 bytes al omitir los $delimitadores de la "OTAN" tabla de palabras y un 1 byte adicional por no saltarse el primer carácter de la cadena de parámetros de línea de comandos (que será siempre bien /o y así será ignorado por el programa de todos modos). El programa terminó teniendo exactamente la misma longitud para poder procesar la tabla en este formato (en el que las palabras están delimitadas solo por mayúsculas, que tienen el doble propósito de ser también la segunda letra de cada palabra), o 2 bytes más tiempo si la capitalización de salida se mantiene igual que antes. La tabla es 26 bytes más pequeña.

En el siguiente volcado de programa, la concatenación por :se usa para mostrar cada secuencia de bytes consecutivos correspondientes a una instrucción:

0000  BE:80:00 AC 91 AC 24:DF 8A:D0 2C:40 3C:1A 77:21  ······$···,@<·w!
0010  8A:F0 B4:02 CD:21 56 BE:34:01 AC A8:20 75:FB FE: ·····!V·4··· u··
0020 :CE 75:F7 8A:D0 CD:21 AC A8:20 75:F7 B2:20 CD:21  ·u····!·· u·· ·!
0030  5E E2:D2 C3 4C 66 61 52 61 76 6F 48 61 72 6C 69  ^···LfaRavoHarli
0040  65 45 6C 74 61 43 68 6F 4F 78 74 72 6F 74 4F 6C  eEltaChoOxtrotOl
0050  66 4F 74 65 6C 4E 64 69 61 55 6C 69 65 74 74 49  fOtelNdiaUliettI
0060  6C 6F 49 6D 61 49 6B 65 4F 76 65 6D 62 65 72 53  loImaIkeOvemberS
0070  63 61 72 41 70 61 55 65 62 65 63 4F 6D 65 6F 49  carApaUebecOmeoI
0080  65 72 72 61 41 6E 67 6F 4E 69 66 6F 72 6D 49 63  erraAngoNiformIc
0090  74 6F 72 48 69 73 6B 65 79 52 61 79 41 6E 6B 65  torHiskeyRayAnke
00A0  65 55 6C 75 40                                   eUlu@

Descargue el ejecutable DOS NATO.COM:
Con mayúsculas sin corregir (165 bytes)
Con mayúsculas limpias (167 bytes)
Versión de bonificación que escribe en mayúscula la primera letra de cada palabra igual que la entrada (167 bytes)

Desmontado:

    .MODEL TINY            ; .COM program, maximum addressing space 65536 bytes
    .CODE
    ORG 100h
start:
    MOV  SI, 80h           ; Point SI to DOS PSP (Program Segment Prefix).
    LODSB                  ; Load command-line parameter (input string) length
                           ; into AL; assume AX=0 before this, which is true
                           ; in most versions of DOS; advance SI to first char
                           ; of parameter, which is either '/' or ' '.
    XCHG CX, AX            ; Set up loop counter with length of input string.
search:
    LODSB                  ; Load next character from [SI] into AL; advance SI.
    AND  AL, NOT ('A' XOR 'a')  ; Make this character uppercase.
    MOV  DL, AL            ; Save character for output. Move this before the
                           ; AND instruction to capitalize the first letter of
                           ; each word identically to how it is in the input.
    SUB  AL, 'A'-1         ; convert letter to one-based index (A=1, Z=26, etc)
    CMP  AL, 'Z'-'A'+1     ; Is this an alphabetical character?
    JA   notFound          ; If not, move to next character.
    MOV  DH, AL            ; Set up DH as our word-finding loop counter.
    MOV  AH, 02h           ; AH=02h, INT 21h: Write character to STDOUT
    INT  21h               ; Display first character of this NATO word.
    PUSH SI                ; Save our current position in the input string.
    MOV  SI, OFFSET table  ; Point LODSB to beginning of word data.
scanLoop:                  ; Find the word in the table corresponding to our
                           ; current character.
    LODSB                  ; Load next character from [SI] into AL; advance SI.
    TEST AL, 'A' XOR 'a'   ; Is this character uppercase?
    JNZ  scanLoop          ; If not, move to next character.
    DEC  DH                ; Delimiter (uppercase) found; decrement counter.
    JNZ  scanLoop          ; Keep looping until counter reaches 0.
    OR   AL, 'A' XOR 'a'   ; Make this character lowercase. This is not
                           ; required by the challenge's specification, and
                           ; this instruction can be removed.
wordLoop:
    MOV  DL, AL            ; Display next character from NATO word.
    INT  21h               ; (We still have AH=02h from before.)
    LODSB
    TEST AL, 'A' XOR 'a'   ; Is this character lowercase?
    JNZ  wordLoop          ; If so, continue the loop.
    MOV  DL, ' '           ; Display a space between words.
    INT  21h               ; (We still have AH=02h from before.)
    POP  SI                ; Restore our current position in the input string.
notFound:
    LOOP search            ; Move to next character in input string.
    RET
table   DB  'LfaRavoHarlieEltaChoOxtrotOlfOtelNdia'
        DB  'UliettIloImaIkeOvemberScarApaUebecOmeo'
        DB  'IerraAngoNiformIctorHiskeyRayAnkeeUlu'
        DB  '@'            ; Terminate the list to make sure that uninitialized
                           ; memory doesn't cause a problem.
    END start

Entrada de muestra:

>NATO The quick brown fox jumped over the lazy dog.
>NATO Jackdaws love my big sphinx of quartz.

Salida (versión de 165 bytes):

TAngo hOtel eCho qUebec uNiform iNdia cHarlie kIlo bRavo rOmeo oScar wHiskey nOvember fOxtrot oScar xRay jUliett uNiform mIke pApa eCho dElta oScar vIctor eCho rOmeo tAngo hOtel eCho lIma aLfa zUlu yAnkee dElta oScar gOlf 
JUliett aLfa cHarlie kIlo dElta aLfa wHiskey sIerra lIma oScar vIctor eCho mIke yAnkee bRavo iNdia gOlf sIerra pApa hOtel iNdia nOvember xRay oScar fOxtrot qUebec uNiform aLfa rOmeo tAngo zUlu 

Versión de capitalización limpia (167 bytes):

Tango Hotel Echo Quebec Uniform India Charlie Kilo Bravo Romeo Oscar Whiskey November Foxtrot Oscar Xray Juliett Uniform Mike Papa Echo Delta Oscar Victor Echo Romeo Tango Hotel Echo Lima Alfa Zulu Yankee Delta Oscar Golf 
Juliett Alfa Charlie Kilo Delta Alfa Whiskey Sierra Lima Oscar Victor Echo Mike Yankee Bravo India Golf Sierra Papa Hotel India November Xray Oscar Foxtrot Quebec Uniform Alfa Romeo Tango Zulu 

Versión de mayúsculas limpias con las mismas mayúsculas que la entrada (167 bytes):

Tango hotel echo quebec uniform india charlie kilo bravo romeo oscar whiskey november foxtrot oscar xray juliett uniform mike papa echo delta oscar victor echo romeo tango hotel echo lima alfa zulu yankee delta oscar golf 
Juliett alfa charlie kilo delta alfa whiskey sierra lima oscar victor echo mike yankee bravo india golf sierra papa hotel india november xray oscar foxtrot quebec uniform alfa romeo tango zulu 

Carbón de leña , 99 bytes

ＥΦ↥Ｓ№αι⁺ι§⪪”&⌊%w⁸D⦃σν:…ⅈ$|@Ｈ¦χＴ⸿]ECrΣＭ^¿←←&⁵↘⁼s(ＪＦ8X´▷⧴⎚Ｐ0V÷AＷχπ¶⌈≧\"dＪ^ZU{M≔⁴｜<¶⁹Ｂ⊞⊟1ＬPH⪪∨Y3`”j⌕αι

Pruébalo en línea! El enlace es a la versión detallada del código. Salidas en caso apropiado. Explicación:

   Ｓ                    Input string
  ↥                     Uppercased
 Φ                      Filtered where
     α                  Predefined uppercase alphabet
    №                   Contains
      ι                 Current character
Ｅ                       Mapped over characters
        ι               Current character
       ⁺                Concatenated with
           ”...”        Compressed string
          ⪪             Split on
                j       Literal string `j`
         §              Indexed by
                 ⌕      Index of
                   ι    Current character
                  α     In uppercase alphabet
                        Implicitly print each word on its own line

Perl 6 , 176 170 166 bytes

*.comb>>.&{$_~:128[q`>$RbD[Orlo~Q1nX,OVq8x9'6%h'1.I$83ua7	vsD=s-{W}{>iQ:Js37py)hNN,i{Pt\~#f4<>`.ords].base(35).split('J')[.ord%32]}.words

Pruébalo en línea!

Salidas en mayúsculas con la primera letra en la caja original. Comprime la cadena, que solo guarda 6 bytes sobre el texto plano más simple:

*.comb>>.&{$_~ <lfa ravo harlie elta cho oxtrot olf otel ndia uliett ilo ima ike ovember scar apa uebec omeo ierra ango niform ictor hiskey ray ankee ulu>[.ord%32-1]if ' 'ne$_}

Pruébalo en línea!

Explicación:

*.comb>>.&{                 }         # Map each letter to
           $_~                        # The letter plus
              <...>[.ord%32]          # The letter indexed into the list of words
                             .words   # And remove the extra spaces

Japt, 108 106 bytes

¸®¬Ë+u cg`ovem¼rws¯r°pawue¼cÙ o±ØǯfmØtØkeyÙ°nkeewªuwlfaæ1ÃÉr¦e³ltawÖoxÉwolfÙ*lÙAawªieâ-¹µ±ke`qw

Intentalo

Los backticks contienen la cadena comprimida:

ovemberwscarwapawuebecwomeowierrawangowniformwictorwhiskeywraywankeewuluwlfawravowharlieweltawchowoxtrotwolfwotelwndiawuliettwilowimawike

PowerShell , 187 183 bytes

$args|% t*y|%{'AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJuliettKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu'-csplit'(?=[A-Z])'-like"$_*"}

Pruébalo en línea!

Script de prueba:

$f = {
$args|% t*y|%{'AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJuliettKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu'-csplit'(?=[A-Z])'-like"$_*"}
}

@(
    ,('Hello World', 'Hotel', 'Echo', 'Lima', 'Lima', 'Oscar', 'Whiskey', 'Oscar', 'Romeo', 'Lima', 'Delta')
) | % {
    $s,$expected = $_
    $result = &$f $s
    "$result"-eq"$expected"
    "$result"
}

Salida:

True
Hotel Echo Lima Lima Oscar Whiskey Oscar Romeo Lima Delta

PHP ,209 205 206 bytes

while($l=$argv[1][$x++])echo$l!=' '?$l.preg_split('/([A-Z][a-z]*)/',ALfaRavoHarlieEltaChoOxtrotOlfOtelNdiaUliettIloImaIkeOvemberScarApaUebecOmeoIerraAngoNiformIctorHiskeyRayAnkeeUlu,0,3)[31&ord($l)].' ':'';

Pruébalo en línea!

Salida:

"Hello World" => "HOtel eCho lIma lIma oScar WHiskey oScar rOmeo lIma dElta"

O 195 bytes, con espacios no completamente eliminados:

while($l=$argv[1][$x++])echo$l,preg_split('/([A-Z][a-z]*)/',ALfaRavoHarlieEltaChoOxtrotOlfOtelNdiaUliettIloImaIkeOvemberScarApaUebecOmeoIerraAngoNiformIctorHiskeyRayAnkeeUlu,0,3)[31&ord($l)].' ';

Pruébalo en línea!

Salida:

"Hello World" => "HOtel eCho lIma lIma oScar   WHiskey oScar rOmeo lIma dElta"

TSQL, 313 bytes

Golfizado:

DECLARE @ varchar(max)='Hello World' 

DECLARE @x INT=len(@)WHILE @x>0SELECT @=stuff(@,@x,1,substring(@,@x,1)+choose(ascii(substring(@,@x,1))%32,'lfa','eta','harlie','elta','cho','oxtrot','olf','otel','ndia','uliett','ilo','ima','ike','ovember','scar','apa','uebec','omeo','ierra','ango','niform','ictor','hiskey','ray','ankee','ulu')+';'),@x-=1PRINT @

Sin golf:

DECLARE @ varchar(max)='Hello World' 

DECLARE @x INT=len(@)
WHILE @x>0
  SELECT @=stuff(@,@x,1,substring(@,@x,1)+choose(ascii(substring(@,@x,1))%32,
    'lfa','eta','harlie','elta','cho','oxtrot','olf','otel','ndia','uliett','ilo',
    'ima','ike','ovember','scar','apa','uebec','omeo','ierra','ango','niform',
    'ictor','hiskey','ray','ankee','ulu')+';'),
    @x-=1

PRINT @

Pruébalo

La salida termina con punto y coma

PowerShell, 228 225 bytes

-3 bytes gracias a @mazzy

"$args".ToLower()-replace' '|% T*y|%{$a+=$_+((-split"lfa ravo harlie elta cho oxtrot olf otel ndia uliett ilo ima ike ovember scar apa uebec omeo ierra ango niform ictor hiskey ray ankee ulu")[('a'..'z').IndexOf($_)])+' '};$a

Pruébalo en línea!

Este es posiblemente el código más feo que he escrito. Además, esto ciertamente puede ser mucho más corto. En mi defensa, todavía me estoy recuperando de los exámenes finales.

PHP, 212 bytes

while($c=ord($argn[$i++]))echo[_,Alpha,Bravo,Charlie,Delta,"Echo",Foxtrot,Golf,Hotel,India,Juliett,Kilo,Lima,Mike,November,Oscar,Papa,Quebec,Romeo,Sierra,Tango,Uniform,Victor,Whiskey,Xray,Yankee,Zulu][$c&31]," ";

Ejecutar como tubería con -nRo probarlo en línea .

Produce advertencias en PHP 7.2; poner elementos de matriz entre comillas para arreglar.

Imprimirá un guión bajo para espacios.

C (clang) , 309 bytes

#define L toupper(v[1][i])
main(j,v)char**v;{int i=0;char*k[]={"lfa","ravo","harlie","elta","cho","oxtrot","olf","otel","ndia","uliett","ilo","ima","ike","ovember","scar","apa","uebec","omeo","ierra","ango","niform","ictor","hiskey","ray","ankee","ulu"};for(;L;i++)j=L-65,j>=0&j<=26?printf("%c%s ",L,k[j]):0;}

Pruébalo en línea!

JavaScript, 179 bytes

s=>s.match(/\w/g).map(c=>c+'LfaRavoHarlieEltaChoOxtrotOlfOtelNdiaUliettIloImaIkeOvemberScarApaUebecOmeoIerraAngoNiformIctorHiskeyRayAnkeeUlu'.match(/.[a-z]+/g)[parseInt(c,36)-10])

Pruébalo en línea!