Programmieren lernen

package ch.programmieraufgaben.simulation.glasen;


/**
 * Programmieraufgabe Schiffsglocke Code: jwpg-qcth
 * @version 0.1 (Aug 14, 2016)
 * @author Philipp Gressly Freimann 
 *         (philipp.gressly@santis.ch)
 */
public class Glasen {

	static final int ORTSZEIT = 2; // Mitteleuropäische Sommerzeit.

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


	void top() {
		int glasen = getGlasen();
		ausgabe(glasen);
	}


	int getGlasen() {
		double stunde = getStundeImTag();
		stunde = stunde + ORTSZEIT;
		int glase  = (int ) (2 * (stunde % 4.0));
		return glase;
	}


	/**
	 * Systemzeit, nicht ortzseit. 
	 * Für die Ortszeit muss die Zeitzone und 
	 * allfällige Sommerzeit noch hinzugefügt werden.
	 * Bsp: Mitteleuropa Sommerzeit  + 2; 

	 * @return Systemzeit in Stunden im aktuellen Tag.
	 */
	double getStundeImTag() {
		// Achtung: Dies ist die Systemzeit, nicht 
		// die umgerechnete Ortszeit!
		long millis       = System.currentTimeMillis();
		long millisImTag  = millis % (24L*60*60*1000);
		long secsImTag    = millisImTag  / 1000  ;
		long minutesImTag = secsImTag    /   60  ;
		double stunde     = minutesImTag /   60.0;
		return stunde;
	}


	void ausgabe(int glasen) {
		if(0 == glasen) {
			glasen = 8; // start == ende
		}
		while(glasen >= 2) {
			System.out.print("..");
			System.out.print(" ");
			glasen = glasen - 2;
		}
		if(1 == glasen) { // ungerade
			System.out.print(".");
		}
	}

} // end of class Glasen
                

Lösung von: Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)

/*----------------------------------------------------------------------------\*
| • Ausgabe akustisch über soundkarte und als text in der konsole
|   (dingding ding)
| • Anzeige des namens der aktuellen wache
| • Glasen nach ortszeit
| • keine extrafunktionen (erstmal)
\*----------------------------------------------------------------------------*/

var watches = [
      "Hundswache",
      "Morgenwache",
      "Vormittagswache",
      "Nachmittagswache",
      "Plattfußwache",
      "Abendwache"
    ],
    now = new Date();

// aktuelle wache anzeigen und
// auf die nächste volle halbstunde warten
(function() {
  var next = new Date();
  showWatch();
  if (next.getMinutes() <= 30) next.setMinutes(30);
  else {
    next.setMinutes(0);
    next.setHours(now.getHours() + 1);
  }
  setTimeout(strike, next - now);
})();

// Ausgabe der aktuellen wache
function showWatch() {
  console.log(watches[Math.floor(now.getHours() / 4)] +
    " (" + getBells() + ")");
}

// Bestimmung der aktuellen schläge
function getBells() {
  var bellTime = new Date(),
      hrs = bellTime.getHours() % 4,
      min = Math.floor(bellTime.getMinutes() / 30);
  if (hrs == 0 && min == 0) return 8;
  return hrs * 2 + min;
}

// Glasen
function strike() {
  var bells = getBells();
  console.clear();
  showWatch();
  soundBell(bells); consoleBell(bells);
  setTimeout(strike, 30 * 60 * 1000);
}

// glasen über soundkarte:
// abspielen einer mp3-datei (beispielsweise)
function soundBell(num) {
  var pause = 1700,
      i = 0;
  function ring() { new Audio("bell.mp3").play(); }   // einzelschlag
  function doubleRing() {                             // doppelschlag
    ring();
    setTimeout(ring, 400);
  }
  while (num > 1) {
    pause *= ++i;
    setTimeout(doubleRing, pause);
    num -= 2;
  }
  if (num == 1) setTimeout(ring, pause * i);
}

// glasen über die konsole
function consoleBell(num) {
  var msg = "";
  while (num > 1) {
    msg += "dingding ";
    num -= 2;
  }
  if (num == 1) msg += "ding";
  console.log(msg);
}                                                          // lissalanda@gmx.at

                

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

import time

Wachen = ['Morgenwache', 'Vormittagswache', 'Nachmittagswache', 'Plattfußwache', 'Abendwache', 'Hundswache'] 

def schiffsglocke( g ):
    schlag = ''
    i = 1
    while i <= g:            
        # jede halbe Stunde ein Schlag
        schlag = schlag + '•' 
        # nach jedem zweitem Schlag eine Pause
        if i % 2 == 0:
            schlag = schlag + ' ' 
        i += 1
    return  schlag

def glasen( m ):
    w = m // 240 + 1
    g = m // 30
    m = m - 30 * g
    while g > 8:
        g = g - 8
    # erst nach einer Minute nächste Wache anzeigen
    if g == 8 and m >= 1:
        g = 0
    if w >= 6: 
        w = 6
    print( '{0}. {1},  {2} Glasen,  {3} Rest-Minuten'.format( w, Wachen[w-1], g, m ) )
    return  g    
    
def zeit_in_minuten( ):    
    t = time.localtime( )
    h = t[3]
    m = t[4]
    return  h * 60 + m


# jede Minute aufrufen, Endlosschleife
run = True
while run == True:
    print( schiffsglocke( glasen( zeit_in_minuten( ) ) ) )
    time.sleep( 60 ) # Sekunden
                

Lösung von: Alex Groeg (Freies Lernen)

// NET 7.x | C# 11.x | VS-2022

/*Zur besseren Darstellung wird auf die
  Nutzung der reellen Uhrzeit verzichtet
  und die Startzeit auf 0:00 Uhr gesetzt*/

var watches = new List<string> {
    "Hundswache",
    "Morgenwache",
    "Vormittagswache",
    "Nachmittagswache",
    "Plattfusswache",
    "Abendwache"
};

var time = new TimeOnly(0,0,0); // C# 10.x (NET 6.x)

// Simulieren der Uhr (48 Halbstunden)
for (var i = 0; i < 48; i++) {
    var hrs = time.Hour;
    var min = time.Minute;
    var full = hrs % 4;
    var half = min == 30 ? 1 : 0;

    if (full== 0 && min == 30) full = 0;
    else if (full == 0) full = 4;

    Console.Write(
        $"{time.ToShortTimeString()} - " + // 03:30
        $"{watches[(int)(hrs / 4.0)]}\t" + // Hundswache
        $"{string.Concat(Enumerable.Repeat(".. ", full))}" + // .. .. ..
        $"{new string('.', half)}\n"); // .

    Thread.Sleep(1000);
    time = time.AddHours(0.5);
}
                

Lösung von: Jens Kelm (@JKooP)

// C++ 20 | VS-2022
#include <iostream>
#include <vector>
#include <format>
#include <sstream>
#include <thread>

struct time_hm {
    size_t hour, minute;
};

std::vector<std::string>watches{
    "Hundswache",
    "Morgenwache",
    "Vormittagswache",
    "Nachmittagswache",
    "Plattfusswache",
    "Abendwache"
};

inline const std::string repeat(const std::string& input_, const size_t& num_) {
    std::ostringstream os;
    std::fill_n(std::ostream_iterator<std::string>(os), num_, input_);
    return os.str();
}

inline const time_hm add_minutes(const time_hm& time_, const size_t& min_) {
    const auto& [h, m] = time_; // C++ 20!
    const auto m_out{ m + min_ > 59 ? (m + min_) % 60 : m + min_ };
    const auto h_tmp{ h + (m + min_) / 60 };
    auto h_out{ h_tmp > 24 ? h_tmp - 24 : h_tmp };
    if (h_out == 24 && m_out > 0) h_out = 0;
    return { h_out, m_out };
}

inline const auto bell_rings() {
    time_hm time{ 0,0 };

    for (size_t i{ 0 }; i < 48; ++i) {
        const auto& [h, m] = time; // C++ 20!
        auto full{ h % 4 };
        const auto half{ m == 30 ? 1 : 0 };
        if (full == 0 && m == 30) full = 0;
        else if (full == 0) full = 4;

        std::cout << std::format("{:02}:{:02} - {} {}{}\n", // C++ 20!
            h, m, // 03:30
            watches[size_t(h / 4.0)], // Hundswache
            repeat(".. ", full), // .. .. ..
            half ? "." : ""); // .
        
        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
        time = add_minutes(time, 30);
    }
}

int main() {
    bell_rings();
}
                

Lösung von: Jens Kelm (@JKooP)