introduction

Il y a quelques jours, j'avais besoin d'un métronome pour quelque chose. Je n'en avais pas, j'ai donc téléchargé une application depuis l'App Store. L'application avait une taille de 71 Mo !!!
71 Mo pour faire du tic-toc ...?!
Alors le code-golf m’est venu à l’esprit et je me demandais si certains d’entre vous pourraient améliorer cela.

Défi

Golf un code qui produit du son. Quel genre de son importe peu. Si nécessaire, créez un fichier son ... mais un bip système fera également l'affaire. ( Voici quelques sons que j'ai créés ... rien de spécial. )

Input : Les battements par minute des sorties du métronome.

Exemple

Ceci est une version Java non-golfée! C'est juste pour vous montrer la tâche.

public class Metronome {
  public static void main(String[] args) throws InterruptedException {
    int bpm = Integer.valueOf(args[0]);
    int interval = 60000 / bpm;

    while(true) {
        java.awt.Toolkit.getDefaultToolkit().beep();
        // or start playing the sound
        Thread.sleep(interval);
        System.out.println("Beep!");

    }
  }
}

Règles

Vous ne pouvez pas utiliser de bibliothèque externe, seuls les outils du langage lui-même sont autorisés.
Seuls les octets du code source comptent ... pas le fichier son.

C'est du code-golf , donc la soumission avec le moins d'octets gagne!

MODIFIER:

Exemple de sortie: Donc, quelque chose comme ceci serait la sortie pour 120 bps : link

Mathematica, 26 octets

Pause[Beep[];60/#]~Do~∞&

Doest normalement utilisé comme une boucle "for" dans le sens le plus étroit: répétez ce morceau de code pour chacun ide xà y... ou même simplement répétez ce bout de code n. Au lieu d'un nombre, nnous pouvons lui donner l'infini pour créer une boucle infinie. Le corps de la boucle Pause[Beep[];60/#]est juste une manière amusante d’écrire, Beep[];Pause[60/#]où se #trouve l’argument de la fonction.

Si la solution peut éventuellement faire exploser la pile d'appels, nous pouvons économiser un octet avec une solution récursive:

#0[Beep[];Pause[60/#];#]&

Pyth, 11 10 9 octets

Merci à Adnan de me l'avoir rappelé #.

#C7.dc60Q

Forever ( #), Caffiche le code du har 7. Puis sommeil ( .d) 60secondes divisé par ( c) entrée ( Q).

JavaScript, 36 45 42 41 34 octets

Enregistré 1 octet grâce à @RikerW

Enregistré 1 octet grâce à @ETHproductions

n=>{for(;;sleep(60/n))print("\7")}

Ceci est une fonction.

Si je l'utilise `\7`, SpiderMonkey se plaint que les littéraux octaux sont obsolètes.

Alternative, 31 octets

n=>{for(;;sleep(60/n))print``}

Le problème est que les non imprimables sont éliminés, mais cela devrait fonctionner.

Bash, 53 55 41 octets

Merci à @Dennis d'avoir réduit de 14 octets ¹

Ok, heure de vérité: je suis terrible au golf bash. Toute aide serait très appréciée.

echo " ";sleep `bc -l<<<60/$1`;exec $0 $1
      ^ That's ASCII char 7

¹ merde sainte. Pas étonnant que personne ne puisse surclasser Dennis.

JavaScript ES6 (navigateur), 43 octets

Cela peut être étirer les règles:

x=>setInterval('new Audio(1).play()',6e4/x)

Donnez un nom à cette fonction (par exemple F=x=>...) et entrez-le dans la console du navigateur sur cette page . Ensuite, appelez la fonction avec vos bps, par exemple F(60), et attendez que la magie se produise. :-)

Pourquoi ça marche? Eh bien, se b.htmltrouve dans le même dossier qu’un fichier nommé 1, qui est l’exemple de fichier son de l’OP. Je ne sais pas si cela respecte les règles (je suppose que c'est comme la version shell; il doit être exécuté dans un environnement spécifique), mais cela en valait la peine.

Version plus sûre, 57 octets

Si le code ci-dessus n'est pas autorisé pour une raison quelconque, essayez plutôt ceci:

x=>setInterval('new Audio("//ow.ly/Xrnl1").play()',6e4/x)

Fonctionne sur n'importe quelle page!

05AB1E , 31 octets

Code:

I60s/[7ç?D.etime.sleep(#.pop())

Si j'avais intégré pour attendre N secondes, cela aurait pu être 11 octets. Malheureusement, ce n'est pas le cas. Voici l'explication:

I                               # Push input
 60                             # Push 60
   s                            # Swap the top 2 items
    /                           # Divide the top 2 items
     [                          # Infinite loop
      7ç                        # Push the character \x07
        ?                       # Output it, which give a sound
         .e                     # Evaluate the following as Python code
           time.sleep(       )  # Wait for N seconds
                      #         # Short for stack
                       .pop()   # Pop the last item

Utilise le codage ISO 8859-1.

osascript, 39 octets

on run a
repeat
beep
delay 60/a
end
end

Il y a littéralement une commande appelée bip? Sweeeet!

Exécutable uniquement sur Mac OS X en raison d'une licence restreinte. Pour l'exécuter, procédez comme suit:

osascript -e "on run a
repeat
beep
delay 60/a
end
end" bpm

Python, 68 67 57 octets

Enregistré 1 octet grâce à @FlagAsSpam

9 octets sauvés grâce à @Adnan

import time
a=input()
while 1:print"\7";time.sleep(60./a)

En outre, il fallait 2 octets de moins après la conversion des fins de ligne au format UNIX.

Ancienne version utilisant bpm comme argument de ligne de commande (66 octets):

import sys,time
while 1:print"\7";time.sleep(60./int(sys.argv[1]))

AutoIt , 56 octets

Func _($0)
While Sleep(6e4/$0)
Beep(900,99)
WEnd
EndFunc

Vitsy, 14 octets

a6*r/V1m
<wVO7

Mode verbeux (interprète à venir):

0:                              // a6*r/V1m
push a; // 10
push 6;
multiply top two; // 60
reverse stack; // bpm on top
divide top two; // bpm/60
save/push permanent variable; 
push 1;
goto top method; // goes to 1
1:                              // <wVO7
go backward; // infinite loop, from the bottom of 1
wait top seconds;
save/push permanent variable; // pushes the bpm in terms of seconds of delay
output top as character;
push 7;

Fondamentalement, j'utilise l' wopérateur pour attendre un certain nombre de secondes comme spécifié par bpm/60, enveloppé dans une boucle infinie. Ensuite, je fais du bruit avec la sortie de terminal du caractère ASCII 7 ( BEL).

C #, 118 octets

class A{static int Main(string[]a){for(;;System.Threading.Thread.Sleep(60000/int.Parse(a[0])))System.Console.Beep();}}

Solution de base.

Java, 103 82 octets

Merci à @Justin d'avoir réduit de 21 octets!

Oh bon sang.

void x(int b)throws Exception{for(;;Thread.sleep(60000/b))System.out.print('\7');}

Méthode et version golfée du programme exemple.

Code machine GMC-4 , 21,5 octets

Le GMC-4 est un ordinateur 4 bits d'une société appelée Gakken, qui enseigne les principes du langage d'assemblage dans un jeu d'instructions simplifié et sur un ordinateur. Cette routine prend en entrée les adresses de mémoire de données 0x5Dpar le biais 0x5F, en décimal gros-boutiste (qui est, par un chiffre quartet).

L’algorithme ajoute l’entrée à la mémoire et attend 0.1 secondes, jusqu’à 600 minimum, puis soustrait 600 et émet un bip dans une boucle infinie. Étant donné que le GMC-4 dispose de nombreuses fonctions d’échange de registre mais pas de fonction de copie de registre , cela se fait à la dure.

En hex (la deuxième ligne est la position en mémoire):

A24A14A04 80EC AF5A2EF AE5A1EF AD5A0EF 8A6 F2AF09 86ADEEE9F09
012345678 9ABC DEF0123 4567890 ABCDEF0 123 456789 ABCDEF01234

En assemblée:

    tiy 2     ;ld y, 0x2
    AM        ;ld a, [0x50 + y]
    tiy 1
    AM
    tiy 0
    AM
start:
    tia 0     ;ld a, 0x0
    cal timr  ;pause for (a+1)*0.1 seconds
    tiy F
    MA        ;ld [0x50 + y], a
    tiy 2
    cal DEM+  ;add a to [0x50 + y]; convert to decimal and carry.
    tiy E     ;do the same for the second digit
    MA
    tiy 1
    cal DEM+
    tiy D     ;and the third.
    MA
    tiy 0
    cal DEM+
    tia A
    M+
    jump beep
    jump start
beep:
    tia 6
    tiy D
    cal DEM-
    cal SHTS  ;'play short sound'
    jump start

Avertissement:

Je ne possède pas réellement un GMC-4. J'ai vérifié méticuleusement ce programme avec la documentation en ligne, mais j'ai peut-être commis une erreur. Je ne connais pas non plus la finalité. On dirait que le GMC-4 est big-endian, mais je ne suis pas sûr. Si quelqu'un possède un GMC-4 et peut vérifier cela / me dire le caractère durable du GMC-4, je l'apprécierais beaucoup.

C, 48 octets

void f(int b){while(printf(""))Sleep(60000/b);}
                            ^ literal 0x07 here

Une solution uniquement Windows (fonction Sleep (), pour être spécifique).

J'ai aussi utilisé (ab) le fait que printf () renvoie le nombre de caractères imprimés pour l'utiliser comme condition de boucle infinie.

Il y a un caractère entre guillemets dans l'appel printf (), mais il ne s'affiche pas ici pour une raison quelconque. En cas de doute, copiez et collez dans Sublime Text 2 ou Notepad ++, le caractère s'affiche comme BEL.

Cela a commencé comme une solution C ++, mais il est tombé dans le sous-ensemble C de C ++ (parce que, vous savez, Sleep()est un peu plus court que std::this_thread::sleep_for(std::chrono::milliseconds())) et printf()est plus court que std::cout<<).

AppleScript 94 octets

Je sais que je suis assez en retard, et ceci est mon premier post ici, mais peu importe.

boîte de dialogue d'affichage "" réponse par défaut ""
mettre x à 60000 / texte du résultat retourné
répéter
bip
délai x
fin

Ungolfed:

boîte de dialogue d'affichage "" réponse par défaut ""
mettre x à 60000 / (le texte du résultat est retourné)
répéter
    bip
    délai x
fin de répéter

VBScript, 113 66 octets

a=InputBox("")
Do
WScript.Echo(Chr(7))
WScript.Sleep(60000/a)
Loop

Ce programme est assez simple. il prend une entrée, fait écho au caractère BEL et attend. Merci à Niel d’avoir rasé presque la moitié du programme!

Ruby, 37 33 octets

m=->b{loop{puts"\7"
sleep 6e1/b}}

Assez simple.

C'est une fonction lambda. Si vous vouliez 60 bpm, vous feriez: m[60].

Japt, 30 octets

6e4/U i`?w Au¹o('../1').play()

Le ?devrait être l'octet littéral 9A. Testez-le en ligne! (Désolé pour la fenêtre contextuelle retardant les premiers battements; elle sera bientôt supprimée.)

Comment ça marche

6e4/U i"new Audio('../1').play()  // Implicit: U = input bps
6e4/U                             // Calculate 60000 / U.
      i                           // Set a timed event every that many milliseconds,
       "new Audio('../1').play()  // running this code every time.
                                  // ../1 is the path to the file used in my JS entry.

Oreillons, 18 octets

R I F  H 60/I W *7

Lisez le tempo dans la variable I, puis F {avec deux espaces après} est une boucle infinie. Arrêtez pendant 60 secondes / BPM, puis écrivez $ CHR (7) {Ascii: BEL} sur la sortie standard en indiquant la sortie audio requise, puis redémarrez à la boucle infinie.

Java, 321 caractères

Cela semble très bien. Fonctionne uniquement sur les systèmes prenant en charge MIDI.

import javax.sound.midi.*;import java.util.*;class A{public static void main(String[] a) throws Exception{int d=new Scanner(System.in).nextInt();Synthesizer b=MidiSystem.getSynthesizer();b.open();MidiChannel c=b.getChannels()[0];c.programChange(116);while(true){c.noteOn(0,100);Thread.sleep((int)(d/.06));c.noteOff(0);}}}

.

ChucK , 90 octets

Bruit blanc qui est activé et désactivé toutes les deux ticks.

60./Std.atoi(me.arg(0))*1000=>float s;while(1){Noise b=>dac;s::ms=>now;b=<dac;s::ms=>now;}

Explication

60./Std.atoi(me.arg(0)) //Convert the input to an int and divide 60 by it
*1000                   //Multiply by 1000 (in order to avoid s::second)
=>float s;              //Store it as a float in variable s
while(1)                //Forever,
{Noise b=>dac;          //Connect a noise generator b to the audio output
s::ms=>now;             //Wait for s milliseconds
b=<dac;                 //Disconnect b from the audio output
s::ms=>now;}            //Wait for s milliseconds

Ceci est fait pour activer le son sur un temps, puis l'éteindre sur le temps après.

Version 98 93 octets (amateur)

Le bruit blanc a joué 10 millisecondes par tick.

60./Std.atoi(me.arg(0))*1000-9=>float s;while(1){Noise b=>dac;10::ms=>now;b=<dac;s::ms=>now;}

Ceci est fait pour être un clic au lieu d'activer et de désactiver le bruit constant.

Perl 5, 36 octets

{{$|=print"\a";sleep 60/$_[0];redo}}

Un sous-programme; l'utiliser comme

sub{{$|=print"\a";sleep 60/$_[0];redo}}->(21)

Jolf, 7 octets, sans compétition

J'ai ajouté des sons après ce très beau défi.

TΑa/Αaj
T       set an interval
 Αa      that plays a short beep (Α is Alpha)
   /Αaj  every 60000 / j (the input) seconds. (Αa returns 60000)

Si vous souhaitez supprimer ce son, prenez note de la sortie. Dis que ce nombre est x. Exécutez une autre commande Jolf ~CP"x"et l'intervalle sera effacé.

Zsh , 32 octets

<<<$'\a'
sleep $[60./$1]
. $0 $1

Basé sur la réponse bash en tête, mais sources au lieu de execs. Les sources de liens TIO en $0:araison de la façon dont le fichier original est exécuté, mais cela ne fonctionnera pas.

Essayez-le en ligne!

Bash + bc + > <> , 44 octets

Jouant sur le fait que l'interprète> <> vous permet de définir une heure de tick:

python fish.py -t $(bc -l<<<"2/$1/60") -c 7o

Le code> <> est 7oet devrait sortir le BELcaractère, produisant un bip système. Il va en boucle jusqu'à ce qu'il soit interrompu.
La -tvaleur est définie sur (2 / tr / min) / 60 afin que le code entier soit lu tr / min * 60 fois par seconde.

SmileBASIC, 26 octets

INPUT B$BGMPLAY@8T+B$+"[C]

Il peut jouer n’importe quel instrument midi général, bien que tout ce qui dépasse 9 utilise plus d’octets.

Stax, 17 octets

ü7»♥O╚⌂╥☻≈OyM╜Δ∩`

ou, déballé:

4|A48*x/W2|A]pc{| }*

Le programme génère des octets qui, lorsqu'ils sont introduits dans l'outil de ligne de commande avec un paramètre par défaut, produisent un bruit de métronome. L'entrée est utilisée comme bpm

Exemple:

example-stax-interpreter metronome.stax -i "60" | aplay

Vous devriez entendre un horrible bip sonore au bpm souhaité