Programmieren lernen

/* Autor: ph gressly */

#include <stdio.h>

#define REAKTIONSZEIT_IN_SEKUNDEN    1.44

// Beschlaeunigungen in (m/s)/s (= meter / Quadratsekunde)
#define BREMSBESCHLAEUNIGUNG_TROCKEN 7.0 
#define BREMSBESCHLAEUNIGUNG_NASS    4.0


/**
 * Lesen der beiden folgenden Attribute:
 * geschwindigkeitInKMH = Kilometer pro Stunde
 * strassenZustand: 't' = trocken; 'n' = nass
 */
void eingabe(float * geschwindigkeitInKMH, char * strassenZustand) {
  printf("Geschwindigkeit in KM/H                 : ");
  scanf ("%f",                   geschwindigkeitInKMH);
  printf("Strassenzustand (t = trocken; n = nass) : ");
  scanf ("\n%c",                      strassenZustand);  }
/**
 * Umrechnug km/h nach m/s
 */
float geschwindigkeitInMeterProSekunde(float geschwindigkeitInKmProStunde) {
  return geschwindigkeitInKmProStunde / 3.6; }

/**
 * Liefere die Bremsbeschläunigung in (m/s)/s anhand des
 * Strassenzustandes (zustand).
 * zustand = 0 -> trocken
 *           1 -> nass  
 * Werte siehe oben (define).
 */
float bremsbeschlaeunigung(char strassenzustand) {
  switch(strassenzustand) {
    case 't': return BREMSBESCHLAEUNIGUNG_TROCKEN;
    case 'n': return BREMSBESCHLAEUNIGUNG_NASS   ;  }
}

/**
 * Die Reaktionszeit in Sekunden bei vollem Bewustsein.
 */
float reaktionszeit() {
  return REAKTIONSZEIT_IN_SEKUNDEN; }

/**
 * Reaktionsweg aus gegebener Geschwindigkeit in Metern pro Sekunde.
 */
float reaktionsweg(float geschwindigkeitMS) {
  return geschwindigkeitMS * reaktionszeit(); }


/**
 * Berechne den Bremsweg aus Bremsbeschläunigung und 
 * aktueller Geschwindigkeit (m/s).
 */
float bremsweg(float geschwindigkeit, float beschlaeunigung) {
  return geschwindigkeit * geschwindigkeit / 2.0 / beschlaeunigung; }

/**
 * Anhaltestrecke = Reaktionsweg + Bremsweg
 */
float anhaltestrecke(float geschwindigkeitMS, float beschlaeunigung) {
  return reaktionsweg(geschwindigkeitMS) + 
         bremsweg(geschwindigkeitMS, beschlaeunigung); }


/**
 * Ausgabe der berechneten Werte 
 * Reaktionsweg, Bremsweg und Anhaltestrecke (alles in Metern)
 */
void ausgabe(float anhaltestrecke) {
  printf("Resultat:\n");
  printf("Anhaltestrecke (=Reaktions- + Bremsweg) : %2.4g\n Meter", anhaltestrecke); }


/**
 * Hauptprogramm:
 * Eingabe Geschwindigkeit, berechne Bremsweg, Ausgabe auf der Konsole.
 */
main() {
  float geschwindigkeitInKMH;
  char       strassenZustand; // 't': trocken 'n': nass

  eingabe(&geschwindigkeitInKMH, &strassenZustand);

  // Berechnung:
  float geschwindigkeitMS = geschwindigkeitInMeterProSekunde(geschwindigkeitInKMH);
  float beschlaeunigung   = bremsbeschlaeunigung(strassenZustand); 
  float anhalteStrecke    = anhaltestrecke(geschwindigkeitMS, beschlaeunigung);

  ausgabe(anhalteStrecke);  }

                

/************** File: bremsweg.js *****************/

/***********************************************
 * Modul: 307
 * Autor: philipp gressly / Santis Training AG
 * Datum: März 2010
 ***********************************************/


/* Initialize: Disable buttons, empty fields and set Default Color*/
function initialisieren() {
  document.getElementById("kmhField")  .value   = "";
  document.getElementById("zustandBox").checked = false;

  setButtonState("", false);
  javaScriptEinschalten();
  bildEinschalten(false);
}


/**
 * Falls JavaScript ausgeschaltet ist: mache nichts ;-) (ginge auch nicht)
 * Falls JavaScript eingeschaltet ist: zeige die JavaScript-abhängige Seite.
 */
function javaScriptEinschalten() {
  var ohneScript = document.getElementById("ohneJavaScript");
  var mitScript  = document.getElementById("mitJavaScript");

  ohneScript.style.display = "none";
  mitScript .style.display = "block";
}


/* Check on every keyUp-Event ...*/
function entryCheck() {

  var kmh     = document.getElementById("kmhField")  .value;
  var zustand = document.getElementById("zustandBox").checked;

  alertUserOnIllegalEntry(kmh);
  setLabelColors();

  setButtonState(kmh, zustand);
}


function setButtonState(kmh, zustand) {
  var submitButton = document.getElementById("submit");
  var resetButton  = document.getElementById("reset");

  submitButton.disabled = ! isFormSubmitable(kmh);
  resetButton.disabled  = ! isFormResetable (kmh, zustand);
}


/* Alert wrong entries and set label colors. */
function alertUserOnIllegalEntry(kmh)
{ 
  alertWrongEntry(kmh,   "kmh");
}	


/* set colors for all labels */
function setLabelColors() {
  setLabelColor("kmh");
}


/* color a single label according to its value.
 *  See "bremsweg.css". 
 */
function setLabelColor(type) {  
  var cls;
  label = document.getElementById(type + "Label");
  value = document.getElementById(type + "Field").value;
  if("" == value)                   { cls = "empty";    }
  else if(isNumericalValue(value))  { cls = "ok";       }
  else if(isOKWhileEntering(value)) { cls = "entering"; }
  else                              { cls = "illegal";  }
  label.setAttribute("class", "entry_" + cls);
}


/**
 * check, if fields are OK (ready to submit).
 * In our case: check, if exactly two (2) fields are
 * filled in.
 */
function isFormSubmitable(kmh) {
  return isNumericalValue(kmh);
}


/* check, if "txt" is a nonempty number */
function isNumericalValue(txt) {
  return ("" != txt && isFinite(txt));
}


/* A value can be wrong while entering - but should not be
 * alerted. E. g. To enter "-6" you have to enter "-" first,
 * which is not ok.
 */
function isOKWhileEntering(value) {
  return (/^(\+)?[0-9]*(\.[0-9]*)?$/.test(value));
}


/**
 * missedValue ist die falsch eingegebene Zahl.
 * Sollte jemand auf dem Dialog (alert) "ENTER" drücken, so wird wieder ein "onchange"
 * ausgelöst, was zu einem neune alert führen würde.
 */
var missedValue = "";
function alertWrongEntry(value, label) {
  // check Field while entering
  if(! isOKWhileEntering(value)) {
    if(missedValue != value) {
      window.alert(label + " muss eine positive Zahl sein!");
      missedValue = value;
    }
  }
}


/*check, if any of the 3 Fields contains a value
 *       so that "reset" makes sense. */
function isFormResetable(kmh, zustand) {
  return ("" != kmh) || (zustand);
}


/* The calculation takes place */
function submitClick() {
  var kmh     = document.getElementById("kmhField"  ).value;
  var nass    = document.getElementById("zustandBox").checked;

  if(isNumericalValue(kmh)) {
    showResult(kmh, nass);
  }
}


/* Show the result in a given "output" field (id = "ausgabe") */
function showResult(kmh, nass) {
  var resultText;
  resultText = bremsweg(kmh, nass).toFixed(2);
  document.getElementById("ausgabeBremsweg").innerHTML = resultText;

  resultText = anhaltestrecke(kmh, nass).toFixed(2);
  document.getElementById("ausgabeAnhaltestrecke").innerHTML = resultText;

  resultText = bremszeit(kmh, nass).toFixed(1);
  document.getElementById("ausgabeBremszeit").innerHTML = resultText;

  resultText = anhaltezeit(kmh, nass).toFixed(1);
  document.getElementById("ausgabeAnhaltezeit").innerHTML = resultText;

  bildEinschalten(bremszeit(kmh, nass) > 3);
}


function bildEinschalten(sichtbar) {
  var vis = sichtbar ? "block" : "none";
  var cDiv = document.getElementById("crashBild");
  cDiv.style.display = vis;
}


/** Berechnugen **/

var reaktionszeitInSekunden  = 1.44;
var bremsverzoegerungTrocken = 7;
var bremsverzoegerungNass    = 4;

function bremsverzoegerung(nass) {
  return nass ? bremsverzoegerungNass : bremsverzoegerungTrocken;
}

function bremsweg(kmh, nass) {
  var vms = kmh / 3.6; // könnte als Funktion geschrieben werden
  var a   = bremsverzoegerung(nass);
  return vms * vms / 2 / a;
}

function anhaltestrecke(kmh, nass) {
  var vms = kmh / 3.6;
  return bremsweg(kmh, nass) + vms * reaktionszeitInSekunden;
}

function bremszeit(kmh, nass) {
  var vms = kmh / 3.6;
  var a   = bremsverzoegerung(nass);
  return vms / a;
}

function anhaltezeit(kmh, nass) {
  return bremszeit(kmh, nass) + reaktionszeitInSekunden;
}

/***** File: bremsweg.xhtml *******************/

<?xml version='1.0' encoding='utf-8' ?>

<!DOCTYPE html PUBLIC '-//W3C//DTD XHTML 1.0 Strict//EN' 
                      'http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd'>

<html xmlns="http://www.w3.org/1999/xhtml" lang="de">

 <head>
  <title>Bremsweg</title>  
  <meta http-equiv="Content-Type"        content="text/html;charset=utf-8" />
  <meta http-equiv="Content-Style-Type"  content="text/css"        />
  <meta http-equiv="Content-Script-Type" content="text/javascript" />

  <link   rel ="stylesheet"      type="text/css"  href="bremsweg.css"  />

  <script type="text/javascript" src= "bremsweg.js"></script>
 </head>

 <!--   B O D Y -->
 
 <body onload="initialisieren()"> 
  <h1>Bremsweg</h1>

  <!-- Der Browser hat Javascript augeschaltet-->
  <div id="ohneJavaScript" style="display: block;">
   <p>Diese Berechnung läuft in Ihrem Browser und benötigt, dass Sie
    <a href="http://www.paedi.uzh.ch/gastro/ibt/hilfe/js_opt.html">JavaScript einschalten</a>.</p>
  </div>

 <!-- Folgendes wird angezeigt, wenn der Anwender Javascript eingeschaltet hat. -->
  <div id="mitJavaScript" style="display: none;">
   <p>Diese Webseite berechnet den Bremsweg, die gesamte Anhatestrecke, die Bremszeit und 
     die gesamte Anhaltezeit eines Autos bei gegebener Reaktionszeit von einer (1.0) Sekunde.</p>
   <p>Eine Bremsverzögerung von 7.7 m/s<sup>2</sup> wird angenommen. Bei naßer Straße
      verringert sich diese auf 4.0 m/s<sup>2</sup>.</p>
   <p>Die Anhaltestrecke (bzw. -zeit) unterscheidet sich vom Bremsweg (bzw. -zeit)
      lediglich dadurch, dass die Reaktionszeit mit eingerechnet wird.</p>
   <p>Weitere Infos: 
      <a href="http://de.wikipedia.org/wiki/Bremsweg">Bremsweg</a>;
      <a href="http://de.wikipedia.org/wiki/Sicherheitsabstand">Sicherheitsabstand</a>.
   </p>



   <table>
    <tr>
     <td  id="kmhLabel"   class="lbl">Geschwindigkeit in km/h: </td>
     <td><input id="kmhField" type ="text" value="" onchange="submitClick()" onkeyup="entryCheck()"/></td>
    </tr>
    <tr>
     <td  id="zustandLabel" class="lbl">Straßenzustand: </td>
     <td><input id="zustandBox" type="checkbox" value="trocken" onchange="entryCheck(); submitClick();"/>nass</td>
    </tr>
    <tr>
     <td> </td>
     <td>
      <input type="submit" value="Berechnen"  id="submit" onclick="submitClick()" />
      <input type="reset"  value="Rücksetzen" id="reset"  onclick="initialisieren()"/>
     </td>
    </tr>
   </table>


   <h2>Resultate</h2>

   <table>
    <tr><td>reiner Bremsweg</td>       <td style="font-weight: bold;" id="ausgabeBremsweg"/>      <td>[Meter]</td></tr>
    <tr><td>gesamte Anhaltestrecke</td><td style="font-weight: bold;" id="ausgabeAnhaltestrecke"/><td>[Meter]</td></tr>
    <tr><td>reine Bremszeit</td>       <td style="font-weight: bold;" id="ausgabeBremszeit"/>     <td>[Sekunden]</td></tr>
    <tr><td>gesamte Anhaltezeit</td>   <td style="font-weight: bold;" id="ausgabeAnhaltezeit"/>   <td>[Sekunden]</td></tr>
   </table>
  </div>

  <div class="bild" id="crashBild" style="display: none;">
   <p><b>Achtung</b>: 2-3 Sekunden Abstand auf den Vorfahrer reicht bei dieser Geschwindigkeit und bei diesem Straßenzustand nicht mehr!</p><a href="http://www.fireworld.at/cms/story.php?id=16097"><img src="http://www.fireworld.at/cms/images/news/puch08_2903mass7.jpg" alt="Autos prallen zusammen" title="Massenkarambolage"/></a></div>

  <p>Dieses Beispiel zeigt den Einsatz von JavaScript in einem XHTML-File.
     Da <tt>document.write()</tt> nicht eingesetzt werden soll, ist hier eine Möglichkeit 
     mit DOM aufgezeigt.<br />
     Betrachten Sie hierzu den JavaScript Code: <a href="bremsweg.js.html"><tt>bremsweg.js</tt></a>.
  </p>
 </body>
</html>

/*************** File: bremsweg.css *******************/

h1 {
  color: blue;
}

body {
  background-color: #d8d8d8;
}

@media print {
  body {
    font-family : "times new roman", Times, serif;
  }
}

@media screen, handheld {
  body {
    font-family: Verdana, Helvetica, Arial, sans-serif;
  }
}

.bild {
   border-style: none;
   margin: 2mm;
   padding: 2mm;
}


table {
  background-color: #ccc;
  border: solid black 1px;
}

/* Colors for Labels */
.entry_ok {
  color : #0A0;
}
.entry_entering {
  color : #830;
}
.entry_illegal {
  color : #F50;
}
.entry_empty {
  color : #058;
}
                

package ch.santis.modul726.aufgabe5_10;

import java.util.Scanner;

public class Aufgabe5_10 {
	public static void main(String[] args) {
		new Aufgabe5_10().top();
	}

	/*Einstieg */
	void top() {
		
		Scanner sc = new Scanner(System.in);
		
		System.out.println("Wie schnell wird gefahren?[km/h]");
		double urgesch = sc.nextDouble();
		System.out.println("Ist die Strasse nass[1] oder trocken[2]?");
		int urtrocken = sc.nextInt();
		
		double geschms = umrechnen(urgesch);
		
		double bb;
		
		if (urtrocken == 1) {
			double bremsbeschleunigungnass = 4;
			bb = bremsbeschleunigungnass;
		} else {
			double bremsbeschleunigungtrocken = 7;
			bb = bremsbeschleunigungtrocken;
		}
		
		double reaktionszeit = 1.44;
		
		double reaktionsweg = rw(reaktionszeit, geschms);
		
		double bremsweg = bw(geschms, bb);
		
		double anhaltestrecke = anh(reaktionsweg, bremsweg);
		
		System.out.println("Die Anhaltestrecke bei " + urgesch + " km/h liegt bei" + anhaltestrecke + "m");

	}

		double anh(double reaktionsweg, double bremsweg) {
		return (reaktionsweg + bremsweg);
	}

		double bw(double geschms, double bb) {
		return ((geschms * geschms)/(2*bb));
	}

	double rw(double reaktionszeit, double geschms) {
		return (geschms * reaktionszeit);
	}

	double umrechnen(double urgesch) {
		return (urgesch/3.6);
	}
}

                

Lösung von: Luca Schulz (Personalamt Kanton Zürich)

def reaktionsweg( Geschwindigkeit ):
    Reaktionszeit = 1.44
    Reaktionsweg  = Geschwindigkeit * Reaktionszeit
    return Reaktionsweg

def bremsweg( Geschwindigkeit, Fahrbahnbeschaffenheit ):
    if Fahrbahnbeschaffenheit == 'n':
        # Nasse Straße
        Bremsbeschleunigung = 4 
    else:
        # Trockene Straße
        Bremsbeschleunigung = 7 
    Bremsweg = Geschwindigkeit **2  / (2 * Bremsbeschleunigung )
    return Bremsweg

def anhaltestrecke( Geschwindigkeit, Fahrbahnbeschaffenheit ):
    Anhaltestrecke = reaktionsweg( Geschwindigkeit ) + bremsweg( Geschwindigkeit, Fahrbahnbeschaffenheit )
    return Anhaltestrecke

def geschwindigkeitInMeterProSekunde( Geschwindigkeit_km ):
    Geschwindigkeit = Geschwindigkeit_km / 3.6
    return Geschwindigkeit

print('   ============   Bremswegberechnung   ============')
Geschwindigkeit_km = float(input('Geschwindigkeit in km/h eingeben: '))
Geschwindigkeit = geschwindigkeitInMeterProSekunde(Geschwindigkeit_km)

Fahrbahnbeschaffenheit = str(input('Fahrbahnbeschaffenheit ist t für trocken, n für nass: '))


print('\nDer Bremsweg beträgt:', round( anhaltestrecke( Geschwindigkeit, Fahrbahnbeschaffenheit ), 2), 'm')

                

Lösung von: Alex Groeg (Freies Lernen)

function totalStoppingDistance(speedKmph, opts) {
  opts = opts || {};
  // geschwindigkeit
  let speed = speedKmph / 3.6;                                    // meter pro sekunde

  //---------------------------------------------------------- bremsverzögerung (m/s²)
  // 1: eis
  // 2: schnee
  // 5-7: nasse straße
  // 8-9: trockene straße
  let brakeRetardation = opts.brakeRetardation || 7;

  //------------------------------------------------------------------------- gefälle
  // --------------------------------------------------------------------- zusatzlast
  // TODO

  //-------------------------------------------------------------- erkennungszeit (s)
  let t_realise = opts.t_realise || 0.1,                    // erkennen der situation
      t_reaction = opts.t_reaction || 1.44,                              // reagieren
      t_tripping = opts.t_tripping || 0.3,                 // ansprechzeit der bremse
      t_braking = speed / 2 * brakeRetardation;                          // bremszeit

  //-------------------------------------------------------------------- strecken (m)
  let d_reaction = speed * (t_realise + t_reaction + t_tripping), // ungebremster weg
      d_braking = speed ** 2 / (2 * brakeRetardation);                    // bremsweg

  return (d_reaction + d_braking).toFixed(2);
}

/************************************************\
| ein paar ausgaben mit verschiedenen parametern |
\************************************************/

// übernahme der deafaultwerte
console.log(totalStoppingDistance(50));

// defaultwerte, auf eis
console.log(totalStoppingDistance(50, {
  brakeRetardation: 1
}));

// defaultwerte, auf eis, fahrer betrunken
console.log(totalStoppingDistance(50, {
    brakeRetardation: 1,
    t_realise: 2,
}));

// defaultwerte, auf eis, fahrer betrunken und mit dem handy beschäftigt
console.log(totalStoppingDistance(50, {
  brakeRetardation: 1,
  t_realise: 0.6,
  t_reaction: 4.1
}));

// defaultwerte, auf eis, fahrer betrunken, mit dem handy beschäftigt,
// irgendwas ist mit den bremsen
console.log(totalStoppingDistance(50, {
  brakeRetardation: 1,
  t_realise: 0.6,
  t_reaction: 3.8,
  t_tripping: 1.2
}));                                                         // lissalanda@gmx.at

                

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

// NET 6.x | C# 10.x | VS-2022

Console.WriteLine(new DrivingSchool(75, BBT.nass, RVT.handy));

public class DrivingSchool {
    private readonly BBT _bremsbeschleunigung_ms2;
    private readonly RVT _reaktionsverminderung;
    
    public DrivingSchool(double geschwindigkeit_kmh, BBT bremsbeschleunigung_ms2, RVT reaktionsverminderung = RVT.keine) {
        
        Geschwindigkeit_kmh = geschwindigkeit_kmh;
        _bremsbeschleunigung_ms2 = bremsbeschleunigung_ms2;
        _reaktionsverminderung = reaktionsverminderung;
    }

    public double Geschwindigkeit_kmh { get; private set; }
    public double Geschwindigkeit_ms => Math.Round(Geschwindigkeit_kmh / 3.6, 2);
    public double Reaktionszeit_s => Math.Round(1.44 * (1 + ((int)_reaktionsverminderung / 10.0)), 2);
    public double Reaktionsweg_m => Math.Round(Geschwindigkeit_ms * Reaktionszeit_s, 2);
    public double Bremsweg_m => Math.Round(Math.Pow(Geschwindigkeit_ms, 2) / (2 * Bremsbeschleunigung_ms2), 2);
    public double Anhaltestrecke => Math.Round(Reaktionsweg_m + Bremsweg_m, 2);
    public int Bremsbeschleunigung_ms2  => (int)_bremsbeschleunigung_ms2; 
    public double Bremszeit_s => Math.Round(Geschwindigkeit_ms / Bremsbeschleunigung_ms2, 2);

    public override string ToString() =>
        $"Geschwindigkeit in m/s: {Geschwindigkeit_ms}\n" +
        $"Bremsbeschleunigung in m/s2: {Bremsbeschleunigung_ms2}\n" +
        $"Reaktionszeit in s: {Reaktionszeit_s}\n" +
        $"Reaktionsweg in m: {Reaktionsweg_m} \n" +
        $"Bremsweg in m: {Bremsweg_m} \n" +
        $"Anhaltestrecke in m: {Anhaltestrecke} \n" +
        $"Bremszeit in s: {Bremszeit_s} \n";
}
public enum BBT { eis = 1, schnee = 2, nass = 4, trocken = 7 } // Bremsbeschleunigung Typ
public enum RVT { keine, muede = 3, handy, alkohol } // Reaktionsverminderung Typ
                

Lösung von: Jens Kelm (@JKooP)

// C++ 20 | VS-2022
#include <iostream>
#include <format> // C++ 20!

enum class Bremsbeschleunigung_Typ {
    eis_ = 1, schnee, nass = 4, trocken = 7
};

enum class Reaktionsverminderung_Typ {
    keine, muede = 3, handy, alkohol
};

using BBT = Bremsbeschleunigung_Typ;
using RVT = Reaktionsverminderung_Typ;

class Fahrschule {
    const double geschwindigkeit_kmh_;
    const BBT bremsbeschleunigung_ms2_;
    const RVT reaktionsverminderung_;
public:
    Fahrschule(double geschwindigkeit_kmh, BBT bremsbeschleunigung_ms2 = BBT::trocken, RVT reaktionsverminderung = RVT::keine):
        geschwindigkeit_kmh_{geschwindigkeit_kmh},
        bremsbeschleunigung_ms2_{bremsbeschleunigung_ms2},
        reaktionsverminderung_{reaktionsverminderung}{}
    Fahrschule() = delete;
    Fahrschule& operator=(const Fahrschule) = delete;

    const double get_bremsbeschleunigung_ms2() const noexcept;
    const double get_geschwindigkeit_kmh() const noexcept;
    const double get_geschwindigkeit_ms() const noexcept;
    const double get_reaktionszeit_s() const noexcept;
    const double get_reaktionsweg_m() const noexcept;
    const double get_bremsweg_m() const noexcept;
    const double get_anhaltestrecke_m() const noexcept;
    const double get_bremszeit_s() const noexcept;
    friend std::ostream& operator << (std::ostream&, Fahrschule);
};

const double Fahrschule::get_bremsbeschleunigung_ms2() const noexcept {
    return (int)bremsbeschleunigung_ms2_;
}

const double Fahrschule::get_geschwindigkeit_kmh() const noexcept {
    return geschwindigkeit_kmh_;
}

const double Fahrschule::get_geschwindigkeit_ms() const noexcept {
    return get_geschwindigkeit_kmh() / 3.6;
}

const double Fahrschule::get_reaktionszeit_s() const noexcept {
    return 1.44 * (1 + ((int)reaktionsverminderung_ / 10.0)); 
}

const double Fahrschule::get_reaktionsweg_m() const noexcept {
    return get_geschwindigkeit_ms() * get_reaktionszeit_s();
}

const double Fahrschule::get_bremsweg_m() const noexcept {
    return pow(get_geschwindigkeit_ms(), 2) / (2 * get_bremsbeschleunigung_ms2());
}

const double Fahrschule::get_anhaltestrecke_m() const noexcept {
    return get_reaktionsweg_m() + get_bremsweg_m();
}

const double Fahrschule::get_bremszeit_s() const noexcept {
    return get_geschwindigkeit_ms() / get_bremsbeschleunigung_ms2();
}

std::ostream& operator<<(std::ostream& os, Fahrschule fs) {
    os << std::format("Geschwindigkeit:     {:.1f} m/s\n",   fs.get_geschwindigkeit_ms());
    os << std::format("Bremsbeschleunigung: {:.1f} m/s*s\n", fs.get_bremsbeschleunigung_ms2());
    os << std::format("Reaktionszeit:       {:.1f} s\n",     fs.get_reaktionszeit_s());
    os << std::format("Reaktionsweg:        {:.2f} m\n",     fs.get_reaktionsweg_m());
    os << std::format("Bremsweg:            {:.2f} m\n",     fs.get_bremsweg_m());
    os << std::format("Anhaltestrecke:      {:.2f} m\n",     fs.get_anhaltestrecke_m());
    os << std::format("Bremszeit:           {:.1f} s\n\n",   fs.get_bremszeit_s());
    return os;
}

int main() {
    Fahrschule fs_1{ 75, BBT::nass, RVT::handy };
    Fahrschule fs_2{ 100 };
    std::cout << fs_1;
    std::cout << fs_2;
}
                

Lösung von: Jens Kelm (@JKooP)