Buch Cover Buch Cover Buch Cover Buch Cover

Web-Code: - Webcode Help

Intervall-Training (Algorithmen)

Zwei Laufsportler (Peter und Paul) treffen sich im örtlichen Sportzentrum, um auf der 400-Meter-Bahn ein Intervall-Training zu absolvieren. Dabei rennt Peter im Uhrzeigersinn, Paul jedoch im Gegenuhrzeigersinn.

Damit die Aufgabe nun nicht all zu kompliziert wird, nehmen wir einfach an, dass die Runde für beide Läufer exakt 400 Meter ist (auch wenn dies in der Realität wohl nicht ganz möglich ist).

Würden Peter und Paul nun exakt gleich schnell laufen, würden sie sich also pro Runde exakt zweimal treffen. Einmal nach 200 und einmal nach 400 Meter. Die beiden möchten ja aber ein Intervalltraining absolvieren - und dass hier ist der Plan:

  • Einer der beiden läuft "langsam" und der andere "schnell"
  • Immer wenn sie sich das zweite Mal begegnet sind, wechseln sie (der "Schnelle" läuft dann "langsam" und der "Langsame" läuft dann "schnell")

Als Tempo legen sie folgendes fest:

  • Schnell = Pace 4m30s (4 Minuten 30 Sekunden pro Kilometer)
  • Langsam = Pace 5m30s (5 Minuten 30 Sekunden pro Kilometer)

Die beiden fragen sich nun:

  1. Wie weit ist die jeweilige Intervall-Einheit und wie lange dauert diese?
  2. Wie würden sich die Daten ändern, wenn sie ein anderes Tempo wählen würden (bsp. 5m00s und 6m00s)?
  3. Wie würden sich die Daten ändern, wenn sie den Tempowechsel erst nach 3 Begegnungen vornehmen würden?

Bonus-Frage:

  1. Wenn Peter mit einer Pace 4m30s läuft und Paul nach exakt 1 Minute treffen will (nach n Begegnungen), welches Tempo müsste dann Paul anschlagen

3 Kommentare

Bitte melde dich an um einen Kommentar abzugeben

Kommentare (3)

ValentinMarolf 18. Oktober 2017 20:37   reply report
Mit Einheit ist der jeweilige Intervall-Teil gemeint, also der Teil zwischen den jeweiligen Wechseln
ValentinMarolf 18. Oktober 2017 20:36   reply report
Pace 4.30 ist eine im Sportbereich übliche Notation für Zeitangaben im Format m.ss, wenn keine Milisekunden vorhanden sind (hh:mm.ss). Sind also 4 Minuten 30 Sekunden
Linus 17. Oktober 2017 19:48   reply report
Wie weit ist die jeweilige Einheit und wie lange dauert diese?
Könntest du diese Frage genauer beschreiben? Was bedeutet hier Einheit? Wer ist zuerst der schnelle und wer der langsame? Und müssten nicht 4 Minuten 30 Sekunden = 4,5 Minuten sein? Da steht 4,3.

4 Lösung(en)

REPORT INTERVALL-TRAINING.

*************************************************************************************************
*Eingabemaske
*************************************************************************************************

SELECTION-SCREEN: BEGIN OF BLOCK b1.
    PARAMETERS: rb_01 RADIOBUTTON GROUP r1.

    PARAMETERS: rb_02 RADIOBUTTON GROUP r1.

    PARAMETERS: rb_03 RADIOBUTTON GROUP r1.

    PARAMETERS: lv_spee1 TYPE p DECIMALS 2.

    PARAMETERS: lv_spee2 TYPE p DECIMALS 2.
SELECTION-SCREEN: END   OF BLOCK b1.



*************************************************************************************************
*Typisierungen
*************************************************************************************************

DATA: lv_runde              TYPE int4,              "Gibt Rundenlänge an (in m)
      lv_km                 TYPE int4,              "Länge eines KM (in m)
      lv_rz1                TYPE p DECIMALS 2,      "Rundenzeit 1
      lv_rz2                TYPE p DECIMALS 2,      "Rundenzeit 2
      lv_spee1s             TYPE int4,              "Geschwindigkeit 1 ( in s )
      lv_spee1sa            TYPE p DECIMALS 2,      "Geschwindigkeit 1 ( in s ) !!Arbeitswert
      lv_spee2s             TYPE int4,              "Geschwindigkeit 2 ( in s )
      lv_spee2sa            TYPE p DECIMALS 2,      "Geschwindigkeit 2 ( in s ) !!Arbeitswert
      lv_begegnungen        TYPE int4,              "Anzahl der Begegnungen
      lv_gefbeg             TYPE int4,              "Anzahl der geforderten Begegnungen
      lv_strecke            TYPE p DECIMALS 2,      "Gibt zurückgelegte Strecke an
      lv_sekunden           TYPE int4,              "Gibt die benötigten Sekunden an
      lv_mps1               TYPE p DECIMALS 2,      "Meter pro Sekunde 1
      lv_mps2               TYPE p DECIMALS 2,      "Meter pro Sekunde 2
      lv_zgs1               TYPE p DECIMALS 2,      "Gibt zurückgelegte Strecke von A an
      lv_zgs1a              TYPE p DECIMALS 2,      "Zurückgelegte Strecke A  !! Arbeitswert
      lv_zgs2               TYPE p DECIMALS 2,      "Gibt zurückgelegte Strecke von B an
      lv_zgs2a              TYPE p DECIMALS 2.      "Zurückgelegte Strecke A  !! Arbeitswert



*************************************************************************************************
*Wertzuweisungen
*************************************************************************************************

lv_km             = 1000.
lv_runde          = 400.



*************************************************************************************************
*Prüfung, welche Aufgabe hat der Anwender gewählt?
*************************************************************************************************

IF rb_01 IS NOT INITIAL.

    lv_gefbeg  = 2.
    lv_spee1   = '4.50'.
    lv_spee2   = '5.50'.

ENDIF.

IF rb_02 IS NOT INITIAL.

    lv_gefbeg  = 2.

ENDIF.

IF rb_03 IS NOT INITIAL.

    lv_gefbeg  = 3.
    lv_spee1   = '4.50'.
    lv_spee2   = '5.50'.

ENDIF.


*************************************************************************************************
*Prüfung, ob Anwender Geschwindigkeiten ausgefüllt hat, wenn Aufg2 2 gewählt ist.
*************************************************************************************************

IF rb_02 IS NOT INITIAL.


    IF lv_spee1 IS INITIAL.

        MESSAGE 'Bitte tragen Sie eine Geschwindigkeit ein.' TYPE 'E'.

    ENDIF.


    IF lv_spee2 IS INITIAL.

        MESSAGE 'Bitte tragen Sie eine Geschwindigkeit ein.' TYPE 'E'.

    ENDIF.


ENDIF.



*************************************************************************************************
*Umrechnung der gegebenen Zeiten in Sekunden
*************************************************************************************************

lv_spee1s  = TRUNC( lv_spee1 ) * 60.        "Umrechung von Geschwindigkeit 1 in Sekunden
lv_spee1sa = FRAC( lv_spee1 )  * 60.
lv_spee1s  = lv_spee1s + lv_spee1sa.

lv_spee2s  = TRUNC( lv_spee2 ) * 60.        "Umrechung von Geschwindigkeit 2 in Sekunden
lv_spee2sa = FRAC( lv_spee2 )  * 60.
lv_spee2s  = lv_spee2s + lv_spee2sa.



*************************************************************************************************
*Berechnung der Meter pro Sekunde (MpS)
*************************************************************************************************

lv_mps1 = lv_km / lv_spee1s.

lv_mps2 = lv_km / lv_spee2s.



*************************************************************************************************
*Berechnung der zurückgelegten Strecke und Prüfung, ob ein Treffen stattfindet.
*************************************************************************************************

WHILE lv_begegnungen <> lv_gefbeg.

    lv_zgs1a     = lv_zgs1a + lv_mps1.
    lv_zgs2a     = lv_zgs2a + lv_mps2.
    lv_strecke   = lv_zgs1a + lv_zgs2a.
    lv_sekunden  = lv_sekunden + 1.

    IF lv_strecke >= lv_runde.

        lv_begegnungen = lv_begegnungen + 1.
        lv_strecke     = lv_strecke - lv_runde.

        lv_zgs1  = lv_zgs1 + lv_zgs1a.
        lv_zgs2  = lv_zgs2 + lv_zgs2a.
        lv_zgs1a = 0.
        lv_zgs2a = 0.

    ENDIF.

ENDWHILE.

WRITE:/ 'Nach ', lv_sekunden, ' Sekunden treffen sich die Beiden zum ' , lv_begegnungen, '  Mal.'.
NEW-LINE.
WRITE:/ 'Zurückgelegte Distanz:'.
NEW-LINE.
WRITE:/ 'A :', lv_zgs1.
NEW-LINE.
WRITE:/ 'B :', lv_zgs2.

Lösung von: Name nicht veröffentlicht

round_length = 400  # Meter

meetings_per_change = 2  # Alle x Begegungen wird das Tempo gewechselt

pace_fast = [4, 30]  # Schema: [Minuten, Sekunden]
pace_slow = [5, 30]

t_fast = pace_fast[0] * 60 + pace_fast[1]  # Umrechnen in Sekunden
t_slow = pace_slow[0] * 60 + pace_slow[1]

v_fast = 1000 / t_fast  # Umrechnen in Meter pro Sekunde
v_slow = 1000 / t_slow


'''
Zu loesende Gleichung:

Folgende Bedingung muss fuer das 1. Treffen erfuellt sein:
t * v_fast = round_length - (t * v_slow)   | + (t*v_slow)
t * (v_fast + v_slow) = round_length       | : (v_*)
t = round_length / (v_fast + v_slow)

t ist die Zeit, nach der sich beide Laeufer das erste Mal treffen.

=> t * meetings_per_change = t_change
'''

t_change = ((round_length / (v_fast + v_slow)) * meetings_per_change)

s_fast = t_change * v_fast
s_slow = t_change * v_slow


# Ausgabe:
print(('Gegeben: Rundenlaenge {0} Meter, schneller Pace {1}:{2}, ' +
     'langsamer Pace {3}:{4}, Wechsel nach {5} Begegnungen.')
     .format(round_length, pace_fast[0], pace_fast[1],
     pace_slow[0], pace_fast[1], meetings_per_change))

print(('\nEin Intervall dauert {:0.2f} Sekunden, das sind ' +
     '{:d} Minute(n) und {:0.2f} Sekunden.')
     .format(t_change, int(t_change // 60), (t_change % 60)))

print(('Der schnellere Laeufer laeuft {:0.2f} Meter' +
     ', der langsamere {:0.2f} Meter.')
     .format(s_fast, s_slow))


'''
Ein Loesen der Bonusaufgabe ist nach Umstellen der obigen Gleichung moeglich.
'''

Lösung von: Name nicht veröffentlicht

# -*- coding:utf-8 -*-
import math

bahn = 0.4 #km
treffenBisWechsel = 2
schnellInput = 4.5 #pace = 4 min 30 sek pro Kilometer
langsamInput = 5.5

schnell = schnellInput*60
langsam = langsamInput*60

#pacesAdded = 3600/(3600/langsam + 3600/schnell) -> Gleichung
pacesAdded = (langsam*schnell)/(langsam+schnell) # Sekunden pro Kilometer
sek = pacesAdded*bahn*treffenBisWechsel

print ("Dauer in Sekunden:", round(sek,3))
print ("Der Schnellere legt", round(sek/schnell*1000,3), "Meter zurück.")
print ("Der Langsamere legt", round(sek/langsam*1000,3), "Meter zurück.")

treffenNach = 60 #sek
n = 1 #Treffen sich bei Begegnung n
peterPace = 4.5*60 #sek/km

peterDistanz = treffenNach/peterPace #km
paulDistanz = bahn*n-(peterDistanz%bahn)
paulPace = 1/paulDistanz*treffenNach

print ("In der Bonusaufgabe läuft Paul mit einer Pace von", round(paulPace,3), "Sekunden.")

Lösung von: Tim Rieder (KSWE)

def PaceToV(ms):			# Umrechnung der Pace in m/s // Angabe der Pace als dezimale Zeit
	m = int(ms)				# dezimale Minuten 
	s = (ms-int(ms))*60 		
	v = 1000 / (60*m + s)
	return v

def TreffZeit(p1,p2,dx):	# Berechnung der Zeit bis zu erstem Treffen bei gegebener Pace und Strecke in sec
	v1 = PaceToV(p1)
	v2 = PaceToV(p2)
	t = dx/(v1+v2)
	return t
	
def WegbisnTreffen (p1, p2, dx, n): 	# Berechnung des zurückgelegten Weges bis zum n-ten Treffen
	t = n * TreffZeit(p1, p2, dx)		# Zeit bis zum n-ten Treffen
	x1 = PaceToV(p1)*t					# jeweils zurückgelegte Wege
	x2 = PaceToV(p2)*t
	return x1, x2
	
def Intervalltraining (p1, p2, dx, n):
	print ("Streckenlänge:", dx,"m")
	print ("Treffen bis zum Wechsel:", n, "m")
	print ("Zeit bis zum Wechsel", round(TreffZeit(p1, p2, dx)*n,2), "s")
	print ("Gelaufene Meter mit p1", int(WegbisnTreffen(p1, p2, dx, n)[0]), "m")
	print ("Gelaufene Meter mit p1", int(WegbisnTreffen(p1, p2, dx, n)[1]), "m")

Lösung von: Name nicht veröffentlicht

Verifikation/Checksumme:

Faktoren:

  • Tempo Peter: 4m30s
  • Tenpo Paul: 5m30s
  • Wechsel nach 2 Begegnungen

Auswertung einer einzelnen Intervall-Einheit:

  • Peter ist 360 Meter mit einer Pace von 4m30s gelaufen
  • Paul ist 440 Meter mit einer Pace von 5m30s gelaufen
  • Dauer: 1 Minute 58.8 Sekunden

Aktionen

Bewertung

Durchschnittliche Bewertung:

Eigene Bewertung:
Bitte zuerst anmelden

Meta

Zeit: 1.5
Schwierigkeit: Mittel
Webcode: i5xk-ey82
Autor: Valentin Marolf (AXA)

Zu Aufgabenblatt hinzufügen