Scrivi un programma per suonare la famosa filastrocca inglese.

(Questo file è concesso in licenza con licenza Creative Commons Attribution-Share Alike 3.0 Unported . Attribuzione: Helix84 in Wikipedia in inglese ; Blahedo in Wikipedia in inglese .)

Alcuni articoli di Wikipedia che potrebbero essere utili:

• Twinkle Twinkle Little Star (ha una clip audio di come dovrebbe apparire l'output del tuo programma)
• Simboli musicali moderni (per conoscere la notazione musicale usata sopra)
• Nota # Nota frequenza (hertz) (la formula per calcolare la frequenza di ciascuna nota)

Alcune linee guida per l'invio:

• Il programma deve utilizzare la scheda audio del computer. Se il tuo linguaggio di programmazione non ha un comodo accesso all'hardware audio, il tuo programma deve creare un file di output in un formato standard come WAV o MIDI.

• Il tuo programma deve effettivamente generare il suo output. Ad esempio, l'incorporamento del file Ogg Vorbis da Wikipedia non sarebbe consentito.

• La qualità audio deve essere accettabile. Per lo meno, la canzone dovrebbe essere facilmente riconoscibile. Preferibilmente, dovrebbe anche suonare bene.

• Il focus dovrebbe essere sulla dimensione del codice, sulla qualità del suono o su entrambi (spiega quale hai deciso). Anche le soluzioni eleganti sarebbero fantastiche. Divertiti!

• Questo è un codice-golf , quindi vince il codice più corto

QBasic (56)

A$="CCGGAAG2FFEEDDC2"
B$="GGFFEED2"
PLAY "L4"+A$+B$+B$+A$

L'attenzione è rivolta alla reminiscenza :)

(Non avere un QBasic per testarlo però)

JavaScript ( 214 212 211 caratteri)

Apri Safari, Opera o Google Chrome su JavaScript Shell , quindi inserisci il codice seguente:

for(s="",y=192e3;x=--y/4e3|0;)s+="~ "[(y%4e3>800|x%8==1)&Math.pow(2,"024579702457245702457970"[x>>1]/12)*y/31%2];open("data:audio/wav;base64,UklGRiXuAgBXQVZFZm10IBAAAAABAAEAQB8AAEAfAAABAAgAZGF0YQHuAgCA"+btoa(s))

Non minimizzato per leggibilità (anche allora potrebbe essere difficile da capire):

for(s = "", y = 192E3; x = --y / 4E3 | 0;) {
  s += "~ "[(y % 4E3 > 800 | x % 8 == 1) & Math.pow(2, "024579702457245702457970"[x >> 1] / 12) * y / 31 % 2];
}
open("data:audio/wav;base64,UklGRiXuAgBXQVZFZm10IBAAAAABAAEAQB8AAEAfAAABAAgAZGF0YQHuAgCA" + btoa(s));

Con molti altri caratteri, potrebbe funzionare anche su Firefox, ma è possibile modificare la audio/wavparte almeno per salvare il file WAV.

C # (Lunghezza: LOL)

Quindi, quello che ho fatto qui è stato implementare il supporto per la generazione di un file .wav dalla stringa utilizzata per la soluzione QBasic in C # (ottava singola, nessun incidente). L'enfasi era su:

1. Evitare unsafeblocchi di codice
2. Non sprecare troppo tempo a farlo
3. Rendendolo relativamente semplice da estendere

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text.RegularExpressions;
using System.IO;

namespace ConsoleApplication1
{
    public static class Extension
    {
        public static byte[] ToByteArray(this object o)
        {
            return o.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance)
                .SelectMany(x =>
                                {
                                    var value = x.GetValue(o, null);
                                    if (value.GetType().Equals(typeof (UInt16)))
                                    {
                                        return BitConverter.GetBytes((UInt16) value);
                                    }
                                    if (value.GetType().Equals(typeof (UInt32)))
                                    {
                                        return BitConverter.GetBytes((UInt32) value);
                                    }
                                    if (value.GetType().Equals(typeof(char[])))
                                    {
                                        return ((char[]) value).Select(y => Convert.ToByte(y));
                                    }
                                    if (value.GetType().Equals(typeof(byte[])))
                                    {
                                        return (byte[]) value;
                                    }
                                    throw new NotImplementedException();
                                }).ToArray();
        }
    }
    public class Wave
    {
        public readonly byte[] WavFile; 

        public Wave(string notes)
        {
            var header = new Header();
            var data = new List<Chunk>();
            var f = new Fmt(8000);
            data.Add(f);
            data.Add(new WavData(notes, f));
            var thefile = data.SelectMany(x => x.ToByteArray()).ToArray();
            header.Size = (uint)thefile.Length + 4;
            WavFile = header.ToByteArray().Concat(thefile).ToArray();
        }
        class WavData: Chunk
        {
            private static IEnumerable<byte> RenderNote(string note, int length, Fmt fmt)
            {
                double frequency;
                switch (note)
                {
                    case "A":
                        frequency = 440;
                        break;
                    case "B":
                        frequency = 493.883;
                        break;
                    case "C":
                        frequency = 261.626;
                        break;
                    case "D":
                        frequency = 293.665;
                        break;
                    case "E":
                        frequency = 329.628;
                        break;
                    case "F":
                        frequency = 349.228;
                        break;
                    case "G":
                        frequency = 391.995;
                        break;
                    default:
                        throw new NotImplementedException("Unsupported Note");
                }
                var result = new byte[fmt.SampleRate / length * 2];  // For 120BPM tempo
                for (int i = 0; i < result.Length; i++)
                {
                    double time = (i % fmt.SampleRate) / (double)fmt.SampleRate;
                    double position = time * frequency;
                    if (result.Length - i <= fmt.SampleRate / 16)
                        result[i] = 127;
                    else
                        result[i] = (byte)Math.Round((Math.Sin(position * 2 * Math.PI) + 1) * 127);
                }
                return result;
            }
            public WavData(string notes, Fmt fmt)
            {
                Samples = new byte[0];
                foreach (var note in Regex.Matches(notes, @"[A-G][1|2|4|8]?").OfType<Match>().Select(x => x.Value))
                {
                    Samples = Samples.Concat(RenderNote(note[0] + "", note.Length > 1 ? note[1] - '0' : 4, fmt)).ToArray();
                }

            }
            public override char[] Id
            {
                get { return "data".ToCharArray(); }
            }
            public override uint DataSize
            {
                get { return (uint)Samples.Length; }
            }
            public byte[] Samples { get; private set; }
        }
        class Fmt : Chunk
        {
            public Fmt(UInt32 sampleRate)
            {
                CompressionCode = 1; // Unknown/PCM
                Channels = 1;
                SampleRate = sampleRate;
                SignificantBits = 8;
            }
            public override char[] Id
            {
                get { return "fmt ".ToCharArray();}
            }
            public override uint DataSize
            {
                get { return 16; }
            }
            public UInt16 CompressionCode { get; private set; }
            public UInt16 Channels { get; private set; }
            public UInt32 SampleRate { get; private set; }
            public UInt32 AvgBytesPerSecond { get { return SampleRate*BlockAlign; } }
            public UInt16 BlockAlign { get { return (UInt16) (SignificantBits/8*Channels); } }
            public UInt16 SignificantBits { get; private set; }
        }
        class Header
        {
            public Header()
            {
                Type = "RIFF".ToCharArray();
                RiffType = "WAVE".ToCharArray();
                Size = 0;
            }

            public char[] Type { get; private set; }
            public UInt32 Size { get; set; }
            public char[] RiffType { get; private set; }
        }
        abstract class Chunk
        {
            public abstract char[] Id { get; }
            public abstract UInt32 DataSize { get; }
        }
    }
    class Program
    {
        public static void Main(string[] args)
        {
            var p1 = "CCGGAAG2";
            var p2 = "FFEEDDC2";
            var p3 = "GGFFEED2";
            var w = new Wave(p1+p2+p3+p3+p1+p2);
            using (var f = new FileStream("testfile.wav", FileMode.Create))
                f.Write(w.WavFile, 0, w.WavFile.Length);
        }
    }
}

Python (259)

import pysynth

c=('c',4)
g=('g',4)
a=('a',4)
b=('b',4)
d=('d',4)
e=('e',4)
f=('f',4)
g2=('g',2)
c2=('c',2)
d2=('d',2)

s=(c,c,g,g,a,a,g2,f,f,e,e,d,d,c2,g,g,f,f,e,e,d2,g,g,f,f,e
            ,e,d2,c,c,g,g,a,a,g2,f,f,e,e,d,d,c2)

pysynth.make_wav(s,fn="s.wav")

C, 277 caratteri

#include<math.h>
a[]={0,7,9,7,5,4,2,0,7,5,4,2,7,5,4,2,0,7,9,7,5,4,2,0},i,j,f;main(){unsigned char
b[8000];f=open("/dev/dsp",1);for(i=0;i<24;i++){for(j=0;j<8000;j++){b[j]=(i%4==3
||j/400%20!=9?1+sinf(j*powf(2,a[i]/12.)):1)*127;}for(j=0;j<8000;j+=write(f,b+j,
8000-j));}close(f);}

Perl, 203 caratteri

open F,'>:raw','/dev/dsp';for$a(0,7,9,17,5,4,2,10,7,5,4,12,7,5,4,12,0,7,9,17,5,4
,2,10){$b=pack'C*',map 127*($a>9||$_/400%20!=9?1+sin($_*2**($a%10/12)):1),0..
7999;$b=substr$b,syswrite F,$b while length$b}

Convenientemente, l' impostazione predefinita OSS è /dev/dsp8 kHz mono u8; tutto quello che faccio qui è aprire il dispositivo e scrivere campioni calcolati.

PowerShell: 207

Codice golfizzato:

filter n {switch($_){C{262}D{294}E{330}F{349}G{392}A{440}}}$t="CCGGAAGFFEEDDCGGFFEEDGGFFEEDCCGGAAGFFEEDDC";1..6|%{$t[0..5]|n|%{[console]::beep($_,600)};$t[6]|n|%{[console]::beep($_,1200)};$t=$t.SubString(7)}

Ungolfed, con commenti:

# Filter to define note frequencies.
filter n {switch($_){C{262}D{294}E{330}F{349}G{392}A{440}}}

# Notes for Twinkle, Twinkle, Little Star.
$t="CCGGAAGFFEEDDCGGFFEEDGGFFEEDCCGGAAGFFEEDDC"

# Run through each phrase in the song.
1..6|%{
    # Play first six notes as quarter notes.
    $t[0..5]|n|%{[console]::beep($_,600)}
    # Play seventh note as half note.
    $t[6]|n|%{[console]::beep($_,1200)}
    # Left-shift $t by 7 notes.
    $t=$t.SubString(7)
}

Non è la versione più suonante della canzone di sempre, ma funziona.

C - 520

Bump.

#include <linux/fd.h>
#include <time.h>
struct timespec t,p;char*q="AAHHJJH  FFEECCA  HHFFEEC  HHFFEEC  AAHHJJH  FFEECCA";x,y,z,v,w;main(){x=open("/dev/fd0",3);for(y;q[y];y++){clock_gettime(CLOCK_MONOTONIC,&p);if(q[y]>' ')for(w=z=0;z<4e8;z+=t.tv_nsec,w++){struct floppy_raw_cmd s={0};s.flags=FD_RAW_NEED_SEEK;v=!v;s.track=v;ioctl(x,FDRAWCMD,&s);clock_gettime(CLOCK_MONOTONIC,&t);t.tv_nsec=(w+1)*5e8/pow(2.,q[y]/12.)-(t.tv_sec-p.tv_sec)*1e9-t.tv_nsec+p.tv_nsec;t.tv_sec=0;nanosleep(&t,0);}t.tv_nsec=2e8;nanosleep(&t,0);}}

Perché usare l'hardware del secolo scorso come altoparlanti e cuffie? Questo eccellente pezzo di codice ti consente di riprodurre la canzone su un hardware moderno: un floppy drive!
Nessun requisito speciale:

• Un'unità floppy IDE
• Kernel Linux
• Compila con -lm
• Assicurati che il programma possa accedere /dev/fd0, quindi chown il dispositivo o esegui come superutente

Piega un po 'le regole, ma per un secondo consideriamo l'unità floppy un dispositivo audio e il controller IDE una scheda audio integrata.

HyperCard 2.2 - 113

play harpsichord "c c g g a a gh fq f e e d d ch gq g f f e e dh gq g f f e e dh cq c g g a a gh fq f e e d d ch"

Utilizzo: avviare HyperCard, digitare ⌘M per aprire la finestra di messaggio, incollare il codice sopra e premere Invio.

harpsichordpuò essere sostituito con fluteo boingper ottenere suoni diversi.

C, 96 caratteri

main(t){for(;++t>>16<3;)putchar(t*!!(t>>9&7|!(-t>>12&7))*(96+"#d|dOE3#dOE3dOE3"[t>>13&15])>>5);}

Produce dati audio mono grezzi senza segno a 8 bit nel classico stile bytebeat . Le frequenze di campionamento consigliate per la riproduzione sono comprese tra 8 e 16 kHz; la modifica della frequenza di campionamento modifica il tempo e il tono.

Per compilare e giocare su Linux, salva il codice sopra come twinkle.ced esegui i seguenti comandi:

gcc twinkle.c -o twinkle
./twinkle | aplay

Alcune note su come funziona il codice:

• Il trucco generale usato per composizioni di bytebeat come questa è che putchar()prende un valore intero ma ne stampa solo gli otto bit bassi. Pertanto, putchar(t)dove si ttrova un contatore crescente, genera un'onda a dente di sega e la frequenza dell'onda può essere modificata moltiplicandola tper un valore adeguato.

• !!(t>>9&7|!(-t>>12&7))produce lo schema ripetuto di note 6 + 1. In particolare, !!(t>>9&7)valuta 0quando t>>9 & 7 == 0e in caso 1contrario. Pertanto, produce un gap di 512 campioni nella forma d'onda ogni 4096 campioni, mentre !(-t>>12&7)elimina ogni ottavo tale gap.

• 96+"#d|dOE3#dOE3dOE3"[t>>13&15]genera la melodia: il codice ASCII di ogni carattere nella stringa più 96 fornisce la frequenza relativa della nota corrispondente. In realtà, i valori sono le frequenze approssimative in Hz delle note di intonazione del concerto nella 3a / ottava piccola, ovvero con A corrispondente a 220. Tuttavia, poiché il tono di base con il quale si moltiplicano questi valori è di circa 64 Hz (se suonato a 16 kHz o 32 Hz quando suonato a 8 kHz), dobbiamo ridimensionare il risultato di cinque ottave con >>5per riportare la frequenza in un intervallo ragionevole.

Ps. Se si desidera provare questo codice su un lettore bytebeat basato su JavaScript, sostituirlo [t>>13&15]con .charCodeAt(t>>13&15).

Pitone 317 305 301

Questa è la mia soluzione, usando solo librerie standard di Python:

import math,wave,struct;d=24000;r=1100.;t=wave.open("t.wav","w");t.setparams((1,2,int(r),d,"NONE",""));a=[0,7,9,7];b=[5,4,2,0];c=[7,5,4,2]
for h in[math.sin(6*[240*2**(j/12.)for j in a+b+c+c+a+b][x/1000]*(x/r))*(x%500>9 or x/1000%4>2)for x in range(d)]:t.writeframes(struct.pack('h', int(h*64000/2)))

Ed eccolo qui con qualche spazio in più per la leggibilità:

import math,wave,struct;d=24000;r=1100.
a=[0,7,9,7];b=[5,4,2,0];c=[7,5,4,2];s=[240*2**(j/12.) for j in a+b+c+c+a+b]
z=[math.sin(6*s[int(x/1000)]*(x/r))*(x%500>10 or int(x/1000)%4>2) for x in range(d)]
t=wave.open("t.wav","w");t.setparams((1,2,int(r),d,"NONE",""))
for h in z:t.writeframes(struct.pack('h', int(h*64000./2)))

Mathematica, 86 caratteri

s=SoundNote;If[#>9,s[#-10,2],{s@#,s@#}]&/@Join[a={0,7,9,17,5,4,2,10},b={7,5,4,12},b,a]

Arduino, 688

int length=15;char notes[]="ccggaag ffeeddc ggffeed ggffeed ccggaag ffeeddc";int beats[]={1,1,1,1,1,1,2,1,1,1,1,1,1,2,4};int tempo=300;void playTone(int tone,int duration){for(long i=0;i<duration*1000L;i+=tone*2){digitalWrite(11,HIGH);delayMicroseconds(tone);digitalWrite(11, LOW);delayMicroseconds(tone);}}void playNote(char note, int duration){char names[]={'c','d','e','f','g','a','b','C'};int tones[]={1915,1700,1519,1432,1275,1136,1014,956};for(int i=0;i<8;i++){if(names[i]==note){playTone(tones[i], duration);}}}void setup(){pinMode(11, OUTPUT);}void loop(){for(int i=0;i<length;i++){if(notes[i]==' '){delay(beats[i]*tempo);}else{playNote(notes[i],beats[i]*tempo);}delay(tempo/2);}}

Collegare il segnale acustico all'uscita 11. Mi sono concentrato principalmente sulla qualità , ma anche sulla lunghezza del codice.

bash + dire + gunzip, 136 byte

say, ovviamente, essendo il comando di sintesi vocale di OS X. Questo è ... stupido. Sì, andiamo con Dorky.

printf '<117 bytes>'|gunzip|sh

I 117 byte sono, ovviamente, un flusso gzip contenente caratteri non stampabili. Ecco un dump xxd dello script che include quei personaggi:

00000000: 7072 696e 7466 2027 1f8b 085c 305c 305c  printf '...\0\0\
00000010: 305c 305c 3002 032b 4eac 54d0 2d0b c9c8  0\0\0..+N.T.-...
00000020: cf4d 2c56 c8e7 c2ca 75cc cb4b c4ce 71cb  .M,V....u..K..q.
00000030: ccc7 c90b 4b4d 85f0 7252 530b 14f4 4ca0  ....KM..rRS...L.
00000040: c2de 8945 a979 4061 6cbc e0c4 dcc4 bc92  ...E.y@al.......
00000050: 8c44 dc02 2e89 7999 a939 685c 5c74 7723  .D....y..9h\\tw#
00000060: ec44 755c 6e2a 8f8a ee19 581b 8767 1402  .Du\n*....X..g..
00000070: 5c30 fa36 7e25 2599 025c 305c 3027 7c67  \0.6~%%..\0\0'|g
00000080: 756e 7a69 707c 7368                      unzip|sh

Spiegazione

117 byte è il seguente script gzip:

say -vThomas o
say -vThomas o
say -vAnna o
say -vAnna o
say -vFiona o
say -vFiona o
say -vVeena o
sleep .4
say -vKaren o
say -vKaren o
say -vSamantha o
say -vSamantha o
say -vDaniel o
say -vDaniel o
say -vThomas o
sleep .4
say -vVeena o
say -vVeena o
say -vKaren o
say -vKaren o
say -vSamantha o
say -vSamantha o
say -vDaniel o
sleep .4
say -vVeena o
say -vVeena o
say -vKaren o
say -vKaren o
say -vSamantha o
say -vSamantha o
say -vDaniel o
sleep .4
say -vThomas o
say -vThomas o
say -vAnna o
say -vAnna o
say -vFiona o
say -vFiona o
say -vVeena o
sleep .4
say -vKaren o
say -vKaren o
say -vSamantha o
say -vSamantha o
say -vDaniel o
say -vDaniel o
say -vThomas o

Esatto, ho appena fatto un sacco di sayvoci diverse dire "o". Per capire quali, ho scritto una sceneggiatura usando aubionotes per ottenere una stima veloce e sporca del tono di ogni voce, quindi ho fatto molte prove ed errori per trovare quelli che suonano per lo più giusti.

Ho pensato di provare a giocare a golf manualmente, ma c'è così tanta ripetizione che ho pensato che Zopfli avrebbe fatto un lavoro più breve, quindi ho preso la via più semplice.

SmileBASIC, 45 byte

BGMPLAY"{M=CCGGAAG2FFEEDDC2}{M}[GGFFEED2]2{M}

Powershell, 120 117 byte

[Console]::beep, nota etichette e frequenze ispirate a Iszi

 ($a='ccggaaGffeeddC')+'ggffeeD'*2+$a|% t*y|%{[console]::beep((0,110,0,65,73,82,87,98)[$_-band7]*4,600+600*($_-lt97))}

Idea principale :

• La melodia è codificata in una stringa.
• Le note sono codificati con caratteri A, C, D, E, F,G .
• Maiuscolo significa a double duration .
• 3 bit inferiori ( $_-band7) di ciascuna nota utilizzano come indice nell'array delle frequenze ( A->1,C->3 , D->4...)
• Questo script utilizza la frequenza di campionamento ridotta per le frequenze: (0,110,0,65,73,82,87,98)[$_-band7]*4invece di Iszi (0,440,0,262,294,330,349,392)[$_-band7].[console]::Beepnon è lo strumento musicale più preciso, quindi può falsificare leggermente :)

Spiegazione : Per ogni carattere della stringa di melodiaccggaaGffeeddCggffeeDggffeeDccggaaGffeeddC , lo script:

• cerca frequensie dall'array usando i bit inferiori come indice
• calcola una durata in base al carattere maiuscolo / minuscolo
• chiama [console]::beepper suonare la nota