Hoje, 11 de novembro de 2015, é o Dia dos Veteranos nos Estados Unidos. " Taps " é a corneta tocada nos funerais militares dos EUA:

^{( "Torneiras" no SoundCloud da vtmiller )}

É uma melodia simples, com apenas vinte e quatro notas e usando apenas quatro notas diferentes. Aqui está a partitura:

^{( fonte )}

Desafio

Escreva um programa ou função que reproduza "Taps" ou emita um arquivo de áudio de "Taps" em qualquer formato de arquivo de áudio comum (por exemplo, MP3, WAV, MIDI). Pode ser tocado em qualquer tecla, usando qualquer tipo de instrumento ou ruído de bipe disponível no seu idioma. Por exemplo, pode parecer um piano em vez de uma corneta. (Embora ainda seja necessário apenas um tipo de instrumento.)

Todas as vinte e quatro notas devem ser tocadas com afinação, duração e espaçamento precisos. Alguém familiarizado com "Taps" deve poder executar seu código e reconhecer facilmente a música que está sendo tocada.

A duração da melodia (do início da primeira nota até o final da última nota) deve estar entre 30 e 70 segundos. Como opção, você pode ter até 5 segundos de silêncio preenchendo o início e / ou o final do seu arquivo de som; portanto, um arquivo de 80 segundos é o mais longo permitido.

Obviamente, você não pode simplesmente baixar a música on-line em algum lugar ou extraí-la de uma biblioteca de áudio que a possui como amostra. No entanto, você pode usar bibliotecas de áudio que podem reproduzir / compor notas individuais e criar arquivos de áudio.

Pontuação

Isso é código-golfe , então a resposta mais curta em bytes vence. No entanto, para esse desafio em particular, incentivo você a não se concentrar na contagem de bytes, especialmente à custa da qualidade do som. Golf seus envios, mas permita-se ser criativo com a escolha do instrumento ou a metodologia de saída de som. Esse desafio é para homenagear veteranos, não para gritar uma versão quase irreconhecível de "Taps".

Observe que você pode incorporar arquivos de áudio do SoundCloud diretamente nas postagens , colando o link em uma linha vazia. Se você tiver uma conta no SoundCloud, essa seria uma ótima maneira de compartilhar sua saída.

qb64, 100 84 bytes

Versão atualizada do antigo Qbasic, disponível para download em http://www.qb64.net/

A contagem exclui os espaços, que não são necessários e apenas existem para dividir os dados em frases de três notas para maior clareza.

PLAY"T99L4C.L8CL1F. L4C.L8FL1A. L4CFL2A L4CFL2A L4CFL1A. L4F.L8AL1>C< L2AFL1C. L4C.L8CL1F."

Comandos na cadeia de reprodução

T99     set tempo to 99 quarter notes per minute (default is 120, only just too short)
CDEFGAB play notes in the current octave
><      up or down one octave
Lx      following notes are of note of 1/x duration
.       extend previous note duration by 50%

História do golfe:

Primeiro post: de 4/4 a 4/2, o que significa que tenho algumas notas inteiras, mas não há semicolcheias.

Edição 1: Chave alterada de C (faixa GG) para F (faixa CC). Agora só preciso realizar uma alteração de oitava uma vez, para o C alto, que ocorre apenas uma vez, em vez de todos os G's baixos, como antes.

Tendo me livrado de todas essas mudanças de oitava, acho que não há mais para jogar golfe. Há um total de 20 L, mas não há uma maneira óbvia de evitá-los.

A última frase (11 caracteres) é igual à primeira, mas não há como inseri-la duas vezes em menos de 11 caracteres. Os dados repetidos teriam apenas 9 caracteres se a inicial L4fosse eliminada (parece desnecessário, pois o tamanho padrão da nota parece ser semínima, mas não está documentado, então eu o deixei.)

JavaScript, 203 198 196 195 bytes

with(new AudioContext)for(t=i=0;n="301093301396202346202346202396331699464390301093"[i++];)with(createOscillator())i%2?l=n/2:(frequency.value=392+n*44,connect(destination),start(t+.1),stop(t+=l))

5 bytes salvos graças ao Dendrobium e 1 graças ao @PatrickRoberts.

Explicação

with(new AudioContext)        // use HTML5 audio
  for(                        // iterate through the note pitches and lengths
    t=i=0;                    // t = current time to place the note
    n=                        // n = note pitch (or temporarily length)

    // This string contains the values of each note alternating between length and pitch
    //     (l1, p1, l2, p2, etc...)
    // Length value is in 16th notes (1 = 1/16th note, 2 = 1/8th, etc...)
    //     The longer notes are limited to 9 but I think it still sounds OK
    // Pitch value 0 = G4, 3 = C5, 6 = E5, 9 = G5 (multiples of 3 saves 1 byte)
    "301093301396202346202346202396331699464390301093"

  [i++];)
    with(createOscillator())  // create the note oscillator
      i%2?                    // alternate between length and pitch characters
        l=n/2                 // l = length (stored for use in the next iteration)
                              // dividing it by 2 sets the speed to 60 beats per minute
                              //     and casts it to a number
      :(
        frequency.value=392   // base note = G5 (392hz)
          +n*44,              // there is (conveniently) roughly 132hz between each note
        connect(destination), // send the note's sound through the speakers
        start(t               // schedule the note to sound
          +.1),               // short delay to distinguish two notes of the same pitch
        stop(t+=l)            // schedule the end of the note and increment the time
      )

Teste aqui no navegador! Funciona em qualquer navegador que suporte a API de áudio da Web HTML5 .

Mathematica, 361 287 285 bytes

Eu fui para a precisão aqui. A saída é exatamente como descrito na partitura, tocada com a trombeta. Você pode encontrar o arquivo aqui .

"G"
e="E5";c="C5";EmitSound@Sound[SoundNote[#,5/#2,"Trumpet",SoundVolume->#3/17]&@@@{%,8,17,%,24,20,c,2,23,%,8,26,c,24,29,e,2,32,%,12,35,c,12,38,e,6,41,%,12,44,c,12,47,e,6,50,%,12,53,c,12,56,e,2,59,c,8,62,e,24,65,"G5",3,68,e,6,170/3,c,6,136/3,%,2,34,%,8,34,%,24,34,c,2,34}~Partition~3]

Obrigado a @ MartinBüttner por sugestões de golfe.

Sonic Pi, 899 bytes

O tempo está um pouco fora, mas acho que está tudo bem.

Golfe leve:

use_synth: blade
use_synth_defaults sustain: 0.70, versão: 0.0
Toque: G4, Lançamento: 0.05
aguarde 0,75
jogo: G4, sustentar: 0.25
aguarde 0,25
hold = rrand_i (3,4)
reproduzir: C5, sustentar: manter, soltar: 0.5
espera espera + 0,5
Toque: G4, Lançamento: 0.05
aguarde 0,75
reproduzir: C5, sustentar: 0.25
sono 0,25
hold = rrand_i (3,4)
reproduzir: E5, sustentar: manter, soltar: 1.25
espera de sono + 1,25
reproduzir: G4
sono 0.70
reproduzir: C5
sono 0.70
2. vezes
  Jogo: E5, Sustain: 1, Lançamento: 0.25
  sono 1,25
  reproduzir: G4
  sono 0.7
  reproduzir: C5
  sono 0.7
fim
hold = rrand_i (3,5)
Toque: E5, mantenha: mantenha, solte: 0.75
retenção de sono + 1
Toque: C5, Lançamento: 0.05
sono 0,75
jogo: E5, sustentar: 0.25
sono 0,25
Jogo: G5, Sustain: 2.45, Lançamento: 0.05
sono 2.5
Jogo: E5, Sustain: 1, Lançamento: 0.25
sono 1,25
reproduzir: C5, sustentar: 1, liberar: 0.25
sono 1,25
hold = rrand_i (3,5)
reproduzir: G4, sustentar: manter, soltar: 0.5
espera de sono + 0,5
Toque: G4, Lançamento: 0.05
sono 0,75
jogo: G4, sustentar: 0.25
sono 0,25
hold = rrand_i (3,5)
reproduzir: C5, sustentar: manter, soltar: 1.5

MATLAB, 338 327 262 258 230 bytes

o=@(L,f)sin(pi*.11*2^(f/12))*(1:600*L))
sound([o(3,-1) o(1,-1) o(12,2) o(3,-1) o(1,2) o(12,4) o(2,-1) o(2,2) o(4,4) o(2,-1) o(2,2) o(4,4) o(2,-1) o(2,2) o(12,4) o(3,2) o(1,4) o(8,6) o(4,4) o(4,2) o(12,-1) o(3,-1) o(1,-1) o(12,4)])

SmileBASIC, 73 bytes

BGMPLAY"@56T50L2.G8.G16B+G8.<C16E>[G8<C8E4>]2G8<C8EC8.E16G2E4C4>GG8.G16B+

Todas as notas e horários estão corretos. Eu usei uma trombeta porque é a coisa mais próxima do MIDI

<audio autoplay controls src="//12me21.github.io/resources/taps.mp3"></audio>

Powershell, 183 175 159 bytes

Viagem de nostalgia, quem não gosta de bipes ?!

foreach($i in 0..23){[console]::beep((196,262,330,392)[(001012012012012123210001-split'')[$i]],(3,1,12,3,1,12,2,2,4,2,2,4,2,2,12,3,1,8,4,4,12,3,1,12)[$i]*400)}

Explicação (sortof)

foreach($i in 0..23) { # foreach loop which ranges from 0 to 23
    [console]::beep( # [console]::beep(Pitch, Duration)
        (196,262,330,392) # the notes in Hertz
            [ # select which note to use
                (001012012012012123210001-split'') # -split '' creates an array of [0,0,1,0,1 ...], spaces can be omitted
                [$i] # select the n-th element
            ],
        (3,1,12,3,1,12,2,2,4,2,2,4,2,2,12,3,1,8,4,4,12,3,1,12) # array of durations
        [$i]*400 # duration in milliseconds * 400
    )
}

Isso será reproduzido em cerca de 45 segundos.

Esta é a minha primeira vez usando o PowerShell do Windows, todas as dicas sobre golfe são bem-vindas.

Versões antigas

175

foreach($i in(0..23)){[console]::beep((196,262,330,392)[(0,0,1,0,1,2,0,1,2,0,1,2,0,1,2,1,2,3,2,1,0,0,0,1)[$i]],(3,1,12,3,1,12,2,2,4,2,2,4,2,2,12,3,1,8,4,4,12,3,1,12)[$i]*400)}

183

$d=3,1,12,3,1,12,2,2,4,2,2,4,2,2,12,3,1,8,4,4,12,3,1,12;$n=0,0,1,0,1,2,0,1,2,0,1,2,0,1,2,1,2,3,2,1,0,0,0,1;foreach($i in(0..23)){[console]::beep((196,262,330,392)[$n[$i]],$d[$i]*400)}

BBC Basic, 111

Faça o download do intérprete em http://www.bbcbasic.co.uk/bbcwin/bbcwin.html

A pontuação exclui espaços em branco e novas linhas, que não são essenciais e adicionadas para facilitar a leitura

FORk=1TO24
  x=ASC(MID$("')F'Lb(Ke(Ke(KbJhxeI#')F",k))
  SOUND1,-9,x DIV7*4+60,INT(12/1.4^(x MOD7))*5
  SOUND1,0,1,1
NEXT

Compressão bastante padrão, 1 caractere ASCII por nota. Os parâmetros de SOUNDsão os seguintes:

Channel (always 1 for the purposes of this challenge)
Amplitude (negative for on, 0 for off, positive is an envelope index)
Pitch (in increments of 1/4 semitone, with middle C at 100)
Duration (20ths of a second)

O alcance da música é de 13 notas, embora apenas 4 sejam usadas. Para obter esse intervalo no intervalo de 95 números do ASCII imprimível, tive que espremer a duração em um intervalo inteiro de 7 e usar o módulo 7. As durações a seguir (em décimos sextos) são usadas (com exceção de 6, que nunca é utilizado): 1,2,3,4,6,8,12. Para produzir esses números, tive a idéia de dividir 12 por um poder de sqrt(2)(aproximado por 1,4) e truncar.

A SOUND1,0,1,1é um aborrecimento, custando 12 bytes. É necessário fornecer uma pausa entre as notas de afinação idêntica.

Ruby + bipe, 178 bytes

f=[260,346,416,499]
n=[12,*1..4]
l=(a="001012012012012123210001310310224224220318440310".chars.map(&:to_i))[24..-1]
`beep#{24.times.map{|i|" -f#{f[a[i]]} -l#{n[l[i]]}00"}*" -n"}`

Demorei um pouco para fazer isso, acho que perdi o barco, mas tanto faz.

fmantém as quatro frequências usadas. ncontém os cinco comprimentos de notas usados, em múltiplos de notas de 16ª.

a="00101...mantém todos os arremessos de notas seguidos por todos os comprimentos das notas, como índices nas respectivas matrizes. lé então definido para o 24º índice e em diante de a. Em seguida, um comando de bipe é construído iterando através de todas as opções acima e executado

C - (Bruto: 318 | WAV: 437)

PCM mono de 8 bits (não assinado) a 44800 Hz, 33,60 segundos.

• Arquivo no mediafire (Nota: fica um pouco alto lá ...)

As dinâmicas mezzo forte, fortíssimo e forte são implementadas de maneira um pouco artística. Os fermatas poderiam ser melhores.

O código depende de unsigned long long8 octetos e o sistema é pouco endian.

#include<stdio.h>
#include<math.h>
#ifdef RAW
main(){unsigned long long D[]={0x422422c13c13,0xc13c44813c22},X[]={27863,37193,46860,55727},O=0x406e64924910,i=0,j;float Z,A,U=40,P;for(;i<24;D[i++/12]>>=4){Z=X[O&3]/1e6;P=0;O>>=2;A=i>18?--U:i<14?U+i/2:U+30;for(j=(D[i/12]&15)*13440;j;A-=--j<7e3&&A>0?.01:0)putchar(A*sin(P+=Z)+128);}}
#else
main(){unsigned long long D[]={0x422422c13c13,0xc13c44813c22},X[]={27863,37193,46860,55727},O=0x406e64924910,i=0,j;float Z,A,U=40,P;int W[]={0x46464952,1570852,0x45564157,544501094,16,65537,44800,44800,524289,0x61746164,1505280};fwrite(W,4,11,stdout);for(;i<24;D[i++/12]>>=4){Z=X[O&3]/1e6;P=0;O>>=2;A=i>18?--U:i<14?U+i/2:U+30;for(j=(D[i/12]&15)*13440;j;A-=--j<7e3&&A>0?.01:0)putchar(A*sin(P+=Z)+128);}}
#endif

Compile e execute com algo como:

gcc -std=c99 -o taps taps.c -lm
./taps > taps.wav
play taps.wav

Adicione -DRAWà linha de compilação para variante bruta.

A saída bruta pode ser reproduzida com, por exemplo, o SoX playcomo:

play -c 1 -b 8 -r 44800 -t u8 <file>
       |    |       |       |
       |    |       |       +--- Unsigned 8-bit
       |    |       +----------- Sample rate
       |    +------------------- 8 Bits
       +------------------------ 1 Channel