Oggi, 11 novembre 2015, è la Giornata dei veterani negli Stati Uniti. " Taps " è la tromba chiamata ai funerali militari statunitensi:

^{( "Taps" su SoundCloud di vtmiller )}

È una melodia semplice, lunga solo ventiquattro note e che utilizza solo quattro note diverse. Ecco gli spartiti:

^{( fonte )}

Sfida

Scrivi un programma o una funzione che riproduce "Taps" o emette un file audio di "Taps" in qualsiasi formato di file audio comune (ad esempio MP3, WAV, MIDI). Può essere riprodotto in qualsiasi tasto, utilizzando qualsiasi tipo di strumento o bip disponibile nella tua lingua. Ad esempio, potrebbe sembrare un piano anziché una tromba. (Anche se dovrebbe essere usato solo un tipo di strumento.)

Tutte le ventiquattro note devono essere suonate con tonalità, durata e spaziatura precise. Qualcuno che abbia familiarità con "Taps" dovrebbe essere in grado di eseguire il codice e riconoscere facilmente la canzone riprodotta.

La durata della melodia (dall'inizio della prima nota alla fine dell'ultima nota) deve essere compresa tra 30 e 70 secondi. Opzionalmente potresti avere fino a 5 secondi di silenzio che riempiono l'inizio e / o la fine del tuo file audio, quindi un file di 80 secondi è il più lungo consentito.

Ovviamente non puoi semplicemente scaricare la canzone online da qualche parte o estrarla da una libreria audio che sembra averla come campione. Tuttavia, è possibile utilizzare librerie audio in grado di riprodurre / comporre singole note e creare file audio.

punteggio

Questo è code-golf , quindi vince la risposta più breve in byte. Tuttavia, per questa sfida particolare ti incoraggio a non concentrarti sul conteggio dei byte, soprattutto a scapito della qualità del suono. Esegui il golf dei tuoi invii, ma concediti di essere creativo con la scelta dello strumento o la metodologia di uscita del suono. Questa sfida ha lo scopo di onorare i veterani, non di strillare una versione appena riconoscibile di "Rubinetti".

Nota che puoi incorporare i file audio SoundCloud direttamente nei post semplicemente incollando il link su una riga vuota. Se hai un account SoundCloud, questo sarebbe un ottimo modo per condividere i tuoi risultati.

qb64, 100 84 byte

Versione aggiornata del vecchio Qbasic, scaricabile da http://www.qb64.net/

Conteggio esclude gli spazi, che non sono richiesti e solo lì per dividere i dati in frasi di tre note per maggiore chiarezza.

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

Comandi nella stringa di riproduzione

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%

Storia del golf:

Primo post: dal 4/4 al 4/2, il che significa che ho alcune note intere, ma nessuna sedicesima.

Modifica 1: tasto modificato da C (intervallo GG) a F (intervallo CC). Ora devo eseguire una variazione di ottava solo una volta, per la C alta, che si verifica solo una volta, piuttosto che per tutte le G basse come prima.

Dopo essermi sbarazzato di tutti quei cambiamenti di ottava, non credo ci sia più nulla da golf. Ci sono in totale 20 Lanni ma non esiste un modo ovvio per evitarli.

L'ultima frase (11 caratteri) è uguale alla prima, ma non è possibile inserirla due volte in meno di 11 caratteri. I dati ripetuti sarebbero solo 9 caratteri se l'iniziale L4fosse eliminata (sembra inutile poiché la lunghezza della nota predefinita sembra essere una nota da un quarto, ma non è documentata, quindi l'ho lasciata.)

JavaScript, 203 198 196 195 byte

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 byte salvati grazie a Dendrobium e 1 grazie a @PatrickRoberts.

Spiegazione

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
      )

Provalo qui nel browser! Funziona su qualsiasi browser che supporti l'API Web Web HTML5 .

Mathematica, 361 287 285 byte

Sono andato per la precisione qui. L'output è esattamente come descritto nella partitura, suonata con la tromba. Puoi trovare il file qui .

"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]

Grazie a @ MartinBüttner per i suggerimenti sul golf.

Sonic Pi, 899 byte

Il tempismo è un po 'fuori, ma penso che sia ok.

Leggermente golf:

use_synth: blade
use_synth_defaults sustain: 0.70, versione: 0.0
gioca: G4, il rilascio: 0.05
attendere 0.75
gioca: G4, sostenere: 0.25
attendere 0,25
hold = rrand_i (3,4)
gioca: C5, sostenere: attesa, il rilascio: 0.5
attendere tenere premuto + 0,5
gioca: G4, il rilascio: 0.05
attendere 0.75
gioca: C5, sostenere: 0.25
dormire 0,25
hold = rrand_i (3,4)
gioca: E5, sostenere: attesa, il rilascio: 1.25
sospensione del sonno + 1,25
gioco: G4
dormire 0,70
gioca: C5
dormire 0,70
2. volte lo fanno
  gioca: E5, sostenere: 1, rilasciare: 0.25
  sonno 1.25
  gioco: G4
  dormire 0.7
  gioca: C5
  dormire 0.7
fine
hold = rrand_i (3,5)
gioca: E5, sostenere: attesa, il rilascio: 0.75
sospensione attesa + 1
gioca: C5, di rilascio: 0.05
dormire 0,75
gioca: E5, sostenere: 0.25
dormire 0,25
gioca: G5, sostenere: 2.45, il rilascio: 0.05
dormire 2.5
gioca: E5, sostenere: 1, rilasciare: 0.25
sonno 1.25
gioca: C5, sostenere: 1, rilasciare: 0.25
sonno 1.25
hold = rrand_i (3,5)
gioca: G4, sostenere: attesa, il rilascio: 0.5
sospensione del sonno + 0,5
gioca: G4, il rilascio: 0.05
dormire 0,75
gioca: G4, sostenere: 0.25
dormire 0,25
hold = rrand_i (3,5)
gioca: C5, sostenere: attesa, il rilascio: 1.5

MATLAB, 338 327 262 258 230 byte

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 byte

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

Tutte le note e i tempi sono corretti. Ho usato una tromba perché è la cosa più vicina al MIDI

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

Powershell, 183 175 159 byte

Viaggio in nostalgia, a chi non piacciono i bip ?!

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

Spiegazione (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
    )
}

Questo verrà riprodotto in circa 45 secondi.

Questa è la prima volta che utilizzo Windows Powershell, tutti i suggerimenti sul golf sono benvenuti.

Vecchie versioni

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

Scarica l'interprete su http://www.bbcbasic.co.uk/bbcwin/bbcwin.html

Punteggio esclude spazi bianchi e nuove righe, che sono non essenziali e aggiunti per la leggibilità

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

Compressione abbastanza standard, 1 carattere ASCII per nota. I parametri di SOUNDsono i seguenti:

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)

La gamma della canzone è di 13 note, anche se ne vengono utilizzate solo 4. Per ottenere questo intervallo nell'intervallo di 95 numeri di ASCII stampabile, ho dovuto comprimere la durata in un intervallo intero di 7 e prenderlo modulo 7. Vengono utilizzate le seguenti durate (in sedicesimi) (ad eccezione di 6 che non è mai usato): 1,2,3,4,6,8,12. Per produrre questi numeri, ho colpito l'idea di dividere 12 per una potenza di sqrt(2)(approssimata per 1,4) e troncare.

Il SOUND1,0,1,1è un fastidio, che costa 12 byte. È necessario fornire una pausa tra note di tonalità identica.

Rubino + segnale acustico, 178 byte

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"}`

Mi ci è voluto un po 'per farlo, penso di aver perso la barca, ma comunque.

fcontiene le quattro frequenze utilizzate. ncontiene le cinque lunghezze di nota utilizzate, in multipli di sedicesime note.

a="00101...contiene tutti i toni delle note seguiti da tutte le lunghezze delle note, come indici nei rispettivi array. lviene quindi impostato al 24 ° indice e successivamente di a. Quindi un comando beep viene costruito ripetendo tutto quanto sopra ed eseguito

C - (Raw: 318 | WAV: 437)

PCM mono a 8 bit (senza segno) a 44800 Hz, 33,60 secondi.

• File at mediafire (Nota: diventa un po 'rumoroso lì dentro ...)

Le dinamiche di mezzo forte, fortissimo e forte sono implementate in qualche modo artisticamente. Le fermate potrebbero essere migliori.

Il codice si basa unsigned long longsull'essere 8 ottetti e sul sistema little 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

Compilare ed eseguire con qualcosa di simile:

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

Aggiungi -DRAWalla riga di compilazione per la variante non elaborata.

L'output non elaborato può essere riprodotto, ad esempio, con SoX playcome:

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