Programmieren lernen

/**
 * @author Philipp Gressly (phi AT gressly DOT ch)
 */
public class Waschautomat {

    /**
     * Berechne das Retourgeld (in einzelnenMünzen in Cent). Es wird eine
     * minimale Fehlerbehandlung durchgeführt, falls das Retourgeld nicht
     * möglich ist. Die "vorhandenenMuenzenInCent" sind nach dieser Methode
     * unverändert! Es wird erwartet, dass der Aufrufende die Fehlerbehandlung,
     * wie auch das aktualisieren der "vorhandeneMuenzenInCent" durchführt.
     * 
     * @param vorhandeneMuenzenInCent
     *            im Automat
     * @param waschPreisInCent
     *            einzugebender Betrag
     * @param eingeworfeneMuenzenInCent
     * @return Array mit dem Retourgeld.
     */
    int[] wechselgeldInCent(int[] vorhandeneMuenzenInCent,
            int waschPreisInCent, int[] eingeworfeneMuenzenInCent) {
        int[] neuVorhandeneMuenzenInCent = vorhandeneUmEingeworfeneErgaenzen(
                vorhandeneMuenzenInCent, eingeworfeneMuenzenInCent);
        int retourGeldbetrag = +betrag(eingeworfeneMuenzenInCent)
                - waschPreisInCent;
        if (0 == retourGeldbetrag) {
            System.out.println("Betrag geht auf -> Kein Rückgeld nötig.");
            return null;
        }

        if (0 > retourGeldbetrag) {
            System.out.println("Zu wenig eingeworfen. Bitte "
                    + (-retourGeldbetrag) + " nachzahlen.");
            return null;
        }

        int[] retourGeldMuenzen = betragUmMuenzen(retourGeldbetrag,
                neuVorhandeneMuenzenInCent);
        return retourGeldMuenzen;
    }

    int[] vorhandeneUmEingeworfeneErgaenzen(int[] vorhandeneMuenzenInCent,
            int[] eingeworfeneMuenzenInCent) {
        int[] total = new int[vorhandeneMuenzenInCent.length
                + eingeworfeneMuenzenInCent.length];
        int pos = 0;
        while (pos < vorhandeneMuenzenInCent.length) {
            total[pos] = vorhandeneMuenzenInCent[pos];
            pos = pos + 1;
        }
        int shift = pos;
        pos = 0;
        while (pos < eingeworfeneMuenzenInCent.length) {
            total[shift + pos] = eingeworfeneMuenzenInCent[pos];
            pos = pos + 1;
        }
        return total;
    }

    /**
     * Erzeuge ein Array mit allen Münzen, die nötig sind, um den "betrag" zu
     * bekommen.
     */
    int[] betragUmMuenzen(int betrag, int[] neuVorhandeneMuenzenInCent) {
        List<Integer> muenzen = new ArrayList<Integer>();
        Arrays.sort(neuVorhandeneMuenzenInCent);
        int z = neuVorhandeneMuenzenInCent.length - 1;

        while (z >= 0 && betrag > 0) {
            while (z >= 0 && betrag >= neuVorhandeneMuenzenInCent[z]) {
                muenzen.add(neuVorhandeneMuenzenInCent[z]);
                betrag = betrag - neuVorhandeneMuenzenInCent[z];
                neuVorhandeneMuenzenInCent[z] = 0;
                z = z - 1;
            }
            z = z - 1;
        }
        if (betrag > 0) {
            System.out.println("Fehler: Kann nicht geügend Rückgeld geben.");
        }
        return toIntArray(muenzen);
    }

    int[] toIntArray(List<Integer> muenzen) {
        int[] resultat = new int[muenzen.size()];
        int pos = 0;
        for (Integer i : muenzen) {
            resultat[pos] = i;
            pos = pos + 1;
        }
        return resultat;
    }

    /**
     * Summiere alle Münzen zu einem Betrag auf.
     */
    int betrag(int[] eingeworfeneMuenzenInCent) {
        int totalBetrag = 0;
        for (int wert : eingeworfeneMuenzenInCent) {
            totalBetrag = totalBetrag + wert;
        }
        return totalBetrag;
    }

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

    /**
     * Testdaten.
     */
    void top() {
        int[] vorhandeneMuenzenInCent = { 100, 200, 500, 500, 500 };
        int waschPreisInCent = 400;
        int[] eingeworfeneMuenzenInCent = { 100, 200, 500 };

        int[] rueckgeld;
        rueckgeld = wechselgeldInCent(vorhandeneMuenzenInCent,
                waschPreisInCent, eingeworfeneMuenzenInCent);
        System.out.println("Retourgeld:");
        ausgabeArray(rueckgeld);
    }

    /**
     * Auf Konsole ausgeben
     */
    void ausgabeArray(int[] rueckgeld) {
        if (null == rueckgeld) {
            return;
        }
        for (int cent : rueckgeld) {
            System.out.println(cent + " cent");
        }
    }

} // end of class Waschautomat
                

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
Waschautomat
https://www.programmieraufgaben.ch/aufgabe/waschautomat/vyyuvu3u
"""

# Programmieraufgabe:
#     Für eine öffentliche Waschmaschine soll eine automatische Kasse
#     programmiert werden. Dazu wird die folgende Methode benötigt:
#         wechselgeldInCent(
#             vorhandeneMuenzenInCent  : integer[],
#             waschPreisInCent         : integer  ,
#             eingeworfeneMuenzenInCent: integer[] ): integer[]
#     Dabei sind die vorhandenenMuenzenInCent einfach diejenigen Münzen,
#     die bereits vor der Wäsche im Apparat waren, um Wechselgeld herausgeben
#     zu können. Beachten Sie auch, dass nach der Kundeneingabe
#     (eingeworfeneMuenzenInCent) neue Münzen im Automaten sind, die gleich
#     wieder als vorhandeneMuenzenInCent verwendet werden können.
#
# Autor, Erstellung:
#     Ulrich Berntien, 2018-06-11
#
# Sprache:
#     Python 3.6.6


from typing import *


class UserError(BaseException):
    """
    Fehlermeldungen an den Benutzer.
    """
    pass


def wechselgeld_in_cent(vorhandene_muenzen_in_cent: Iterable[int],
                        waschpreis_in_cent: int,
                        eingeworfene_muenzen_in_cent: List[int]) -> List[int]:
    """
    Bestimmt die Münzen für die Geldrückgabe.
    :param vorhandene_muenzen_in_cent: Münzen, die bereits vor der Wäsche im Apparat waren.
    :param waschpreis_in_cent: Preis für die Wäsche.
    :param eingeworfene_muenzen_in_cent: Münzen, die eingeworfen wurden.
    :return: Münzen, die als Rückgeld ausgegeben werden sollen.
    """
    eingeworfen_in_cent = sum(eingeworfene_muenzen_in_cent)
    rueckgabe_in_cent = eingeworfen_in_cent - waschpreis_in_cent
    if rueckgabe_in_cent < 0:
        raise UserError("Zu wenige Münzen eingeworfen")
    # Alle Münzen stehen für die Rückgabe zur Verfügung, auch die gerade eingeworfenen Münzen.
    alle_muenzen_in_cent = list(vorhandene_muenzen_in_cent) + eingeworfene_muenzen_in_cent
    alle_muenzen_in_cent.sort(reverse=True)
    rueckgabe_muenzen_in_cent = []
    rest_in_cent = rueckgabe_in_cent
    # Durch die Sortierung der Münzen werden zuerst die großen Münzen verwendet, so die Anzahl der
    # ausgegebenen Münzen reduziert.
    for muenze in alle_muenzen_in_cent:
        if muenze <= rest_in_cent:
            rueckgabe_muenzen_in_cent.append(muenze)
            rest_in_cent -= muenze
    if rest_in_cent > 0:
        raise UserError("Zu wenige Münzen für Rückgabe")
    assert sum(rueckgabe_muenzen_in_cent) == rueckgabe_in_cent
    return rueckgabe_muenzen_in_cent


vorhandeneMuenzenInCent = [100, 100, 200, 200, 500, 500, 500]
waschPreisInCent = 400
eingeworfeneMuenzenInCent = [100, 100, 100, 500]
wechselgeldInCent = wechselgeld_in_cent(vorhandeneMuenzenInCent, waschPreisInCent, eingeworfeneMuenzenInCent)
print("Wechselgeld Münzen:", wechselgeldInCent)
                

Lösung von: Ulrich Berntien ()

/**
 * Programmieraufgabe: Waschautomat
 * https://www.programmieraufgaben.ch/aufgabe/waschautomat/vyyuvu3u
 */


/**
 * Einfache Fehlermeldung bei Eingabefehler.
 * @param message Fehlermeldung.
 */
class UserException(override val message: String?) : RuntimeException(message)


/**
 * Bestimmt die Münzen für die Geldrückgabe.
 *  @param vorhandeneMuenzenInCent Münzen (in Cent), die bereits vor der
 *  Wäsche im Waschautomat waren.
 *  @param waschPreisInCent Preis (in Cent) für die Wäsche.
 *  @param eingeworfeneMuenzenInCent Münzen (in Cent), die eingeworfen wurden.
 *  @return Münzen (in Cent), die als Rückgeld ausgegeben werden sollen.
 */
fun wechselgeldInCent(vorhandeneMuenzenInCent: IntArray,
                      waschPreisInCent: Int,
                      eingeworfeneMuenzenInCent: IntArray): IntArray {
    val eingeworfen = eingeworfeneMuenzenInCent.sum()
    val rueckgeld = eingeworfen - waschPreisInCent
    if (rueckgeld < 0)
        throw UserException("Zu wenige Münzen eingeworfen")
    // Alle Münzen stehen für die Rückgabe zur Verfügung,
    // auch die gerade eingeworfenen Münzen.
    val alleMuenzen = vorhandeneMuenzenInCent + eingeworfeneMuenzenInCent
    var rueckgabe = intArrayOf()
    var rest = rueckgeld
    // Durch die Sortierung der Münzen werden zuerst die großen Münzen
    // verwendet, so die Anzahl der ausgegebenen Münzen reduziert.
    for (muenze in alleMuenzen.sortedDescending())
        if (muenze <= rest) {
            rueckgabe += muenze
            rest -= muenze
        }
    if (rest > 0)
        throw UserException("Zu wenige Münzen für Rückgabe")
    assert(rueckgabe.sum() == rueckgeld)
    return rueckgabe
}


/**
 * Testfall automatisch ausführen.
 * @param argv Parameter werden ignoriert.
 */
fun main(argv: Array<String>) {
    val vorhanden = intArrayOf(100, 200, 500, 500, 500 )
    val preis = 400
    val eingeworfen = intArrayOf(100, 200, 500)
    println("""
        |Vorhandene Münzen:  ${vorhanden.contentToString()}
        |Waschpreis:         $preis
        |Eingeworfene Münzen:${eingeworfen.contentToString()}
        |Wechselgeld Münzen: ${wechselgeldInCent(vorhanden, preis, eingeworfen).contentToString()}
        """.trimIndent())
}

                

Lösung von: Ulrich Berntien ()

const PRICE = 400;
let coins = [100, 100, 200, 200, 500, 500, 500],  // vorhandene münzen
    buffer = [];                                  // reservoir für ein- und ausgabe
console.log(`Preis: ${PRICE}`);

// array aufsummieren
Array.prototype.sum = function() {
  let sum = 0;
  for (let i = 0; i < this.length; i++) sum += parseInt(this[i]);
  return sum;
}

function insert(coin) {

  // reservoir den vorhandenen münzen hinzufügen
  function pocket() {
    coins = coins.concat(buffer);
    buffer = [];
  }

  buffer.push(coin);

  switch (true) {

    case buffer.sum() < PRICE:
      console.log(`Noch zu zahlen: ${PRICE - buffer.sum()}`);
      break;

    case buffer.sum() == PRICE:
      pocket();
      console.log('Gut Wasch!');
      break;

    case buffer.sum() > PRICE:
      let change = buffer.sum() - PRICE;
      pocket();
      coins = coins.sort().reverse();
      for (let i = 0; i < coins.length; i++)
        if (coins[i] <= change) {
          let c = coins.splice(i, 1);
          buffer.push(c);
          change -= c;
        }
      console.log(`Rückgeld: ${buffer.join(', ')}`);
      buffer = [];
  }
}

// eingabemaske
document.write(`
  <button onclick="insert(100)">100</button><br>
  <button onclick="insert(200)">200</button><br>
  <button onclick="insert(500)">500</button>
`);                                                          // lissalanda@gmx.at

                

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