Morse la nouvelle année

33

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.

Martin Ender
la source
1
Défi supplémentaire: Faites en sorte que cela sonne vraiment bien.
Kaz Wolfe
6
@Mew A quel point Morse peut-il bien paraître?
Martin Ender
1
Faire cela dans Brainf ** k rendrait cela génial avec autant de niveaux bonus.
Mât
@Mast Probablement, mais malheureusement, BF ne peut pas écrire dans un fichier. ;) (Je ferai en sorte d'être plus indulgent avec cette prochaine fois.)
Martin Ender
Les formats de notation musicale, ne contenant que la partition et aucun audio (.mid, .abc, voir ci-dessous) sont-ils considérés comme acceptables comme "fichier audio"? Qu'en est-il des formats "tracker", qui contiennent à la fois des échantillons et une partition, mais pas de piste audio rendue (.mod, .xm)?
Tobia

Réponses:

4

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: Last (I hope :o) ) version of 2015's score

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: last version of "2015" partition

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: score of 2015

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: Score of "2015" in morse

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

LeFauve
la source
Vous devriez l'afficher en tant qu'ABC sans l'emballage AWK et réclamer la prime!
Tobia
Tobia, ABC est un format de fichier et non un langage de programmation. Et jusqu’à présent, avec 86 octets, c’est la réponse la plus courte ... La question est maintenant "le son résultant est-il suffisamment proche des exigences pour que la réponse soit valide?"
LeFauve
J'aurais aussi appelé cela un format de fichier, mais la page wiki sur laquelle l'OP lié le répertorie en tant que langage de programmation Sound. J'ai envoyé mon propre fichier ABC comme entrée, à côté d'un programme Csound plus approprié. Voyons ce qu'ils en pensent.
Tobia
C'est le problème avec les wikis ... parfois les gens qui les rédigent font des erreurs: o). Beaucoup de choses différentes peuvent être appelées "langages de programmation" mais je pense qu'ABC n'en fait pas partie. Quoi qu'il en soit, merci d'avoir découvert que le "L" était facultatif. Cela m'a sauvé quelques octets; o)
LeFauve
"Les segments longs doivent être au moins 3 fois plus longs que les segments courts." La dernière ligne musicale affichée ne répond pas aux exigences.
mbomb007
13

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))
Matteo Italia
la source
Vous n'avez pas nécessairement besoin d'une extension de fichier, si cela peut vous sauver quatre octets.
Martin Ender
4
@ MartinBüttner: en réalité, cela me permet d'économiser 3 octets. Le aof a.sndest placé juste avant l'en-tête SND, qui commence par .sndsuivi d'un octet nul. Je récupère donc la .sndpartie gratuitement et je recycle son terminateur zéro. De plus, le fait que l'en-tête commence un octet après le nom du fichier me permet d'utiliser un inc dxpour passer à l'en-tête (1 octet) au lieu de mov dx, header(3 octets). OTOH, si on me permettait de l'appeler tout .sndseul, je pourrais économiser deux octets, mais je ne suis pas sûr que le vrai DOS le permette (le traitement de l'extension sous DOS était assez particulier).
Matteo Italia
J'ai fait quelques tests pour appeler le fichier .SND: je suis arrivé .SNDsur DosBox, SND~1sur FreeDOS, et j'attends autre chose sur du "vrai" DOS; donc, c’est définitivement le domaine du "comportement non défini". En fin de compte, j'ai réglé l'appel du fichier SND(moins d'un octet à cause de la suppression a, en gardant le coût du inc dx- qui devient dec dx).
Matteo Italia
8

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
     ],[email protected]
   ]
]

Jouer en ligne

bruissement
la source
Oh, vous pouvez également utiliser la notation infixe pour Export, comme "m.mid"~Export~Sound@....
Martin Ender
(b=None~s~#&)@.6devrait (b=None~s~#&)@.4 également être , vous pouvez enregistrer 3 caractères en utilisantr = Riffle; s = SoundNote; Export["m.mid", Sound@r[r[Table[s[0, If[{1, 2, 11}~MemberQ~k || k > 15, .2, .6]], {k, 20}], None~s~.2], None~s~.4, 11]]
DavidC
Martin, mais il y avait déjà un .2 à chaque pause. .4 + .2
DavidC
@ David Carraher Ah, vous avez raison.
Martin Ender
7

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=
nutki
la source
U pourrait utiliser l' .auextension, peut-être. Bien joué!
F. Hauri
7

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)

LeFauve
la source
Vous n'avez pas besoin d'espace dans la d=d "\177... concaténation. Cela sauve un octet. Mais quand je joue le fichier audio résultant, il semble qu'il manque la dernière phrase du 5.
Mark Reed
Merci. J'ai enregistré un deuxième octet avec une autre concaténation utilisant la même astuce. Je viens de vérifier le fichier audio avec vlc 2.1.1 et ça sonne complet. Quel joueur as-tu utilisé?
LeFauve
J'utilisais QuickTime Player sous OS X. Je l'ai ouvert dans VLC et le son est correct, alors ne vous en faites pas. La faute d'Apple, pas la vôtre.
Mark Reed le
7

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
Vectorisé
la source
Depuis west un effet secondaire, je pense que vous pouvez lister comp pour économiser deux octets:while h:[w(h%4*chr(i%99))for i in range(h%2*k)];w((2-h%2)*k*" ");h/=4
Sp3000
@ Sp3000 oo ... n'y pensais pas = D. THX!
Vectorisé le
Cela pourrait être une question stupide, mais si h est divisé par 4 à chaque itération, comment la boucle while s'arrête-t-elle?
Derek 會 功夫
@Derek 朕 功夫 Pour python, lorsque h devient 0, la valeur est False, mettant fin à la boucle. La boucle while est une astuce permettant d'extraire les valeurs de la séquence "11333033333013333011111" l'une après l'autre.
Vectorisé le
@bitpwner Je comprends que 0 est évalué à false, mais n'est-ce pas que pour tous les nombres positifs, si vous le divisez par un autre nombre positif, vous ne pouvez absolument pas obtenir un 0?
Derek 會 功夫
6

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();
        }
    }
}
ProgramFOX
la source
5

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)
PurkkaKoodari
la source
4

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();
        }
    }
}
Sam
la source
Vous pouvez enregistrer des octets en encapsulant votre classe dans l'espace de noms System.Collections.Generic (qui fonctionne réellement). Il existe également des espaces inutiles que vous pouvez supprimer.
ProgramFOX le
4

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
            );
        }
    }
}
VisualMelon
la source
Le défi n’exige pas que le nom du fichier se termine .wav, vous pouvez donc y sauvegarder 4 octets.
ProgramFOX
Belle façon d’intégrer le code PWM 69 bits dans une constante de 64 bits. J'essayais quelque chose comme ça mais je ne pouvais probablement pas raccourcir mon code avec votre méthode.
nutki
2

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;
ProgramFOX
la source
2

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.

KSFT
la source
1
J'ai réussi à le réduire à 164 avec un truc similaire à celui utilisé dans ma réponse:WvOut w=>blackhole;"x"=>w.wavFilename;SinOsc s=>w;0=>int j;for(1016835=>int i;i>0;2/=>i){j++;300=>s.freq;(600-i%2*400)::ms=>now;s=<w;(j%5>0?200:600)::ms=>now;s=>w;}
Vectorisé le
@bitpwner Vous utilisez jpour éviter le tableau?
KSFT
Le nombre magique 1016835en binaire est 11111000010000000011. jest là pour simplement garder trace des pauses entre chaque chiffre de 2015(chaque chiffre a 5 sons).
Vectorisé le
@bitpwner Ah, je n'ai même pas remarqué cela. C'est une très bonne idée!
KSFT
Vous pouvez l'éditer dans votre réponse pour augmenter vos chances d'obtenir une prime. imo, l'amélioration n'est pas beaucoup pour justifier une nouvelle réponse depuis que vous avez déjà fait l'essentiel du travail à comprendre Chuck;)
Vectorisé le
2

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!

Tobia
la source
Ah, j'avais hâte de jouer à CSound. Si personne n'avait posté de réponse, j'aurais probablement essayé d'en écrire une moi-même. :)
Martin Ender
1

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
+++++[>
 -[+>++[++<]>]>[....................-]
 -[+>++[++<]>]>[>..........-..........+<-]
<<<<<-]
plafondcat
la source