Charlie, Oscar, Delta, Eco

30

Uma grande parte da comunicação via rádio é o Alfabeto Fonético da OTAN , que codifica letras como palavras para torná-las mais fáceis de entender através de comunicações. Seu trabalho, se você deseja aceitá-lo, é imprimi-los um por um.

Você deve imprimir esta sequência exata no 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

Regras:

  • Seu programa não recebe nenhuma entrada
  • As brechas padrão não são permitidas .
  • Se houver algum componente interno no seu idioma que gire letras para os equivalentes da OTAN, você não poderá usá-los (estou olhando para você, Mathematica).
  • Você pode ter espaços à direita e uma nova linha à direita.
sagiksp
fonte
1
Relacionado.
Martin Ender
4
Estou encerrando isso como uma bobagem, porque não possui nenhuma estrutura explorável que permita que os esquemas de compactação personalizados tenham um desempenho melhor que a compactação interna, e o desafio de destino é o nosso desafio padrão de fato para compactação incorporada.
Mego
1
Intimamente relacionado.Se alguma coisa eu chamaria isso de burro, mas permitia que as pessoas escolhessem suas próprias palavras, o que realmente tornava a compressão muito mais possível.
Martin Ender
3
não deveria ser o primeiro A: Alpha?
21717 SeanC
3
@SeanC: De acordo com a wikipedia (ver link em questão), não. Isso é ATIS, não a OTAN. Mas então, deveria ser Juliett, não Juliete em X-rayvez de Xray.
Titus

Respostas:

18

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

Experimente online!


Anterior: (isso foi legal, mas percebi que a versão mais simples poderia ser reduzida por um byte)

w=''
i=65
for c in"lfAravOharliEeltAchOoxtroTolFoteLndiAulieTilOimAikEovembeRscaRapAuebeComeOierrAangOniforMictoRhiskeYraYankeEulU":
 w+=c.lower()
 if'_'>c:print'%c: %c'%(i,i)+w;w='';i+=1
Jonathan Allan
fonte
12

Geléia , 76 bytes

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

Experimente online!

Quão?

Praticamente apenas valores e compactação de dicionário. O código entre e »é apenas um valor compactado que formará a 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"pesquisando todas as palavras (com prefixos de espaço único, exceto "Alfa") no dicionário Jelly (exceto o " Xray"que não está no dicionário), portanto, o valor direto da string " X"e o dicionário entrada "ray"é usada).

O restante do código faz o resto:

“...»ḲØ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
Jonathan Allan
fonte
(OBSERVAÇÃO: nunca programei no Jelly.) Quando vejo seu código, fico pensando em duas coisas: 1. No momento, você passa por cima do alfabeto e se junta a eles com as palavras. É possível no Jelly obter o primeiro caractere de uma string, para que você faça um loop sobre as palavras em vez do alfabeto e junte-as a first_letter_of_word + ":" + word? E 2. Você recupera todas as palavras, incluindo espaços, e depois divide por espaço. É possível dividir inclusivamente pelas principais letras maiúsculas? Não faço ideia se esses espaços até mesmo dar bytes extras em sua forma comprimida ou não, e se eles podem ser reduzidos com a minha descrição em 2.
Kevin Cruijssen
1
@KevinCruijssen (1) sim, é possível usar a primeira letra de cada palavra, no entanto, não será tão curta, já que o rendimento do alfabeto é um átomo de dois bytes. (2) sim, é possível dividir em letras maiúsculas, mas surpreendentemente a compactação da string sem espaços é realmente mais longa (muitas palavras com espaços à esquerda estão realmente no dicionário, assim como todas com letras maiúsculas).
Jonathan Allan
2
O dicionário não contém espaços à esquerda. No entanto, ao descomprimir várias palavras seguidas, o padrão é separá-las por espaços; a primeira palavra não terá um espaço à esquerda, mas todas as palavras a seguir terão.
7897 Dennis
11

Retina , 156 bytes

A contagem de bytes assume a codificação ISO 8859-1.


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

Experimente online!

Martin Ender
fonte
11

05AB1E , 102 98 bytes

Economizou 4 bytes graças a Erik the Outgolfer

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

Experimente online!

Explicação

Usa a compactação de dicionário para as palavras no dicionário 05AB1E.
Usa compactação parcial do dicionário sempre que possível para outras palavras.
Palavras em texto sem formatação onde isso não é possível.

#          # 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
Emigna
fonte
2
Obtê-lo para baixo para 98 usando esta corda comprimido em vez disso: ”AlfaІvo¼¯¤œ®È¨›trotŠˆƒ‹Š™ÈŸt Kilo´àma—……ÍЗŽêpa¼°«Äoµ†Çâgo¸šÉµ Whiskey Xrayµ‹nkeeâ¸lu”.
Erik the Outgolfer
@EriktheOutgolfer: Obrigado! Eu tinha certeza de procurar pae lino dicionário, mas devo ter sentido falta deles. Eu não considerar yae zucomo palavras embora :)
Emigna
6

Ruby, 169 caracteres

(Fortemente baseada em Jonathan Allan do Python 2 solução. Se você gosta da idéia, por favor upvote a resposta original.)

i=?@
"LfaRavoHarlieEltaChoOxtrotOlfOtelNdiaUlietIloImaIkeOvemberScarApaUebecOmeoIerraAngoNiformIctorHiskeyRayAnkeeUlu".scan(/.[a-z]+/){|w|puts i.succ!+": "+i+w.downcase}

Exemplo de execução:

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
homem a trabalhar
fonte
6

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

Explicação:

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

Código do teste:

Experimente aqui.

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();
  }
}
Kevin Cruijssen
fonte
Deve funcionar com Java 5 e todas as versões subseqüentes.
Holger
5

Oitava, 215 210 209 bytes

Guardado 5 bytes graças a Luis Mendo. Salvei 4 bytes graças a Luis Mendo, mas alterar a abordagem me ajuda a salvar mais uma

fprintf('%s: %s%s\n',[k=num2cell(65:90);k;regexp('lfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu','[A-Z]','split')]{:})

Experimente online!

Se eu me livrasse dos espaços, economizaria 25 bytes, mas precisaria usar uma regex. O regex em si custaria alguns bytes e também removeria a letra maiúscula de todas as palavras, deixando-me com as palavras lfa, ravoetc. Por isso, teria que concatenar as novas strings com os caracteres principais. Tudo isso custa bytes.

Antiga explicação:

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' ...
Stewie Griffin
fonte
Obrigado! Isso foi um pouco mais confuso! E três bytes mais tempo ...
Stewie Griffin
Ah, sim, 'split'seria mais por aqui
Luis Mendo
'split'foi menor: 209 :)
Stewie Griffin
Eu vejo! Bem feito!
Luis Mendo
Você pode dividir em espaços e economizar mais 5 bytes
Luis Mendo
5

PHP, 202 227 196 187 bytes

Agradecimentos a Dewi Morgan por salvar 9 bytes

echo preg_replace('/([A-Z])[a-z]+/',"$1: $0\n",AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu);

https://repl.it/GMkH/1


versões mais antigas

Obrigado ao manatwork e insertusernamehere por salvar 31 bytes!

foreach(preg_split('/\B(?=[A-Z])/',AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu)as$k)echo"$k[0]: $k\n";

https://eval.in/749541

Obrigado a insertusernamehere por perceber que a saída estava errada com a versão anterior.

$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

ʰᵈˑ
fonte
Por que variável $a? Apenas mova a preg_split()chamada inteira no foreachparâmetro. Então, nenhum dos espaços ao redor asserá mais necessário.
Manatwork
Em vez de constante PREG_SPLIT_NO_EMPTY, melhor usar o seu valor: 1. Mas pessoalmente eu iria ajustar a expressão regular em vez disso: /\B(?=[A-Z])/.
Manatwork
1
Graças @insertusernamehere eu vou fazer essa edição agora :DAinda se acostumando com codegolfing
ʰᵈˑ
Isso seria um byte mais curto com uma matriz simples em vez de preg_split.
Titus
1
10 caracteres mais curtos:echo preg_replace('/([A-Z])[a-z]+/',"$1 = $0\n",Alfa...Zulu);
Dewi Morgan
4

Braquilog , 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?ẉ}ᵐ

Experimente online!

Explicação

"…"ṇ₁               Split the string on spaces
     {         }ᵐ   Map on each word:
      hw              Write the first letter
        ": "w         Write ": "
             ?ẉ       Write the word followed by a new line
Fatalizar
fonte
4

PHP, 188 186 180 174 bytes

sem espaços à direita, uma nova linha principal

<?=preg_filter("#[A-Z]#","
$0: $0",AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu);

simplesmente substitui todas as letras maiúsculas na string compactada por
<newline><letter><colon><space><letter>

Titus
fonte
Desta vez competitivo ? ;)
Christoph
-13 bytes com gzinflate-ing o resultado de gzdeflate(Alfa...Zulu).
Titus
Infelizmente, nenhuma nova linha líder é permitida, apenas uma (única) de fuga de nova linha
aross
@aross: veja o comentário do OP de ontem:and for your other question, yes, but just one.
Titus
4

Montagem x86, 512 bytes

Compilado com NASM e testado com QEMU. Para inicializar, você precisa colocar uma assinatura de inicialização de 2 bytes no final do setor de inicialização (510 bytes no arquivo), então eu perdi 317 bytes preenchendo o código compilado com zeros. Este é o meu primeiro golfe, por isso tenho que me desculpar por qualquer erro gigantesco.

[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

Saída

É isso que o código acima gera. Como você pode ver A: Alfa está ausente e isso ocorre porque o prompt tem 25 linhas de altura ... Saída dos códigos acima

Para provar que imprimi A: Alfa , substitui 0,"ulu"por, 32,"Z: Zulu"para que o Zulu seja o mesmo da Yankee. Código alterado

Eu apreciaria se alguém me dissesse se eu seria capaz de subtrair os 317 bytes de zerofill do meu código, de forma que seriam 195 bytes. Além disso, se isso for válido, porque a saída não caberá na tela.

Dino alarmado
fonte
4

Python 2 , 186 182 bytes

print''.join('\n%s: '%c*('['>c)+c for c in'AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu')

Experimente online!

Felipe Nardi Batista
fonte
2
ver comentários sobre questão: uma nova linha líder é (agora) aceitou
Titus
Bem-vindo ao PPCG! Coisas legais.
Jonathan Allan
4

C (MinGW, Clang), 218 bytes

Graças a @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,":"));}

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

Experimente online!

Steadybox
fonte
Como eu compilaria isso?
Itay Grudev
1
@ItayGrudev, GCC e Clang devem compilar isso como está. gcc src.cou clang src.c. Aqui está um exemplo de execução com uma função principal adicionado para que o código vai realmente link e executar: ideone.com/4Eowlh
chris
@chris Então, às custas de 4 bytes, não deve fser substituído por, mainpara que o código seja válido, ou estou perdendo alguma convenção de golfe.
Itay Grudev
2
@ItayGrudev, a meu ver, a pergunta apenas pedia a funcionalidade, não um programa completo e independente.
chris
1
218 com strtok () e alguns mexendo com a 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,":"));}Não está claro se funciona em qualquer lugar: o TIO segfaults, mas funciona no MinGW pelo menos. Não vejo muita razão para não funcionar.
Gastropner 23/11
3

Gema, 168 caracteres

\A=@subst{?<J>=\?: \$0\\n;AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu}@end

Exemplo de execução:

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
homem a trabalhar
fonte
3

Bash , 224 205 188 180 bytes

Agradecemos ao Digital Trauma pela remoção de 17 bytes e ao trabalho manual por 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;}

Experimente online!

luk3yx
fonte
1
Some golfing
Digital Trauma
A matriz de indexação aé muito longa. set {A..Z};for i in lfa … ulu;{ echo $1: $1$i;shift;}
Manatwork
2

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

Experimente online!

Não é emocionante ou inteligente. Basta percorrer a lista e imprimir a primeira letra e depois ':' depois a palavra inteira.

ElPedro
fonte
2

PHP, 184 bytes 179 bytes 178

<?=preg_filter('/(.)[a-z]+/',"$1: $0
",AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu);

salvou um único byte usando preg_filter em vez de preg_replace.


Resposta original 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
";

usa o fato de que é classificado para gerar o primeiro caractere em tempo real.

5 bytes salvos por @Titus.

Christoph
fonte
2
Golf seu original até 180-1 com for($c=A;$s=[lfa,...,ulu][+$i++];$c++)echo"$c: $c$s\n";. Regex agradável embora.
Titus
@ Titus eu tinha em mente que deve haver uma maneira melhor, mas mudei para preg. Obrigado pela dica !
Christoph
2

SOGL , 91 bytes

╗D↕«∙φā¡75↔TI.½!γΜΧ…¡%<F┼0h╔κy|▓@TņV≈%⁹cr_σy░mgļΕžΕ⅝ »τ{M╔|«▼↔»aΓ²⁹┘′⅓G…└g↔bFΞ‽‘θ{KUtƧ: ooo

Explicação:

...‘θ{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
dzaima
fonte
2

GNU sed , 165 bytes

Esse script é baseado na resposta da Retina de Martin Ender.

s/$/AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu/
s/[A-Z]/\n&: &/g
s/.//

Experimente online!

Explicação:

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
seshoumara
fonte
2

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}{,}

Experimente online!

Dennis
fonte
+1. O {,}truque na expansão de chaves é uma maneira muito inteligente de dobrar cada membro da lista!
Digital Trauma
2

Lua, 278 260 bytes

Agradecemos novamente ao Manatwork por salvar 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"

Experimente online


versões mais antigas

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

Na primeira vez em que Lua, provavelmente você pode jogar mais, mas achei que eu a adicionaria como resposta.

ʰᵈˑ
fonte
Minha pergunta pode se tornar entediante, mas novamente: por que variável a? ;) Você pode mover toda a declaração da matriz dentro do for. E a sintaxe for.. inajuda a evitar escrever esses índices longos de array: pastebin.com/rxck79md Coisa estranha de Lua: se você declarar uma função e chamá-la 26 vezes "manualmente" (quero dizer, não em um loop) é mais curta: pastebin. com / FMF9GmLJ
manatwork
¯\_(ツ)_/¯pela simples razão de nunca ter usado Lua antes, estava apenas seguindo o manual para tentar fazê-lo funcionar, aha. Obrigado @manatwork pela informação, eu não sabia disso.
ʰᵈˑ
2

Lua , 177 bytes

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

Experimente online!

Sem nova linha à direita, 180 bytes:

io.write(("AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu"):gsub('%u',"\n%1: %1"):sub(2))

Explicação

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

Ele usa a função de substituição string.gsub de Lua para corresponder às letras maiúsculas. As letras são substituídas pelo formato solicitado (mais as próprias letras). Novas linhas também são adicionadas no mesmo passe.

A subfunção no final apara a nova linha desde o início e também funciona muito bem para ocultar o segundo valor de retorno do gsub, que teria sido a quantidade de substituições.

L. Koivunen
fonte
2

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')[$_]}

Experimente online!

Loops de 0para 25, cada iteração que forma $ao capital correspondente char. Em seguida, concatenado com uma string : $a(ou seja, a letra do espaço de dois pontos). Em seguida, essa sequência é concatenada com uma sequência formada pela indexação em uma matriz criada pela -splitmarcação da sequência fonética em espaços. Cada uma dessas 26 strings é deixada no pipeline e um implícito Write-Outputacontece na conclusão do programa, inserindo uma nova linha entre os elementos.

Economizou dois bytes graças a @Matt.

AdmBorkBork
fonte
Agradável. Remover o primeiro caractere de cada palavra nem me ocorreu. Você pode cortar 2 bytes fazendo o seguinte: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
@ Matt Oh claro, isso faz sentido. Obrigado!
AdmBorkBork
2

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

Experimente online!

Uma versão detalhada, legível por humanos, bem comentada e perfeitamente válida (sem avisos do compilador) do programa pode ser encontrada abaixo:

#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 );
    }
}
Itay Grudev
fonte
1
Bem-vindo ao PPCG! Bom primeiro post!
Rɪᴋᴇʀ
@ceilingcat Não só o, char*smas o printfpoderia ir lá também. Assim, economizamos mais 3 bytes - um ponto-e-vírgula e 2 chaves, pois não precisamos mais deles, pois existe apenas uma instrução em seu corpo - o outro forloop.
Itay Grudev
2

JavaScript ES6, 216 187 184 180 174 bytes

"AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu".replace(/[A-Z]/g,`
$&: $&`).trim()

Guardou um byte graças a Neil. Economizou 5 bytes graças ao ETHproductions.

console.log("AlfaBravoCharlieDeltaEchoFoxtrotGolfHotelIndiaJulietKiloLimaMikeNovemberOscarPapaQuebecRomeoSierraTangoUniformVictorWhiskeyXrayYankeeZulu".replace(/[A-Z]/g,`
$&: $&`).trim());

Japonês , 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""
$&: $&

Experimente online!

Guardado 2 bytes graças a obarakon.

Tom
fonte
Fiquei me perguntando de que outra forma você poderia se livrar dessa nova linha principal - seria realmente um byte mais barato do que sua abordagem anterior para anexar manualmente A: Aà string. Mas você ainda pode salvar outro byte usando um caractere literal de nova linha em vez de \n.
911 Neil
Boas respostas. Você também pode usar uma nova linha literal no Japt. Além disso, replace aceita uma string para seu segundo argumento e substitui qualquer $&s nela pela correspondência, para que você possa fazer, por exemplo, "\n$&: $&"para os dois idiomas em vez de usar funções.
ETHproductions
Você pode alterar @"\n{X}: {X}"}em Japt para apenas "\n$&: $&":-) #
1100 ETHproductions
@ETHproductions Obrigado pela ajuda!
Tom
Boa resposta! Você pode salvar alguns bytes soltando " xe inserindo um -xsinalizador na entrada. Observe que o sinalizador adiciona 1 byte ao total de bytes.
913 Oliver Oliver
2

PHP, 175 171 164 162 bytes

Nota: não requer mais arquivo compactado, usa a codificação IBM-850.

for($l=A;$c=LfaRavoHarlieEltaChoOxtrotOlfOtelNdiaUlietIloImaIkeOvemberScarApaUebecOmeoIerraAngoNiformIctorHiskeyRayAnkeeUlu[$i++];)echo$c<a?"
$l: ".$l++:"",$c|~▀;

Execute assim:

php -nr 'for($l=A;$c=LfaRavoHarlieEltaChoOxtrotOlfOtelNdiaUlietIloImaIkeOvemberScarApaUebecOmeoIerraAngoNiformIctorHiskeyRayAnkeeUlu[$i++];)echo$c<a?"
$l: ".$l++:"",$c|~▀;';echo

Explicação

Imprime todos os caracteres individualmente (em minúsculas por OR com um espaço). Se um caractere maiúsculo for encontrado, ele primeiro imprime uma sequência no formato "\ nA: A".

Tweaks

  • Salva 4 bytes usando outra estratégia de compactação
  • Economizou 7 bytes usando um delimitador diferente (para combinar a atribuição de $lcom o parâmetro explodir) e não impedindo uma nova linha principal
  • 2 bytes salvos com um novo método
aross
fonte
1

Japonês, 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

Explicação: Provavelmente existe uma maneira muito melhor de fazê-lo, mas como sou novo, não o conheço. Eu basicamente comprimi a string com Oc "e coloquei essa string para ser descompactada usando Od"

Se alguém quiser me ajudar a salvar bytes usando algo diferente de quebras de linha, ficaria feliz em aprender!

editar: salvou 2 bytes usando `em vez de Od"

Martijn Vissers
fonte
Usando Experimente online! não dá o resultado desejado #:/
71717
@ Sim, pode ser que eu não tenha tido tempo suficiente para verificar tudo antes de começar a trabalhar. Eu poderia fazê-lo novamente (e melhor) depois do trabalho.
Martijn Vissers
1
@ ʰᵈˑ Existem alguns caracteres não imprimíveis na string que não aparecem no Markdown. Experimente online!
ETHproductions
@ETHproductions ah obrigado por isso, eu não sabia
#
1

Pyke, 89 bytes

.d⻵㡺ᐒଆຳ뼙΋ÒΗ䊊繎ㅨڨǔᯍⰬᐓ❤ᄵ㤉ተ᤬䆰髨⨈性dc Fl5DhRJ": 
Azul
fonte
Esses caracteres estão em um conjunto de caracteres específico de byte único?
Adám 7/03/2017
O TIO apresenta um erro de avaliação ruim e relata 161 bytes na mensagem. O Pyke precisa ser empurrado para lá ou algo deu errado com uma cópia e colagem aqui. @ Adám, se fosse 1-1, seriam 41 bytes, utf-8 seria 88, mas algo definitivamente parece um pouco errado.
Jonathan Allan
@ JonathanAllan, deve ser UTF-8. O TIO não executa UTF-8. Eu acho que o byte de contagem pode estar errado porque é medido como UTF-8
azul
1

Qbasic, 383 bytes

Não é impressionante, mas pelo que vale a pena:

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
anonymous2
fonte
Memórias BASIC antigas ... Elas não podem ser armazenadas em uma datainstrução e depois readdentro do loop for.. next?
precisa saber é
@ manatwork, é uma boa ideia; Eu não tinha pensado nisso!
anonymous2
Simplesmente não ?"A: Alfa" seria apenas 360 bytes?
21817 oerkelens
@oerkelens, você pode estar certo. Eu nem considerei a possibilidade. :)
anonymous2
1

/// , 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

Experimente online!

-20 bytes graças a @ETHproductions.

Camarada SparklePony
fonte
Não é difícil e economiza 20 bytes: Experimente online!
ETHproductions
@ETHproductions eu entendi ... por algum motivo eu estava pensando demais. Eu atualizarei a resposta.
usar o seguinte comando