C'est le défi hebdomadaire n ° 1. Thème: Traitement audio

Votre tâche est d’écrire un programme, qui écrit un fichier audio sur un disque (dans un format de votre choix), qui contient le code Morse pour 2015, c’est-à-dire

..--- ----- .---- .....

Vous êtes libre de choisir n'importe quel type de son pour les segments, comme une onde sinusoïdale à fréquence unique, un accord, du bruit, un instrument (par exemple, l'utilisation de fichiers MIDI), à condition que ce soit audible. Cependant, le calendrier est soumis à certaines contraintes:

• Les segments courts doivent durer au moins 0,2 seconde.
• Les segments longs doivent être au moins 3 fois plus longs que les segments courts.
• Les sauts entre les segments d’un chiffre doivent avoir la même longueur que les segments courts.
• Les sauts entre les chiffres doivent avoir la même longueur que les longs segments.
• Chaque segment et pause peut s'écarter jusqu'à 10% de la longueur moyenne de ce type de segment / pause.
• La totalité du fichier audio ne doit pas dépasser 30 secondes.

Les pauses n'ont pas besoin d'être complètement silencieuses, mais les segments Morse doivent être plus forts que les pauses.

Notez que vous devez écrire un fichier audio. Vous ne pouvez pas simplement jouer le son, par exemple en utilisant des bips système. Vous êtes autorisé à utiliser n'importe quel type de bibliothèque pour gérer le format de fichier et la génération audio, mais vous ne devez pas utiliser les fonctionnalités intégrées pour le codage Morse.

C'est le code de golf, donc la réponse la plus courte (en octets) gagne.

Veuillez envisager de créer un lien vers un téléchargement du fichier audio résultant (sur SoundCloud ou similaire), afin que les utilisateurs puissent consulter le résultat sans avoir à exécuter votre code. Si vous téléchargez sur SoundCloud, assurez-vous d’activer les téléchargements dans l’onglet Autorisations de la piste.

Si votre sortie utilise un format de fichier plutôt inhabituel, veuillez ajouter des informations sur la manière de la lire et / ou la convertir en un format plus courant, puis téléchargez-la.

Exemple de piste

Il s’agit d’un exemple de piste généré manuellement qui est conforme à la spécification et utilise du bruit pour les segments Morse (bruit de fond du microphone, pour être précis). Voici un lien vers SoundCloud si le lecteur intégré ne fonctionne pas pour vous.

Détails de la prime

J'attribuerai la prime à la soumission la plus courte dans un langage de programmation audio , c'est-à-dire un langage conçu pour synthétiser le son. Cette liste n’est pas complète, alors n'hésitez pas à utiliser un autre langage de programmation audio, si vous en connaissez un. Si vous ne savez pas si un langage que vous souhaitez utiliser peut être considéré comme un langage de programmation audio, veuillez me le faire savoir dans les commentaires ou dans le chat , et nous pourrons en discuter.

Notez que votre soumission doit toujours respecter toutes les règles - en particulier, elle doit écrire un fichier, ce qui pourrait ne pas être possible dans tous les langages de programmation audio. Par exemple, pour autant que je sache , Gibber ne peut que lire le son et ne pas l'enregistrer dans un fichier.

AWK BASH: 66 86 67 74 octets

À la demande de Martin Büttner, j’ai ajouté un tempo car, après vérification de la norme de notation ABC , il semble qu’il n’y ait pas de valeur par défaut définie pour cela (merci nutki de nous l'avoir signalé).
J'écris aussi dans un fichier disque (a) au lieu de STDOUT puisque la question voulait explicitement "un fichier sur disque".

a=C3z;echo "X:1
K:A
Q:99
CzCz$a$a$a3$a$a$a$a${a}3Cz$a$a$a${a}3CzCzCzCzC">a

Je mets un tempo de 99 qui fait que le fichier audio dure 22 secondes; C'est plus lent que ma version précédente, mais au moins maintenant, il est supposé avoir la même longueur sur tous les joueurs de ABC, et cela dure moins de 30 secondes.

Cela ressemble beaucoup à la version précédente, comme vous pouvez le constater:

Voici le nouveau fichier midi .

Première version de BASH (le tempo est manquant)

Pourquoi n'ai-je pas pensé à cela en premier ...: o)

C'est 22 octets de moins qu'avec AWK, pour le même résultat

a=C3z;echo "X:1
K:A
CzCz$a$a$a3$a$a$a$a${a}3Cz$a$a$a${a}3CzCzCzCzC"

Comme la version précédente dans AWK, il écrit sur stdout un fichier de notation "ABC" valide (merci à Tobia d'avoir découvert que l'instruction "L" était facultative).

Cela ressemble à ceci:

Et cela ressemble exactement à la version précédente .

Version précédente en AWK (86 octets)

Voici une nouvelle version. un peu plus long, mais avec un timing plus précis. Je laisse la première version ci-dessous pour comparaison / référence:

BEGIN{a="C3z";print"X:1\nK:A\nL:1/8\nCzCz"a a a"3"a a a a a"3Cz"a a a a"3CzCzCzCzCz";}

Ceci est toujours un fichier "abc" valide, qui ressemble à ceci:

Voici le nouveau fichier midi (j'ai accéléré le tempo pour rester sous la limite des 30 secondes).

Première version en AWK (66 octets):

C'est beaucoup moins intéressant que ma réponse précédente , mais c'est beaucoup plus court, donc:

BEGIN{print"X:1\nK:A\nL:1/4\nCCC2C2C2zC2C2C2C2C2zCC2C2C2C2zCCCCC"}

Cela génère un fichier "abc" valide, qui peut être lu (entre autres) dans EasyABC. Il ressemblera à ceci:

et ça sonnera comme ça (fichier midi) . +

Code machine x86 (fichier .COM): 121 120 113 109 octets

Hexdump:

00000000  b4 3e bb 01 00 cd 21 b4  3c 31 c9 ba 3e 01 cd 21  |.>....!.<1..>..!|
00000010  4a b4 09 cd 21 be 56 01  8a 0c 46 e8 0c 00 b1 32  |J...!.V...F....2|
00000020  e8 07 00 81 fe 6d 01 75  ef c3 88 cb c0 e3 07 c1  |.....m.u........|
00000030  e1 04 30 d2 b4 02 00 da  cd 21 e2 fa c3 2e 73 6e  |..0......!....sn|
00000040  64 00 00 00 18 ff ff ff  ff 00 00 00 02 00 00 10  |d...............|
00000050  00 00 00 00 01 24 33 33  99 99 99 66 99 99 99 99  |.....$33...f....|
00000060  99 66 33 99 99 99 99 66  33 33 33 33 33           |.f3....f33333|
0000006d

Peut être facilement exécuté sous DosBox; la sortie est un fichier .SND nommé SND. Voici une version FLAC de sa sortie (et ici le fichier .COM).

Assemblée commentée:

    org 100h

start:
    ; close stdout
    mov ah,3eh
    mov bx,1
    int 21h
    ; open snd
    mov ah,3ch
    xor cx,cx
    mov dx,filename
    int 21h
    ; write the header
    ; we used the `snd` part of the header as file name, back off one byte
    dec dx
    mov ah,9h
    int 21h
    mov si,data
.l:
    ; data read cycle
    ; read the current byte in cl (zero-extending to 16-bit)
    ; notice that ch is already zero (at the first iteration it's 0 from the
    ; int 21h/3ch, then we are coming from gen, which leaves cx to zero)
    mov cl,[si]
    ; move to next byte
    inc si
    ; generate the tone
    call gen
    ; generate the pause
    mov cl,50
    call gen
    ; repeat until we reach the end of data
    cmp si,eof
    jne .l
    ; quit
    ret

gen:
    ; generate a sawtooth wave at sampling frequency/2 Hz
    ; receives length (in samples>>4) in cx, with lowest bit indicating if
    ; it has to write a wave or a pause
    mov bl,cl
    ; shift the rightmost bit all the way to the left; this kills the
    ; unrelated data and puts a 128 in bl (if cx & 1 != 0)
    shl bl,7
    ; rescale the samples number
    shl cx,4
    ; zero the starting signal
    xor dl,dl
    ; prepare the stuff for int 21h
    mov ah,2h
.l:
    ; increment the signal
    add dl,bl
    ; write it
    int 21h
    ; decrement iteration count and loop
    loop .l
    ret

    ; .SND file header (4096 samples, mono, PCM)
header:
    db "."
    ; we also use "snd" as the file name
filename:
    db "snd",0,0,0,24,0xff,0xff,0xff,0xff,0,0,0,2,0,0,0x10,0,0,0,0,1
    ; terminator for int 21h/ah=9h
    db '$'
data:
    ; generated by gendata.py
    incbin "data.dat"
eof:

L’ data.datinclusion ci-dessus est une représentation facile à utiliser de la chaîne morse (bit inférieur: son activé / désactivé, 7 bits supérieurs: longueur du son dans les échantillons >> 4) générée par un script Python:

#!/usr/bin/env python2
import sys

# source string
s = "..--- ----- .---- ....."
# samples
sr = 4096
conv =  {
            '.': 1 | (((sr/5) >> 4) & ~1),    # dot:   1/5 second, dI/dt=1
            '-': 1 | (((sr/5*3) >> 4) & ~1),  # line:  3/5 second, dI/dt=1
            ' ':     ((sr/5*2) >> 4) & ~1     # space: 2/5 second (+1/5 from the always-present pause), dI/dt=0 (silent)
        }
sys.stdout.write(''.join(chr(conv[a]) for a in s))

Mathematica - 130

r = Riffle;
s = SoundNote;
Export["m.mid", 
 Sound@
   r[Flatten@
     r[
       s[0,.4(Boole@#+.5)]&/@Array[#>4&,5,5-#]&/@{2,0,1,5},
       (b=None~s~#&)@.6
     ],b@.2
   ]
]

Jouer en ligne

Perl 5: 94 122 140

Les fichiers SND ont des en-têtes plus simples, pas besoin d’imprimer en binaire. Cette version produit un fichier SND mono de 8khz nommé 'a':

open A,'>a';print
A".snd",pack"N*",24,-1,2,8e3,1,map{(--$|x3)x(894261072>>$_&1?1600:400)}0..39

Le fichier de résultat .

Ancienne solution. Produit un fichier WAV mono de 1khz 8 bits nommé 'a':

open
A,'>a';print
A pack"A4lA8lssllssA4ls*",RIFF,17040,WAVEfmt,16,1,1,(1e3)x2,1,8,data,17004,map{($_)x(894261072>>$v++&1?400:100)}(255,0)x20

Le fichier de résultat .

Pour obtenir 122 caractères, je devais coller l'en-tête en binaire au lieu de le compresser, ce qui rend le code difficile à copier ici. La version échappée est:

open
A,'>a';print
A"RIFF\x90B\0\0WAVEfmt \0\0\0\0\0\xe8\0\0\xe8\0\0\0\0datalB\0\0",pack"s*",map{($_)x(894261072>>$v++&1?400:100)}(255,0)x20

Encodage en base64 de la solution actuelle de 122 octets:

b3BlbgpBLCc+YSc7cHJpbnQKQSJSSUZGkEIAAFdBVkVmbXQgEAAAAAEAAQDoAwAA6AMAAAEACABk
YXRhbEIAACIscGFjayJzKiIsbWFweygkXyl4KDg5NDI2MTA3Mj4+JHYrKyYxPzQwMDoxMDApfSgy
NTUsMCl4MjA=

AWK: 172 170 octets

... et sans utiliser aucune bibliothèque d'ondes! (*)

BEGIN{for(;++i<204;){d=d"\177\177\n";D=D"\n\n"}t=d d d D;d=d D;T=D D D;u=t t t;print".snd\0\0\0\30\0\0\221\306\0\0\0\2\0\0\20\0\0\0\0\1"d d u T u t t T d u t T d d d d d}

Ceci sort un fichier audio Sun au sur stdout qui peut être lu par vlc (entre autres). Au fileformat n’ayant aucune limitation de fréquence d’échantillonnage, VLC refuse de lire les fichiers dont le taux d’échantillonnage est inférieur à 4096 Hz. J’ai donc utilisé cette fréquence.

EDIT: Lien vers le fichier audio résultant sur DropBox

(*) Ne devrait-il pas y avoir un bonus pour cela? ; o)

Python, 155

Utilise le module wave intégré python.

import wave
n=wave.open(*"nw")
k=17837
n.setparams((2,2,k,0,"NONE",0))
h=k*1314709609
while h:[n.writeframes(`i%9`)for i in[0]*(2-h%2)*k+range(h%4*k)];h/=4

Écrit dans un fichier appelé n.

Merci à Sp3000 pour ses suggestions sur l’utilisation de la compréhension de liste pour la boucle (cela a permis de supprimer un peu d’indentation).

Écoute le:

https://soundcloud.com/bitpwner/morse-the-new-year-2015

Voici un lien vers SoundCloud si le lecteur intégré ne fonctionne pas pour vous.

Code commenté:

import wave
n=wave.open("n.wav","w")         # Open a wav file for writing
k=44100                            
n.setparams((2,2,k,0,"NONE","")) # Sets the minimal params for the wav file
w=n.writeframes
h=23450475295733                 # Contains base-4 morse: '.'=1, '-'=3, ' '=0
while h:
    for i in range(h%2*k):w(h%4*chr(i%99)) # Writes saw-tooth signal using i%99
    w((2-h%2)*k*" ")                       # Writes the pauses
    h/=4

C #, 556 552 536 535 516 506 503 491 483 octets

Utilise la bibliothèque Wav.Net .

using System;using System.Linq;namespace WavDotNet.Core{using S=Samples<float>;class P{static void Main(){var w=new WavFileWrite<float>("a",9999);var b=new Tools.Generators.Sawtooth(9999);Func<long,float,S>g=(t,a)=>b.Generate32Bit(new TimeSpan(t),99,a);var l=2500000;S x=g(l,1),y=g(l*3,1),z=g(l*3,0),_=g(l,0),v=new S(new[]{x,_,x,_,y,_,y,_,y,z,y,_,y,_,y,_,y,_,y,z,x,_,y,_,y,_,y,_,y,z,x,_,x,_,x,_,x,_,x}.SelectMany(c=>c).ToList());w.AudioData.Add(new Channel<float>(v,0));w.Flush();}}}

Sorties dans un fichier nommé a.

Résultat hébergé sur Dropbox

Code non golfé:

using System;
using System.Linq;
namespace WavDotNet.Core
{
    using FloatSamples = Samples<float>;
    class P
    {
        static void Main()
        {
            var file = new WavFileWrite<float>("output.wav", 9999);
            var sawtoothGen = new Tools.Generators.Sawtooth(9999);
            Func<long, float, FloatSamples> generate = (t, amplitude) => sawtoothGen.Generate32Bit(new TimeSpan(t), 99, amplitude);
            var length = 2500000;
            FloatSamples shortBeep = generate(length, 1),
            longBeep = generate(length * 3, 1),
            shortPause = generate(length * 3, 0),
            longPause = generate(length, 0),
            allSamples = new FloatSamples(new[] { shortBeep, longPause, shortBeep, longPause, longBeep, longPause, longBeep, longPause, longBeep, shortPause,
                longBeep, longPause, longBeep, longPause, longBeep, longPause, longBeep, longPause, longBeep, shortPause, 
                shortBeep, longPause, longBeep, longPause, longBeep, longPause, longBeep, longPause, longBeep, shortPause, 
                shortBeep, longPause, shortBeep, longPause, shortBeep, longPause, shortBeep, longPause, shortBeep }
                .SelectMany(c => c).ToList());
            file.AudioData.Add(new Channel<float>(allSamples, 0)); // 0 == ChannelPositions.Mono
            file.Flush();
        }
    }
}

Python 3 2 191 188 174 171 (pas de bibliothèques)

Les fichiers WAV sont incroyablement simples. Voulu essayer sans bibliothèques. Pour une raison quelconque, mes fichiers semblent planter Windows Media Player. Quick Timetravauxbugs à mi-chemin dans le fichier. La conversion à une plus grande fréquence d'échantillonnage en utilisant Audition résout ce problème.

Mise à jour : implémentation de certaines optimisations à partir de la réponse Perl. Maintenant, sorties avec juste le nom net en échantillonnage 1000Hz. Edité les informations ci-dessus en conséquence.

w,s=200*" ",50*"~~  "
a,b,c=s+w,3*s+w,2*w
open(*"nw").write("RIFF\xD46\0\0WAVEfmt \20\0\0\0\1\0\1\0\xE8\3\0\0\xE8\3\0\0\1\0\10\0data\xB06\0\0"+a*2+b*3+c+b*5+c+a+b*4+c+a*5)

Ancienne version

w,s=1600*" ",200*"~~~~    "
a,b,c=s+w,3*s+w,2*w
open("n.wav","wb").write("RIFF\244\265\1\0WAVEfmt \20\0\0\0\1\0\1\0@\x1f\0\0@\x1f\0\0\1\0\10\0data\200\265\1\0"+a*2+b*3+c+b*5+c+a+b*4+c+a*5)

C # ~ 485 octets

Utilisation de la bibliothèque Wav.Net .

using WavDotNet.Core;namespace System.Collections.Generic{using f=Single;class T{static void Main(){var i=new WavFileWrite<f>("x",8000);Func<long,Samples<f>>g=d=>new WavDotNet.Tools.Generators.Sawtooth(8000).Generate32Bit(new TimeSpan(d),600,1);var s=new List<f>();var k="..--- ----- .---- .....";foreach(var c in k){s.AddRange(c=='.'?g(2000000):g(6000000));s.AddRange(new f[1600]);if(c==' '){s.AddRange(new f[3200]);}}i.AudioData.Add(new Channel<f>(new Samples<f>(s),0));i.Flush();}}}

Et voici la sortie.

Version lisible,

using WavDotNet.Core;

namespace System.Collections.Generic
{
    using f = Single;

    class T
    {
        static void Main()
        {
            var i = new WavFileWrite<f>("x", 8000);
            Func<long, Samples<f>> g = d => new WavDotNet.Tools.Generators.Sawtooth(8000).Generate32Bit(new TimeSpan(d), 600, 1);
            var s = new List<f>();
            var k = "..--- ----- .---- .....";

            foreach (var c in k)
            {
                s.AddRange(c == '.' ? g(2000000) : g(6000000));
                s.AddRange(new f[1600]);

                if (c == ' ')
                {
                    s.AddRange(new f[3200]);
                }
            }

            i.AudioData.Add(new Channel<f>(new Samples<f>(s), 0));
            i.Flush();
        }
    }
}

C # 382 333bytes

N'utilise pas de bibliothèques non standard, écrit un wav de 44100 échantillons par seconde à 8 bits par échantillon, avec ce que j'espère est un en-tête valide (semble jouer / charger dans WMP / .NET / Audacity).

L'en-tête est codé en base64 et le morse est codé en tant que signal activé / désactivé qui est stocké dans une seule longueur (64 bits) car les 5 derniers bits sont identiques au premier.

Le résultat peut être trouvé ici

Code de golf:

using System.IO;class P{static void Main(){using(var w=new FileStream("w.wav",FileMode.Create)){int i=0,d=9980;w.Write(System.Convert.FromBase64String("UklGRhCCCgBXQVZFZm10IBAAAAABAAEARKwAAESsAAABAAgAZGF0YeyBCgA="),0,44);for(var k=5899114207271221109L;i++<d*69;w.WriteByte((byte)(System.Math.Sin((k>>(i/d)%64&1)*i*0.1)*127+127)));}}}

Avec des commentaires:

using System.IO;

class P
{
    static void Main()
    {
        using(var w=new FileStream("w.wav",FileMode.Create))
        {
            int i=0,d=9980; // d is samples per tone

            // write wav header
            w.Write(System.Convert.FromBase64String("UklGRhCCCgBXQVZFZm10IBAAAAABAAEARKwAAESsAAABAAgAZGF0YeyBCgA="),0,44);

            for(var k=5899114207271221109L; // 0101000111011101110111010001110111011101110111000111011101110101 as long
                i++<d*69; // 69 is number of bits
                w.WriteByte((byte)(
                    System.Math.Sin(
                        (k>>(i/d)%64&1) // read bit (0 or 1)
                        *i*0.1) // mul by ticker (sin(0) = 0)
                    *127+127)) // make sensible
            );
        }
    }
}

SuperCollider , 625 605 octets

Soumission en langage de programmation audio!

La sortie est écrite dans un fichier bau format AIFF. Windows Media Player ne parvient pas à l'ouvrir, mais cela fonctionne correctement dans VLC Media Player. Le fichier généré aest un fichier OSC .

c=0;d=0;f={c=c+d;d=0.2;[c,[\s_new,\w,1001,0,0,\freq,800]]};g={c=c+d;d=0.2;[c,[\n_free,1001]]};h={c=c+d;d=0.6;[c,[\s_new,\w,1001,0,0,\freq,800]]};i={c=c+d;d=0.6;[c,[\n_free,1001]]};x=[f.value,g.value,f.value,g.value,h.value,g.value,h.value,g.value,h.value,i.value,h.value,g.value,h.value,g.value,h.value,g.value,h.value,g.value,h.value,i.value,f.value,g.value,h.value,g.value,h.value,g.value,h.value,g.value,h.value,i.value,f.value,g.value,f.value,g.value,f.value,g.value,f.value,g.value,f.value,i.value];Score.recordNRT(x,"morse.osc","Morse2015.aiff");SynthDef("w",{arg freq=440;Out.ar(0,SinOsc.ar(freq,0,0.2))}).writeDefFile;

J'ai créé quelques fonctions SuperCollider: fgénère un bip court,g une courte pause, hun long bip et iune longue pause. SuperCollider a besoin des positions de départ pour chaque onde sinusoïdale et non d'une longueur. J'ai donc dû créer des fonctions qui génèrent une onde avec la position de départ correcte et je dois les appeler à chaque fois que j'ai besoin d'une onde sinusoïdale. (Je ne pouvais pas stocker une vague d'une longueur spécifique dans une variable pour la réutiliser). La \wdéfinition est créée à la fin du bloc de code.

Sur mon ordinateur Windows, le fichier audio n'a pas été enregistré dans le même répertoire que mon code, mais dans ce répertoire:

C:\Users\MyName\AppData\Local\VirtualStore\Program Files (x86)\SuperCollider-3.6.6

Résultat hébergé sur Dropbox

Code avec indentation:

c = 0;
d = 0;
f = { c=c+d;d=0.2;[ c, [ \s_new, \w, 1001, 0, 0,  \freq, 800 ] ] };
g = { c=c+d;d=0.2; [ c, [\n_free, 1001]] };
h = { c=c+d;d=0.6; [ c, [ \s_new, \w, 1001, 0, 0, \freq, 800]]};
i = { c=c+d;d=0.6;[ c, [\n_free, 1001]] };

x = [ f.value, g.value, f.value, g.value, h.value, g.value, h.value, g.value, h.value, i.value,
      h.value, g.value, h.value, g.value, h.value, g.value, h.value, g.value, h.value, i.value,
      f.value, g.value, h.value, g.value, h.value, g.value, h.value, g.value, h.value, i.value,
    f.value, g.value, f.value, g.value, f.value, g.value, f.value, g.value, f.value, i.value
];

Score.recordNRT(x, "morse.osc", "Morse2015.aiff");

SynthDef("w",{ arg freq = 440;
    Out.ar(0,
         SinOsc.ar(freq, 0, 0.2)
    )
}).writeDefFile;

ChUCK - 1195 217 201 147 145 144

ChucK est un langage de programmation audio. bitpwner m'a aidé à passer de 201 octets à 147 octets.

SinOsc s;WvOut w=>blackhole;"y"=>w.wavFilename;int j;for(1016835=>int i;i>0;2/=>i){s=>w;j++;(i%2?200:600)::ms=>now;s=<w;(j%5?200:600)::ms=>now;}

Voici un lien direct vers SoundCloud si le lecteur intégré ne fonctionne pas pour vous.

Csound, 140 + 40 = 180

Langage de programmation audio.

C'est le fichier d'orchestre:

instr 1
a1 oscil 2^15,990,1
out a1
endin

et voici le fichier Score:

f1 0 512 10 1
t0 300
i1 0 1
i1 2
i1 40
i1 60
i1 62
i1 64
i1 66
i1 68
i1 4 3
i1 8
i1 12
i1 18
i1 22
i1 26
i1 30
i1 34
i1 42
i1 46
i1 50
i1 54

Les tailles sont calculées en supposant l'absence d'espaces supplémentaires, d'un terminateur de ligne unique (UNIX) et d'aucun terminateur après la dernière ligne.

Vous les appelez à l'aide de la commande csound:

csound morse.org morse.sco

qui produira un fichier de sortie dans le répertoire courant, nommé par défaut "test.aif"

https://soundcloud.com/whatfireflies/morse-code-golf-in-csound/s-qzsaq

J'aurais pu raser deux ou trois octets en choisissant une forme d'onde plus laide, mais j'aime bien le son de la traditionnelle onde sinusoïdale Morse.

PS: Je suis un novice total chez Csound, tous les conseils relatifs au golf sont appréciés, en particulier en ce qui concerne le fichier de score!

brainfuck , 649 octets

++[>-[+>++[++<]>]>[>..........-..........+<-]-[+>++[++<]>]>[....................-]<<<<<-]+++[>+++[>-[+>++[++<]>]>[>..........-..........+<-]<<<-]-[+>++[++<]>]>[....................-]<<<-]-[+>++[++<]>]>[....................-]+++++[>-[+>++[++<]>]>[....................-]+++[>-[+>++[++<]>]>[>..........-..........+<-]<<<-]<<<-]+++[>-[+>++[++<]>]>[....................-]<<<-]-[+>++[++<]>]>[>..........-..........+<-]++++[>-[+>++[++<]>]>[....................-]+++[>-[+>++[++<]>]>[>..........-..........+<-]<<<-]<<<-]++[>-[+>++[++<]>]>[....................-]<<<-]+++++[>-[+>++[++<]>]>[....................-]-[+>++[++<]>]>[>..........-..........+<-]<<<<<-]

Cela génère une séquence d'échantillons non signés de 8 bits qui peuvent être lus à 8 000 échantillons par seconde avec un outil tel que aplayLinux. Crédit au tableau des constantes BF .

Essayez-le en ligne!

Un peu moins golfé

DIT DIT DAH DAH DAH
++[>
 -[+>++[++<]>]>[>..........-..........+<-]
 -[+>++[++<]>]>[....................-]
<<<<<-]
+++[>
 +++[>
  -[+>++[++<]>]>[>..........-..........+<-]
 <<<-]
 -[+>++[++<]>]>[....................-]
<<<-]
-[+>++[++<]>]>[....................-]
DAH DAH DAH DAH DAH
+++++[>
 -[+>++[++<]>]>[....................-]
 +++[>
  -[+>++[++<]>]>[>..........-..........+<-]
 <<<-]
<<<-]
+++[>
 -[+>++[++<]>]>[....................-]
<<<-]
DIT DAH DAH DAH DAH
-[+>++[++<]>]>[>..........-..........+<-]
++++[>
 -[+>++[++<]>]>[....................-]
 +++[>
  -[+>++[++<]>]>[>..........-..........+<-]
 <<<-]
<<<-]
++[>
 -[+>++[++<]>]>[....................-]
<<<-]
DIT DIT DIT DIT DIT
+++++[>
 -[+>++[++<]>]>[....................-]
 -[+>++[++<]>]>[>..........-..........+<-]
<<<<<-]