Sortierenn einfach Verketteter Listen – Insertion Sort

  //Aufgabe 17 - InsertionSort
	  /*Kurzform: Nimm das nächste unsortierte Element und füge es an der richtigen Stelle ein. */
	  public void sort3(){
			ElementL<I> sortiert = head;
			ElementL<I> unsortiert = head.next;
			ElementL<I> vergleich;
			ElementL<I> vorgaenger;
			
			//Äußere Schleife: Weitermachen, so lange es noch unsortierte Elemente gibt
			while(unsortiert != null){
				//Liste immer von vorne prüfen
				vergleich = head; 
				vorgaenger = null;
				
				//Innere Schleife: Liste bis zum unsortierten Element durchlaufen und Position prüfen, falls nicht vorher abgebrochen wird
				while(vergleich != unsortiert ){ 
					
					//Prüfen ob das unsortiere Element vor dem Vergleichselement platziert werden muss
					if(unsortiert.inhalt.compareTo(vergleich.inhalt)== -1){
						//Cut+Paste					
						sortiert.next = unsortiert.next; //Element aus dem Unsortierten Bereich ausschneiden
						unsortiert.next = vergleich; //Vor dem Vergleichselement einfügen
						
						//Wenn das Element nicht am Anfang eingefügt wird muss das Vorgäner-Element angehängt werden
						if(vorgaenger != null){
							vorgaenger.next = unsortiert;
							System.out.println("Zwischenstand4:" + this);
						}
						else{
							 head = unsortiert;
						}
						
						break; //Element wurde platziert, durchlauf kann abgebrochen werden
					}		
					
					//Das unsortierte Element kann auch größer sein und an seiner Position bleiben
					if(vergleich.next.equals(unsortiert)){
						sortiert = unsortiert; //Sortierte Menge erweitern		
						break;
					}
					
					//Werte für nächsten Schleifendurchlauf vorbereiten
					vorgaenger = vergleich; //Vorgänger Merken falls das unsortierte Element dazwischen eingebunden werden muss
					vergleich = vergleich.next; //Nächstes Element vergleichen		
				}//Ende Innere Schleife

				unsortiert = sortiert.next; //Neues unsortiertes Element ziehen
			}//Ende Äußere Schleife
		    
	  }

Programmieren Praxis: Java und Kommandozeile

Übugnsblatt 13

Aufgabe 47

/*
 * Aufgabe 47
 */
 public class Rechne { 
 	 public static void main (String[] args) {

		double zahl1 = Double.parseDouble(args[0]);
		double zahl2 = Double.parseDouble(args[2]);
		String operator = args[1];
		double erg = 0;

		if(operator.equals("+")){
		    erg = zahl1 + zahl2;
		}
		else if(operator.equals("-")){
		    erg = zahl1 - zahl2;
		}
		else if(operator.equals("*")){
		    erg = zahl1 * zahl2;
		}
		else if(operator.equals("/")){
		    erg = zahl1 / zahl2;									
		}
		else {
		System.out.println("Fehlerhafte Eingabe");
 	    } 
		System.out.println("Ergebnis:" + erg);	
 	 }
 }
// Kommandozeilenbefehl: java Rechne 1 + 2

Aufgabe 48

Unbenannt1

Unbenannt2

Klasse Eingabe

/*
 * Aufgabe 48
 */
import Prog1Tools.IOTools;

public class Eingabe{
	  public static void main (String[] args) {
	  	String eingabe = "";
	  	Sammlung sammlung = new Sammlung();

	  	for(;;){
	  		eingabe = IOTools.readLine("Ihre Eingabe: ");
	  		if(eingabe.equals("")){

	  			String[] ausgabe = sammlung.alsStringFeld();
	  			
	  			System.out.println("Ausgabe:");
	  			for (int i=0; i< ausgabe.length; i++){
	  				System.out.println(ausgabe[i]);

	  				while(sammlung.enthaelt(ausgabe[i])){  				
	  					sammlung.entferne(ausgabe[i]);
	  				}
	  					
	  				sammlung.fuegeHinzu(ausgabe[i]); 				
	  			}

	  			sammlung.sortieren();
	  			ausgabe = sammlung.alsStringFeld();
	  			
	  			System.out.println("Ausgabe sortiert ohne Duplikate:");
	  			for (int i=0; i< ausgabe.length; i++){
	  				System.out.println(ausgabe[i]);
	  			}  			
		  			
	  			return;
	  		}
	  		else{
	  			sammlung.fuegeHinzu(eingabe);
	  		}
	  	}
	}
}
Klasse Sammlung
  
import java.util.*;

/** Die Klasse Sammlung dient der Darstellung und Manipulation einer 
  * Sammlung von Zeichenketten. 
  *
  * @author Dietmar Ratz
  * @version 19.08.2008
  */
public class Sammlung {
  private ArrayList<String> worte;

  /** erzeugt eine zunächst leere Sammlung.
    */
  public Sammlung () {
    worte = new ArrayList<String>();
  }
  
  /** nimmt den String <code>s</code> in die Sammlung auf.
    * 
    * @param s aufzunehmender String
    */
  public void fuegeHinzu (String s) {
    worte.add(s);
  }

  /** entfernt den String <code>s</code> aus der Sammlung.
    *
    * @param s zu entfernender Wert
    */
  public void entferne (String s) {
    worte.remove(s);
  }

  /** liefert genau dann den Wert <code>true</code> zurück, wenn 
    * der String <code>s</code> in der Sammlung enthalten ist.
    *
    * @param s zu überprüfender Wert
    * @return <code>true</code>, falls der String <code>s</code> in der
    * Sammlung enthalten ist, und <code>false</code>, andernfalls.
    */
  public boolean enthaelt (String s) {
    return worte.contains(s);
  }
  
  /** liefert die komplette Sammlung als <code>String</code>-Feld zurück.
    * @return <code>null</code>, falls die Sammlung keine Strings enthält.
    */
  public String[] alsStringFeld() {
    return worte.toArray(new String[0]);
  }
  
  /** sortiert die Sammlung alphabetisch.
    */
  public void sortieren() {
    Collections.sort(worte);
  }
  
}

Programmieren Praxis: OOP und Vererbung

-Übungsblatt 12-

Aufgabe 43-45

Klasse Bildschirm

/*
 * @autor: Prof. D. Ratz
 */
public class Bildschirm {
  public static void loeschen() { // Schreibt 100 Leerzeilen auf den Bildschirm
    for (int i=0; i<100; i++)
      System.out.println();
  }
}

 

Klasse Spielfigur

/*
 * @autor: Prof. D. Ratz
 */
public class Spielfigur {
  private char xPos;
  private int yPos;
  private String farbe;
  public Spielfigur (char x, int y, String f) {
    xPos = x;
    yPos = y;
    farbe= f;
    korrigierePosition();
  }
  private void korrigierePosition () {
    if (xPos < 'A')
      xPos = 'A';
    else if (xPos > 'H')  
      xPos = 'H';
    if (yPos < 1)
      yPos = 1;
    else if (yPos > 8)  
      yPos = 8;
  }
  public char getXpos () {
    return xPos;
  }
  public int getYpos () {
    return yPos;
  }
  public String getFarbe () {
    return farbe;
  }
  public void ziehe (int xFelder, int yFelder) {
    xPos = (char) (xPos + xFelder);
    yPos = yPos + yFelder;
    korrigierePosition();
  }
  public String toString() {
    return farbe + "e Figur auf Feld " + xPos + yPos;
  }
}

Klasse DameFigur

/*
 * Aufgabe 44
 */
 public class DameFigur extends Spielfigur{

 	static String name = "Dame";

 	DameFigur(char x, int y, String f)
 	{
 		super(x,y,f) ;	
 	}

 	public void ziehe(char richtung, int anzahl){

		if (richtung=='-')
			ziehe(anzahl,0);
		else if(richtung=='|')
			ziehe(0,anzahl);
 		else if(richtung=='/')
			ziehe(anzahl,-anzahl);
 		else if(richtung=='\\')
			ziehe(anzahl,anzahl);
 	} 

 	public boolean trifft(DameFigur trifft){
 		return (this.getXpos() == trifft.getXpos() && this.getYpos() == trifft.getYpos());
 	}

 	public String toString(){
 		return getFarbe() + "e Dame auf Feld " + getXpos() + getYpos();
 	}
 }

Klasse DSpiel

/*
 * Aufgabe 45
 */
import Prog1Tools.IOTools;
 
public class DSpiel{

	public static void eingabeZug(DameFigur figur){
		char richtung;
		
		do{ richtung = IOTools.readChar("Wollen Sie waagrecht (-), senkrecht (|) oder diagonal(/,\\)ziehen ?"); }
		while( richtung != '-' && richtung != '|' && richtung != '/' && richtung != '\\');

		int anzahl = IOTools.readInt("Wieviele Felder ziehen? (>0 nach rechts oben, <0 nach links unten) ");
		figur.ziehe(richtung,anzahl);
	}		
	
	public static void main (String[] args) {
		System.out.println("Positioneieren Sie ihre Beute");
		DameFigur beute = new DameFigur(IOTools.readChar("Spalte (A-H) ihrer Figur:"),
										IOTools.readInt("Zeile (1-8) ihrer Firgur:"),
										IOTools.readString("Farbe ihrer Figur:"));

		Bildschirm.loeschen();										

		System.out.println("Die Beute steht, positionieren Sie ihren Jäger");
		DameFigur jaeger = new DameFigur(IOTools.readChar("Spalte (A-H) ihrer Figur:"),
										IOTools.readInt("Zeile (1-8) ihrer Firgur:"),
										IOTools.readString("Farbe ihrer Figur:"));

		if(jaeger.trifft(beute)){
			System.out.println("Treffer! Sie (als Jäger) haben gewonnen!");			
		}
		else{
			System.out.println("Die Beute-Figur steht woanders!");
			System.out.println("Sie haben nun 10 Dame-Züge, um die Beute-Figur zu treffen.");

			for(int i = 10; i>=0; i--){
				if(jaeger.trifft(beute)){
				  System.out.println("Treffer! Sie (als Jäger) haben gewonnen!");	
				  return;
				}
				else{
					if(i != 10) //Beim ersten mal nicht ausgeben.
						System.out.println("Leider kein Treffer!");
					
					if(i>0){//Versuch(e) übrig
						
						System.out.println("Bewegen Sie ihre "+jaeger);
						eingabeZug(jaeger);
					}
					else{
						System.out.println("Sie (als Beute) haben gewonnen!");
					}
				}
				  						
			}
		}
	}
}

Aufgabe 45

Klasse Fernseher

/*
 * @autor: Prof. D. Ratz
 */
public class Fernseher {        
  private String raum;   // Raum, in dem der Fernseher steht
  private int volume;    // Eingestellte Lautstaerke
  private int program;   // Eingestelltes Programm

  public Fernseher (String ra, int vo, int pr) {  // Konstruktor
    raum = ra;
    volume = Math.max(0,Math.min(vo,50));   // laustaerke im Bereich [0,50]
    program = Math.max(1,Math.min(pr,99));  // program im Bereich [1,99]
  }

  public int getVolume () { // liefert den Wert der Variable volume
    return volume;
  }

  public void change (String einstell, int wert) { // verändert die zu 'einstell'
    if (einstell.equals("volume")) {               // gehoerende Einstellung
      volume = volume + wert;                      // um 'wert'
      volume = Math.max(0,Math.min(volume,50));
    }
    else if (einstell.equals("program")) {
      program = program + wert;
      program = Math.max(1,Math.min(program,99));
    }
  }

  public String toString() { // liefert String-Darstellung des Fernsehers
    return "Fernseher im " + raum +
           ": v=" + volume + 
           ", p=" + program;
  }
}

Klasse Fernseher Demo

/*
 * @autor: Prof. D. Ratz
 */
import Prog1Tools.IOTools;
public class FarbFernseherDemo {
  public static void main (String[] args) {
    FarbFernseher ff1, ff2;

    // Einen Farbfernseher erzeugen
    ff1 = new FarbFernseher("Wohnzimmer", 6, 7, 8);
    
    System.out.println("Daten des Farbfernsehers 1 ausgeben:");
    System.out.println(ff1);
    System.out.println();
    
    // Farbfernseher 2 erzeugen
    ff2 = new FarbFernseher("Schlafzimmer", 35, 15, 20);
    
    System.out.println("Daten des Farbfernsehers 2 ausgeben:");
    System.out.println(ff2);
    System.out.println();
    
    System.out.println("Die beiden Farbfernseher vergleichen:");
    if (ff1.istAngenehmerAls(ff2))
      System.out.println("Farbfernseher 1 ist angenehmer als Farbfernseher 2");
    else if (ff2.istAngenehmerAls(ff1))
      System.out.println("Farbfernseher 2 ist angenehmer als Farbfernseher 1");
    else
      System.out.println("Beide Farbfernseher sind komisch eingestellt");
    System.out.println();
     
    System.out.println("Der Farbfernseher 1 wird nun anders eingestellt:");
    System.out.println("Laustaerke um 5 erniedrigt, Farbe um 15 erhoeht");
    ff1.change ("volume", -5);
    ff1.change ("color", 15);
    System.out.println();

    System.out.println("Daten des neu eingestellten Farbfernsehers 1 ausgeben:");
    System.out.println(ff1);
    System.out.println();
    
    System.out.println("Die beiden Farbfernseher nochmals vergleichen:");
    if (ff1.istAngenehmerAls(ff2))
      System.out.println("Farbfernseher 1 ist angenehmer als Farbfernseher 2");
    else if (ff2.istAngenehmerAls(ff1))
      System.out.println("Farbfernseher ist angenehmer als Farbfernseher 1");
    else
      System.out.println("Beide Farbfernseher sind komisch eingestellt");
    System.out.println();
  }
}

Klasse FarbFernseher

/*
 * Aufgabe 46
 */
public class FarbFernseher extends Fernseher{ 

  private int farbe;   // Eingestelltes Farbe

  public FarbFernseher (String ra, int vo, int pr, int fa) {  // Konstruktor
    super(ra,vo,pr);
    farbe = Math.max(0,Math.min(fa,50));   // laustaerke im Bereich [0,50]
  }

  public int getFarbe () { // liefert den Wert der Variable volume
    return farbe;
  }

  public void change (String einstell, int wert) { // verändert die zu 'einstell' gehoerende Einstellung um 'wert'
    if (einstell.equals("color")) {              
      farbe = farbe + wert;                    
      farbe = Math.max(0,Math.min(farbe,50));
    }
    else 
      super.change(einstell,wert);
  }

  public boolean istAngenehmerAls(FarbFernseher anderer){
  	if (this.getVolume() < anderer.getVolume() && this.getFarbe()< 40 && this.getFarbe() > anderer.getFarbe())
  	  return true;
  	else 
  	  return false;
  }

  public String toString() { // liefert String-Darstellung des Fernsehers
    return super.toString() + 
           ", f=" + farbe;
  }
}

Klasse FarFernseherDemo

/*
 * @autor: Prof. D. Ratz
 */
import Prog1Tools.IOTools;
public class FarbFernseherDemo {
  public static void main (String[] args) {
    FarbFernseher ff1, ff2;

    // Einen Farbfernseher erzeugen
    ff1 = new FarbFernseher("Wohnzimmer", 6, 7, 8);
    
    System.out.println("Daten des Farbfernsehers 1 ausgeben:");
    System.out.println(ff1);
    System.out.println();
    
    // Farbfernseher 2 erzeugen
    ff2 = new FarbFernseher("Schlafzimmer", 35, 15, 20);
    
    System.out.println("Daten des Farbfernsehers 2 ausgeben:");
    System.out.println(ff2);
    System.out.println();
    
    System.out.println("Die beiden Farbfernseher vergleichen:");
    if (ff1.istAngenehmerAls(ff2))
      System.out.println("Farbfernseher 1 ist angenehmer als Farbfernseher 2");
    else if (ff2.istAngenehmerAls(ff1))
      System.out.println("Farbfernseher 2 ist angenehmer als Farbfernseher 1");
    else
      System.out.println("Beide Farbfernseher sind komisch eingestellt");
    System.out.println();
     
    System.out.println("Der Farbfernseher 1 wird nun anders eingestellt:");
    System.out.println("Laustaerke um 5 erniedrigt, Farbe um 15 erhoeht");
    ff1.change ("volume", -5);
    ff1.change ("color", 15);
    System.out.println();

    System.out.println("Daten des neu eingestellten Farbfernsehers 1 ausgeben:");
    System.out.println(ff1);
    System.out.println();
    
    System.out.println("Die beiden Farbfernseher nochmals vergleichen:");
    if (ff1.istAngenehmerAls(ff2))
      System.out.println("Farbfernseher 1 ist angenehmer als Farbfernseher 2");
    else if (ff2.istAngenehmerAls(ff1))
      System.out.println("Farbfernseher ist angenehmer als Farbfernseher 1");
    else
      System.out.println("Beide Farbfernseher sind komisch eingestellt");
    System.out.println();
  }
}

2. Historisches zu Rechnersystemen

Im folgeden eine kurze Zusammenfassugn der für mich relevaten Inhalte zur Klausurvorbereitung.

Ausgewählte Ereignisse der Informatik-Geschichte

  • 1957: Einführugn des Begriff “Informatik” als verschmelzung von “Information” und “Automatik” – Karl Steinbuch (engl. computer science )
  • 1970: Diplom Studiengang Informatik an der Uni Karlsrueh (heute KIT)
  • 1100v.Chr: Abakus, ältestes bekaets Rechenhilfsmittel
  • um 1600: Rechenschieber auf Basis der Etwicklung der Logarithmen
  • 1623 (Shickard), 1643 (Pascal): Erste mechanische Rechenmaschinen
  • 1673: Dreiteilung Input, Rechnen, Output (Leibniz)
  • 1673: Binäre Arithmetik (Dualsystem) – Leibiz
  • 1847: Boolesche Algebra – George Boole (AND,OR,XOR,NOT)
  • 1936-39: Zuse Z1 – Erste elektromechanische Rechenmaschine
  • 1941: Zuse Z3 – gilt heute als erster Computer der Welt
  • 1945: Von Neuman Rechnerarchitektur
  • 1962: Arpanet  als erstes Computernetzwerk (69 vom US-Militär) in Betreib genommen)
  • 1967: IBM – Trenung von Hard- und Software
  • 1981: Erster Persoal Computer
  • 1984: Erste E-Mail nach Deutschland

Coputergeneratione

  • Mechanisch
  • Elektro-mechanisch
  • Elektronenröhren
  • Transistoren
  • integrierte Schaltkreise
  • Hochintegrierte Schaltkreise
  • Parallelrechner

Konrad Zuse (1910-1995)

  • Entwickelte den “ersten Computer”
  • Zuse Z1 – erster frei programmierbarer Rechner
  • Zerstört im WW2, Nachbau 1963/1989
  • Zuse Z3- Binäres Gleitkommarechenwerk, Treung von Speicher, Steuerwerk, Rechenwerk, Ein-Ausgabe

Moore’s Law

  • Die komplexität integrierter Schaltkreise verdoppelt sich etwa alle zwei Jahre

Koomey’s Law

  • Die Energieeffizienz von Rechnen verdoppelt sich alle 18 Monate
  • -> Bei definierter Rechenlast halbiert sich die nötige Batterieleistung alle eieinhalb Jahre

Von-Neumann-Architektur

Komponenten:

  • Rechenwerk
  • Steuerwerk
  • Speicherwerk
  • Eni-Ausgabewerk
  • Bus-System

Vorteile/Prizipien:

  • Gespeicherte Programme (gemeinsam mit Daten)
  • Sequentielle Programmausführung

Harvard Architektur

Vorteile:

  • Gleichzeitiges Lade und Speichern von Befehlen und Date (da Getrennt gespeichert)
  • Bei Softwarefehlern kann keine Programmcode überschrieben werde
  • Datenwortbreite kann sich von Befehlswortbreite unterscheiden

Nachteile:

  • Komplexer als von Neumann
  • Datenspeicher kann nicht als Programmspeicher verwendet werden, vice versa

Programmieren Praxis: OOP

Aufgabe 36

Test

/* @author Prof. D. Ratz */
import Prog1Tools.IOTools;
public class TestSound {
  public static void main (String[] args) {
    int laut, bass, hoch;
    String raum;
    Sound anlage;

    System.out.println("Daten fuer eine Anlage einlesen");
    raum = IOTools.readString("Raum-Bezeichnung: ");
    laut = IOTools.readInteger("Standard-Einstellung fuer die Lautstaerke: ");
    bass = IOTools.readInteger("Standard-Einstellung fuer die Baesse: ");
    hoch = IOTools.readInteger("Standard-Einstellung fuer die Hoehen: ");
    System.out.println();

    // Anlage erzeugen
    anlage = new Sound(raum, laut, bass, hoch);

    System.out.println("Daten der Anlage ausgeben");
    System.out.println(anlage);
    System.out.println();

    System.out.println("Die Anlage wird nun anders eingestellt");
    System.out.println("(Baesse um 4 erhoeht, Hoehen um 2 erniedrigt)");
    anlage.verstaerke ("baesse", 4);
    anlage.verstaerke ("hoehen", -2);
    System.out.println();

    System.out.println("Daten der neu eingestellten Anlage ausgeben");
    System.out.println(anlage);
  }
}

Klasse Sound

/*
 * Aufgabe 36
 */
import Prog1Tools.IOTools;

public class Sound{
    private String raum;
    private int lautstaerke;
    private int baesse;
    private int hoehen;

    public Sound(String raum, int lautstaerke, int baesse, int hoehen){
        this.raum = raum;
        this.lautstaerke = lautstaerke;
        this.baesse = baesse;
        this.hoehen = hoehen;    
    }

    public String getRaum (){
        return raum;
    }

    public int getLautstaerke(){
        return lautstaerke;
    }

    public int getBaesse(){
        return baesse;
    }

    public int getHoehen(){
        return hoehen;
    }

    public void setLautstaerke(int lautstaerke){
        this.lautstaerke = lautstaerke;
    }

    public void setBaesse(int baesse){
        this.baesse = baesse;
    }

    public void setHoehen(int hoehen){
        this.hoehen = hoehen;
    }        

    public void verstaerke (String regler, int wert){
        if(regler.equals("hoehen")){
            setHoehen(getHoehen()+wert);
        }
        else if(regler.equals("baesse")){
            setBaesse(getBaesse()+wert);
        }
        else if(regler.equals("lautstaerke")){
            setLautstaerke(getLautstaerke()+wert);
        }
    }

    public String toString(){
        return ("Anlage in Raum:"+getRaum()+": la: "+getLautstaerke()+" ba: "+getBaesse()+" ho: "+getHoehen());
    }

}

Aufgabe 37

Klasse Punkt

/*
 * Aufgabe 37
 */
import Prog1Tools.IOTools;

public class Punkt{
	private double x;
	private double y;

	public Punkt(double x, double y){
		this.x = x;
		this.y = y;
	}

	public double getX(){
		return x;
	}
	public double getY(){
		return y;
	}
	public void setX(double x){
		this.x = x;
	}
	public void setY(double y){
		this.y = y;
	}	

	public void read(){
		setX(IOTools.readDouble("Eingabe x: "));
		setY(IOTools.readDouble("Eingabe y: "));
	}	

	public void read(String bezeichner){//Überladen mit bezeichner
		setX(IOTools.readDouble("Eingabe "+bezeichner+" x: "));
		setY(IOTools.readDouble("Eingabe "+bezeichner+" y: "));
	}

	public String toString (){
		return "("+getX()+","+getY()+")";
	}

}

Klasse Strecke

/*
 * Aufgabe 37
 */
import Prog1Tools.IOTools;

public class Strecke{
	private Punkt p;
	private Punkt q;

	public Strecke(Punkt p, Punkt q){
		this.p = p;
		this.q = q;

	}

	public void read(){
		p.read("p");
		q.read("q");
	}

	public double getLaenge(){
		return Math.sqrt( ((p.getX() - q.getX())*(p.getX() - q.getX())) + ((p.getY() - q.getY())*(p.getY() - q.getY())) );
	}

	public String toString(){
		return "q:"+q.toString()+"p:"+p.toString();
	}

}

Klasse TestStrecke

/*
 * Aufgabe 37
 */
 /*@author Prof. D. Ratz */
public class TestStrecke {
  public static void main(String[] args) {
    Punkt ursprung = new Punkt(0.0,0.0); 
    Punkt endpunkt = new Punkt(4.0,3.0);
    Strecke s = new Strecke(ursprung,endpunkt);
    System.out.println("Die Laenge der Strecke " + s + 
                       " betraegt " + s.getLaenge() + ".");
    System.out.println();

    System.out.println("Strecke s eingeben:");
    s.read();
    System.out.println();

    System.out.println("Die Laenge der Strecke " + s + 
                       " betraegt " + s.getLaenge() + ".");
  } 
}

/*
 * Konsolen-Ausgabe:
 * Die Laenge der Strecke q:(4.0,3.0)p:(0.0,0.0) betraegt 5.0.
 *
 * Strecke s eingeben:
 * Eingabe p x: 1
 * Eingabe p y: 1
 * Eingabe q x: 2
 * Eingabe q y: 2
 *
 * Die Laenge der Strecke q:(2.0,2.0)p:(1.0,1.0) betraegt 1.4142135623730951.
 *
 */

Aufgabe 38+39

Klasse Bruch

/*
 * Aufgabe 38
 */
import Prog1Tools.IOTools;

public class Bruch{
    private int zaehler;
    private int nenner;

    public Bruch(int zaehler, int nenner){
        this.zaehler = zaehler;
        this.nenner = nenner;
    }

    public Bruch(){
    }    

    public int getZaehler(){
        return zaehler;
    }
    public int getNenner(){
        return nenner;
    }

    public int ggt(int a, int b){
    if ( a == 0)
         return b;
        if (b == 0)
         return a;

        int x = Math.abs(a);
        int y = Math.abs(b);

        while(x != y){
            if(x>y)
                x=x-y;
            else
                y=y-x;
            
        }
        return x;
    }

    public String toString(){
        return zaehler+"/"+nenner ;
    }

    public Bruch kuerze(){
        int ggT = ggt(this.zaehler,this.nenner);
        Bruch gekuerzt = new Bruch(this.zaehler/ggT,this.nenner/ggT);
        
        if (gekuerzt.zaehler < 0 && gekuerzt.nenner < 0){
            gekuerzt.zaehler = -gekuerzt.zaehler;
            gekuerzt.nenner = -gekuerzt.nenner;
        }    
        return gekuerzt;    
    }

    public void einlesen(){
        zaehler = IOTools.readInteger("Zaehler:");
        nenner = 0;
        while(nenner == 0){
            nenner = IOTools.readInteger("Nenner (nicht 0):");
        }                
    }

    public Bruch kehrwert(){
        Bruch returnWert = new Bruch(this.nenner,this.zaehler);

        return returnWert;        
    }

    public Bruch neg(){
        Bruch returnWert = new Bruch(-this.zaehler,this.nenner);

        return returnWert;        
    }

    public double wert(){
        return (double) this.zaehler/this.nenner;
    }

    public Bruch mul(Bruch faktor){
        Bruch returnWert = new Bruch(this.zaehler * faktor.zaehler,this.nenner * faktor.nenner);

        return returnWert.kuerze();        
    }

    public Bruch div(Bruch divisor){
        return mul(divisor.kehrwert());        
    }

    public Bruch add(Bruch summand){
        Bruch returnWert = new Bruch(this.zaehler * summand.nenner + summand.zaehler * this.nenner,this.nenner * summand.nenner );

        return returnWert.kuerze();        
    }

    public Bruch sub(Bruch subtrahendIn){
        //Original Bruch soll nicht verändert werden, deshalb zunächst Kopie erzeugen;
        Bruch subtrahend = new Bruch(subtrahendIn.zaehler,subtrahendIn.nenner);

        return add(subtrahend.neg());        
    }    
}

Klasse BruchTest

/*
 * Aufgabe 39
 */
import Prog1Tools.IOTools;

public class BruchTest{
  public static void main (String[] args) {
  	Bruch b1 = new Bruch();
  	b1.einlesen();
  	Bruch b2 = new Bruch();
  	b2.einlesen();

  	/*Ausführliche Schreibweise der Ausgabe: 
  	mul liefert ein Objekt zurück, diese wir mit toString() ausgegeben*/
  	Bruch erg;
	erg = b1.mul(b2);
  	System.out.println("Multiplikation:"+ erg.toString());

  	/*Kurzschreibweise: Die Laufzeitumgebung erkennt als Ergebnis ein Objekt und führt toString() aus */
  	System.out.println("Division:"+ b1.div(b2));
  	System.out.println("Addition:"+ b1.add(b2));
  	System.out.println("Subtratkion:"+ b1.sub(b2));
  	System.out.println("Doublewert:"+ b1.wert());
  	System.out.println("Kehrwert:"+ b1.kehrwert());
  	System.out.println("negativ:"+ b1.neg());
  	System.out.println("gekuerzt:"+ b1.kuerze());

  }
}

Aufgabe 40

Hier gibt es entsprechend der “komplexität” bzw. des “Umfangs” des Programms verschiedene Lösungsmöglichkeiten.  Ich habe eine Lösung mittels Do-While Schleife gewählt und Frage die Aktionen in einer If-Abfrage ab. Hier wäre auch ein Switch-Case Block möglich. Wichtig ist in jedem fall die Strings mit .equals(“…”) zu vergleichen. Ob die Berechnung oder dei Eingabe im Programm zuerst gemacht wird spielt in diese Konstellation ebenfalls keine Rolle.

Klasse BruchRechner

/*
 * Aufgabe 40
 */
import Prog1Tools.IOTools;
 
public class BruchRechner{
	  public static void main (String[] args) {
	  	String control = "";
	  	Bruch b1 = new Bruch();
	  	Bruch b2 = new Bruch();
	  	
	  	do{
			if(control.equals("1")){
				b1.einlesen();
			}
			else if(control.equals("2")){
				b2.einlesen();
			}
			else if(control.equals("b")){
				b1 = b1.kuerze();
				b2 = b2.kuerze();
			}
			else if(control.equals("*")){
				System.out.println("Ergebnis Multiplikation: "+b1.mul(b2));
			}
			else if(control.equals("/")){
				System.out.println("Ergebnis Division: "+b1.div(b2));
			}	
			else if(control.equals("+")){
				System.out.println("Ergebnis Addition: "+b1.add(b2));
			}
			else if(control.equals("-")){
				System.out.println("Ergebnis Subtraktion: "+b1.sub(b2));
			}	
			else if(control.equals("n")){
				b1 = b1.neg();
			}				
			else if(control.equals("k")){
				b1 = b1.kehrwert();
			}						
			else if(control.equals("d")){
				System.out.println("Double Wert Bruch1: "+ b1.wert());
			}
		
	  	
	  		System.out.println("Bruch 1: "+b1);
	  		System.out.println("Bruch 2: "+b2);

	  		System.out.println("Aktionen:");
			System.out.println("  x: beenden");
			System.out.println("  1: Bruch 1 einlesen");
			System.out.println("  2: Bruch 2 einlesen");
			System.out.println("  b: Brueche kuerzen");		
			System.out.println("  *,/,+,-: Grundrechenarten");	
			System.out.println("  n: Bruch 1 negativ");	
			System.out.println("  k: Kehrwert von Bruch 1");
			System.out.println("  d: Double-Wert von Bruch 1");
				  		
	  		control = IOTools.readString("Eingabe:");
	  	}
	  	while (!control.equals("x"));
	  }
}

Programmieren Praxis 5: Objekte, Instanzen

Aufgabe 32

Klasse
/*
 * Aufgabe 32
 */

import Prog1Tools.IOTools;

public class In{

	public static int readI(String text){

		return IOTools.readInteger(text);

	}

	public static double readD(String text){

		return IOTools.readDouble(text);

	}	

}
Test
/*
 * Aufgabe 32 - Test
 */

public class In_Test{

	public static void main (String[] args){
		int intZahl = In.readI("Eine Integer Zahl:");
		System.out.println(intZahl);
		double doubleZahl = In.readD("Eine Double Zahl:");
		System.out.println(doubleZahl);

	}

}

Aufgabe 33

/*
 * Aufgabe 33
 */

public class MyMath{

	public static int hoch(int x, int k){
		return (int)hoch((double)x,k);		
	}

	public static double hoch(double x, int k){
		//Erstmal Exponent 0 abfangen
		if(k==0)
		  return (1*x)/Math.abs(x); //1 bzw. -1 bei negativer Basis

		double wert = x;
		for(int i = Math.abs(k); i > 1; i--){
			wert = wert * x;
		}

		if (k<0){//Negative Exponenten
			return 1/wert;
		}		
		else{//Positive Exponenten
			return wert;
		}
	}	

	public static void main (String[] args){	
		int Basis1 = In.readI("Basis (ganze Zahl) eingeben:");
		int Exponent1 = In.readI("Exponent (ganze Zahl) eingeben:");

		System.out.println("int hoch int: " + hoch(Basis1,Exponent1));

		double Basis2 = In.readD("Basis (Double Zahl) eingeben:");
		int Exponent2 = In.readI("Exponent (ganze Zahl) eingeben:");		

		System.out.println("double hoch int: " + hoch(Basis2,Exponent2));

	}

}

Aufgbe 34

Klasse

Ergänzend zur Aufgabe habe ich noch einen Überladenen Konstruktor ohne Parameter der das Objekt mit Default-Werten befüllt

/*
 * Aufgabe 34
 */

public class CD{
	public String titel;
	public double spieldauer;
	public boolean ausgeliehen;

	//Konstruktor
	public CD(String inTitel, double inSpieldauer, boolean inAusgeliehen){
		titel = inTitel;
		spieldauer = inSpieldauer;
		ausgeliehen = inAusgeliehen;
	}

	//Überladener Konstruktor mit Default Werten
	public CD(){
		titel = "-ohne Titel-";
		spieldauer = 0.0;
		ausgeliehen = false;
	}

 	//Instanzfunktion
	public String toString(){ 	
		return titel + " (" + spieldauer + " Minuten)" ;
	}
}
Test
/*
 * Aufgabe 34 - Test
 */

import Prog1Tools.IOTools;

public class CD_Test{

	public static void main (String[] args){

		    String titel      	= IOTools.readLine("Titel:");
		    double spieldauer 	= IOTools.readDouble("Spieldauer:");
		    boolean ausgeliehen = IOTools.readBoolean("Ausgeliehen:");

			CD meineCD = new CD(titel,spieldauer,ausgeliehen);

			System.out.println("Ausgabe: \n" + meineCD.toString());

			CD nochneCD = new CD();
			System.out.println("Ausgabe: \n" + nochneCD.toString());
	}
}
/*
 * Konsolen-Ausgabe:
 * 
 * Titel:blubb
 * Spieldauer:40
 * Ausgeliehen:false
 * Ausgabe: 
 * blubb (40.0 Minuten)
 * Ausgabe: 
 * -ohne Titel- (0.0 Minuten)
 * 
 */

Aufgabe 35

Es wird die Klasse CD.class aus Aufgabe 34 verwendet.

/*
 * Aufgabe 35
 */
import Prog1Tools.IOTools;
 
public class Party{
	
		public static void einlesen(CD[] cdf){
			for(int i = 0; i< cdf.length;i++){
				cdf[i] = new CD(IOTools.readLine("Titel CD"+(i+1)+":")
							   ,IOTools.readDouble("Spieldauer CD"+(i+1)+":")
							   ,IOTools.readBoolean("Ausgeliehen CD"+(i+1)+":")
							   );
			}
		}

		public static void sortieren(CD[] cdf){ //SelectionSort
			for (int i = 0; i < cdf.length-1; i++){
				for (int j = i + 1; j < cdf.length; j++) {
					if (cdf[i].spieldauer < cdf[j].spieldauer) {
						CD temp = cdf[i];
						cdf[i] = cdf[j];
						cdf[j] = temp;
					}
				}				
			}
		}	

		public static void vorhandeneAusgeben(CD[] cdf){
			double spieldauerGesamt = 0.0;
			System.out.println("\nNicht ausgeliehene CDs nach Spieldauer sortiert:");
			for(int i = 0; i<cdf.length; i++){
				if(!cdf[i].ausgeliehen){ //Kurzschreibweise für (cdf[i].ausgeliehen != true)
				  System.out.println(cdf[i].toString());
				  spieldauerGesamt = spieldauerGesamt + cdf[i].spieldauer;
				}
			}
			System.out.println("Gesamtspieldauer: " + spieldauerGesamt);			
		}				
	
		public static void main (String[] args){
			int anzahlCDs = IOTools.readInt("Wieviele CDs willst du eingeben:");
			CD[] meineCDs  = new CD[anzahlCDs];
			einlesen(meineCDs);
			sortieren(meineCDs);
			vorhandeneAusgeben(meineCDs);
		}
}
/*
 * Konsolenausgabe bei Verwendung von party.in
 * 
 *Nicht ausgeliehene CDs nach Spieldauer sortiert:
 *Pink Floyd: Echoes - The Best Of Pink Floyd (145.0 Minuten)
 *Madonna: GHV2 - Greatest Hits Vol. 2 (71.0 Minuten)
 *Lighthouse Family: Whatever Gets You Through The Day (59.0 Minuten)
 *Alicia Keys: Songs In A Minor (58.0 Minuten)
 *Robbie Williams: Swing When You're Winning (51.0 Minuten)
 *Sarah Connor: Green Eyed Soul (43.0 Minuten)
 *Gesamtspieldauer: 427.0
 * 
 */

Programmieren Praxis 4: Objekte

Aufgabe 24 + 25

Klasse Person

public class Person {
	public static int anzPersonen = 0;
	public int lfdNummer;
	public String vorname;
	public String name;
	public int alter;
	public boolean maennlich;
}

Klasse PersonenStatistik (Hauptprogramm)

/*
 * Aufgabe 24: Personen sortieren 
 * Aufgabe 25: Statistik
 */

import Prog1Tools.IOTools;

public class PersonenStatistik{
	public static void main (String[] args){
		//Deklarieren und Initialisieren für Einlesen und Sortieren
    	int anzPersonen = IOTools.readInteger("Bitte Anzahl der zu sortiertenden Personen eingeben:");
    	Person [] Personen = new Person[anzPersonen];
    	Person merker;

    	//Deklarieren für Statistik
    	int maximum = 0;
    	int minimum = 999999999;
    	double helperSummeMittelwert = 0;
    	double mittelwert = 0.0;
    	double helperSummeVarianz =0.0;
    	double varianz = 0.0;

		//Einlesen der Personen
		for (int i=0; i < Personen.length; i++){
			Personen[i] = new Person();
			Personen[i].lfdNummer = ++Person.anzPersonen; 
			Personen[i].name = IOTools.readString(i + 1 + ". Person Nachname:");
			Personen[i].vorname = IOTools.readString(i + 1 + ". Person Vorname:");
			Personen[i].alter = IOTools.readInt(i + 1 + ". Person Alter:");
			Personen[i].maennlich = IOTools.readBoolean(i + 1 + ". Person Maennlich (true/false): ");

			//Laufzeit sparen: Statistik gleich mitschreiben
			if (Personen[i].alter < minimum)
				minimum = Personen[i].alter;
			if (Personen[i].alter > maximum)
				maximum = Personen[i].alter;
			helperSummeMittelwert = helperSummeMittelwert + Personen[i].alter;
		}

		//Bubble-Sort nach Alter
		for (int i=1; i<Personen.length; i++){
			for (int j=0; j<Personen.length-i; j++){
				if (Personen[j].alter>Personen[j+1].alter){
					//Tauschen der Position im Array (Referenz wird getauscht, nicht das Objekt verändert)
					merker = Personen[j] ; 
					Personen[j] = Personen[j+1];
					Personen[j+1] = merker; 
				}
			}
		}

		//Statistik: Mittelwert und Varianz
		mittelwert = helperSummeMittelwert / Personen.length;
		for (int i = 0; i<Personen.length; i++){		
			helperSummeVarianz = helperSummeVarianz + Math.pow(Personen[i].alter-mittelwert,2);
		}
		varianz = helperSummeVarianz / Personen.length;

		//Ausgabe der Personen
		for (int i=0; i<Personen.length; i++){
			System.out.print("Person "+ (i+1) +": ");
			System.out.print(Personen[i].vorname+" ");
			System.out.print(Personen[i].name+", ");
			System.out.print(Personen[i].alter+" Jahre ");
			if (Personen[i].maennlich)
				System.out.print("maennlich, ");
			else
				System.out.print("weiblich, ");
			System.out.print("Lfd. Nr. " + Personen[i].lfdNummer);
			System.out.print("\n");
		}		

		//Ausgabe der Statistik
		System.out.println("Statistik:");
		System.out.println("Mittelwert der Altersangaben: "+mittelwert);
		System.out.println("Varianz der Altersangeben: "+varianz);
		System.out.println("Minimum der Altersangaben: "+minimum);
		System.out.println("Maximum der Altersangaben: "+maximum);

	}
}
/*
 * Konsolenausgabe (bei verwendung von PersListe.in):
 * Person 1: Dietmar Ratz, 5 Jahre maennlich, Lfd. Nr. 26
 * Person 2: Gisela Schillinger, 15 Jahre weiblich, Lfd. Nr. 32
 * ...
 * Person 47: Anatoli Semenenko, 118 Jahre maennlich, Lfd. Nr. 38
 * Person 48: Roland Schätzle, 121 Jahre maennlich, Lfd. Nr. 29
 * Statistik:
 * Mittelwert der Altersangaben: 44.520833333333336
 * Varianz der Altersangeben: 677.2078993055557
 * Minimum der Altersangaben: 5
 * Maximum der Altersangaben: 121
 */

Aufgabe 28 -31

Klasse Bruchzahl

public class Bruchzahl{
	public int zaehler;
	public int nenner;
}

Klasse Rechnen (Hauptprogramm)

/*
 * Aufgabe 28: Funktion ggt
 * Aufgabe 29: Bruchzahl
 * Aufgabe 30: Funktion kehrwert
 * Aufgabe 31: Grundrechenarten (mul,div,add,sub)
 */

import Prog1Tools.IOTools;
 
public class Rechnen{

	public static int ggt(int a, int b){
		if ( a == 0)
		 return b;
		if (b == 0)
		 return a;

		int x = Math.abs(a);
		int y = Math.abs(b);

		while(x != y){
			if(x>y)
				x=x-y;
			else
				y=y-x;
			
		}
		return x;
	}

	public static void einlesen(Bruchzahl bruchzahl){

		bruchzahl.zaehler = IOTools.readInteger("Zaehler:");
		bruchzahl.nenner = 0;
		while(bruchzahl.nenner == 0){
			bruchzahl.nenner = IOTools.readInteger("Nenner (nicht 0):");
		}
	}

	public static void ausgeben (Bruchzahl bruchzahl){
		System.out.println(bruchzahl.zaehler + " / "+bruchzahl.nenner);
	}

    //Überladene Methode ausgeben mit zusätzlicher Text-Ausgabe über Parameter
	public static void ausgeben (String text, Bruchzahl bruchzahl){
		double reelerWert = (double)bruchzahl.zaehler / (double)bruchzahl.nenner;
		System.out.println(text + " "+ bruchzahl.zaehler + " / "+bruchzahl.nenner + " (" + reelerWert  + ")");
	}	

	public static double wert (Bruchzahl bruchzahl){
		return (double)bruchzahl.zaehler / (double)bruchzahl.nenner;
	}

	public static Bruchzahl kehrwert (Bruchzahl bruchzahl){
		Bruchzahl returnWert = new Bruchzahl();

		returnWert.zaehler = bruchzahl.nenner;
		returnWert.nenner = bruchzahl.zaehler;

		return returnWert;
	}

	public static Bruchzahl neg (Bruchzahl bruchzahl){
		Bruchzahl returnWert = new Bruchzahl();

		returnWert.zaehler = -bruchzahl.zaehler; //negieren
		returnWert.nenner = bruchzahl.nenner;

		return returnWert;
	}	

	public static void kuerzen (Bruchzahl bruchzahl){
		int ggT = ggt(bruchzahl.zaehler,bruchzahl.nenner);
		bruchzahl.zaehler = bruchzahl.zaehler / ggT;
		bruchzahl.nenner = bruchzahl.nenner / ggT;
		if (bruchzahl.zaehler < 0 && bruchzahl.nenner < 0){
			bruchzahl.zaehler = -bruchzahl.zaehler;
			bruchzahl.nenner = -bruchzahl.nenner;
		}
	}

	public static Bruchzahl mul (Bruchzahl a, Bruchzahl b){
		Bruchzahl returnWert = new Bruchzahl();

		returnWert.nenner = a.nenner * b.nenner;
		returnWert.zaehler = a.zaehler * b.zaehler;
		kuerzen (returnWert);
		return returnWert;
	}

	public static Bruchzahl div (Bruchzahl a, Bruchzahl b){
		Bruchzahl returnWert = new Bruchzahl();
		Bruchzahl kehrWert = new Bruchzahl();

		kehrWert.nenner = b.zaehler;
		kehrWert.zaehler = b.nenner;
		
		returnWert = mul(a,kehrWert);

		return returnWert;
	}	

	public static Bruchzahl add (Bruchzahl a, Bruchzahl b){
		Bruchzahl returnWert = new Bruchzahl();
		returnWert.nenner = a.nenner * b.nenner;
		returnWert.zaehler = a.zaehler * b.nenner + b.zaehler * a.nenner;
		kuerzen(returnWert);

		return returnWert;
	}	

	public static Bruchzahl sub (Bruchzahl a, Bruchzahl b){
		Bruchzahl returnWert = new Bruchzahl();
		b.nenner = -(Math.abs(b.nenner));
		returnWert = add(a,b);

		return returnWert;
	}			

	
	public static void main (String[] args){

/*
		int a = IOTools.readInteger("a:");
		int b = IOTools.readInteger("b:");
		System.out.print("ggt: "+ ggt(a,b));
*/

/*
		Bruchzahl meineBruchzahl = new Bruchzahl();
		einlesen(meineBruchzahl);
		kuerzen(meineBruchzahl);
		ausgeben(meineBruchzahl);
		System.out.println("Wert: " + wert(meineBruchzahl));
*/

		Bruchzahl ersteBruchzahl = new Bruchzahl();
		Bruchzahl zweiteBruchzahl = new Bruchzahl();
		einlesen(ersteBruchzahl);
		einlesen(zweiteBruchzahl);
		ausgeben ("Multiplikation:",mul(ersteBruchzahl,zweiteBruchzahl));
		ausgeben ("Division:",div(ersteBruchzahl,zweiteBruchzahl));
		ausgeben ("Addition:",add(ersteBruchzahl,zweiteBruchzahl));
		ausgeben ("Subtraktion:",sub(ersteBruchzahl,zweiteBruchzahl));	
	}
}

Programmieren Praxis 3: Arrays

Aufgabe 21

/*
 * Aufgabe 21: Sortieren von int Werten in einem Array
 */

import Prog1Tools.IOTools;

public class Aufgabe21{
	public static void main (String[] args){
		//Deklarieren und Initialisieren entsprechend der einzugebenden Zahlen	
		int	count	= IOTools.readInteger("Anzahl der zu sortierenden Zahlen:");
		int []feld  = new int [count];	
		int merker  ;

		//Einlesen der n-Zahlen
		for (int i=0; i<count; i++){
			feld[i] = IOTools.readInteger(i + 1 + ". Zahl:");
		}

		//Sortieren
		for (int i=1; i<feld.length; i++){
			for (int j=0; j<feld.length-i; j++){
				if (feld[j]>feld[j+1]){
					merker = feld[j] ; //Wert aus 1.Feld merken
					feld[j] = feld[j+1]; //Wert aus 2.Feld in 1.Feld schreiben
					feld[j+1] = merker; //Alter Wert aus Feld 1 in Feld 2 schreiben
				}
			}
		}

		//Kontrollausgabe
		for (int i=0; i<count; i++){
			System.out.print(feld[i] + ";");
		}					
	}
}

Aufgabe 22

/*
 * Aufgabe 22: Ausgabe eines Weihnachtsbau mit n-Ebenen
 */

import Prog1Tools.IOTools;

public class Aufgabe22{
	public static void main (String[] args){
		int	hoehe = IOTools.readInteger("Höhe des Baumes:");

		//Durchlauf durch alle Ebenen
		for(int ebene=1; ebene <= hoehe ; ebene++){

			//Leerstellen Ausgeben
			for(int j = 1; j <= hoehe-ebene; j++){
				System.out.print(" ");
			}		

			//Sterne Ausgaben
			for(int j = 1; j <= ebene+(ebene-1); j++){
				System.out.print("*");
			}
			System.out.print("\n");		
		}

		//Stamm ausgeben
		for(int j = 1; j < hoehe; j++){
			System.out.print(" ");
		}				
		System.out.print("I");	
	}
}

Aufgabe 23

/*
 * Aufgabe 23: Magisches Quadrat
 */

import Prog1Tools.IOTools;

public class Aufgabe23{
	public static void main (String[] args){
		//Deklarieren und Initialisieren unabhängigen Variablen
		int n = 0;
		int min = 2;
		int max = 10;

		//Einlesen einer ungeraden Zahl zwischen 2 und 10 als Bezugswert
		do{
			n = IOTools.readInteger("Bitte eine ungerade Zahl >2 < 10 Eingeben:");
		}
		while( (n > max) || (n < min) || (n%2 == 0) );

		//Deklarieren und Initialisieren der vom Bezugswert Abhängigen Variablen und des Feldes
		int[][]feld = new int[n][n];
		int zeile = n/2;
		int spalte = (n/2+1);

		//Befüllen des Feldes
		for(int i=1; i <= (n*n); i++){
			//Schreiben des Wertes an Position 
			feld[zeile][spalte] = i;

			//Neue Position einnehmen
			spalte++;
			zeile--;

			//Prüfen ob Position innerhalb des Feldes ist
			if(zeile <0){
				zeile = n-1; //Zurück ins Feld
			}
			if(spalte == n){
				spalte = 0; //Zurück ins Feld
			}

		    //Prüfen ob an der Position noch kein Wert vorhanden ist
			if (feld[zeile][spalte] !=0){
				//Position überpringen
				zeile++;
				spalte++;
				//Prüfen ob Position innerhalb des Feldes
				if(zeile == n){
					zeile = 0; //Zurück ins Feld
				}
				if(spalte == n){
					spalte = 0; //Zurück ins Feld
				}												
			}			
		}

		//Ausgabe des Feldes
		for (int i=0; i < n; i++){
			for( int k=0; k < n; k++){
				if(feld[i][k] < 10)
				 System.out.print(" ");

				System.out.print(feld[i][k]+" ");
			}
			System.out.print("\n");
		}		
	}
}

Praxis 2: If-Anweisung und Schleifen

Bearbeitung des Übungsblatt 3 im PC-Labor. Diesmal gab es keine komplizierteren Sachen, sondern nur Fingerübungen.

Wie immer sind alle Programmbeispiele in EJE7.0 Erstellung und kompiliert, also lauffähig.

Aufgabe 10

/*
 * Aufabe 10: Zu einem beliebigen Datum den zugehörigen Wochentag ausgeben
 */

import Prog1Tools.IOTools;

public class Aufgabe10{
		public static void main (String[] args){

		//Initialisieren der Variablen 
		//Hinweis: Variablennamen sind in der Aufgabe vorgegeben
		int 	t; 		//Tag 
		int 	m; 		//Montag
		int 	j; 		//Jahr
		int 	iot; 	//Eingabe Tag;
		int 	iom; 	//Eingabe Monat;
		int 	ioj; 	//Eingabe Jahr;
		int 	h; 		//Wochentag
		int 	c; 		//Hilfsvariable
		int 	y; 		//Hilfsvariable
		String 	wochentag = "";

		//Einlesen des Datum aus Eingabe
        t = iot = IOTools.readInteger("Bitte Datum eingeben - Tag:");
        m = iom = IOTools.readInteger("Bitte Datum eingeben - Monat:");
        j = ioj = IOTools.readInteger("Bitte Datum eingeben - Jahr:");                

		//Berechnung Wochentag (Numerisch)
		if (m &lt;= 2){
		  m = m+10;
		  j--;
		}
		else{
		  m = m-2;
		}

		c = j/100;
		y = j%100;

		h = (((26*m-2)/10)+t+y+y/4+c/4-2*c)%7;

		if (h&lt;=0){
		  h = h+7;
		}		

		//Zuordnung Wochentag
		switch (h){
			case 1:
			  wochentag = "Montag";
			  break;
			case 2:
			  wochentag = "Dienstag";
			  break;
			case 3:
			  wochentag = "Mittwoch";
			  break;
			case 4: 
			  wochentag = "Donnerstag";
			  break;
			case 5:
			  wochentag = "Freitag";
			  break;
			case 6:
			  wochentag = "Samstag";
			  break;
			case 7: 
			  wochentag = "Sonntag";
			  break;
			default:
			  wochentag ="Fehler";
		}
		//Ausgabe Datum + Wochentag
		System.out.println("Der "+iot+"."+iom+"."+ioj+" ist ein "+wochentag+". ");			
		}
}
<span style="color: #666666; font-family: Courier New;">/*
 * Konsolenausgabe: 
 * Bitte Datum eingeben - Tag:11
 * Bitte Datum eingeben - Monat:10
 * Bitte Datum eingeben - Jahr:2013
 * Der 11.10.2013 ist ein Freitag.
 */</span>

Aufgabe 11

/*
 * Aufabe 11: Das vielfache (1-10fache) einer eingelesenen Zahl ausgeben
 */

import Prog1Tools.IOTools;

public class Aufgabe11{
	public static void main (String[] args){

		//Initialisieren + Einlesen der Zahl
		int zahl = IOTools.readInteger("Bitte eine ganze Zahl eingeben:");

		//Vorbereiten der Ausgabe
		System.out.print("Die Vielfachen: ");

		//Berechnen und Ausgabe des Vielfachen
		for (int i = 1; i<=10; i++)
		  System.out.print(zahl*i +" ");			
	}
}
/*
 * Konsolenausgabe:
 * Bitte eine ganze Zahl eingeben:3
 * Die Vielfachen: 3 6 9 12 15 18 21 24 27 30 
 */

Aufgabe 12

Hier habe ich ergänzend zur Aufgabenstellung noch eine Rundung auf zwei Nachkommastellen mit der Methode Java.text vorgenommen.

/*
 * Aufabe 12: Zineszinsberechnung mit Ausgabe des Wertes nach jedem Jahr der Laufzeit 
 */

import Prog1Tools.IOTools;
import java.text.*;

public class Aufgabe12{
	public static void main (String[] args){

		//Initialisieren und Einlesen der Berechnungsgrundlage
		double	betrag 			= IOTools.readDouble("Anzulegender Geldbetrag in EUR:");
		double	zinssatz 		= IOTools.readDouble("Jahreszins (z.B. 0.1 für 10 Prozent:");
		int		laufzeit 		= IOTools.readInteger("Laufzeit (in Jahre):");
		DecimalFormat f 		= new DecimalFormat("#0.00"); //Formatierung der Ausgabe festlegen

		//Berechnung und Ausgabe über die gesamte Laufzeit
		for( int i = 1; i <= laufzeit; i++){
			betrag = betrag + (betrag * zinssatz);
			System.out.println("Wert nach "+i+" Jahren:" + f.format(betrag)); //Ausgabe gerundet auf 2 Nachkommastellen
		}	
	}
}
/*
 * Konsolenausgabe:
 * nzulegender Geldbetrag in EUR:1000
 * Jahreszins (z.B. 0.1 für 10 Prozent:0.06
 * Laufzeit (in Jahre):6
 * Wert nach 1 Jahren:1060,00
 * Wert nach 2 Jahren:1123,60
 * Wert nach 3 Jahren:1191,02
 * Wert nach 4 Jahren:1262,48
 * Wert nach 5 Jahren:1338,23
 * Wert nach 6 Jahren:1418,52
 */

Aufgabe 13

/*
 * Aufabe 13: Ausgabe eines Dreieck aus "*" nach eingabe der Ebenen
 */

import Prog1Tools.IOTools;

public class Aufgabe13{
	public static void main (String[] args){
		int	ebenen	= IOTools.readInteger("Anzahl der Ebenen:");

		for(int i = 1; i <= ebenen; i++){
			for(int j=1; j <= i; j++){
          	  System.out.print("*");
			}			
			System.out.print("\n"); //Zeilenumbruch
		}	
	}
}
/*
 * Konsolenausgabe:
 * Anzahl der Ebenen:6
 * *
 * **
 * ***
 * ****
 * *****
 * ******
 */

Aufgabe 14

Auch hier habe ich das Programm über die Aufgabenstellung hinaus erweitert. Es ist auch in der Lage die Eingabe der Zahl 0 sowie negative Zahlen zu verarbeiten.

/*
 * Aufabe 14: Einlesen einer Zahl und Ausgabe als Ziffer in umgekehrter Reihenfolge
 */

import Prog1Tools.IOTools;

public class Aufgabe14{
	public static void main (String[] args){
		int	zahl	= IOTools.readInteger("Positive ganze Zahl:");		
		int ziffer;
		boolean zahlNegativ = false;

		//Abfangen von 0 und negativen Zahlen
		if (zahl == 0){
			System.out.println("Null - Nicht wirklich eine Positive Zahl!");
		}
		else if(zahl < 0){
			zahl = Math.abs(zahl); //Betrag der Zahl => Positive Zahl
			zahlNegativ = true;
		}

		//Zerlegen der Zahl und ausgabe der einzelnen Ziffern
		while(zahl > 0){

		  ziffer = zahl % 10;
		  zahl = zahl/10;

		  switch(ziffer){
		  	case 0: System.out.println("Null"); break;
		  	case 1: System.out.println("Eins"); break;
		  	case 2: System.out.println("Zwei"); break;
		  	case 3: System.out.println("Drei"); break;
		  	case 4: System.out.println("Vier"); break;
		  	case 5: System.out.println("Fünf"); break;
		  	case 6: System.out.println("Sechs"); break;
		  	case 7: System.out.println("Sieben"); break;
		  	case 8: System.out.println("Acht"); break;
		  	case 9: System.out.println("Neun"); break;	
		  }			
		}		

		//Bei Negativen Zahlen noch "Minus" ausgeben
		if(zahlNegativ){
		  System.out.println("Minus");
		}
	}
}
/*
 * Konsolenausgabe:
 * Positive ganze Zahl:-456
 * Sechs
 * Fünf
 * Vier
 * Minus
 */

Aufgabe 15

TODO: Unschön sollte nochmal überarbeitet werden!

/*
 * Aufabe 15: Zahlenratespiel 
 */

import Prog1Tools.IOTools;

public class Aufgabe15{
	public static void main (String[] args){

        //Deklarieren und Initialisieren
		int geheimeZahl = (int) (99*Math.random()+1);
		int maxVersuche = 10; //Beschränkung der Versuche ist in der Aufgabe eigentlich nicht gefordert
		int gerateneZahl = 0;
		int anzVersuche = 0;

		geheimeZahl = 88;

		//Ausgabe Begrüßungstext
		System.out.println("Wilkommen beim Zahlenraten!");
		System.out.println("Ich denke mir eine Zahl zwischen 0 und 100. Rate die Zahl!");

		if (maxVersuche > 0){
		  System.out.println("Damit es nicht zu einfach wird hast du nur "+maxVersuche+" Versuche!!!");
		}

		//Hauptprogramm: 
		//Einlesen und prüfen ob die Zahl größer oder kleiner ist, solange sie nicht richtig geraten ist
		do{
			anzVersuche ++;
			gerateneZahl = IOTools.readInteger(anzVersuche + ". Versuch: ");		

            if(gerateneZahl < geheimeZahl){
            	System.out.println("Meine Zahl ist größer!");
            }
            else if(gerateneZahl > geheimeZahl){
            	System.out.println("Meine Zahl ist kleiner!");
            }

			if (maxVersuche > 0 && ((maxVersuche - anzVersuche)>0)){
				System.out.println("Du hast noch " + (maxVersuche - anzVersuche) +" Versuche!");
			}
		}
		while(gerateneZahl != geheimeZahl && (maxVersuche <= 0 || (maxVersuche > anzVersuche) ) );

		//Entscheiden ob Gewonnen oder Verloren wurde (Wenn Anzahl der Versuche begrenzt)
		if ((gerateneZahl == geheimeZahl) && (maxVersuche <= anzVersuche) || (maxVersuche == 0)){
			System.out.println("Glückwunsch! Du hast die Zahl beim "+ anzVersuche +" Versuch erraten!");
		}
		else{
			System.out.println("Verloren! Du hast die Zahl beim "+ anzVersuche +". Versuch noch nicht erraten!");
		}

	}
}