Schreiben Sie ein Programm, um den beliebten englischen Kinderreim zu spielen.

(Diese Datei ist unter der Creative Commons Namensnennung-Weitergabe unter gleichen Bedingungen 3.0 Unported- Lizenz lizenziert. Namensnennung: Helix84 aus der englischsprachigen Wikipedia ; Blahedo aus der englischsprachigen Wikipedia .)

Einige Wikipedia-Artikel, die nützlich sein können:

• Twinkle Twinkle Little Star (enthält einen Audioclip darüber, wie die Ausgabe Ihres Programms klingen soll)
• Moderne Musiksymbole (um mehr über die oben verwendete Musiknotation zu erfahren)
• Note # Notenfrequenz (Hertz) (die Formel zur Berechnung der Frequenz jeder Note)

Einige Richtlinien für Ihre Einreichung:

• Ihr Programm muss die Soundkarte des Computers verwenden. Wenn Ihre Programmiersprache keinen bequemen Zugriff auf Audio-Hardware hat, muss Ihr Programm eine Ausgabedatei in einem Standardformat wie WAV oder MIDI erstellen.

• Ihr Programm muss tatsächlich seine Ausgabe generieren. Das Einbetten der Ogg Vorbis-Datei aus Wikipedia ist beispielsweise nicht zulässig.

• Die Audioqualität muss akzeptabel sein. Zumindest sollte das Lied leicht erkennbar sein. Vorzugsweise sollte es auch gut klingen.

• Der Fokus sollte auf Codegröße, Klangqualität oder beidem liegen (erläutern Sie, für welche Sie sich entschieden haben). Auch elegante Lösungen wären toll. Habe Spaß!

• Dies ist ein Code-Golf , also gewinnt der kürzeste Code

QBasic (56)

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

Der schwerpunkt liegt auf der erinnerung :)

(Habe keinen QBasic um das zu testen)

JavaScript ( 214 212 211 Zeichen)

Öffnen Sie Safari, Opera oder Google Chrome in der JavaScript-Shell und geben Sie den folgenden Code ein:

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

Aus Gründen der Lesbarkeit ungekürzt (selbst dann ist es möglicherweise schwer zu verstehen):

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

Mit einigen weiteren Zeichen könnte es auch in Firefox funktionieren, aber Sie können den audio/wavTeil ändern , um zumindest die WAV-Datei zu speichern.

C # (Länge: LOL)

Ich habe hier also die Unterstützung für die Generierung einer WAV-Datei aus der Zeichenfolge implementiert, die für die QBasic-Lösung in C # verwendet wird (eine Oktave, keine Zufälle). Der Schwerpunkt lag auf:

1. unsafeCodeblöcke vermeiden
2. Verschwenden Sie nicht zu viel Zeit damit
3. Dies macht es relativ einfach zu erweitern

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 Zeichen

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

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}

Zweckmßigerweise OSS ‚s /dev/dspstandardmäßig 8kHz mono U8; Ich öffne hier nur das Gerät und schreibe berechnete Samples.

PowerShell: 207

Golf Code:

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, mit Kommentaren:

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

Nicht die am besten klingende Wiedergabe des Songs, aber es funktioniert.

C - 520

Stoßen.

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

Warum sollten Sie die Hardware vergangener Jahrhunderte wie Lautsprecher und Kopfhörer verwenden? Mit diesem hervorragenden Code können Sie den Song auf einer modernen Hardware abspielen: einem Diskettenlaufwerk!
Keine besonderen Anforderungen:

• Ein IDE-Diskettenlaufwerk
• Linux Kernel
• Kompilieren mit -lm
• Stellen Sie sicher, dass das Programm darauf zugreifen kann /dev/fd0, und klicken Sie entweder auf das Gerät, oder führen Sie es als Superuser aus

Biegt die Regeln ein wenig, aber betrachten wir für eine Sekunde das Diskettenlaufwerk als Soundgerät und den IDE-Controller als integrierte Soundkarte.

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"

Verwendung: Starten Sie HyperCard, geben Sie ⌘M ein, um das Meldungsfeld zu öffnen, fügen Sie den obigen Code ein und drücken Sie die Eingabetaste.

harpsichordkann durch fluteoder ersetzt werden boing, um andere Geräusche zu erhalten.

C 96 Zeichen

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

Erzeugt unformatierte 8-Bit-Mono-Audiodaten ohne Vorzeichen im klassischen Bytebeat- Stil. Die empfohlenen Abtastraten für die Wiedergabe liegen zwischen 8 und 16 kHz. Durch Ändern der Samplerate werden das Tempo und die Tonhöhe geändert.

Um unter Linux zu kompilieren und zu spielen, speichern Sie den obigen Code unter twinkle.cund führen Sie die folgenden Befehle aus:

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

Einige Hinweise zur Funktionsweise des Codes:

• Der allgemeine Trick, der für Bytebeat-Kompositionen wie diese verwendet wird, ist, dass putchar()ein ganzzahliger Wert verwendet wird, aber nur die unteren acht Bits davon gedruckt werden. Somit putchar(t), wo tes ein zunehmender Zähler erzeugt eine Sägezahnwelle, und die Frequenz der Welle kann durch Multiplikation geändert werden , tmit einem geeigneten Wert ist .

• !!(t>>9&7|!(-t>>12&7))erzeugt das sich wiederholende 6 + 1-Notenmuster. Insbesondere wird !!(t>>9&7)ausgewertet, 0wann t>>9 & 7 == 0und 1ansonsten. Auf diese Weise wird alle 4096 Abtastungen eine 512-Abtastungslücke in der Wellenform erzeugt, während !(-t>>12&7)jede achte derartige Lücke beseitigt wird.

• 96+"#d|dOE3#dOE3dOE3"[t>>13&15]generiert die Melodie: Der ASCII-Code jedes Zeichens in der Zeichenfolge plus 96 gibt die relative Häufigkeit der entsprechenden Note an. Tatsächlich sind die Werte die ungefähren Frequenzen in Hz von Konzerttönen in der 3. / kleinen Oktave, dh mit A entsprechend 220. Da jedoch der Grundton, mit dem diese Werte multipliziert werden, ungefähr 64 Hz beträgt (wenn bei 16 kHz gespielt) (oder 32 Hz bei 8 kHz), müssen wir das Ergebnis um fünf Oktaven verkleinern >>5, um die Frequenz wieder in einen vernünftigen Bereich zu bringen.

Ps. Wenn Sie diesen Code auf einem JavaScript-basierten Bytebeat-Player testen möchten, ersetzen Sie ihn [t>>13&15]durch .charCodeAt(t>>13&15).

Python 317 305 301

Dies ist meine Lösung, die nur Standard-Python-Bibliotheken verwendet:

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

Und hier ist es mit etwas mehr Leerzeichen für die Lesbarkeit:

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 Zeichen

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

Schließen Sie den Summer an Ausgang 11 an. Ich habe mich hauptsächlich auf die Qualität konzentriert , aber auch auf die Codelänge.

Bash + Say + Gunzip, 136 Bytes

sayDies ist natürlich der OS X-Sprachausgabebefehl. Das ist ... bescheuert. Ja, lass uns mit dorky gehen.

printf '<117 bytes>'|gunzip|sh

Die 117 Bytes sind natürlich ein gzip-Stream, der nicht druckbare Zeichen enthält. Hier ist ein xxd-Dump des Skripts mit diesen Zeichen:

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

Erläuterung

Die 117 Bytes sind das folgende gezippte Skript:

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

Das stimmt, ich habe nur eine Menge verschiedener sayStimmen dazu gebracht, "o" zu sagen. Um herauszufinden, welche, schrieb ich ein Skript mit Hilfe von Aubionoten , um eine schnelle und fehlerfreie Schätzung der Tonhöhe jeder Stimme zu erhalten.

Ich überlegte, dies manuell zu versuchen, aber es gibt so viele Wiederholungen, dass ich dachte, Zopfli würde es kürzer machen, also habe ich den einfachen Ausweg gewählt.

SmileBASIC, 45 Bytes

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

Powershell, 120 bis 117 Bytes

[Console]::beep, Beschriftungen und Frequenzen von Iszi inspiriert

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

Hauptidee :

• Die Melodie ist in einer Zeichenfolge codiert.
• Die Noten werden mit Zeichen codiert A, C, D, E, F, G.
• Großbuchstaben bedeutet a double duration.
• 3 niederwertigen Bits ( $_-band7) jeden Hinweis Verwendungen als Index im Array Frequenzen ( A->1, C->3, D->4...)
• Dieses Skript verwendet die reduzierte Abtastrate für Frequenzen: (0,110,0,65,73,82,87,98)[$_-band7]*4stattdessen Iszi's (0,440,0,262,294,330,349,392)[$_-band7]. [console]::Beepist nicht das genaueste Musikinstrument, daher kann es leicht fälschen :)

Erläuterung : Für jedes Zeichen aus der Melodiezeichenfolge ccggaaGffeeddCggffeeDggffeeDccggaaGffeeddCführt das Skript Folgendes aus :

• Sucht Frequenzen aus dem Array, wobei die unteren Bits als Index verwendet werden
• berechnet eine Dauer basierend auf Groß- / Kleinschreibung
• Anrufe [console]::beep, um die Note zu spielen