Écrivez un programme pour jouer la comptine anglaise populaire.

(Ce fichier est sous licence Creative Commons Attribution-Share Alike 3.0 Unported . Attribution: Helix84 sur Wikipedia en anglais ; Blahedo sur Wikipedia en anglais .)

Quelques articles Wikipedia qui peuvent être utiles:

• Twinkle Twinkle Little Star (a un clip audio de ce à quoi devrait ressembler la sortie de votre programme)
• Symboles musicaux modernes (pour en savoir plus sur la notation musicale utilisée ci-dessus)
• Note # Fréquence des notes (hertz) (la formule de calcul de la fréquence de chaque note)

Quelques directives pour votre soumission:

• Votre programme doit utiliser la carte son de l'ordinateur. Si votre langage de programmation n'a pas un accès pratique au matériel audio, votre programme doit créer un fichier de sortie dans un format standard tel que WAV ou MIDI.

• Votre programme doit réellement générer sa sortie. Par exemple, l'incorporation du fichier Ogg Vorbis de Wikipedia ne serait pas autorisée.

• La qualité audio doit être acceptable. À tout le moins, la chanson devrait être facilement reconnaissable. De préférence, cela devrait aussi bien paraître.

• L'accent doit être mis sur la taille du code, la qualité du son ou les deux (expliquez lequel vous avez choisi). Des solutions élégantes seraient également formidables. S'amuser!

• Ceci est un code-golf , donc le code le plus court gagne

QBasic (56)

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

L'accent est mis sur la réminiscence :)

(N'avez pas de QBasic pour tester cela cependant)

JavaScript ( 214 212 211 caractères)

Ouvrez Safari, Opera ou Google Chrome vers JavaScript Shell , puis entrez le code ci-dessous:

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 lisible pour la lisibilité (même alors, il peut être difficile à comprendre):

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

Avec plusieurs autres caractères, cela pourrait également fonctionner sur Firefox, mais vous pouvez modifier la audio/wavpartie pour au moins enregistrer le fichier WAV.

C # (Longueur: LOL)

Donc, ce que j'ai fait ici, c'est implémenter la prise en charge de la génération d'un fichier .wav à partir de la chaîne utilisée pour la solution QBasic en C # (octave unique, pas d'accident). L'accent était mis sur:

1. Éviter les unsafeblocs de code
2. Je ne perds pas trop de temps à le faire
3. Rendre l' extension relativement simple

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 caractères

#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 caractères

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}

Idéalement, la valeur par défaut de l' OSS/dev/dsp est 8 kHz mono u8; tout ce que je fais ici est d'ouvrir l'appareil et d'écrire des échantillons calculés.

PowerShell: 207

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

Non golfé, avec commentaires:

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

Pas la meilleure interprétation de la chanson, mais ça marche.

C - 520

Bosse.

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

Pourquoi utiliser le matériel du siècle dernier comme les haut-parleurs et les écouteurs? Cet excellent morceau de code vous permet de jouer la chanson sur un matériel moderne: un lecteur de disquette!
Pas d'exigences particulières:

• Un lecteur de disquette IDE
• Noyau Linux
• Compiler avec -lm
• Assurez-vous que le programme peut accéder /dev/fd0, donc montrez l'appareil ou exécutez en tant que superutilisateur

Contourne un peu les règles, mais considérons le lecteur de disquette un périphérique audio et le contrôleur IDE une carte son intégrée.

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"

Utilisation: Démarrez HyperCard, tapez ⌘M pour ouvrir la boîte de message, collez le code ci-dessus et appuyez sur Entrée.

harpsichordpeut être remplacé par fluteou boingpour obtenir des sons différents.

C, 96 caractères

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

Produit des données audio mono 8 bits non signées brutes dans un style d' octet classique. Les fréquences d'échantillonnage recommandées pour la lecture se situent entre 8 et 16 kHz; changer la fréquence d'échantillonnage change le tempo et la hauteur.

Pour compiler et jouer sous Linux, enregistrez le code ci-dessus sous twinkle.cet exécutez les commandes suivantes:

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

Quelques notes sur le fonctionnement du code:

• L'astuce générale utilisée pour les compositions d'octets comme celle-ci est celle qui putchar()prend une valeur entière mais n'en imprime que les huit bits les plus faibles. Ainsi, putchar(t)où test un compteur croissant, génère une onde en dents de scie, et la fréquence de l'onde peut être modifiée en multipliant tavec une valeur appropriée.

• !!(t>>9&7|!(-t>>12&7))produit le motif de note répétitif 6 + 1. Plus précisément, !!(t>>9&7)évalue 0chaque fois t>>9 & 7 == 0et 1autrement. Ainsi, il produit un écart de 512 échantillons dans la forme d'onde tous les 4096 échantillons, tandis que le !(-t>>12&7)élimine tous les huitième de cet écart.

• 96+"#d|dOE3#dOE3dOE3"[t>>13&15]génère la mélodie: le code ASCII de chaque caractère de la chaîne plus 96 donne la fréquence relative de la note correspondante. En fait, les valeurs sont les fréquences approximatives en Hz des notes de hauteur de concert dans la 3ème / petite octave, c'est-à-dire avec A correspondant à 220. Cependant, puisque le ton de base avec lequel ces valeurs sont multipliées est d'environ 64 Hz (lorsqu'il est joué à 16 kHz , ou 32 Hz lorsqu'il est joué à 8 kHz), nous devons réduire le résultat de cinq octaves avec >>5pour ramener la fréquence dans une plage raisonnable.

Ps. Si vous souhaitez essayer ce code sur un lecteur bytebeat basé sur JavaScript, remplacez-le [t>>13&15]par .charCodeAt(t>>13&15).

Python 317 305 301

Ceci est ma solution, en utilisant uniquement des bibliothèques python standard:

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

Et le voici avec un peu plus d'espace pour la lisibilité:

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 caractères

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

Branchez le buzzer sur la sortie 11. Je me suis concentré principalement sur la qualité , mais aussi sur la longueur du code.

bash + say + gunzip, 136 octets

say, bien sûr, étant la commande de synthèse vocale OS X. C'est ... stupide. Ouais, allons-y avec dorky.

printf '<117 bytes>'|gunzip|sh

Les 117 octets sont, bien sûr, un flux gzip contenant des caractères non imprimables. Voici un vidage xxd du script comprenant ces caractères:

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

Explication

Les 117 octets sont le script suivant compressé:

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

C'est vrai, je viens de faire un tas de sayvoix différentes dire "o". Pour déterminer lesquels, j'ai écrit un script en utilisant des aubionotes pour obtenir une estimation rapide et sale de la hauteur de chaque voix, puis j'ai fait beaucoup d'essais et d'erreurs pour trouver ceux qui sonnent le plus bien.

J'ai envisagé d'essayer de jouer au golf manuellement, mais il y a tellement de répétitions que je me suis dit que Zopfli ferait un travail plus court, alors j'ai pris la solution de facilité.

SmileBASIC, 45 octets

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

PowerShell, 120 117 octets

[Console]::beep, étiquettes de notes et fréquences inspirées d' Iszi

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

Idée principale :

• La mélodie est codée dans une chaîne.
• Les notes sont codées avec les caractères A, C, D, E, F, G.
• Majuscule signifie a double duration.
• 3 bits inférieurs ( $_-band7) de chaque utilisation de notes comme index dans le tableau des fréquences ( A->1, C->3, D->4...)
• Ce script utilise le taux d'échantillonnage réduit pour les fréquences: à la (0,110,0,65,73,82,87,98)[$_-band7]*4place d'Iszi (0,440,0,262,294,330,349,392)[$_-band7]. [console]::Beepn'est pas l'instrument de musique le plus précis, il peut donc légèrement simuler :)

Explication : Pour chaque caractère de la chaîne mélodique ccggaaGffeeddCggffeeDggffeeDccggaaGffeeddC, le script:

• fréquences de recherche à partir du tableau en utilisant les bits inférieurs comme index
• calcule une durée en fonction des caractères majuscules / minuscules
• appels [console]::beeppour jouer la note