Programmieren lernen

import input.StdInput;


public class Automat {
	public static void main(String[] args) {
		
		String automat[][] = {{"Pizza","8"}, {"Twix", "1"},
							{"Malteser","1"},{"Gummibärchen", "2"}, 
							{"Popcorn","3"}, {"Cola","1"}, 
							{"Apfel", "1"}, {"Salat","2"}};
		int summe = 0;
		Automat a = new Automat();
		char menueWahl = ' ';
		
		do {
			menueWahl = a.erfassenMenuewahl();
			
			switch (menueWahl) {
				case 'e': //einwerfen (Summe wird um 1 Euro erhöht)
					summe++;
					break;
				case 'v': //verfügbar mit meinem aktuellen Budget  		
					a.vorhanden (summe, automat);
					break;	
				case 'a':   		
					summe = a.auswaehlen (summe, automat);
					break;	
				default:
					System.out.println("verdruckt");
			}
		}while(menueWahl != 'x');
		
	}
	
	private int auswaehlen(int summe, String[][] automat) {
		int taste = StdInput.readInt("Bitte Taste wählen");
		if(Integer.parseInt(automat[taste][1]) <= summe && Integer.parseInt(automat[taste][1]) != -1){
			summe = summe - (Integer.parseInt(automat[taste][1]));
			automat[taste][1]= "-1";
			System.out.println("Hurra Sie bekommen ihr/e: " + automat[taste][0]);
		}
		else if (Integer.parseInt(automat[taste][1]) == -1){
			System.out.println("Produkt ausverkauft");
		}
		else{
			System.out.println("Zu wenig Geld!");
		}
		return summe;
	}

	private void vorhanden(int summe, String[][] automat) {
		for (int i = 0; i<automat.length;i++){
			if (Integer.parseInt(automat[i][1])<= summe && Integer.parseInt(automat[i][1]) != -1){
				System.out.println("Taste " + i + " für " + automat[i][0] + " drücken um " + automat[i][1] + " Euro.");
			}
		}
		
	}

	public char erfassenMenuewahl() {
		char wahl = ' ';
	wahl = StdInput.readString("(e)inwerfem, (v)orhanden, (a)uswählen, (E)xit wählen: ").charAt(0);	
	return wahl;
	}
	
}

                

Lösung von: Karin Eben (digital Business HAK )

import java.awt.Dimension;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.geom.Rectangle2D;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.ListSelectionModel;
import javax.swing.UIManager;
import javax.swing.table.DefaultTableModel;

public class Automat {

    // Modell für die Tabelle
    protected DefaultTableModel model;

    // Daten der Tabelle
    protected String[] header = new String[] { "Fressalie", "Geld (€)" };
    protected String[][] data = new String[][] { { "Pizza", "8" }, { "Twix", "1" }, { "Malteser", "1" },
            { "Gummibärchen", "2" }, { "Popcorn", "3" }, { "Cola", "1" }, { "Apfel", "1" }, { "Salat", "2" } };

    // Modell wird mit den Daten erstellt
    protected void setModell() {
        model = new DefaultTableModel(data, header);
    }

    // Tabelleneigenschaften und Daten werden festgelegt
    protected JTable setJTable() {

        // Modell wird der Tabelle angefügt
        JTable table = new JTable(model);

        // Passt die Spaltenbreite automatisch dem Inhalt an
        table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
        autoresizeColumns(table);

        // Lässt nur einzelne spalten makieren
        table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
        return table;
    }

    // Passt die Spaltengrößen einer Tabelle dem Inahlt an
    protected void autoresizeColumns(JTable table) {

        // Anzahl an Spalten und Reihen
        int columnnumber = table.getColumnModel().getColumnCount();
        int rownumber = table.getRowCount();

        // Größe des Inhalts abhängig von Schrifttyp etc
        Rectangle2D size = null;

        // Schrifttyp wird ermittelt
        Font font = UIManager.getDefaults().getFont("Table.font");
        FontMetrics fontMetrics = table.getFontMetrics(font);

        // Passt jede Spalte einzeln an
        for (int i = 0; i < columnnumber; i++) {

            // Inhalt einer Zelle und dessen Zeichenlänge
            String str = "";
            int length = 0;

            // Durchsucht die Reihen der Spalte nach dem längsten Inhalt
            for (int o = 0; o < rownumber; o++) {
                length = table.getModel().getValueAt(o, i).toString().length();
                if (length > str.length()) {
                    str = table.getModel().getValueAt(o, i).toString();
                }
            }
            length = str.length();

            // Überprüft ob der Kopf der Spalte länger ist als jeder andere
            // Eintrag
            if (length < table.getColumnModel().getColumn(i).getHeaderValue().toString().length()) {
                str = table.getColumnModel().getColumn(i).getHeaderValue().toString();
            }

            // Ermittelt die graphische Größe des längsten Inhalts in der Spalte
            size = fontMetrics.getStringBounds(str, table.getGraphics());

            /*
             * Legt die Größe der Spalte entsprechend dem gefundenen größten
             * Eintrag + einen Extraabstand von 10 fest
             */
            table.getColumnModel().getColumn(i).setPreferredWidth((int) size.getWidth() + 10);
        }
    }

    // Erstellt den Panel sammt Inhalt
    private JPanel setPanel() {

        // Erstellt das Modell für die Tabelle
        setModell();

        // JTable wird erstellt
        final JTable table = setJTable();

        // Panel und GBC-Objekt werden erstellt
        JPanel panel = new JPanel(new GridBagLayout());
        GridBagConstraints grid = new GridBagConstraints();

        // Kaufenbutton wird erstellt und dessen Größe wird festgelegt
        JButton button = new JButton("Kaufen");
        button.setPreferredSize(new Dimension(120, 28));

        // Scrollpane wird erstellt und deren Größe wird festgelegt
        JScrollPane pane = new JScrollPane(table);
        pane.setPreferredSize(new Dimension(table.getPreferredSize().width + 3, table.getPreferredSize().height + 23));

        // Platzieren der Elemente auf dem Panel
        grid.gridx = 0;
        grid.gridy = 0;
        grid.insets = new Insets(3, 3, 3, 3);
        grid.anchor = GridBagConstraints.NORTH;
        panel.add(pane, grid);
        grid.gridx = 1;
        panel.add(button, grid);

        // Funktion des Buttons
        button.addActionListener(new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent arg0) {

                // Zählt jeden Übertrag in das zweite Array mit
                int count = 0;

                // Zweites Array zum Übertragen der Tabellendaten
                String[][] array = new String[data.length - 1][2];

                // In der Tabelle ausgewählter Eintrag
                String selected = table.getModel().getValueAt(table.getSelectedRow(), 0).toString();

                /*
                 * Schreibt alle Einträge, bis auf den ausgewählten, in das
                 * zweite Array ein
                 */
                for (int i = 0; i < data.length; i++) {
                    if (!selected.equals(data[i][0])) {
                        array[count][0] = data[i][0];
                        array[count][1] = data[i][1];
                        count++;
                    }
                }

                // Tabellendaten werden angepasst und Modell damit erstellt
                data = array;
                setModell();

                // Tabelle wird aktualisiert
                table.setModel(model);
            }
        });

        return panel;
    }

    // Hauptmethode
    public static void main(String[] args) {

        // Hauptfenster wird erstellt
        JFrame frame = new JFrame("Automat");

        // Panel wird dem Hauptfenster hinzugefügt
        frame.add(new Automat().setPanel());

        // Hauptfenster beendet beim Schließen seinen Prozess
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        // Hauptfenster wird auf eine Größe von 400x300 gesetzt
        frame.setSize(400, 300);

        // Hauptfenster wird sichtbar geschalten
        frame.setVisible(true);
    }

}
                

Lösung von: Sebastian Littel ()

#automat - nicht schön, aber es funzt

liste = {"pizza":8, "twix":1, "malteser":1, "gummibärchen":2, "popcorn":3, "cola":1,
         "apfel":1, "salat":2}


def kaufen():
    summe = 0
    
    for key in liste:
            print ("Im Automaten sind noch ", key, "für ",  liste[key], " Euro.")
    auswahl = input("Was möchten Sie kaufen?")
    auswahl = auswahl.lower()
    
    if auswahl in liste:
        preis = liste[auswahl]
        print("Der Artikel: ", auswahl, " kostet ", preis, " Euro.")
        print("Bitte bezahlen Sie ", preis)
        
        for geld in range(preis):
            print("Bitte werfen Sie 1 Euro ein. Drücken Sie 'Enter' für jeden Euro")
            eingeworfen = input()
            summe+=1
            
            print ("eingeworfen: ", summe)
        print("Danke, Sie haben ", summe, " Euro bezahlt")
        del liste[auswahl]
        
        kaufen()
    else:
        print("Falsche Auswahl")
        kaufen()
        
kaufen()

                

Lösung von: Py Thon ()

package programmierenuebungen;

import java.awt.BorderLayout;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JTable;
import javax.swing.JTextField;
import javax.swing.table.DefaultTableModel;

/**
 * 
 * @author MadDeer
 */
public class Automat extends JFrame{

    private JPanel north;
    private JButton einwurf;
    private JTextField anzeige;
    private JTable data;
    private int currentKontostand = 0;
    
    public Automat(){
        north = new JPanel();
        einwurf = new JButton("Geld einwerfen");
        anzeige = new JTextField("Guthaben: 0");
        data = new JTable();
        init();
    }

    private void init(){ //erstellt die GUI
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setTitle("Wunderautomat v1.0");
        //GUI basteln
        north.setLayout(new GridLayout());
        anzeige.setEditable(false);
        north.add(anzeige);
        einwurf.addActionListener(new ActionListener(){
            @Override
            public void actionPerformed(ActionEvent e) {
                anzeige.setText("Guthaben: " + ++currentKontostand);
            }
        });
        north.add(einwurf);
        setCustomModel(); //ausgelagerte Methode, wiederverwendbar!!
        data.addMouseListener(new MouseAdapter(){
            @Override
            public void mouseClicked(MouseEvent e) {
                int sel = Integer.parseInt((String) data.getValueAt(data.getSelectedRow(), 1));
                if (currentKontostand >= sel){
                    currentKontostand -= sel;
                    anzeige.setText("Guthaben: " + currentKontostand);
                    DefaultTableModel dtm = (DefaultTableModel)data.getModel();
                    dtm.removeRow(data.getSelectedRow());
                    data.setModel(dtm);
                    if(dtm.getRowCount() == 0){ //automatisch wieder auffuellen
                        setCustomModel();
                    }
                } else {
                    JOptionPane.showMessageDialog(null, "Sie haben zu wenig Geld eingeworfen!", "Armageddon", JOptionPane.ERROR_MESSAGE);
                }
            }
        }); //fertig
        //Obekte zum Frame hinzufuegen, verpacken und anzeigen
        this.add(north, BorderLayout.NORTH);
        this.add(data, BorderLayout.CENTER);
        this.pack();
        this.setVisible(true);
    }
    
    private void setCustomModel(){ //Erstellt den Dateninhalt der Tabelle
        data.setModel(new DefaultTableModel(new String[][]{{"Pizza", "8"},{"Cola","1"}
                ,{"Twix","1"},{"Malteser","1"},{"Gummibaerchen","2"},{"Popcorn","3"}
                ,{"Apfel","1"},{"Salat","2"},{"Doener","4"}},
                new String[]{"Angebot", "Kosten"}) {
            Class[] types = new Class[]{java.lang.String.class, java.lang.String.class};
            boolean[] canEdit = new boolean[]{false, false};
            @Override
            public Class getColumnClass(int columnIndex) {
                return types[columnIndex];
            }
            @Override
            public boolean isCellEditable(int rowIndex, int columnIndex) {
                return canEdit[columnIndex];
            }
        });
    }
    
    public static void main(String[] args){
        new Automat();
    }
}
                

Lösung von: Mad Deer (FH Ulm)

/// F# - Automat
/// Ein einfaches Beispiel

(*** Ich habe es leider nicht mit dem VS Editor geschrieben sondern mit ganz normalen Notepad aber sollte funktionieren ***)

open System

exception ProductError of string

let mutable wartetGeld = true

type Produkt = {
    Name: string
    mutable Amount: int
}

let produkten = [ 
  { Name = "Pizza"; Amount = 8;  }
  { Name = "Twix"; Amount = 1; }
  { Name = "Malteser"; Amount = 1; }
  { Name = "Gummibärchen"; Amount = 2; }
  { Name = "Popcorn"; Amount = 3; }
  { Name = "Cola"; Amount = 1; }
  { Name = "Apfel"; Amount = 1; }
  { Name = "Salat"; Amount = 2; }]

let decAmount (name) : unit = 
    let index = List.findIndex (fun (p : Produkt) -> p.Name = name) produkten
    produkten.[index].Amount <- produkten.[index].Amount - 1 

let rec startAutomat wartet =   
  try
    printfn "Geld einwerfen: " 
    let einwurf = int (Console.ReadLine())
    if einwurf = 1 then
        automat
    elif einwurf > 1 then
        raise (ProductError ("Produkt ausverkauft."))
    else
        startAutomat true
        
  with | ProductError(str) -> printfn "%s" str; startAutomat true
and  automat =
  try
    Console.Write ("Auswahl: ")
    let eingabe = Console.ReadLine()
    let fprodukt : Produkt = 
        (List.filter (fun (p : Produkt) -> p.Name = eingabe) produkten).[0]
    
    if fprodukt.Amount > 0 then
        decAmount eingabe
        printfn "Danke für Ihren Einkauf!"
    else
        raise (ProductError ("Produkt ausverkauft."))
        startAutomat true
        
  with | :? ArgumentException as e -> printfn "Produkt kann nicht gefunden!"
       | ProductError(str) -> printfn "%s" str

                

Lösung von: Vural Acar ()

using System;
using System.Collections.Generic;
using System.Linq;

namespace Automat {
	class Program {
		static void Main(string[] args) {
			int[] preis = new int[] { 1, 2, 3, 8 };
			Dictionary<string, float> Produkte = new Dictionary<string, float> {
				{"Pizza", preis[3]}, {"Twix", preis[0]}, {"Malteser", preis[0]}, {"Gummibärchen", preis[2]},
				{"Popcorn", preis[2]}, {"Cola", preis[0]}, {"Apfel", preis[0]}, {"Salat", preis[1]}
			};
			sbyte befüllt = -1;

			ConsoleKey temp_key;
			do{
				Console.Clear();

				for (int i = 0, produkt = 1; 
					i < Produkte.Count;
					i++, produkt <<= 1) 
					Console.WriteLine("[{0}] {1}: {2,2:#0.00} Euro", 
						(befüllt & produkt) == produkt ? (i+1).ToString("00") : "--", 
						Produkte.ElementAt(i).Key, 
						Produkte.ElementAt(i).Value);
				
				temp_key = Console.ReadKey(true).Key;
				switch (temp_key) {
					case ConsoleKey.D1:
					case ConsoleKey.NumPad1:
						befüllt &= ~1;
						break;
					case ConsoleKey.D2:
					case ConsoleKey.NumPad2:
						befüllt &= ~2;
						break;
					case ConsoleKey.D3:
					case ConsoleKey.NumPad3:
						befüllt &= ~4;
						break;
					case ConsoleKey.D4:
					case ConsoleKey.NumPad4:
						befüllt &= ~8;
						break;
					case ConsoleKey.D5:
					case ConsoleKey.NumPad5:
						befüllt &= ~16;
						break;
					case ConsoleKey.D6:
					case ConsoleKey.NumPad6:
						befüllt &= ~32;
						break;
					case ConsoleKey.D7:
					case ConsoleKey.NumPad7:
						befüllt &= ~64;
						break;
					case ConsoleKey.D8:
					case ConsoleKey.NumPad8:
						befüllt &= ~-128;
					break;
				}
			} while (temp_key != ConsoleKey.Escape);
		}
	}
}
                

Lösung von: Marcel Kapma ()

// eingabemaske
document.write(
   '<select id="menu" style="float:left;margin-right:1em">' + 
      '<option value="8" onclick="compute()">Pizza</option>' +
      '<option value="1" onclick="compute()">Twix</option>' +
      '<option value="1" onclick="compute()">Malteser</option>' +
      '<option value="2" onclick="compute()">Gummibärchen</option>' +
      '<option value="3" onclick="compute()">Popcorn</option>' +
      '<option value="1" onclick="compute()">Cola</option>' +
      '<option value="1" onclick="compute()">Apfel</option>' +
      '<option value="2" onclick="compute()">Salat</option>' +
   '</select>' +
   '<p id="display">0</p>' + 
   '<button id="insert" disabled>Münze einwerfen</button>'
);

var menu = document.getElementById("menu"),
    display = document.getElementById("display"),
    insert = document.getElementById("insert");
    
function compute() {
   var i = menu.selectedIndex;
   insert.disabled = false;
   display.innerHTML = menu.options[i].value;
   insert.onclick = function() {
      menu.disabled = true;
      if (display.innerHTML > 1) display.innerHTML--;
      else {
         alert("Bitteschön!");
         menu.remove(i);
         if (menu.length == 0) {
            insert.disabled = true;
            display.innerHTML = "Außer Betrieb";
         } else {
         insert.disabled = true;
         menu.disabled = false;
         display.innerHTML = 0;         
         }
      }
   }
}
                

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

// NET 6.x | C# 10.x | VS-2022
using static System.Console;
using static System.ConsoleKey;

_ = new Automat();

class Automat {
    enum G { _1 = 1, _2, _3, _4 = 8 } // Preisgruppe
    enum I { Pizza, Twix, Malteser, Gummibaerchen, Popcorn, Cola, Apfel, Salat } // Artikel

    private readonly List<(I item, G group, bool available)> _lst = new() {
        (I.Pizza, G._4, true), (I.Twix, G._1, true), (I.Malteser, G._1, true),
        (I.Gummibaerchen, G._2, true), (I.Popcorn, G._3, true), (I.Cola, G._1, true),
        (I.Apfel, G._1, true), (I.Salat, G._2, true)
    };

    public Automat() {
        while (true) {
            Print();
            Write("Wähle einen Artikel (0 für Beenden): ");
            _ = int.TryParse(ReadLine(), out int n);
            if (n != 0) Buy(n);
            else return;
        }
    }

    private void Print() {
        var i = 1;
        foreach (var (item, group, available) in _lst) {
            if (available) WriteLine($"({i}) - {item}: {(int)group} Euro");
            i++;
        }
    }

    private static bool Pay(int amount) {
        WriteLine($"Bitte {amount} Euro zahlen (Taste 1 drücken oder 0 für Beenden)");
        while (amount > 0) {
            switch (ReadKey(true).Key) {
                case D1: case NumPad1: amount--; break;
                case D0: case NumPad0: return false;
                default: WriteLine("Falsche Taste!"); break;
            }
            WriteLine(amount > 0 ? $"noch {amount} Euro" : "bezahlt");
        }
        return true;
    }

    private void Buy(int num) {
        if (Enum.IsDefined(typeof(I), num - 1))
            for (var i = 0; i < _lst.Count; i++) {
                var (it, gr, av) = _lst[i];
                if (num - 1 == i && av) {
                    if (Pay((int)gr)) {
                        _lst[i] = new(it, gr, false);
                        WriteLine($"Ausgabe: {it}\n");
                    }
                    else WriteLine($"Der Vorgang wurde abgebrochen\n");
                    return;
                }
            }
        WriteLine("Artikel nicht (mehr) vorhanden!\n");
    }
}
                

Lösung von: Jens Kelm (@JKooP)

// C++ 20 | VS-2022

#include <iostream>
#include <vector>
#include <format>
#include <sstream>

struct Item {
    std::string name;
    size_t price;
    size_t amount;
};

std::vector<Item>items{
    {"Pizza", 8, 4}, {"Twix", 1, 20}, {"Malteser", 1, 10},
    {"Gummibaerchen", 2, 1}, {"Popcorn", 3, 4}, {"Cola", 1, 5},
    {"Apfel", 1, 10}, {"Salat", 2, 0}
};

const std::ostream& print_items(const std::ostream& os_) {
    auto i{ 1 };
    for (const auto& [name, price, amount] : items)
        std::cout << std::format("{:02} - {}: {}{} Euro\t Anzahl: {}\n", i++, name, std::string(15-name.length(), ' '), price, amount);
    std::cout << "\n";
    return os_;
}

const bool item_paid(size_t amount_) {
    std::string chr{};
    std::cout << std::format("Bitte {} Euro zahlen (Taste 1) oder 0 fuer beenden\n", amount_);
    std::cin.ignore();
    while (amount_) {
        switch (getchar()) {
            case '1': amount_--; std::cin.ignore(); break;
            case '0': return false; break;
            default: std::cout << "Falsche Taste!\n"; std::cin.ignore(); break;
        }
        if (amount_) std::cout << std::format("noch {} Euro\n", amount_);
        else std::cout << "Artikel bezahlt!\n\n";
    }
    return true;
}

const auto buy_item(const size_t& num_) {
    if (num_ > items.size()) {
        std::cout << "Artikelnummer nicht bekannt!\n\n";
        return;
    }

    auto& [name, price, amount] = items[num_ - 1];

    if (!amount) {
        std::cout << "Artikel nicht mehr vorhanden!\n\n";
        return;
    }

    if (!item_paid(price)) {
        std::cout << "Der Vorgang wurde abgebrochen!\n\n";
        return;
    }
    amount--;
    std::cout << "Ausgabe: " << name << "\n";
}

int main() {
    size_t num{};
    while (1) {
        print_items(std::cout);
        std::cout << "Waehle einen Artikel (0 fuer Beenden): ";
        std::cin >> num;
        if (num) buy_item(num);
        else break;
    }
}
                

Lösung von: Jens Kelm (@JKooP)