Escreva um programa para tocar a popular rima infantil inglesa.

(Este arquivo está licenciado sob a licença Unported Creative Commons Attribution-Share Alike 3.0 . Atribuição: Helix84 na Wikipedia em inglês ; Blahedo na Wikipedia em inglês .)

Alguns artigos da Wikipedia que podem ser úteis:

• Twinkle Twinkle Little Star (possui um clipe de áudio com o que a saída do seu programa deve soar)
• Símbolos musicais modernos (para aprender sobre a notação musical usada acima)
• Nota # Frequência das notas (hertz) (a fórmula para calcular a frequência de cada nota)

Algumas diretrizes para o seu envio:

• Seu programa deve usar a placa de som do computador. Se sua linguagem de programação não tiver acesso conveniente ao hardware de áudio, seu programa deverá criar um arquivo de saída em algum formato padrão, como WAV ou MIDI.

• Seu programa deve realmente gerar sua saída. Por exemplo, a incorporação do arquivo Ogg Vorbis da Wikipedia não seria permitida.

• A qualidade do áudio deve ser aceitável. No mínimo, a música deve ser facilmente reconhecível. De preferência, deve soar bem também.

• O foco deve estar no tamanho do código, na qualidade do som ou em ambos (explique qual você decidiu). Soluções elegantes também seriam ótimas. Diverta-se!

• Este é um código de golfe , então o código mais curto vence

QBasic (56)

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

O foco está na reminiscência :)

(Não possui um QBasic para testar isso)

JavaScript ( 214 212 211 caracteres)

Abra o Safari, Opera ou Google Chrome no JavaScript Shell e digite o código abaixo:

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

Desminificado para facilitar a leitura (mesmo assim, pode ser difícil de entender):

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

Com vários outros caracteres, ele também pode funcionar no Firefox, mas você pode alterar a audio/wavparte para salvar pelo menos o arquivo WAV.

C # (comprimento: LOL)

Portanto, o que eu fiz aqui foi implementar o suporte para gerar um arquivo .wav a partir da string usada para a solução QBasic em C # (oitava única, sem acidentes). A ênfase estava em:

1. Evitando unsafeblocos de código
2. Sem perder demasiado muito do meu tempo fazendo isso
3. Tornando relativamente simples estender

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 caracteres

#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 caracteres

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, o padrão da OSS é /dev/dsp8kHz mono u8; tudo o que faço aqui é abrir o dispositivo e gravar amostras computadas.

PowerShell: 207

Código de golfe:

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, com comentários:

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

Não é a versão de melhor som da música de todos os tempos, mas funciona.

C - 520

Colisão.

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

Por que usar o hardware do século passado, como alto-falantes e fones de ouvido? Este excelente código permite que você toque a música em um hardware moderno: uma unidade de disquete!
Nenhum requesito especial:

• Uma unidade de disquete IDE
• Kernel Linux
• Ajuntar com -lm
• Verifique se o programa pode acessar /dev/fd0, para exibir o dispositivo ou executar como superusuário

Dobra um pouco as regras, mas vamos considerar por um segundo a unidade de disquete como um dispositivo de som e o controlador IDE como uma placa de som integrada.

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"

Uso: Inicie o HyperCard, digite ⌘M para abrir a Caixa de Mensagens, cole o código acima e pressione enter.

harpsichordpode ser substituído por fluteou boingpara obter sons diferentes.

C, 96 caracteres

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

Produz dados de áudio mono não assinados e brutos de 8 bits no estilo clássico de bytebeat . As taxas de amostragem recomendadas para reprodução estão entre 8 e 16 kHz; alterar a taxa de amostragem altera o andamento e o tom.

Para compilar e reproduzir no Linux, salve o código acima twinkle.ce execute os seguintes comandos:

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

Algumas notas sobre como o código funciona:

• O truque geral usado para composições de bytebeat como essa é que putchar()assume um valor inteiro, mas apenas imprime os oito bits baixos. Assim, putchar(t)onde texiste um contador crescente, gera uma onda dente de serra, e a frequência da onda pode ser alterada multiplicando-se tpor um valor adequado.

• !!(t>>9&7|!(-t>>12&7))produz o padrão de repetição de 6 + 1 nota. Especificamente, !!(t>>9&7)avalia para 0quando t>>9 & 7 == 0e para o 1contrário. Assim, produz um intervalo de 512 amostras na forma de onda a cada 4096 amostras, enquanto !(-t>>12&7)elimina cada oitavo intervalo.

• 96+"#d|dOE3#dOE3dOE3"[t>>13&15]gera a melodia: o código ASCII de cada caractere na sequência mais 96 fornece a frequência relativa da nota correspondente. Na verdade, os valores são as frequências aproximadas em Hz das notas da afinação de concerto na terceira / pequena oitava, ou seja, com A correspondente a 220. No entanto, uma vez que o tom de base com o qual esses valores são multiplicados é de cerca de 64 Hz (quando tocado a 16 kHz ou 32 Hz quando reproduzido a 8 kHz), precisamos reduzir o resultado em cinco oitavas >>5para obter a frequência novamente em uma faixa razoável.

Ps. Se você quiser experimentar esse código em um bytebeat player baseado em JavaScript, substitua [t>>13&15]por .charCodeAt(t>>13&15).

Python 317 305 301

Esta é minha solução, usando apenas bibliotecas python padrão:

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

E aqui está um pouco mais de espaço em branco para facilitar a leitura:

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 caracteres

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

Ligue a campainha na saída 11. Concentrei-me principalmente na qualidade , mas também no comprimento do código.

bash + say + gunzip, 136 bytes

say, é claro, sendo o comando de conversão de texto em fala do OS X. Isso é ... idiota. Sim, vamos com idiota.

printf '<117 bytes>'|gunzip|sh

Os 117 bytes são, é claro, um fluxo gzip contendo caracteres não imprimíveis. Aqui está um despejo xxd do script, incluindo os caracteres:

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

Explicação

Os 117 bytes são o seguinte script compactado:

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

É isso mesmo, eu apenas fiz um monte de sayvozes diferentes dizerem "o". Para descobrir quais, escrevi um script usando aubionotes para obter uma estimativa rápida e suja do tom de cada voz, depois fiz muitas tentativas e erros ao encontrar os que soam mais corretos.

Pensei em tentar jogar isso manualmente, mas há tanta repetição que achei que o Zopfli faria um trabalho mais curto, então tomei o caminho mais fácil.

SmileBASIC, 45 bytes

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

Powershell, 120 117 bytes

[Console]::beep, observe rótulos e frequências inspirados em Iszi

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

Ideia principal :

• A melodia é codificada em uma sequência.
• As notas são codificados com caracteres A, C, D, E, F, G.
• Maiúsculas significa a double duration.
• 3 bits inferiores ( $_-band7) de cada um dos blocos de utilizações como índice da matriz frequências ( A->1, C->3, D->4...)
• Este script usa a taxa de amostragem reduzida para frequências: em (0,110,0,65,73,82,87,98)[$_-band7]*4vez do Iszi (0,440,0,262,294,330,349,392)[$_-band7]. [console]::Beepnão é o instrumento musical mais preciso, então pode ser um pouco falso :)

Explicação : Para cada caractere da sequência de melodia ccggaaGffeeddCggffeeDggffeeDccggaaGffeeddC, o script:

• pesquisas frequensies da matriz usando os bits mais baixos como índice
• calcula uma duração com base em maiúsculas / minúsculas
• chamadas [console]::beeppara tocar a nota