Solange Stapel nicht leer:
 zeichen = pop()
 Wenn zeichen nicht '(':
   schreibe zeichen in die Ausgabe
Verlasse Schleife wenn zeichen '(' ist

Wenn Stapel leer:
 push(neuerOp)
sonst:
 Solange Stapel nicht leer ist:
   zeichen = pop()
   Wenn zeichen '(' ist:
      lege zeichen wieder auf den Stapel (push(zeichen))
   Wenn zeichen ein Operator opTop ist und
      wenn opTop < neuerOp:
      push(opTop)
   Wenn opTop >= neuerOp:
      schreibe opTop in die Ausgabe
 Verlasse die Schleife, wenn opTop < neuerOp oder
   wenn das zeichen '(' ist
 push(neuerOp)

Solange Stapel nicht leer ist:
 zeichen = pop()
 schreibe zeichen in die Ausgabe

Die Vergleiche opTop >= neuerOp bzw. opTop < neuerOp bedeuten einen Vergleich der Priorität (Auswertungsreihenfolge, Präzendent, Vorrang, Priorität). Es gilt Präzedenz:

0. (
1. + und -
2. * und /
3. alles Andere (z.B. sin, cos usw.)

Labels: Aufgabe, Java, PR2

# Eingestellt von Harald R. Haberstroh @ 11:58 0 Kommentare

hh@turing:~/netbeans/Gui2Eclipse/src> ls gui2eclipse/
Gui2EclipseAboutBox.form  Gui2EclipseAboutBox.java  Gui2EclipseApp.java  Gui2EclipseView.form  Gui2EclipseView.java  resources
hh@turing:~/netbeans/Gui2Eclipse/src> cp -r gui2eclipse/ ~/workspace/Gui2Eclipse/src/
hh@turing:~/netbeans/Gui2Eclipse/src> cd ~/workspace/Gui2Eclipse/

hh@turing:~/workspace/Gui2Eclipse/src> mkdir lib
hh@turing:~/workspace/Gui2Eclipse/src> cd lib
hh@turing:~/workspace/Gui2Eclipse/src/lib> cp /usr/local/netbeans-6.1/java2/modules/ext/appframework-1.0.3.jar .
hh@turing:~/workspace/Gui2Eclipse/src/lib> cp /usr/local/netbeans-6.1/java2/modules/ext/swing-worker-1.1.jar .

Labels: eclipse, Java, netbeans, PR3, PR5

# Eingestellt von Harald R. Haberstroh @ 15:58 0 Kommentare

Sein vielleicht bekanntestes Vermächtnis stammt aus RFC 793, welches das Robustheitsprinzip beinhaltet und oft als Postels Gesetz bezeichnet wird: „be conservative in what you do, be liberal in what you accept from others“ („sei konservativ in dem was Du tust, sei tolerant in dem was Du von anderen akzeptierst“, oft formuliert als „sei konservativ in dem was Du sendest, sei tolerant in dem was Du empfängst“).

Dieses Prinzip klingt ziemlich vernünftig und wurde bei der TCP/IP-Implementierung und bei der Implementierung von Webbrowsern umgesetzt. Bei Protokollen bedeutet es, "halte dich genau an die Spezifikation beim Senden, sei aber tolerant beim Parsen der empfangenen Daten". Solange sich jeder an das Prinzip hält, funktioniert das prima. Wehe aber, wenn sich die Sender nicht alle an das Prinzip halten. Eine Zeit lang wird das funktionieren, das ist ja der Sinn dieses Prinzips.

Problematisch wird die Sache jedoch, wenn es Änderungen oder Erweiterungen des Protokolls gibt. Wie gesagt, kein Problem, wenn sich alle daran halten. Wenn sich nicht alle daran halten, es dann vielleicht aufgrund des Marktes ergibt, dass sich eine nicht-Standard-konforme Software weit verbreitet, kann es passieren, dass vieles nicht mehr funktioniert.

Ein Beispiel ist das World Wide Web mit HTML (ist zwar kein Protokoll sondern eine Auszeichnungssprache, das Protokoll ist HTTP): die Webbrowser waren sehr tolerant gegenüber dem empfangenen HTML-Code und versuchten eine "möglichst gute" Darstellung des Inhalts. Manche Browser waren da sehr tolerant (IE), andere sehr viel weniger (Netscape, Mozilla).

Ein Beispiel

<b>das ist fett und das ist <i>fett-und-kursiv</b></i>

Labels: allgemeines

# Eingestellt von Harald R. Haberstroh @ 18:21 0 Kommentare

/**
 * Beispiel für Bilderanzeige. Kann Bilddateien öffnen. Bild wird in etwa auf 
 * Fenstergröße skaliert.
 * Rotieren eines Bildes ist möglich.
 * Alle nötigen Klassen in dieser Datei.
 * FIXME: Ist noch ein bisschen Buggy: Skalieren sollte man extra aufrufen
 * können, ImageComponent passt nicht ganz nach rotieren (oder die Grafik?).
 * 
 * @author Harald R. Haberstroh
 */
package image;

import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.InputEvent;
import java.awt.event.KeyEvent;
import java.awt.geom.AffineTransform;
import java.awt.image.BufferedImage;
import java.awt.image.PixelGrabber;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;
import javax.swing.ImageIcon;
import javax.swing.JComponent;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JScrollPane;
import javax.swing.KeyStroke;
import javax.swing.filechooser.FileFilter;

/**
 * Bildkomponente, kann Bilder zeichnen, skalieren und rotieren.
 * 
 * @author Harald R. Haberstroh (hh)
 * 
 */
class ImageComponent extends JComponent {
  private static final long serialVersionUID = 8055865896136562197L;

  private BufferedImage image; // gelesenes Bild

  private Image scaled; // Hilfsvariable für skaliertes Bild

  /**
   * über diese Methode kann man eine Datei angeben, die geffnet und angezeigt
   * wird.
   * 
   * @param file
   *          Bilddatei
   */
  public void setImage(File file) {
    try {
      if ((image = ImageIO.read(file)) != null) {
        // Skalieren, unterscheide Hoch- und Querformat
        double scale = 1.0;
        if (image.getWidth() > image.getHeight()) { // Querformat
          scale = (double)getParent().getWidth() / image.getWidth();
        } else { // Hochformat
          scale = (double)getParent().getHeight() / image.getHeight();
        }
        scaled = image.getScaledInstance((int)(image.getWidth() * scale),
            (int)(image.getHeight() * scale), Image.SCALE_FAST);
        image = toBufferedImage(scaled);
        setPreferredSize(new Dimension(image.getWidth(), image.getHeight()));
        repaint();
      }
    } catch (IOException e) {
      e.printStackTrace();
    }
  }

  /**
   * rotieren der aktuellen Grafik.
   * 
   * @param degrees
   *          um soviele Grad wird gedreht (im Uhrzeigersinn).
   */
  public void rotate(double degrees) {
    image = rotateImage(image, degrees);
    setPreferredSize(new Dimension(image.getWidth(), image.getHeight()));
    repaint();
  }

  /**
   * Hilfsmethode, die eine Grafik (BufferedImage) drehen kann. Verwendet
   * AffineTransform zum Drehen. Wichtig ist, den Drehpunkt in die Mitte der
   * Grafik zu legen.
   * 
   * @param src
   *          Grafik
   * @param degrees
   *          um soviele Grad wird gedreht
   * @return neue gedrehte Grafik
   */
  private static BufferedImage rotateImage(BufferedImage src, double degrees) {
    AffineTransform affineTransform = AffineTransform.getRotateInstance(Math
        .toRadians(degrees), src.getWidth() / 2, src.getHeight() / 2);
    BufferedImage rotatedImage = new BufferedImage(src.getWidth(), src
        .getHeight(), src.getType());
    Graphics2D g = (Graphics2D)rotatedImage.getGraphics();
    g.setTransform(affineTransform);
    g.drawImage(src, 0, 0, null);
    return rotatedImage;
  }

  /**
   * hier wird gezeichnet..
   */
  @Override
  protected void paintComponent(Graphics g) {
    if (image != null) {
      g.drawImage(image, 0, 0, this);
    }
  }

  /**
   * Hilfsmethode, die ein Image in ein BufferedImage umwandelt, da direktes
   * Umwandeln nicht möglich. Benötigt man z.B. für Saklieren, da dort ein Image
   * geliefert wird, sonst aber BufferedIMage benötigt wird.
   * 
   * @param image
   *          Image
   * @return BufferedImage
   */
  public static BufferedImage toBufferedImage(Image image) {
    if (image instanceof BufferedImage) {
      return (BufferedImage)image;
    }

    // wirklich alle Pixel des image laden:
    image = new ImageIcon(image).getImage();

    // Gibt es transparente Pixel?
    boolean hasAlpha = hasAlpha(image);

    BufferedImage bimage = null;
    // Erzeuge buffered image mit dem default color model
    int type = BufferedImage.TYPE_INT_RGB;
    if (hasAlpha == true) {
      type = BufferedImage.TYPE_INT_ARGB;
    }
    bimage = new BufferedImage(image.getWidth(null), image.getHeight(null),
        type);

    // Kopiere image zu buffered image über den Graphic-Kontext:
    Graphics g = bimage.createGraphics();

    // Zeichne nun das Image auf den neuen Gracphic-Kontext (und damit auf das
    // buffered image)
    g.drawImage(image, 0, 0, null);
    g.dispose();

    return bimage;
  }

  /**
   * Hilfsmethode, die bestimmt, ob Transparenz vorhanden.
   * 
   * @param image
   * @return hat Alpha (Transparenz)
   */
  public static boolean hasAlpha(Image image) {
    // Wenn das image bereits ein buffered image, dann gibt's schon ein color
    // model
    if (image instanceof BufferedImage) {
      return ((BufferedImage)image).getColorModel().hasAlpha();
    }

    // Verwende einen pixel grabber um das color model (Farbmodell) zu
    // bestimmen.
    // Ein einzelnes Pixel genügt.
    PixelGrabber pg = new PixelGrabber(image, 0, 0, 1, 1, false);
    try {
      pg.grabPixels();
    } catch (InterruptedException e) {
    }

    // von dem Pixel wird nun das color model bestimmt und zurückgeliefert
    return pg.getColorModel().hasAlpha();
  }
}

/**
 * Aktion für Dateiauswahl.
 * 
 * @author Harald R. Haberstroh (hh)
 * 
 */
class FileOpenAction implements ActionListener {
  private final ImageComponent viewComponent;

  public FileOpenAction(ImageComponent viewComponent) {
    this.viewComponent = viewComponent;
  }

  /**
   * Dateiauswahldialog anzeigen.
   */
  public void actionPerformed(ActionEvent e) {
    JFileChooser d = new JFileChooser();
    d.setFileFilter(new FileFilter() {
      @Override
      public boolean accept(File f) {
        return f.isDirectory() || f.getName().toLowerCase().endsWith(".jpg")
            || f.getName().toLowerCase().endsWith(".gif");
      }

      @Override
      public String getDescription() {
        return "*.jpg;*.gif";
      }
    });

    d.showOpenDialog(null);
    File file = d.getSelectedFile();

    if (file != null)
      viewComponent.setImage(file);
  }
}

/**
 * Aktion für Rotieren.
 * 
 * @author Harald R. Haberstroh (hh)
 * 
 */
class RotateAction implements ActionListener {
  private final ImageComponent viewComponent;

  public RotateAction(ImageComponent viewComponent) {
    this.viewComponent = viewComponent;
  }

  public void actionPerformed(ActionEvent e) {
    viewComponent.rotate(90.0);
  }

}

/**
 * Einfacher Bildbetrachter.
 * 
 * @author Harald R. Haberstroh (hh)
 * 
 */
public class ImageViewer {
  public static void main(String[] args) {
    JFrame f = new JFrame("Bildbetrachter");

    ImageComponent viewComponent = new ImageComponent();
    f.add(new JScrollPane(viewComponent)); // zum Scrollen, falls Bild zu groß

    JMenuBar mbar = new JMenuBar();
    JMenu menu = new JMenu("Datei");
    JMenuItem item = new JMenuItem("Öffnen");
    item.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_O,
        InputEvent.CTRL_MASK));
    item.addActionListener(new FileOpenAction(viewComponent));
    menu.add(item);
    item = new JMenuItem("Drehen");
    item.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_R,
        InputEvent.CTRL_MASK));
    item.addActionListener(new RotateAction(viewComponent));
    menu.add(item);
    mbar.add(menu);
    f.setJMenuBar(mbar);

    f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    f.setSize(600, 400);
    f.setLocationRelativeTo(null); // zentrieren auf Bildschirmmitte
    f.setVisible(true);
  }
}

Labels: Java, PR3

# Eingestellt von Harald R. Haberstroh @ 07:09 0 Kommentare

/**
 * java-directories/utils.dir.FileFinder.java
 * @author (c) 2009, Harald R. Haberstroh
 * 21.01.2009
 */
package utils.dir;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
import java.util.logging.FileHandler;
import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.logging.SimpleFormatter;
import java.util.regex.Pattern;

/**
 * Suchen aller Dateien in einem Verzeichnis bzw. Unterverzeichnissen nach einem
 * bestimmten Muster (entnommen aus "Java ist eine Insel").
 * 
 * Ergänzt um Logging, da NullPointerException bei Verzeichnis mit seeeeehr
 * vielen Dateien und Unterverzeichnissen.
 * Tatsächliche Fehlerursache waren symbolische Links auf Verzeichnisse, auf
 * die ich keine Leserechte besaß.
 * 
 * @author Harald R. Haberstroh (hh)
 * 
 */
public class FileFinder {
  private static Logger logger = Logger.getAnonymousLogger();
  /**
   * initialisiere Klasse, setze Logging aus
   */
  static {
    logger.setLevel(Level.OFF); // default kein Logging
  }

  /**
   * Setze Logging Level
   * 
   * @param level
   */
  public static void setLogLevel(Level level) {
    logger.setLevel(level);
  }

  /**
   * Logging zusätzlich in Datei (*.txt Text, XML sonst)
   * 
   * @param filename
   *          Logfilename
   */
  public static void setLogFile(String filename) {
    try {
      if (filename.endsWith("txt")) { // lesbarer Text in Datei
        Handler handler = new FileHandler(filename);
        handler.setFormatter(new SimpleFormatter());
        logger.addHandler(handler);
      } else { // sonst XML (default)
        logger.addHandler(new FileHandler(filename));
      }
    } catch (IOException e) {
      e.printStackTrace(); // kann Logfile nicht schreiben, seeeehr schlimm
    }
  }

  /**
   * suche alle Dateien mit gegebenem Muster.
   * 
   * @param start
   *          Startverzeichnis
   * @param extensionPattern
   *          Dateimuster (regulärer Ausdruck)
   * @return Liste von Dateien
   */
  public static List find(String start, String extensionPattern) {
    List files = new ArrayList(1024);
    Stack dirs = new Stack();
    File startdir = new File(start);
    Pattern p = Pattern.compile(extensionPattern, Pattern.CASE_INSENSITIVE);

    if (startdir.isDirectory()) {
      logger.info(startdir + " ist ein Verzeichnis");
      dirs.push(startdir); // Startverzeichnis auf den Stack
    }

    while (dirs.size() > 0) { // solange ein Verzeichnis am Stack
      try {
        File[] listFiles = dirs.pop().listFiles();
        logger.info("prüfe " + listFiles.length + " Dateien");
        for (File file : listFiles) { // alle Dateien des Verzeichnisses
          if (file.isDirectory()) {
            logger.info(file + " ist ein Verzeichnis");
            dirs.push(file);
          } else {
            logger.info(file + " ist eine Datei");
            if (p.matcher(file.getName()).matches()) {
              files.add(file); // passt das Muster, dann in die Liste
            }
          }
        }
      } catch (Exception e) {
        logger.severe(e.getLocalizedMessage());
        e.printStackTrace();
        System.exit(1);
      }
    }
    return files;
  }
}

  static {
    logger.setLevel(Level.OFF); // default kein Logging
  }

  /**
   * listet alle Bilddateien der gegebenen Verzeichnisse.
   * 
   * @param args
   *          Verzeichnisse, aktuelles Verzeichns, falls leer
   */
  public static void main(String[] args) {
    // Logging aktivieren durch entfernen der Kommentarzeichen:
    // FileFinder.setLogFile("filefinder.txt");
    // FileFinder.setLogLevel(Level.ALL);
    String[] dirs = null;
    if (args.length > 0) {
      dirs = args;
    } else {
      dirs = new String[1];
      dirs[0] = new File(System.getProperty("user.dir")).getAbsolutePath();
    }
    for (String dir : dirs) {
      List files = FileFinder.find(dir,
          "(.*\\.gif$)|(.*\\.png$)|(.*\\.jpg$)"); // *.gif, *.png, *.jpg
      System.out.printf("Verzeichns %s - %s Datei%s:\n", dir,
          files.size() == 0 ? "keine" : "" + files.size(),
          files.size() == 1 ? "" : "en");
      for (File file : files) {
        System.out.println("  " + file.getAbsolutePath());
      }

    }
  }

Labels: Java, PR3

# Eingestellt von Harald R. Haberstroh @ 13:16 0 Kommentare

Labels: Aufgabe, Java, PR3

# Eingestellt von Harald R. Haberstroh @ 23:03 0 Kommentare

############################################################
#   Default Logging Configuration File
#
# You can use a different file by specifying a filename
# with the java.util.logging.config.file system property.
# For example java -Djava.util.logging.config.file=myfile
############################################################

############################################################
#   Global properties
############################################################

# "handlers" specifies a comma separated list of log Handler
# classes.  These handlers will be installed during VM startup.
# Note that these classes must be on the system classpath.
# By default we only configure a ConsoleHandler, which will only
# show messages at the INFO and above levels.
handlers= java.util.logging.ConsoleHandler

# To also add the FileHandler, use the following line instead.
#handlers= java.util.logging.FileHandler, java.util.logging.ConsoleHandler

# Default global logging level.
# This specifies which kinds of events are logged across
# all loggers.  For any given facility this global level
# can be overriden by a facility specific level
# Note that the ConsoleHandler also has a separate level
# setting to limit messages printed to the console.
.level= INFO

############################################################
# Handler specific properties.
# Describes specific configuration info for Handlers.
############################################################

# default file output is in user's home directory.
java.util.logging.FileHandler.pattern = %h/java%u.log
java.util.logging.FileHandler.limit = 50000
java.util.logging.FileHandler.count = 1
java.util.logging.FileHandler.formatter = java.util.logging.XMLFormatter

# Limit the message that are printed on the console to INFO and above.
java.util.logging.ConsoleHandler.level = INFO
java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter


############################################################
# Facility specific properties.
# Provides extra control for each logger.
############################################################

# For example, set the com.xyz.foo logger to only log SEVERE
# messages:
com.xyz.foo.level = SEVERE

java -Djava.util.logging.config.file=/pfad/zur/datei/logging.properties StartKlasse

/**
 * java-logging/log.LogDemo.java
 * @author (c) 2009, Harald R. Haberstroh
 * 20.01.2009
 */
package log;

import java.io.IOException;
import java.util.logging.FileHandler;
import java.util.logging.Filter;
import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.LogRecord;
import java.util.logging.Logger;
import java.util.logging.SimpleFormatter;

/**
 * Demonstration von Logging.
 * 
 * @author Harald R. Haberstroh (hh)
 * 
 */
public class LogDemo {
  /*
   * ein Logger für alle Instanzen - in der Logdatei sollten ALLE div()-Aufrufe
   * sein
   */
  // private Logger jlog = Logger.getLogger("at.haberstroh");
  /*
   * einLogger pro Instanz - in der Logdatei sollten nur die beiden
   * div()-Aufrufe sein
   */
  private Logger jlog = Logger.getAnonymousLogger();

  /**
   * Objekt mit Default-Logger
   */
  public LogDemo() {
    jlog.info("erzeuge LogDemo-Objekt");
  }

  /**
   * @param filter
   *          Log-Filter
   */
  public LogDemo(Filter filter) {
    this("log.txt");
    jlog.setLevel(Level.ALL);
    jlog.setFilter(filter);
    jlog.info("erzeuge LogDemo-Objekt");
  }

  /**
   * @param level
   *          Level, der angezeigt wird
   */
  public LogDemo(Level level) {
    jlog.setLevel(level);
    jlog.info("erzeuge LogDemo-Objekt");
  }

  /**
   * Log in Datei, *.txt -> lesbar, sonst XML.
   * 
   * @param filename
   *          Name der Log-Datei
   */
  public LogDemo(String filename) {
    try {
      if (filename.endsWith("txt")) { // lesbarer Text in datei
        Handler handler = new FileHandler(filename);
        handler.setFormatter(new SimpleFormatter());
        jlog.addHandler(handler);
      } else { // sonst XML (default)
        jlog.addHandler(new FileHandler(filename));
      }
    } catch (SecurityException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
    jlog.info("erzeuge LogDemo-Objekt");
  }

  /**
   * unsere Demo-Methode, dividier a durch b.
   * 
   * @param a
   * @param b
   * @return a/b
   */
  public double div(int a, int b) {
    jlog.fine("super, bin in div");
    jlog.entering("LogDemo", "div"); // verschiedene Log-DingsDas
    jlog.info("entering div");
    if (b == 0) {
      jlog.log(Level.SEVERE, "Division durch 0 ");
    }
    double result = 0.0;
    result = (double)a / b;
    jlog.exiting("LogDemo", "div", result);
    return result;
  }

  /**
   * @param args
   */
  public static void main(String[] args) {
    LogDemo demo;
    double r;
    System.out.println("*** LogDemo() ***");
    demo = new LogDemo();
    r = demo.div(5, 2);
    System.out.printf("Ergebnis: %f\n", r);
    r = demo.div(2, 0);
    System.out.printf("Ergebnis: %f\n", r);

    // Logdatei log.xml
    System.out.println("*** LogDemo(\"log.xml\") ***");
    demo = new LogDemo("log.xml");
    r = demo.div(5, 2);
    System.out.printf("Ergebnis: %f\n", r);
    r = demo.div(2, 0);
    System.out.printf("Ergebnis: %f\n", r);

    // Logdatei log.txt
    System.out.println("*** LogDemo(\"log.txt\") ***");
    demo = new LogDemo("log.txt");
    r = demo.div(5, 2);
    System.out.printf("Ergebnis: %f\n", r);
    r = demo.div(2, 0);
    System.out.printf("Ergebnis: %f\n", r);

    System.out.println("*** LogDemo(Level.OFF) ***");
    // logging off siehe entsprechenden Konstruktor:
    demo = new LogDemo(Level.OFF);
    r = demo.div(5, 2);
    System.out.printf("Ergebnis: %f\n", r);
    r = demo.div(2, 0);
    System.out.printf("Ergebnis: %f\n", r);

    System.out.println("*** LogDemo(Level.ALL) ***");
    demo = new LogDemo(Level.ALL); // logging alles
    r = demo.div(5, 2);
    System.out.printf("Ergebnis: %f\n", r);
    r = demo.div(2, 0);
    System.out.printf("Ergebnis: %f\n", r);

    System.out.println("*** LogDemo(new Filter() ...) ***");
    demo = new LogDemo(new Filter() {
      @Override
      public boolean isLoggable(LogRecord record) {
        String msg = record.getMessage();
        boolean log = msg.toLowerCase().contains("return");
        // System.out.println(".isLoggable(" + msg + ") " + log);
        if (log) {
          return true;
        } else {
          return false;
        }
      }

    });
    r = demo.div(5, 2);
    System.out.printf("Ergebnis: %f\n", r);
    r = demo.div(2, 0);
    System.out.printf("Ergebnis: %f\n", r);

  }

}

Labels: Java, PR3, PR5

# Eingestellt von Harald R. Haberstroh @ 22:22 0 Kommentare

• allgemeines - allgemeine Programmierthemen
• Aufgabe - Aufgabenstellung, der Bereich wird durch weitere Labels angegeben (z.B. Java, PR2)
• C - Programmiersprache C
• C# - Programmiersprache C#
• C++ - Programmiersprache C++
• eclipse - betrifft die Entwicklungsumgebung eclipse
• Fehler - Beispiele, Informationen zu Programmierfehlern
• Java - Programmiersprache Java
• Lösung - Musterlösung zu einer Aufgabe
• PR2 - Programmieren 2. Klasse
• PR3 - Programmieren 3. Klasse
• PR4 - Programmieren 4. Klasse
• PR5 - Programmieren 5. Klasse
• Programmiersprachen - allgemeine Themen zu Programimersprachen
• Python - Programmiersprache python
  

Labels: allgemeines, PR2, PR3, PR5

# Eingestellt von Harald R. Haberstroh @ 19:22 0 Kommentare

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;

/**
 * java-such-mark: .SuchMark.java
 * 
 * Zweck: markiere alle Suchbegriffe in der Eingabe durch Großschreibung und
 * Sternchen davor und danach.
 *
 * 10.01.2009, Harald R. Haberstroh
 */

/**
 * TODO Zweck
 * 
 * @author Harald R. Haberstroh (user)
 * 
 */
public class SuchMark {

  private String[] suchbegriffe;

  /**
   * @param suchbegriffe
   */
  public SuchMark(String[] suchbegriffe) {
    this.suchbegriffe = suchbegriffe;
  }

  /**
   * markiere alle Vorkommnisse der suchbegriffe im String content und liefere
   * das Ergebnis zurück.
   * 
   * @param content
   *          Eingabetext
   * @return Text mit Markierungen
   */
  public String mark(String content) {
    for (String what : suchbegriffe) {
      content = mark(content, what);
    }
    return content;
  }

  /**
   * markiere alle Vorkommnisse des Suchbegriffs what im Text content. Suche die
   * Position des Suchbegriffs mit indexOf() und verkleinere den content auf den
   * Rest hinter den Suchbegriff, nachdem der String vor dem Suchbegriff und der
   * markierte Suchbegriff an einen StringBuilder angehängt wurde.
   * 
   * @param content
   *          Text
   * @param what
   *          Suchbegriff
   * @return Text mit Markierungen
   */
  private String mark(String content, String what) {
    StringBuilder sb = new StringBuilder();
    int pos;
    int len = what.length();
    String wHAT = what.toUpperCase(); // der großgeschriebene Suchbegriff
    while ((pos = content.indexOf(what)) >= 0) {
      sb.append(content.substring(0, pos)); // alles vor Suchbegriff dazu
      sb.append('*'); // Markierung...
      sb.append(wHAT);
      sb.append('*');
      content = content.substring(pos + len); // alles vor Suchbegriff und
      // Suchbegriff selbst entfernen
    }
    sb.append(content); // den Rest noch anhängen
    return sb.toString();
  }

  /**
   * liest eine ganze Textdatei.
   * 
   * @param in
   *          geöffneter BufferedReader (Inputstream)
   * @return gelesener String
   * @throws IOException
   */
  public String readStream(BufferedReader in) throws IOException {
    StringBuilder sb = new StringBuilder();
    String line;
    while ((line = in.readLine()) != null) {
      sb.append(line);
      sb.append("\n");
    }
    return sb.toString();
  }

  /**
   * schreibt den String in Textdatei.
   * 
   * @param out
   *          PrintStream zum Schreiben
   * @param content
   *          Text zum Speichern
   */
  public void writeStream(PrintWriter out, String content) {
    out.write(content);
    out.flush();
  }

  /**
   * Hilfe ausgeben und Ende
   */
  private static void help() {
    System.out.println("Markieren der Suchbegriffe in der Eingabe.\n"
        + "Aufruf: java SuchMark [-h] [-o out] suchbegriffe...\n"
        + "  -h ... Hilfe\n" + "  -o out ... Ausgabe in die Datei out\n"
        + "  suchbegriffe ... ein oder mehrere Suchbegriffe");
    System.exit(0);
  }

  /**
   * Ausgeben einer Fehlermeldung und optional beenden des Programms.
   * 
   * @param exitStatus
   *          Programm beenden, wenn != 0
   * @param format
   *          Formatstring (Text)
   * @param objects
   *          Weiterer Parameter
   */
  private static void fehler(int exitStatus, String format, Object... objects) {
    System.err.print("FEHLER in SuchMark: ");
    System.err.printf(format, objects);
    if (exitStatus != 0) {
      System.exit(exitStatus);
    }
  }

  /**
   * @param args
   */
  public static void main(String[] args) {
    if (args.length > 0) {
      PrintWriter out = new PrintWriter(System.out);
      BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
      if (args[0].equals("-h")) {
        help();
      } else if (args[0].equals("-o")) {
        // Ausgabedatei
        if (args.length > 2) { // -o out such...
          try {
            out = new PrintWriter(args[1]);
          } catch (FileNotFoundException e) {
            fehler(2, "Kann Datei %s nicht für Ausgabe öffnen! (%s)\n",
                args[1], e.getLocalizedMessage());
          }
          // Erzeuge neues args nur mit den Suchbegriffen...
          String[] argumente = new String[args.length - 2];
          for (int i = 0; i < argumente.length; i++) {
            argumente[i] = args[i + 2];
          }
          args = argumente;
        } else {
          fehler(1,
              "Es muss bei Option -o der Name einer Datei und mindestens "
                  + "\nein Suchbegriff angegeben werden!\n");
        }
      }
      // Suchbegriffe bearbeiten
      SuchMark suchmark = new SuchMark(args);
      String content = null;
      try {
        content = suchmark.readStream(in);
      } catch (IOException e) {
        fehler(3, "Ein-/Ausgabefehler: %s\n", e.getLocalizedMessage());
      }
      String markedContent = suchmark.mark(content);
      suchmark.writeStream(out, markedContent);
      out.close();
    } else {
      fehler(0, "mindestens einen Suchbegriff angeben. Hilfe mit -h\n");
    }
  }

}

Labels: Java, Lösung, PR2

# Eingestellt von Harald R. Haberstroh @ 18:43 0 Kommentare

Allgemeines

Erstellen Sie ein Projekt klasse-suchmark-name, z.B. 2cd-suchmark-mueller. Das Programm soll Strings in der Eingabe suchen und markieren, indem sie großgeschrieben werden (alle Buchstaben) und mit Sternchen vor und nach dem Suchstring markiert werden (siehe Aufrufbeispiele).

Aufgabe 1 – SuchMark, readStream(), writeStream()

Erstellen Sie eine Klasse SuchMark mit einem Konstruktor SuchMark(String[] such). such ist ein Array mit Suchbegriffen, die markiert werden sollen.

public String readStream(BufferedReader in) liest bis zu EOF alles in einen String. Implementieren Sie die Methode möglichst effizient (Stichwort "Shlemiel the Paitner").

public void writeSream(PrintWriter out, String content) schreibt den gesamten String content auf den Stream out (Datei oder stdout).

Aufgabe 2 – mark()

public String mark(String content) markiert die im Konstruktor angegebenen Worte im Text content,indem alle Buchstaben groß geschrieben werden und davor und danach ein Sternchen steht.

Der String mit den markierten Worten wird zurückgeliefert.

Aufgabe 3 – main()

Erstellen Sie eine main()-Methode, sodass die Klasse als Programm verwendet werden kann.

Das Programm soll immer von stdin lesen, die Ausgabe soll entweder auf stdout oder in eine Datei erfolgen. Die Suchbegriffe sind auf der Kommandozeile anzugeben.

Aufruf: java SuchMark [-h] [-o out] suchbegriff...

-h ... Hilfe ausgeben und Programm beenden

-o out ... optionale Ausgabe in Datei out

suchbegriff ... ein oder mehrere Suchbegriffe

Aufrufbeispiele:

hp@linux $ cat test.txt
Viel Erfolg im neuen Jahr!
Übung macht den Meister!
Erfolg ist das was folgt.
hp@linux $ java SuchMark folg neu < test.txt
Viel Er*FOLG* im *NEU*en Jahr!
Übung macht den Meister!
Er*FOLG* ist das was *FOLG*t.
hp@linux $ java SuchMark -o ausgabe.txt folg neu  < test.txt
hp@linux $ cat ausgabe.txt
Viel Er*FOLG* im *NEU*en Jahr!
Übung macht den Meister!
Er*FOLG* ist das was *FOLG*t.
hp@linux $ java SuchMark -h
Markieren der Suchbegriffe in der Eingabe.
Aufruf: java SuchMark [-h] [-o out] suchbegriffe...
-h ... Hilfe
-o out ... Ausgabe in die Datei out
suchbegriffe ... ein oder mehrere Suchbegriffe

Labels: Aufgabe, Java, PR2

# Eingestellt von Harald R. Haberstroh @ 18:02 0 Kommentare

Allgemeines

Erstellen Sie ein Projekt klasse-intNumbers-name, z.B. 2ad-intNumbers-mueller.

Schreiben Sie ein Programm zum Auffinden von ganzen Zahlen in Textdateien.

Die gefundenen Zahlen speichern Sie in einem int-Array und geben Sie am Ende der Verarbeitung in Tabellenform aus.

Aufgabe 1 – FindIntNumbers(), find(), fill()

Erstellen Sie eine Klasse FindIntNumbers mit einem Konstruktor FindIntNumbers(int value). value ist die, aus der Kommandozeile eingelesene Größe eines anzulegenden Arrays zum Speichern der Zahlen.

public void find(BufferedReader in) liest pro Datei bis zu EOF alle Zeichen des Streams ein und sucht nach ganzen Zahlen. Ganze Zahlen bestehen nur aus zusammenhängenden Ziffern (1-n, begrenzt durch den Wertebereich vom integer-Datentyp). Die Zahlen werden durch beliebige Zeichen getrennt. Die gefundenen Zahlen werden in einem StringBuffer zusammengestellt und mit der Methode fill() im angelegten Array abgespeichert.

public void fill(StringBuffer sb)füllt die Zahl aus dem StringBuffer in das nächste freie Arrayelement. (maximal size Zahlen!). Bei Array-Überlauf bitte eine Fehlermeldung auf stderr ausgeben.

Aufgabe 2 – toString()

public String toString() erstellt aus dem Array die Ausgabe in Tabellenform.

Die Formatierung der Zahlen (Spaltenbreite) wird durch die größte gefundene Zahl bestimmt, damit die Zahlen in der Tabelle linksbündig ausgerichtet untereinander stehen. In einer Zeile der Tabelle dürfen nicht mehr als 80 Zeichen stehen!

Beispiel:

Tabelle der gefundenen Zahlen

43 515 45 43 3567 24 36 23

478 6 59 346 1356887656 266 57 3624

487 346 57 345 245 6 6 3

3567 4 2134 934 193 4 934 934

931 193 934 3498 1943 190843 314 143

4 4 43 13

zugehörige Eingabedatei:

43 515 45 43 3567 24 36 23 478 6 59 346 1356887656 266 57 3624 487 346 57 345

245 6 gfr 6z3 qg tg rtg3567 4g

sadjfhalsd 2134h c934h fcnc193h4c nx934hc934ncjkd c931hqnc193hcudc 934

3498f 1943j190843jx n314dj143..4.4.43c13

Aufgabe 3 – main()

Erstellen Sie eine main()-Methode, sodass die Klasse als Programm verwendet werden kann.

Das Programm soll beliebig viele Dateien durchsuchen oder von der Standardeingabe lesen, wenn kein Dateiname angegeben ist. Die Ausgabe soll immer auf Standardausgabe erfolgen.

Aufruf:

java FindIntNumbers [-h] size [dat1 ... datn]

-h ... Hilfe ausgeben und Programm beenden

size ... Zahl, welche die Größe des Arrays angibt

dat1,datn ... aus diesen Dateien wird gelesen

Aufrufbeispiele:

java FindIntNumbers -h ... gibt Hilfe aus und sonst nichts

java FindIntNUmbers 200 dat.txt text.txt ... versucht alle Zahlen in den Dateien dat.txt und text.txt zu finden und gibt maximal die ersten 200 aus..

java FindIntNUmbers 100 ... liest aus der Standardeingabe und sucht nach allen Zahlen und gibt maximal 100 aus.

• das Array mit den gelesenen Zahlen
• den Füllstand des Arrays
• die maximale Zeilenlänge (Konstant)
• die längste Zahl (d.h. die Anzahl der Ziffern der größten Zahl)

private static final int zeilenLaenge = 80;
private int[] array;
private int arraySize = 0;
private int fillTo = 0;
private int max = 0;

 public void find(BufferedReader in) throws IOException {
   int c;
   boolean inZahl = false;
   StringBuffer sb = new StringBuffer();
   while ((c = in.read()) != EOF) {
     if (inZahl) {
       if (!Character.isDigit((char) c)) {
         inZahl = false;
         fill(sb);
         sb = new StringBuffer();
       } else {
         sb.append((char) c);
       }
     } else {
       if (Character.isDigit((char) c)) {
         inZahl = true;
         sb.append((char) c);
       }
     }
   }
 }

 public void fill(StringBuffer sb) {
   if (fillTo < arraySize) {
     array[fillTo] = Integer.parseInt(sb.toString());
     if (array[fillTo] > max) {
       max = array[fillTo];
     }
     //System.out.printf("filled %d into array[%d]\n", array[fillTo], fillTo);
     fillTo++;
   }
 }

 public String toString() {
   StringBuffer sb = new StringBuffer();
   String format = String.format("%%-%dd", maxlen());
   int anzZahlenProZeile = zeilenLaenge / maxlen();
   int spaltennummer = 0;
   for (int i = 0; i < fillTo; i++) {
     int zahl = array[i];
     sb.append(String.format(format, zahl));
     spaltennummer++;
     if (spaltennummer >= anzZahlenProZeile) {
       spaltennummer = 0;
       sb.append("\n");
     }
   }
   if (spaltennummer > 0) {
     sb.append("\n");
   }
   return sb.toString();
 }

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * lehrer-intNumbers-haberstroh: .FindIntNumbers.java
 * 
 * 17.12.2008, Harald R. Haberstroh
 */

/**
 * Auffinden von ganzen Zahlen in Dateien und speichern in einem Array.
 * 
 * @author Harald R. Haberstroh (hp)
 * 
 */
public class FindIntNumbers {

  private static final int EOF = -1;
  private static final int zeilenLaenge = 80;
  private int[] array;
  private int arraySize = 0;
  private int fillTo = 0;
  private int max = 0;

  /**
   * @param arraySize
   */
  public FindIntNumbers(int arraySize) {
    this.arraySize = arraySize;
    this.array = new int[this.arraySize];
    this.fillTo = 0;
    this.max = Integer.MIN_VALUE;
  }

  /**
   * default Konstruktor
   */
  public FindIntNumbers() {
    this(10);
  }

  /**
   * liest bis EOF und ermittelt alle ganzen Zahlen und speichert sie im Array.
   * 
   * @param in
   *          Eingabestrom
   * @throws IOException
   */
  public void find(BufferedReader in) throws IOException {
    int c;
    boolean inZahl = false;
    StringBuffer sb = new StringBuffer();
    while ((c = in.read()) != EOF) {
      if (inZahl) {
        if (!Character.isDigit((char) c)) {
          inZahl = false;
          fill(sb);
          sb = new StringBuffer();
        } else {
          sb.append((char) c);
        }
      } else {
        if (Character.isDigit((char) c)) {
          inZahl = true;
          sb.append((char) c);
        }
      }
    }
  }

  /**
   * liefert maxmale Länge einer Zahl in Zeichen.
   * 
   * @return maximale Länge + 1
   */
  private int maxlen() {
    return Integer.toString(max).length() + 1;
  }

  /**
   * füllt die Zahl im Stringbuffer in die nächste freie Stelle von array.
   * 
   * @param sb
   */
  public void fill(StringBuffer sb) {
    if (fillTo < arraySize) {
      array[fillTo] = Integer.parseInt(sb.toString());
      if (array[fillTo] > max) {
        max = array[fillTo];
      }
      System.out.printf("filled %d into array[%d]\n", array[fillTo], fillTo);
      fillTo++;
    }
  }

  /**
   * liefert schön formatierte Tabelle als String.
   * 
   * @return Tabella als String.
   */
  @Override
  public String toString() {
    StringBuffer sb = new StringBuffer();
    String format = String.format("%%-%dd", maxlen());
    int anzZahlenProZeile = zeilenLaenge / maxlen();
    int spaltennummer = 0;
    for (int i = 0; i < fillTo; i++) {
      int zahl = array[i];
      sb.append(String.format(format, zahl));
      spaltennummer++;
      if (spaltennummer >= anzZahlenProZeile) {
        spaltennummer = 0;
        sb.append("\n");
      }
    }
    if (spaltennummer > 0) {
      sb.append("\n");
    }
    return sb.toString();
  }

  /**
   * @param args
   */
  public static void main(String[] args) {
    if (args.length >= 1) {
      if (args[0].equals("-h")) {
        System.out.println("Aufruf: java FindIntNumber [-h] size [dateien...]");
      } else {
        try {
          int size = Integer.parseInt(args[0]);
          BufferedReader in;
          FindIntNumbers fn = new FindIntNumbers(size);
          if (args.length > 1) { // Dateien
            for (int i = 1; i < args.length; i++) {
              in = new BufferedReader(new FileReader(args[i]));
              fn.find(in);
              in.close();
            }
          } else { // stdin
            in = new BufferedReader(new InputStreamReader(System.in));
            fn.find(in);
          }
          System.out.print(fn.toString());
        } catch (NumberFormatException e) {
          System.err.println("ungültige Größe angegeben, Hilfe mit -h");
        } catch (IOException e) {
          System.err.println("Ein-/Ausgabefehler: " + e.getLocalizedMessage());
        }
      }
    } else {
      System.err.println("keine Größe angegeben, Hilfe mit -h");
    }
  }

}

Labels: Aufgabe, Java, Lösung, PR2

# Eingestellt von Harald R. Haberstroh @ 08:59 0 Kommentare

Erstellen Sie ein Projekt klasse-caesar-name, z.B. 2cd-caesar-mueller.

Schreiben Sie ein Programm zum Knacken einfacher Caesar-Chiffren (z.B. A->C, B->D, C->E,..., Y->A, Z->B).

Verschlüsseln: Der Klartext wird zunächst in Kleinbuchstaben umgewandelt, wobei alle Zeichen, die keine Buchstaben sind, entfernt werden. Dann wird der über die Kommandozeile angegebene Schlüssel Zeichen für Zeichen angewendet. Zum Schluss soll eine zufällige Auswahl an Buchstaben wieder in Großbuchstaben umgewandelt werden und Leerzeichen eingefügt werden.

Entschlüssen: Der verschlüsselte Text wird wieder komplett in Kleinbuchstaben umgewandelt, danach wird der Schlüssel auf der Kommandozeile genau umgekehrt zeichenweise angewendet.

In beiden Fällen wird der (de-)kodierte Text ausgegeben

Knacken des Codes: Folgendes Verfahren funktioniert nur bei längeren sinnvollen Texten. Ermittle die Häufigkeiten der Zeichen. Das häufigste Zeichen entspricht dem E (zweithäufigstes ist das A), d.h. der Schlüssel muss entsprechend angesetzt werden.

Erstellen Sie eine Klasse Caesar mit einem Konstruktor Caesar(int key). key ist der Schlüssel (Verschiebung der Zeichen für das De-/Kodieren.

public String readStream(BufferedReader in) liest bis zu EOF alles in einen String. Implementieren Sie die Methode möglichst effizient (Stichwort "Shlemiel the Paitner").

public void writeSream(PrintWriter out, String content) schreibt den gesamten String content auf den Stream out (Datei oder stdout).

public String prepare(String content) entfernt aus content alle Zeichen, die nicht Buchstaben von A bis Z sind und wandelt alle verbleibenden Buchstaben in Kleinbuchstaben um.

public String crypt(String content) verschlüsselt den Text content mit dem im Konstruktor angegebenen key.

Ist key == 0, so bleibt der Text wie er ist, bei key == 1, wird aus jedem A ein B, aus jedem B ein C usw. ist key == 10, so wird aus dem A ein K, aus dem B ein L usw. aus dem Z wird I.

public String decrypt(String content) entschlüsselt den Text content mit dem aus dem Konstruktor angegebenen key (bzw. dem aus Aufgabe 6 ermittelten key). Z.B. bei key == 3 wird aus einem A ein X, aus B ein Y, aus C ein Z, aus D ein A usw.

public String crack(String content) entschlüsselt den Text, indem das häufigste Zeichen ermittelt wird. Dieses Zeichen entspricht also statistisch gesehen dem E. Ist zum Beispiel das häufigste Zeichen ein K, so ist der Schlüssel key = K-E, also 6. Dann wird die Methode decrypt() verwendet, um den Text zu dekodieren.

Erstellen Sie eine main()-Methode, sodass die Klasse als Programm verwendet werden kann.

Das Programm soll immer aus einer Datei lesen, die Ausgabe soll entweder auf stdout oder in eine Datei erfolgen.

Verschlüsseln bedeutet immer die Kombination prepare(), crypt() und disguise(), Entschlüsseln entsprechend prepare(), decrypt().

Aufruf: java Caesar [-h] key eingabedatei [ausgabedatei]

-h ... Hilfe ausgeben und Programm beenden

key ... besteht aus dem Zeichen c für crypt, d für decrypt und k für crack() sowie im Falle von c und d aus einer Zahl, welche die Verschiebung angibt.

eingabedatei ... aus dieser Datei wird gelesen

ausgabedatei ... in diese Datei wird geschrieben, wird sie nicht angegeben, so ist auf stdout auszugeben.

Aufrufbeispiele:

java Caesar -h ... gibt Hilfe aus

java Caesar c5 text geheim ... verschlüsselt den Text aus Datei text mit dem Schlüssel 5 und speichert das Ergebnis in Datei geheim.

java Caesar d5 geheim ... entschlüsselt die Datei geheim mit dem Schlüssel 5 und gibt das Ergebnis auf stdout aus.

java Caesar k geheim ... knackt die Datei geheim und gibt das (hoffentlich richtig entschlüsselte) Ergebnis auf stdout aus.

String text = "abcdefghijklmnopqrstuvw";
String shiftText = "defghijklmnopqrstuvwxyzabc"; // Schlüssel 3

  public String crypt(String text) {
    StringBuffer sb = new StringBuffer(text.length());
    for (char c : text.toCharArray()) {
      sb.append(shiftText.charAt(zeichensatz.indexOf(c)));
    }
    return sb.toString();
  }

/**
 * Code: code.Code.java
 * 
 * 08.01.2009, Harald R. Haberstroh
 */

package code;

/**
 * Caesarverschlüsselung.
 * 
 * @author Harald R. Haberstroh (hp)
 * 
 */
public class Code {

  private final String zeichensatz = "abcdefghijklmnopqrstuvwxyz"; // Zeichensatz
  private String shiftText; // verschobener Zeichensatz

  /**
   * @param code
   *          Verschiebung des Alphabets
   */
  public Code(int code) {
    int len = zeichensatz.length();
    StringBuffer sb = new StringBuffer(len);
    if (code < 0) {
      code += len;
    }
    for (int i = 0; i < len; i++) {
      int idx = (i + code) % len;
      sb.append(zeichensatz.charAt(idx));
    }
    shiftText = sb.toString();
  }

  /**
   * verschlüsselt (entschlüsselt) Text mit gegebenen Code, indem Zeichenweise
   * verschoben wird (Caesar-Code).
   * 
   * @param text
   *          zu verschlüsselnder Text (nur Kleinbuchstaben ohne Umlaute und
   *          'ß')
   * @return verschlüsselter Text
   */
  public String crypt(String text) {
    StringBuffer sb = new StringBuffer(text.length());
    for (char c : text.toCharArray()) {
      sb.append(shiftText.charAt(zeichensatz.indexOf(c)));
    }
    return sb.toString();
  }

  /**
   * vorbereiten des Texts, indem alles auf Kleinbuchstaben und nur mehr Zeichen
   * aus Zeichensatz 'zeichensatz'.
   * 
   * @param text
   *          Rohtext
   * @return vorbereiteter Text
   */
  public String prepare(String text) {
    StringBuffer sb = new StringBuffer(text.length());
    for (char c : text.toCharArray()) {
      c = Character.toLowerCase(c);
      if (zeichensatz.indexOf(c) >= 0) { // gültig
        sb.append(c);
      }
    }
    return sb.toString();
  }

  /**
   * @param args
   */
  public static void main(String[] args) {
    Code code = new Code(3);
    System.out.println(code.zeichensatz);
    System.out.println(code.shiftText);
    Code decode = new Code(-3);
    String text = "Hallo, das ist streng geheim!";
    String ctext = code.crypt(code.prepare(text));
    System.out.println(ctext);
    text = decode.crypt(ctext);
    System.out.println(text);
  }
}

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Random;

/**
 * lehrer-caesar-haberstroh/.Caesar.java
 * @author (c) 2008, Harald R. Haberstroh
 * 16.12.2008
 */

/**
 * @author Harald R. Haberstroh (hh)
 * 
 */
public class Caesar {
  private int key;

  /**
   * default für's Knacken.
   */
  public Caesar() {
    key = 0;
  }

  /**
   * @param key
   */
  public Caesar(int key) {
    this.key = key;
  }

  /**
   * liest eine ganze Textdatei.
   * 
   * @param in
   *          geöffneter BufferedReader (Inputstream)
   * @return gelesener String
   * @throws IOException
   */
  public String readStream(BufferedReader in) throws IOException {
    StringBuilder sb = new StringBuilder();
    String line;
    while ((line = in.readLine()) != null) {
      sb.append(line);
      sb.append("\n");
    }
    return sb.toString();
  }

  /**
   * schreibt den String in Textdatei.
   * 
   * @param out
   *          PrintStream zum Schreiben
   * @param content
   *          Text zum Speichern
   */
  public void writeStream(PrintWriter out, String content) {
    out.write(content);
    out.flush();
  }

  /**
   * entfernt alles, was kein Buchstabe und macht die dann zu Kleinbuchstaben.
   * 
   * @param content
   *          zu konvertierender Text
   * @return konvertierter Text
   */
  public String prepare(String content) {
    StringBuilder sb = new StringBuilder();
    for (char c : content.toCharArray()) {
      if ('a' <= c && c <= 'z' || 'A' <= c && c <= 'Z') {
        sb.append(Character.toLowerCase(c));
      }
    }
    return sb.toString();
  }

  /**
   * veschlüsselt Text mit Caesar-Chiffre und key.
   * 
   * @param content
   *          zu verschlüsselnder Text
   * @return verschlüsselter Text
   */
  public String crypt(String content) {
    StringBuilder sb = new StringBuilder();
    char[] table = new char[26];
    for (int i = 0; i < table.length; i++) {
      char cryptChar = (char)((int)'a' + (i + key) % table.length);
      table[i] = cryptChar;
    }
    for (char c : content.toCharArray()) {
      sb.append(table[(int)c - (int)'a']);
    }
    return sb.toString();
  }

  /**
   * verschleiert Text, indem zufällige Groß-/Kleinschreibung verwendet wird und
   * zufällig Leerzeichen eingefügt werden.
   * 
   * @param content
   *          zu verschleiernder Text
   * @return verschleierter Text
   */
  public String disguise(String content) {
    StringBuilder sb = new StringBuilder();
    for (char c : content.toCharArray()) {
      sb.append(disguise(c));
    }
    return sb.toString();
  }

  /**
   * für's disguise, immer selbe Folge von Zufallszahlen.
   */
  private Random rand = new Random(23);

  /**
   * @param c
   *          Zeichen
   * @return zufällig Groß/Klein, zufällig Leerezichen dazu
   */
  private String disguise(char c) {
    if (rand.nextBoolean()) {
      c = Character.toUpperCase(c);
    }
    if (rand.nextBoolean()) {
      return Character.toString(c) + " ";
    } else {
      return Character.toString(c);
    }
  }

  /**
   * entschlüsseln mit Caesar-Chiffre.
   * 
   * @param content
   *          zu entschlüsselnder Text.
   * @return entschlüsselter Text
   */
  public String decrypt(String content) {
    StringBuilder sb = new StringBuilder();
    char[] table = new char[26];
    for (int i = 0; i < table.length; i++) {
      int shift = (i - key) < 0 ? (i - key) + table.length : i - key;
      char cryptChar = (char)((int)'a' + shift);
      table[i] = cryptChar;
    }
    for (char c : content.toCharArray()) {
      sb.append(table[(int)c - (int)'a']);
    }
    return sb.toString();
  }

  /**
   * versucht den key zu finden, indem das häufigste Zeichen ermittelt wird,
   * welches dem 'E' entspricht.
   * 
   * @param content
   *          verschlüsselter Text
   * @return hoffentlich Klartext
   */
  public String crack(String content) {
    int[] hauf = new int[26];
    for (char c : content.toCharArray()) {
      hauf[(int)c - (int)'a']++;
    }
    char e = 'e';
    int max = 0;
    for (int i = 0; i < hauf.length; i++) {
      if (hauf[i] > max) {
        max = hauf[i];
        e = (char)((int)'a' + i);
      }
    }
    key = (int)e - (int)'e';
    System.out.println("key = " + key);
    String ret = decrypt(content);
    return ret;
  }

  /**
   * Hilfe ausgeben
   */
  private static void help() {
    System.out
        .println("Aufruf: java Crypt [-h] key eingabedatei [ausgabedatei]");
    System.out
        .println("key besteht aus Zeichen plus Zahl, c...crypt, d...decypt, "
            + "k...cracken");

  }

  /**
   * @param args
   *          [-h] key eingabedatei [ausgabedatei]
   */
  public static void main(String[] args) {
    if (args.length >= 2) { // scheint OK
      if (args[0].equals("-h")) {
        help();
      } else {
        try {
          BufferedReader in = new BufferedReader(new FileReader(args[1]));
          PrintWriter out = new PrintWriter(System.out);
          if (args.length == 3) {
            out = new PrintWriter(args[2]);
          }
          Caesar caesar;
          String eingabe;
          String ausgabe;
          switch (args[0].charAt(0)) {
            case 'c': // crypt
              caesar = new Caesar(Integer.parseInt(args[0].substring(1)));
              eingabe = caesar.readStream(in);
              ausgabe = caesar.disguise(caesar.crypt(caesar.prepare(eingabe)));
              caesar.writeStream(out, ausgabe);
              break;
            case 'p': // prepare
              caesar = new Caesar(Integer.parseInt(args[0].substring(1)));
              eingabe = caesar.readStream(in);
              ausgabe = caesar.prepare(eingabe);
              caesar.writeStream(out, ausgabe);
              break;
            case 'd': // decypt
              caesar = new Caesar(Integer.parseInt(args[0].substring(1)));
              eingabe = caesar.readStream(in);
              ausgabe = caesar.decrypt(caesar.prepare(eingabe));
              caesar.writeStream(out, ausgabe);
              break;
            case 'k': // crack
              caesar = new Caesar();
              eingabe = caesar.readStream(in);
              ausgabe = caesar.crack(caesar.prepare(eingabe));
              caesar.writeStream(out, ausgabe);
              break;
            default:
              System.err.println("Ungültiger Aufruf (key), Hilfe mit -h");
          }
        } catch (FileNotFoundException e) {
          System.err
              .println("Datei nicht gefunden: " + e.getLocalizedMessage());
        } catch (IOException e) {
          System.err.println("Ein-/Ausgabefehler: " + e.getLocalizedMessage());
        } catch (NumberFormatException e) {
          System.err.println("Ungültiger Aufruf (key), Hilfe mit -h");
        }
      }
    } else if (args.length >= 1 && args[0].equals("-h")) { // Hilfe
      help();
    } else { // Fehler
      System.err.println("Ungültiger Aufruf, Hilfe mit -h");
    }
  }

}

Labels: Aufgabe, Java, Lösung, PR2

# Eingestellt von Harald R. Haberstroh @ 16:34 1 Kommentare

Die Teilnehmer werden eingegeben, z.B.

Hansi 56
Kurt 90
Jürgen Bauer 76

Jede Zeile muss mindestens einen Namen (evtl. mehrere) haben und durch ein Leerzeichen getrennt die ganzzahlige Punktezahl.
Nach jedem Eintrag soll die Top 10 Liste angezeigt werden, z.B.

*** Top 10 ***
Kurt 90
Jürgen Bauer 76
Hansi 56

Wird die Eingabe beendet (EOF), so wird die aktuelle Liste in einer Datei gespeichert (die Datei enthält also die Top 10 oder weniger Zeilen).

Bei einem neuerlichen Start des Programms wird die Datei eingelesen und die Liste gleich angezeigt. Neue Einträge können wie schon vorher vorgenommen werden. Bei EOF wird die geänderte Liste gespeichert.

Labels: Aufgabe, Java, PR2

# Eingestellt von Harald R. Haberstroh @ 09:59 0 Kommentare

• C wird in der Spielindustrie oft verwendet, weil sie sehr maschinennah ist. Die Spieleindustrie ist eine der am stärksten wachstenden Branchen.
• Auch bei "embedded software" wird immer noch das meiste in C programmiert, obwohl C++ schon seit langem dafür verwendet werden soll.
  

Rang Jänner 2009	Rang Jänner 2008	Änderung des Rangs	Programmiersprache	Verbreitung Jänner 2009	Vergleich Jänner 2008	Status
1	1		Java	19.022%	-1.83%	A
2	2		C	15.931%	+2.01%	A
3	5		C++	10.116%	+1.39%	A
4	3		(Visual) Basic	9.161%	-1.80%	A
5	4		PHP	8.882%	-0.31%	A
6	8		C#	5.609%	+0.75%	A
7	6		Python	4.731%	-0.81%	A
8	7		Perl	4.303%	-0.94%	A
9	10		JavaScript	3.360%	+0.16%	A
10	9		Delphi	3.303%	-0.03%	A
11	11		Ruby	3.149%	+0.80%	A
12	14		D	1.022%	-0.15%	A
13	12		PL/SQL	1.006%	-0.22%	A
14	13		SAS	0.797%	-0.41%	A
15	18		Pascal	0.661%	+0.21%	B
16	20		Logo	0.632%	+0.25%	B
17	15		COBOL	0.579%	-0.35%	B
18	28		ABAP	0.537%	+0.34%	B
19	17		FoxPro/xBase	0.477%	-0.03%	B
20	21		ActionScript	0.455%	+0.11%	B

Labels: C, C#, C++, Java, Programmiersprachen, Python

# Eingestellt von Harald R. Haberstroh @ 09:12 2 Kommentare