Buch Cover Buch Cover Buch Cover Buch Cover

Web-Code: - Webcode Help

Bremsweg (Unterprogramme)

Berechnen Sie die Anhaltestrecke eines Autos bei gegebener Geschwindigkeit [km/h] für trockene bzw. nasse Straße. In eckigen Klammern stehen die Maßeinheiten, die jedoch für die Programmierung nicht von Bedeutung sind. Für die Anhaltestrecke gelten folgende Gleichungen:

  • Die Geschwindigkeit [km/h] kann vom Anwender eingegeben werden.
  • Geschwindigkeit [m/s] = Geschwindigkeit [km/h] / 3.6

    (z. B. 72 [km/h] = 20 [m/s])

  • Die Bremsbeschleunigung (auch Bremsverzögerung genannt) wird in Metern pro Quadratsekunden gemessen.
    Trockene Straße:  Bremsbeschleunigung = 7 [m/s2].
    Nasse Straße: Bremsbeschleunigung = 4 [m/s2].
    Wer das Programm benutzt, kann dabei "t" für die trockene bzw. "n" für die nasse Straße eingeben.
  • Reaktionszeit [s] = 1.44
  • Reaktionsweg [m] = Geschwindigkeit [m/s] * Reaktionszeit [s]
  • Bremsweg [m] = Geschwindigkeit2 [(m/s)2] / (2 * Bremsbeschleunigung [m/s2])
  • Anhaltestrecke [m] = Reaktionsweg [m] + Bremsweg [m]

Programmieren Sie möglichst viele der benötigten Größen als Funktionen mit sinnvollen Eingabeparametern. Beispiele:

  • reaktionsweg()
  • bremsweg()
  • anhaltestrecke()
  • geschwindigkeitInMeterProSekunde()

Zusatzaufgabe (Auffahrunfall): Wie viel Abstand (in Metern und in Sekunden) zum vor ihm fahrenden Wagen muss ein Fahrer einhalten, um einen Auffahrunfall zu vermeiden, falls der vor ihm Fahrende augenblicklich stillsteht?

Dazu ist zusätzlich die Bremszeit zu berechnen:

  • Bremszeit [s] = Geschwindigkeit [m/s] / Bremsbeschleunigung [m/s2]

0 Kommentare

Bitte melde dich an um einen Kommentar abzugeben

6 Lösung(en)

/* 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)

Verifikation/Checksumme:

50 km/h (trockene Straße) -> 33.78m

30 km/h (nasse Straße) -> 20.68m

Aktionen

Bewertung

Durchschnittliche Bewertung:

Eigene Bewertung:
Bitte zuerst anmelden

Meta

Zeit: 1
Schwierigkeit: k.A.
Webcode: dh44-7qtd
Autor: Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)

Download PDF

Download ZIP

Zu Aufgabenblatt hinzufügen