Programmieren lernen

// getestet mit: msvc v19.38

#include <iostream>
#include <chrono>
#include <conio.h>

const size_t MINUTE{ 60'000 };
// Die Anzahl der Anschläge kann hier verändert werden
const size_t KEYSTROKES{ 10 };

int main() {
    auto strokes{ KEYSTROKES };
    char input;
    std::chrono::high_resolution_clock::time_point t_begin;

    // Beginn Zeitmessung beim ersten Drücken der Leertaste  
    while (1) {
        std::cout << "Bitte " << KEYSTROKES << "x Leertaste im Takt druecken.\n";
        input = _getch();
        if (input == 32) break;
    }

    t_begin = std::chrono::high_resolution_clock::now();
    std::cout << "noch " << --strokes << " ";

    while (strokes) {
        input = _getch();
        if (input == 32) strokes--;
        std::cout << strokes << " ";
    }
    const auto t_end{ std::chrono::high_resolution_clock::now() };
    const std::chrono::duration<double, std::milli> t_result{ t_end - t_begin };
    const auto bpm{ size_t(MINUTE * KEYSTROKES / t_result.count()) };

    std::cout << "\nBPM: " << bpm << "\n";
}
                

Lösung von: Jens Kelm (@JKooP)

// NET 8.x | C# 12.x | VS-2022

const int KEYSTROKE = 10;

var strokes = KEYSTROKE;

Console.WriteLine($"Bitte {KEYSTROKE}x Leertaste im Takt drücken.");

var begin = DateTime.Now;

while (strokes > 0) {
    if (Console.ReadKey(true).Key == ConsoleKey.Spacebar) strokes--;
    Console.Write($"{strokes} ");
}

var bpm = KEYSTROKE * 60_000 / (int)(DateTime.Now - begin).TotalMilliseconds;

Console.WriteLine($"\nBPM: {bpm}");
                

Lösung von: Jens Kelm (@JKooP)

Array.prototype.avg = function() {
  let sum = 0;
  for (let i of this) sum += i;
  return sum / this.length;
}

// ausgabemonitor
document.write(`
  <div id="bpm">
    Premadu la spacklavon por enigi ritmon
  </div>
`);

let inputs = [],
    bpmScr = document.getElementById('bpm');

document.addEventListener('keydown', function(evt) {
  if (evt.key == ' ') inputs.push(new Date());
  if (inputs.length > 2) {
    let tmp = [],
        i = inputs.length-1;
    for (i; i > 1; i--) tmp.push(inputs[i] - inputs[i-1]);
    bpmScr.innerText = `~ ${Math.round(60_000 / tmp.avg())} bpm`;
  }
});
                

Lösung von: Lisa Salander (Heidi-Klum-Gymnasium Bottrop)

/* NET 8.x | C# 12.x | VS-2022
  -------------------------------------------------------------------------
  Die Ausgabe des aktuellen BPM-Wertes nach jedem Tastendruck wäre möglich,
  würde aber wegen des hohen Zeitaufwandes zum Schreiben auf die Konsole
  die Zeiten verschfälschen (ca. 50% Zeitverlust).
  Deshalb wird die Durchschnittszeit am Ende ausgegeben.
  -------------------------------------------------------------------------
*/
using System.Diagnostics; // Stopwatch

Console.WriteLine($"Bitte Leertaste im Takt drücken." +
    $"\nZum Beenden beliebige Taste drücken.");
Stopwatch sw = new();
List<long> lst = [];
sw.Start();

while (Console.ReadKey(true).Key == ConsoleKey.Spacebar) {
    sw.Stop();
    lst.Add(sw.ElapsedMilliseconds);
    sw.Restart();
}
// erster und letzter Wert werden als statistische Ausreisser eleminiert
Console.WriteLine($"BPM: {(int)(6e4 / lst.Skip(1).Take(lst.Count - 2).Average())}");

                

Lösung von: Jens Kelm (@JKooP)

// C++14 | VS-2022

#include <iostream>
#include <chrono>  // clock
#include <conio.h> // _getch
#include <vector>
#include <numeric> // accumulate

int main() {
    std::vector<double>vec{};

    std::cout << "\nBitte Leertaste im Takt druecken."
                << "\nZum Beenden beliebige Taste druecken.\n";

    auto t_begin{ std::chrono::high_resolution_clock::now() };

    while (_getch() == 32) {
        const auto t_end{ std::chrono::high_resolution_clock::now() };
        const std::chrono::duration<double, std::milli> t_result{ t_end - t_begin };
        vec.push_back(t_result.count());

        if (vec.size() > 2) {
            const auto avg{ std::accumulate(vec.begin() + 1, vec.end() - 1, 0) / (vec.size() - 2)};
            const auto bpm{ size_t(6e4 / avg) };
            std::system("cls");
            std::cout << "\nBPM: " << bpm << "\n";
        }
        t_begin = t_end;
    }

    if (vec.size() < 2)
        std::cout << "Nicht genuegend Leertastenschlaege.\n";
}
                

Lösung von: Jens Kelm (@JKooP)

#include <time.h>
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>

#define MAX_KEYSTROKES 100
#define UINT unsigned int

double average(double arr[], UINT begin, UINT end) {
    UINT i = (begin == 0 ? 1 : begin);
    double sum = 0.0;
    for (; i <= end; ++i)
        sum += arr[i];
    return sum / i;
}

int main() {
    double arr[MAX_KEYSTROKES];

    printf("\nBitte Leertaste im Takt druecken. (max. %i)", MAX_KEYSTROKES);
    printf("\nZum Beenden beliebige Taste druecken.\n");

    double t_begin, t_time = 0.0;
    UINT strokes = 0;
    t_begin = clock();

    while (getch() == 32 && strokes < MAX_KEYSTROKES) {
        t_time += clock() - t_begin;
        t_time /= CLOCKS_PER_SEC;
        arr[strokes++] = t_time;

        if (strokes > 1) {
            double avg = average(arr, 1, strokes - 1);
            UINT bpm = (UINT)(60 / avg);
            system("cls");
            printf("\nBPM: %i\n", bpm);
        }
        t_begin = clock();
    }

    if (strokes < 2)
        printf("Nicht genuegend Leertastenschlaege.\n");
}
                

Lösung von: Jens Kelm (@JKooP)