Escribe un programa para tocar la popular canción infantil inglesa.

(Este archivo está licenciado bajo la licencia Creative Commons Reconocimiento-Compartir Igual 3.0 Unported . Atribución: Helix84 en Wikipedia en inglés ; Blahedo en Wikipedia en inglés ).

Algunos artículos de Wikipedia que pueden ser útiles:

• Twinkle Twinkle Little Star (tiene un clip de audio de cómo debería sonar la salida de tu programa)
• Símbolos musicales modernos (para aprender sobre la notación musical utilizada anteriormente)
• Nota # Frecuencia de nota (hertz) (la fórmula para calcular la frecuencia de cada nota)

Algunas pautas para su envío:

• Su programa debe usar la tarjeta de sonido de la computadora. Si su lenguaje de programación no tiene acceso conveniente al hardware de audio, su programa debe crear un archivo de salida en algún formato estándar como WAV o MIDI.

• Su programa realmente debe generar su salida. Por ejemplo, no se permitiría incrustar el archivo Ogg Vorbis de Wikipedia.

• La calidad del audio debe ser aceptable. Por lo menos, la canción debe ser fácilmente reconocible. Preferiblemente, también debería sonar bien.

• El enfoque debe estar en el tamaño del código, la calidad del sonido o en ambos (explique cuál decidió). Las soluciones elegantes también serían geniales. ¡Que te diviertas!

• Este es un código de golf , por lo que gana el código más corto

QBasic (56)

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

El foco está en la reminiscencia :)

(Sin embargo, no tengo un QBasic para probar esto)

JavaScript ( 214 212 211 caracteres)

Abra Safari, Opera o Google Chrome a JavaScript Shell , luego ingrese el código a continuación:

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

No minificado para facilitar la lectura (incluso entonces puede 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));

Con varios caracteres más, podría funcionar también en Firefox, pero puede cambiar la audio/wavparte para guardar al menos el archivo WAV.

C # (Longitud: LOL)

Entonces, lo que hice aquí fue implementar soporte para generar un archivo .wav a partir de la cadena utilizada para la solución QBasic en C # (octava única, sin accidentes). El énfasis estaba en:

1. Evitar unsafebloques de código
2. Sin perder demasiado gran parte de mi tiempo en hacerlo
3. Haciéndolo relativamente simple de extender

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

Pitón (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, el valor predeterminado de OSS es 8 /dev/dspkHz mono u8; Todo lo que hago aquí es abrir el dispositivo y escribir muestras calculadas.

PowerShell: 207

Código de golf:

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

Sin golf, con comentarios:

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

No es la interpretación de la canción que suena mejor, pero funciona.

C - 520

Bache.

#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 qué usar hardware del siglo pasado como parlantes y auriculares? Este excelente código te permite tocar la canción en un hardware moderno: ¡una unidad de disquete!
Ningún requerimiento especial:

• Una unidad de disquete IDE
• Kernel de Linux
• Compilar con -lm
• Asegúrese de que el programa pueda acceder /dev/fd0, por lo que puede ver el dispositivo o ejecutarlo como superusuario

Dobla un poco las reglas, pero consideremos por un segundo la unidad de disquete como un dispositivo de sonido y el controlador IDE como una tarjeta de sonido 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 HyperCard, escriba ⌘M para abrir el cuadro de mensaje, pegue el código anterior y presione Entrar.

harpsichordpuede ser reemplazado por fluteo boingpara obtener diferentes sonidos.

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

Produce datos de audio mono sin signo de 8 bits sin procesar en el clásico estilo bytebeat . Las frecuencias de muestreo recomendadas para la reproducción son entre 8 y 16 kHz; cambiar la frecuencia de muestreo cambia el tempo y el tono.

Para compilar y jugar en Linux, guarde el código anterior como twinkle.cy ejecute los siguientes comandos:

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

Algunas notas sobre cómo funciona el código:

• El truco general utilizado para composiciones de bytebeat como este es que putchar()toma un valor entero pero solo imprime los ocho bits más bajos. Por lo tanto, putchar(t)donde thay un contador creciente, genera una onda de diente de sierra, y la frecuencia de la onda se puede alterar multiplicándola tcon un valor adecuado.

• !!(t>>9&7|!(-t>>12&7))produce el patrón repetitivo de 6 + 1 notas. Específicamente, !!(t>>9&7)evalúa a 0cuando t>>9 & 7 == 0y de lo 1contrario. Por lo tanto, produce una brecha de 512 muestras en la forma de onda cada 4096 muestras, mientras que !(-t>>12&7)elimina cada octava brecha.

• 96+"#d|dOE3#dOE3dOE3"[t>>13&15]genera la melodía: el código ASCII de cada carácter en la cadena más 96 da la frecuencia relativa de la nota correspondiente. En realidad, los valores son las frecuencias aproximadas en Hz de las notas de tono de concierto en la tercera / octava pequeña, es decir, con A correspondiente a 220. Sin embargo, dado que el tono base con el que se multiplican estos valores es de aproximadamente 64 Hz (cuando se reproduce a 16 kHz , o 32 Hz cuando se juega a 8 kHz), necesitamos reducir el resultado en cinco octavas >>5para que la frecuencia vuelva a un rango razonable.

PD. Si desea probar este código en un reproductor de bytebeat basado en JavaScript, reemplácelo [t>>13&15]con .charCodeAt(t>>13&15).

Pitón 317 305 301

Esta es mi solución, usando solo bibliotecas python estándar:

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

Y aquí está con un poco más de espacio en blanco para facilitar la lectura:

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

Conecte el timbre en la salida 11. Me concentré principalmente en la calidad , pero también en la longitud del código.

bash + say + gunzip, 136 bytes

say, por supuesto, siendo el comando de texto a voz de OS X. Esto es ... tonto. Sí, vamos con Dorky.

printf '<117 bytes>'|gunzip|sh

Los 117 bytes son, por supuesto, una secuencia gzip que contiene caracteres no imprimibles. Aquí hay un volcado xxd del script que incluye esos 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

Explicación

Los 117 bytes son el siguiente script comprimido:

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

Así es, acabo de hacer que un montón de sayvoces diferentes digan "o". Para averiguar cuáles, escribí un guión usando aubionotes para obtener una estimación rápida y sucia del tono de cada voz, luego hice un montón de prueba y error para encontrar las que suenan más bien correctas.

Pensé en intentar jugar golf manualmente, pero hay tanta repetición que pensé que Zopfli haría un trabajo más corto, así que tomé el camino fácil.

SmileBASIC, 45 bytes

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

PowerShell, 120 117 bytes

[Console]::beep, notas de etiquetas y frecuencias inspiradas en Iszi

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

Idea principal :

• La melodía está codificada en una cadena.
• Las notas están codificados con carbones de leña A, C, D, E, F, G.
• Mayúscula significa a double duration.
• 3 bits inferiores ( $_-band7) de cada usos nota como índice de la matriz de frecuencias ( A->1, C->3, D->4...)
• Este script utiliza la frecuencia de muestreo reducida para frecuencias: en (0,110,0,65,73,82,87,98)[$_-band7]*4lugar de Iszi (0,440,0,262,294,330,349,392)[$_-band7]. [console]::Beepno es el instrumento musical más preciso, por lo que puede ser un poco falso :)

Explicación : Para cada char de la cadena de melodía ccggaaGffeeddCggffeeDggffeeDccggaaGffeeddC, el script:

• busca frecuencias de la matriz utilizando los bits inferiores como índice
• calcula una duración basada en caracteres mayúsculas / minúsculas
• llama [console]::beeppara tocar la nota