Brilha Brilha Estrelinha

27

Escreva um programa para tocar a popular rima infantil inglesa.

Partitura (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:

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 , então o código mais curto vence

PleaseStand
fonte
posso aproximar frequências de notas?
Ming-Tang
1
Por que isso está fechado?
Programmer5000 #
@ programmer5000 Eu diria que a razão perto descreve muito bem ...
totallyhuman
2
Mesmo depois de codificá-lo, eu diria que isso ainda está fora de tópico. A qualidade do áudio deve ser aceitável. não é um critério objetivo de validade.
Dennis
3
@ Dennis, eu diria que é mais "claro" do que "fora de tópico".
Erik the Outgolfer

Respostas:

30

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)

Eelvex
fonte
1
Funciona na minha instalação do DOSBox pelo menos, mas você pode modificá-lo para reproduzir a música completa?
precisa saber é o seguinte
Feito. Vou trabalhar nas minhas habilidades de leitura: /
Eelvex 31/01
Hmm, esta página está errada? pt - br
mootinator
6
Uau, isso traz de volta memórias das minhas primeiras experiências de programação com o QBasic ... que envolviam, entre outras coisas, escrever músicas de queijo!
Daniel Standage
3
+1 para tropeçar na memória! Agora tudo necessidade I é uma amostra de comando DESENHAR :)
Sistema de Down
16

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.

PleaseStand
fonte
1
Funciona muito bem no Chrome.
mootinator
@mootinator: Funciona para mim também. Eu não tinha pensado em verificá-lo no Chrome - ele não ganhou suporte a arquivos WAV até bem recentemente. code.google.com/p/chromium/issues/detail?id=23916
Favor
Uau! Isso é maravilhoso.
Phillip Senn
o que você quer dizer com "com vários outros caracteres"? Quais seriam esses personagens?
Phillip Senn
@cf_PhillipSenn: Quando executei o código no Firefox, obtive um QuickTime Player não funcional. Eu tive que mudar o código open(...)para Audio(...).play()(mais 8 caracteres) para usar o reprodutor de áudio embutido do Firefox.
PleaseStand
11

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);
        }
    }
}
mootinator
fonte
Notei que a onda de saída tem uma amplitude muito pequena na minha resposta acima. Claramente, estou perdendo algo sobre como funciona uma amostra de 8 bits.
mootinator
Ah, consertou. A ordem das operações é importante. Exemplo de saída aqui: dl.dropbox.com/u/469380/testfile.wav
mootinator
FromDigits["LOL",36]==28101Isso não parecer LOL <sub> 36 </ sub> bytes ...
CalculatorFeline
6

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")
John
fonte
3
isso não poderia ser reduzido import ttls?
zzzzBov
@zzz: Hum, isso é uma piada?
John
2
@zzz: -Bangs-head-on-desk- O que você está dizendo exatamente?
John
1
@ John é obviamente um koan. você deve se curvar ou bater nele.
Ixtmixilix 9/09/11
1
(comentário muito tardio) Para referência, aqui está uma versão -60 bytes, porque é realmente jogado.
Erik the Outgolfer
5

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.

efémero
fonte
Postar Perl separadamente; você está no codegolf :)
Eelvex 2/11/11
179 -j,f;main(i){char b[8000];f=open("/dev/dsp",1);for(i=24;i--;write(f,b,j))for(j=0;j<8000;j++)b[j]=(i%4&&j/400%20==9?1:1+sinf(j*powf(2,("@BDEGIG@BDEGBDEG@BDEGIG@"[i]-64)/12.)))*127;}
gastropner 30/12/19
4

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.

Iszi
fonte
1
(comentário tardio) Você pode fazer em n{vez de n {?
Erik the Outgolfer
4

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.

mniip
fonte
Eu diria que este é razoável, unidades de disquete são surpreendentemente capazes para essa tarefa youtu.be/LkqYLOa76E0
Teclas de atalho
3

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.

Joey Adams
fonte
(comentário muito tarde) harpsichord-> flute-6 remover o espaço entre o instrumento e citações -1 total de -7
Erik o Outgolfer
3

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

Ilmari Karonen
fonte
2

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)))
cortador
fonte
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]
alefalpha
fonte
2

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.

Timtech
fonte
(comentário tardio) "ccggaag ffeeddc ggffeed ggffeed ccggaag ffeeddc "remover espaço? int beats[] =remover espaço? for (longremover espaço? 11, LOWremover espaço? note, intremover espaço? i], durationremover espaço? 11, OUTPUTremover espaço?
Erik the Outgolfer
Você realmente esqueceu alguns espaços? Tanto quanto eu entendo, o espaço ffeeddc "é para algum tipo de atraso, que você não precisa no final e beats[] =não tem motivos para ter um espaço. Além disso, você deve criar uma versão concentrada no comprimento do código, apenas para o que importa!
Erik the Outgolfer
Suponho que as variáveis ​​possam ser todas de uma letra, mas não acho que valha o tempo com uma resposta tão antiga. Obrigado por essas dicas.
Timtech
Ok, fique à vontade para postar como uma resposta separada, se desejar.
Timtech
@Timtech Como a questão está fechada, que não pode ser feito, infelizmente ... :-(
wizzwizz4
2

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.

Jordânia
fonte
1

SmileBASIC, 45 bytes

BGMPLAY"{M=CCGGAAG2FFEEDDC2}{M}[GGFFEED2]2{M}
12Me21
fonte
0

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
confuso
fonte