Programmieren mit Harald R. Haberstroh

Neue Programmdateien haben im Allgemeinen eine ziemlich fixe (Anfangs-)Struktur. So wird immer ein Programmkopf (Kommentar) benötigt, der den Namen des Autors und andere Informationen enthält. Für Python sieht das z.B. so aus:

#!/usr/bin/python
# -"- coding: UTF-8 -*-
# newprog.py
# Ein neues Programmfile mit Header anlegen.
# 2006-09-28, Maier Maria, 23, d84123, 5AHDVK

Schreiben Sie ein Pythonprogramm newprog.py, welches aus einer Vorgabedatei so ein Programmgerüst erzeugt. In dieser Vorgabedatei gibt es Wörter, die dann von newprog.py durch die entsprechenden Werte ersetzt werden. Obiges Gerüst ist aus folgender Vorgabedatei entstanden:

#!/usr/bin/python
# -"- coding: UTF-8 -*-
# NAME
# ZWECK
# DATUM, AUTOR, KNR, EVIDENZ, KLASSE

Für die Ersetzungen soll ein Dictionary verwendet werden, z.B.:

ersetzungen = {
"NAME": progname,
"ZWECK": zweck,
"DATUM": datum,
"AUTOR": "Maier Maria",
"KNR": "23",
"EVIDENZ": "d84123",
"KLASSE": "5AHDVK"
}

progname, zweck, datum müssen natürlich vorher bestimmt werden (eingegeben).

Zur Bestimmung des Datums verwenden Sie strftime():

from time import strftime
datum = strftime("%F")

strftime kennt verschiedenste Formatangaben und liefert die aktuelle Uhrzeit bzw. Datum formatiert zurück. Hilfe mit help(strftime) in Python bzw. man strftime von der Shell (liefert die Beschreibung der C-Funktion, aber die Formatangaben gelten auch für Python).

Die Vorgabedatei und der Name der zu erzeugenden Datei sind auf der Kommandozeile anzugeben, z.B.:

~/work/tmp > python newprog.py vorgabe.py meinNeuesProgramm.py
~/work/tmp >

Wird keine Vorgabedatei angegeben, so wird eine Standardvrogabedatei verwendet:

~/work/tmp > python newprog.py meinNeuesProgramm.py
~/work/tmp >

Für die Programmargumente betrachten Sie folgendes Beispiel, welches die Argumente einfach untereinander ausgibt:

#!/usr/bin/python
# -"- coding: UTF-8 -*-
# argtest.py
from sys import argv
for arg in argv:
print arg

Ausgabe bei Aufruf von python argtest.py hallo du da:

argtest.py
hallo
du
da

Das heißt, argv[0] enthält den Programmnamen.

Abgabetermin: 4. November 2009

Labels: Aufgabe, PR2, Python

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

Labels: Aufgabe, PR2, Python

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

Labels: Aufgabe, PR2, Python

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

Labels: Aufgabe, PR2, Python

# Eingestellt von Harald R. Haberstroh @ 10:54 0 Kommentare

Labels: allgemeines, PR2, PR5

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

     Main.java      1.4
     Gui.java       1.9
     Net.java       1.6    

     Main.java      1.4
     Gui.java       1.10
     Net.java       1.7    

Links
Ximbiot
Einführung in das Concurrent Versions System (CVS)
Wikipedia:CVS
ganz kurze Einführung in CVS (pdf)

Bücher
Versionsverwaltung mit CVS

Kurzreferenz
2-seitige Kurzreferenz

Labels: CVS, PR2

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

Anmeldung am Server

erfolgt über ssh. Man muss zunächst den Server und das CVS-Verzeichnis wählen. Die Anmeldung erfolgt bei jedem CVS-Befehl über ssh.

 ~ > export CVSROOT=:ext:USER@cvs.htlwrn.ac.at:/cvs/USER
~ > export CVS_RSH=ssh

USER ist der Username (Projektuser, Evidenznummer).

Repository einrichten

 ~ > cvs init
Password:

damit wird ein Repository eingerichtet (dieser Schritt wird für Schüler vom Administrator beim Anlegen der User durchgeführt). Die Zeile mit Password: deutet das Anmelden am Server an. Hier ist das Passwort einzugeben. Die Meldungen vom CVS werden in diesem Text nicht angegeben.

Importieren eines Projektes

Soll ein Projekt ins CVS aufgenommen werden, so muss man zunächst ein Verzeichnis mit allen Unterverzeichnissen und Dateien anlegen (natürlich können später weitere Dateien hinzugefügt werden).
Dann importiert man das Projekt mit

 ~ > cd neues_projekt
~/neues_projekt > cvs import -m "eine Beschreibung des Projekts" projektname name start

projektname ist der Name des Projekts im CVS.
name ist das sog. Vendor Tag, eine Bezeichnung des Verkäufers (Entwicklers).
start ist das Release Tag, welches den Start des Projekts anzeigt (beide Tags sind eigentlich unnötig, aber vom CVS zwingen einzugeben...).

Nach dem Import kann (soll) das Verzeichnis neues_projekt gelöscht werden, denn wenn man an diesem Projekt nun weiterarbeiten will, muss es ausgecheckt werden.

Checkout

In einem Arbeitsverzeichnis (workspace) wird das Projekt ausgecheckt (dieser Vorgang ist normalerweise pro Arbeitsplatz und User nur einmal zu machen):

 ~ > cd workspace
~/workspace > cvs checkout projektname
Password:

Im Verzeichnis workspace wird nun ein Verzeichnis projektname angelegt. In diesem Verzeichnis kann man nun editieren, compilieren, debuggen usw. projektname kann auch ein Modulname sein (vgl. Einführung in CVS).

Update

Ein Update ist nötig, um Änderungen, die von anderen Personen oder von einem anderen Arbeistplatz aus eingecheckt wurden, in den eigenen workspace zu übernehmen. Hier kann es natürlich zu Konflikten kommen, d.h. dieselben Dateien haben sich im Repository und im eigenen Workspace geändert.

 ~/workspace > cvs update
Password:

Falls es Konflikte gibt, müssen diese gelöst werden.

commit - Änderungen ins Repository übernehmen (check in)

Änderungen im eigenen workspace sollten regelmäßig ins CVS übernommen werden. Dadurch werden von den geänderten Dateien neue Versionen angelegt. Arbeitet man im Team, so dürfen nur Sourcen eingecheckt (commit) werden, die sich zumindest überetzen lassen. Noch besser ist es, wenn die nötigen Tests bestanden werden.

 ~/workspace > cvs commit -m "der Text, der beschreibt, was sich geändert hat"
Password:

add - neue Dateien aufnehmen

Werden neue Dateien angelegt, so müssen sie der Versionsverwaltung zunächst bekannt gegeben werden. Die Dateien werden aber erst wirklich aufgenommen, wenn ein commit gemacht wird.

 ~/workspace > cvs add neue_dateien...
Password:

Nun müssen die Dateien auch eingecheckt werden (commit):

 ~/workspace > cvs commit -m "der Text, der beschreibt, was sich geändert hat (welche Dateien neu sind)"
Password:

Genauere Informationen sind bei Links und Literatur zu CVS sowie mit man cvs bzw. cvs –help zu finden.

Labels: CVS, PR2

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

binäre Dateien

Unter binären Dateien verstehen wir hier Dateien, die nicht aus Textzeilen bestehen. Das sind z.B. Word- und Excel-Dateien, Bilder usw. CVS speichert normalerweise Textdateien und deren Zeilenänderungen. Dies ist bei Binärdateien nicht möglich. Wird z.B. eine Word-Datei nicht als Binärdatei markiert, so wird sie vom CVS zerstört (Subversion, der Nachfolger von CVS, kann gut mit Binärdateien umgehen, CVS ist aber immer noch weit verbreitet...).

Damit nicht bei jedem cvs add, cvs import" usw. die Option %-W *.gif -k 'b' (für jede Dateiendung von Binärdateien einmal!) angegeben werden muss, schreibt man diese Dateien in die Konfigurationsdatei CVSROOT/cvswrappers.

Die Konfiguration eines Repositories befindet sich im Projekt CVSROOT, welches man auscheckt, bearbeitet und dann wieder eincheckt (commit).

~/work > cvs checkout CVSROOT
...
~/work > cd CVSROOT
~/work/CVSROOT > vim cvswrappers

Die Datei sollte z.B. so aussehen (Zeilen mit # sind Kommentare, die schon enthalten sind):

# This file affects handling of files based on their names.
#
# The -m option specifies whether CVS attempts to merge files.
#
# The -k option specifies keyword expansion (e.g. -kb for binary).
#
# Format of wrapper file ($CVSROOT/CVSROOT/cvswrappers or .cvswrappers)
#
#  wildcard [option value][option value]...
#
#  where option is one of
#  -f    from cvs filter      value: path to filter
#  -t    to cvs filter     value: path to filter
#  -m    update methodology   value: MERGE or COPY
#  -k    expansion mode    value: b, o, kkv, &c
#
#  and value is a single-quote delimited value.
# For example:
*.img -k 'b'
*.cramfs -k 'b'
*.jar -k 'b'
*.m2v -k 'b'
*.mvi -k 'b'
*.ppc -k 'b'
*.jffs* -k 'b'
*.nfi -k 'b'

# Microsoft
*.doc -k 'b'
*.xls -k 'b'
*.ppt -k 'b'

# Openoffice 1.*
*.stc -k 'b'
*.std -k 'b'
*.sti -k 'b'
*.stw -k 'b'
*.sxc -k 'b'
*.sxd -k 'b'
*.sxq -k 'b'
*.sxi -k 'b'
*.sxm -k 'b'
*.sxp -k 'b'
*.sxw -k 'b'

# dia
*.dia -k 'b'

# Bilder
*.xcf -k 'b'
*.jpg -k 'b'
*.bmp -k 'b'
*.gif -k 'b'
*.png -k 'b'

Für jeden Dateityp mit Binärformat gibt es eine Zeile der Form *.endung -k 'b'.

Diese Einträge speichern, den Editor beenden und das Projekt wieder commiten:

~/work/CVSROOT > cvs commit -m "Binärdateien bekanntgegeben"
...

Das Verzeichnis ~/work/CVSROOT können Sie löschen, da Sie es ja jederzeit wieder auschekcen können, wenn Sie eine Dateiendung vergessen haben.

Ignorieren von Dateien/Verzeichnissen

Bestimmte Dateien im Projektverzeichnis will man nicht in die Versionsverwaltung aufnehmen, z.B. Testdateien à la xxx oder die Sicherungsdateien vom vim (*~ - diese werden standardmäßig ignoriert), Klassendateien (*.class) usw.

Dafür gibt es auch Kommandozeilenargumente für cvs (z.B. -I '*.class'), aber besser ist es, diese Dateien ein für alle mal zu ignorieren. Die Konfigurationsdatei heißt CVSROOT/cvsignore. Leider existiert diese Datei in der Standardkonfiguration nicht und muss daher mit cvs add aufgenommen werden.

Hat man CVSROOT bereits ausgecheckt, so muss man die Datei mit einem Editor erzeugen:

~/work/CVSROOT > vim cvsignore

Bei mir hat die Datei folgenden Inhalt:

*.nfi
*.img
*.pyc
*.class
*.log
*.tmp
xxx
*.ppc
*.jffs*
*.cramfs

Dann muss man die Datei dem Repository hinzufügen und einchecken (commit):

~/work/CVSROOT > cvs add cvsignore
~/work/CVSROOT > cvs commit -m "zu ignorierende Dateien"
...

Labels: CVS, PR2

# Eingestellt von Harald R. Haberstroh @ 10:55 0 Kommentare

Will man auf eine alte Version zugreifen, so kann man beim Auschecken angeben, welchen Zustand man haben will, in dem man die Option -D datum angibt. datum kann entweder in der englischen Schreibweise angegeben werden (MM/TT/JJJJ), im ISO-Format (JJJJ-MM-TT) oder auch relativ als Text unter Hochkomma (z.B. 3 weeks ago, 1 day ago 27 minutes ago oder 3 days ago o.ä.).

Das Projekt python im Zustand vor einer Woche auschecken:

~/work > cvs co -D "1 week ago" python
cvs checkout: Updating python
U python/dreieck.py
U python/prim.py
~/work >

Das Projekt python im Zustand vom 22.9.2006 auschecken:

~/work > cvs co -D 09/22/2006 python
cvs checkout: Updating python
U python/calc.py
U python/craten.py
U python/dreieck.py
U python/ggt.py
U python/mittelwert.py
U python/muster.py
U python/prim.py
U python/pyintro.pdf
U python/raten.py
U python/summe.py
~/work >

Ältere Versionen sollten in eigene Verzeichnisse ausgecheckt werden. Sobald eine bestimmte Version ausgecheckt wurde, ist sie sticky (klebrig). Das bedeutet, dass sich alle Arbeiten in diesem ausgecheckten Verzeichnisbaum auf diese Version beziehen.

Daher ist das Weiterarbeiten an einer solchen Version nur sinnvoll bei Zweigen.

Labels: CVS, PR2

# Eingestellt von Harald R. Haberstroh @ 10:50 0 Kommentare

Anzahl der Wörter in der Eingabe

Schreiben Sie ein Pythonprogramm, welches die Wörter in der Eingabe (Datei und/oder interaktiv) zählt. Das Programm soll aus einer Datei lesen, wenn ein Dateiname auf der Kommandozeile angegeben wurde: python wc.py eingabe.txt. Das Programm wc.py liest die Wörter aus der Datei eingabe.txt.

Beim Aufruf von python wc.py wird von stdin (Tastatur) gelesen.

Anzahl der verschiedenen Worte in der Eingabe

Schreiben Sie ein Pythonprogramm, welches die Wörter in der Eingabe (Datei und/oder interaktiv) zählt. Mehrfach vorkommende Worte werden nur einmal gezählt. Das Programm soll aus einer Datei lesen, wenn ein Dateiname auf der Kommandozeile angegeben wurde: python wcd.py eingabe.txt. Das Programm wcd.py liest die Wörter aus der Datei eingabe.txt.

Worthäufigkeiten in der Eingabe ermitteln

Schreiben Sie ein Pythonprogramm, welches die Häufigkeiten der Wörter in der Eingabe (Datei und/oder interaktiv) ermittelt und dann sortiert nach Häufigkeiten ausgibt (häufigstes Wort zuerst). Das Programm soll aus einer Datei lesen, wenn ein Dateiname auf der Kommandozeile angegeben wurde: python hauf.py eingabe.txt. hauf.py liest die Wörter aus der Datei eingabe.txt. Groß-/Kleinschreibung soll nicht beachtet werden (heim == Heim).

Beim Aufruf von python hauf.py wird von stdin (Tastatur) gelesen.

Ausgegeben werden soll immer das Wort und dann die Häufigkeit, sortiert nach Häufigkeit (häufigstes zuerst).

Hinweis: verwenden Sie ein Dictionary zum Erfassen der Daten (Wort ist Schlüssel, Häufigkeit ist der Wert). Wandeln Sie am Ende das Dictionary in eine Liste zum Sortieren um.

Vokabeltrainer

Schreiben Sie ein Programm, welches als Vokabeltrainer verwendet werden kann. Dazu soll eine Vokabeldatei eingelesen werden, welche Worte und deren Übersetzung enthält. Das Programm hat zwei Modi:

Prüfungsmodus Das Programm gibt in zufälliger Reihenfolge Wörter aus. Der Benutzer gibt die Übersetzung ein. Das Programm prüft, ob das Wort in der Liste der Übersetzungen vorkommt und zählt die richtigen/falschen Eingaben. Zum Schluss wird die Anzahl der Fehler bzw. richtgen ausgegeben.

Übungsmodus Das Programm gibt der Reihe nach Wörter plus deren Übersetzungen aus.

Buchstabierhilfe

Schreiben Sie ein Programm, welches jeden Text buchstabieren kann, d.h. für jedes a das Wort Alfa, für jedes b das Wort Bravo usw. ausgibt. Groß-/Kleinschreibung soll nicht berücksichtigt werden. Verwenden Sie z.B. das Nato-Alphabet (alpha, bravo, charlie, delta, echo,...)

Labels: Aufgabe, PR2, Python

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

Labels: Aufgabe, PR5

# Eingestellt von Harald R. Haberstroh @ 11:18 1 Kommentare

Schreiben Sie ein python Programm, welches für eingegebene Zahlen prüft, ob es eine Primzahl ist.
Verwenden Sie für die Primzahlbestimmung das Sieb des Eratosthenes .

Variante 1 (einfacher)

Das Programm soll eine Primzahlentabelle fixer Größe (z.B. 1000) erstellen und dann bis EOF Zahlen einlesen und ausgeben, ob die Zahl eine Primzahl ist (oder nicht).

Variante 2 (schwieriger)

Das Programm soll zunächst wieder eine fixe Tabelle erzeugen. In der Prüfphase (Eingabe der Zahlen) soll wie oben ermittelt werden, ob die Zahl eine Primzahl ist. Ist die eingegebene Zahl jedoch größer als das letzte Tabellenelement, so soll die Tabelle entsprechend erweitert und neu geprüft werden.

Lösung Variante 1

Wir müssen zunächst eine Tabelle erzeugen, die lauter True (für "eine Primzahl") enthält.

def gentable(end):
  """
  erzeuge Tabelle bis Obergrenze end
  end: Obergrenze
  """
  tab = []
  for i in range (0, end):
    tab.append(True)
  return tab

Eine ganze Zahl kann mit input() eingelesen werden. Tippt man aber einen Text, so interpretiert input() diesen Text als Python-Programm, d.h. im allgemeinen bekommt man folgende Fehlermeldung:

>>> input()
hallo
Traceback (most recent call last):
  File "", line 1, in 
  File "", line 1, in 
NameError: name 'hallo' is not defined
>>>

>>> input()
float(2)/3
0.66666666666666663
>>>

def liesInt():
  """
  lies eine ganze Zahl
  """
  ok = False
  while not ok:
    try:
      z = int(input("ganze Zahl: "))
      ok = True
    except EOFError:
      return -1
    except:
      pass
  return z

Die Funktion sieb(tab) wendet den Algorithmus des Primzahlensiebs an, d.h. alle Vielfachen einer bereits ermittelten Primzahl werden gestrichen (False). Der Index in die Tabelle entspricht der entsprechenden Zahl:

def sieb(tab):
  """
  wende Sieb des Eratosthenes auf Tabelle an
  tab: Tabelle
  """
  end = len(tab)
  print "Sieb bis %d" % end
  tab[0] = False
  tab[1] = False
  zahl = 2
  while zahl < end:
    if tab[zahl]:
      for t in range(zahl + zahl, end, zahl):
        tab[t] = False
    zahl += 1

Es fehlt also nur noch das "Hauptprogramm":

# Hauptprogram
tab = gentable(1000)
sieb(tab)
z = liesInt()
while z > -1:
  if tab[z]:
    print "%d ist prim" % z
  else:
    print "%d ist NICHT prim" % z
  z = liesInt()

Hier noch einmal das ganze Programm:

#!/usr/bin/python
# -"- coding: utf8 -*-
# eratosthenesfix.py
# Primzahlenprüfung nach dem Sieb des Eratosthenes.
# 2009-10-07, Harald R. Haberstroh

def gentable(end):
  """
  erzeuge Tabelle bis Obergrenze end
  end: Obergrenze
  """
  tab = []
  for i in range (0, end):
    tab.append(True)
  return tab

def sieb(tab):
  """
  wende Sieb des Eratosthenes auf Tabelle an
  tab: Tabelle
  """
  end = len(tab)
  print "Sieb bis %d" % end
  tab[0] = False
  tab[1] = False
  zahl = 2
  while zahl < end:
    if tab[zahl]:
      for t in range(zahl + zahl, end, zahl):
        tab[t] = False
    zahl += 1

def liesInt():
  """
  lies eine ganze Zahl
  """
  ok = False
  while not ok:
    try:
      z = int(input("ganze Zahl: "))
      ok = True
    except EOFError:
      return -1
    except:
      pass
  return z

# Hauptprogram
tab = gentable(1000)
sieb(tab)
z = liesInt()
while z > -1:
  if tab[z]:
    print "%d ist prim" % z
  else:
    print "%d ist NICHT prim" % z
  z = liesInt()

Lösung Variante 2

Hier wird bei Bedarf die Tabelle erweitert. Ohne weitere Erklärung:

#!/usr/bin/python
# -"- coding: utf8 -*-
# eratosthenes.py
# Primzahlenprüfung nach dem Sieb des Eratosthenes.
# 2007-09-27, Harald R. Haberstroh

def gentable(tab, end):
  """
  erzeuge/ändere Tabelle bis Obergrenze end
  tab: (leere) Tabelle
  end: Obergrenze
  """
  for i in range (len(tab), end):
    tab.append(True)

def sieb(tab, start):
  """
  wende Sieb des Eratosthenes auf Tabelle an
  tab: Tabelle
  start: ab hier neu belegen
  """
  end = len(tab)
  print "Sieb bis %d" % end
  tab[0] = False
  tab[1] = False
  zahl = 2
  while zahl < end:
    if tab[zahl]:
      for t in range(zahl + zahl, end, zahl):
        tab[t] = False
    zahl += 1

def liesInt():
  """
  lies eine ganze Zahl
  """
  ok = False
  while not ok:
    try:
      z = int(input("ganze Zahl: "))
      ok = True
    except EOFError:
      return -1
    except:
      pass
  return z

# Hauptprogram
tab = []
gentable(tab, 1000)
sieb(tab, 2)
z = liesInt()
while z > -1:
  if z >= len(tab): # größer machen
    l = len(tab)-1
    gentable(tab, z * 2)
    sieb(tab, l)
  if tab[z]:
    print "%d ist prim" % z
  else:
    print "%d ist NICHT prim" % z
  z = liesInt()

Labels: Aufgabe, Lösung, PR2, Python

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

Summe aus einer beliebigen Anzahl von positiven Zahlen

Schreiben Sie ein Pythonprogramm summe.py, welches eine beliebige Anzahl positiver Zahlen einliest und die Summe ausgibt. Ende der Eingabe mit einer Zahl kleiner oder gleich 0.

Mittelwert aus einer beliebigen Anzahl von positiven Zahlen

Schreiben Sie ein Pythonprogramm mittelwert.py, welches eine beliebige Anzahl positiver Zahlen einliest und den Mittelwert ausgibt. Ende der Eingabe mit einer Zahl kleiner oder gleich 0.

Primzahlenbestimmung

Schreiben Sie ein Pythonprogramm primzahlen.py, welches eine untere und eine obere Grenze einliest und die Primzahlen in diesem Bereich ausgibt.

Größter gemeinsamer Teiler

Schreiben Sie ein Pythonprogramm ggt.py, welches zwei ganze positive Zahlen einliest und den größten gemeinsamen Teiler dieser Zahlen ausgibt.

Zahlen raten (I)

Schreiben Sie ein Pythonprogramm raten.py, welches eine Zahl zwischen 1 und 100 zufällig auswählt. Der Benutzer versucht diese Zahl zu erraten. Das Programm gibt Hinweise der Art Zahl zu klein oder Zahl zu groß aus.

Hinweis: ganze Zufallszahlen bekommt man mit randint(a, b), wobei a die unter Grenze und b die obere Grenze ist (from random import * nicht vergessen).

Zahlen raten (II)

Schreiben Sie ein Pythonprogramm craten.py, welches eine versucht eine gedachte Zahl zwischen 1 und 100 zu erraten. Der Benutzer gibt Hinweise der Art Zahl zu klein oder Zahl zu groß ein (z.B. mit < und > bzw. =, wenn fertig).

Schaltjahrbestimmung

Schreiben Sie ein Pythonprogramm schaltjahr.py, welches ein Jahr einliest und ausgibt, ob es ein Schaltjahr ist.

1×1-Tabelle

Schreiben Sie ein Pythonprogramm, welches das kleine 1×1 als Tabelle ausgibt.

Labels: Aufgabe, PR2, Python

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

• Wie ein Informatiker denken lernen
  englisches Original How to Think Like a Computer Scientist
• http://www.python.org/
• Einführung in Python
• Python Bibliotheca
• Der Weg zur Programmierung mit Python
• Programmieren lernen
• Mit leichten Schritten in die objektorientierte Programmierung

Labels: PR2, Python

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

Legen Sie eine Datei mit ihren Initialen und Extension .txt an
Bsp:

  rr.txt

Einfügen von 5 Zeilen mit beliebigem Text

Einfügen von Asterix als eigene Zeile nach der 4. Zeile

Positionieren auf 3. Zeile

Am Ende der Zeile das wort xyyz einfügen

Kopieren der 3. Zeile

Einfügen dieser Zeile 85 mal nach der 5. Zeile

Suchen nach String rix

Schalten Sie die Zeilennummerierung ein

Gehe zu Zeile 70

Lösche 10 Zeilen

Kopiere Zeilen 13-45 in eine neue Datei mit Namen 'partrr.txt'

Alle Zeichen 'y' durch '§' ersetzen

Einfügen der Zeilen 5-10 aus der Datei 'partrr.txt' nach der letzten Zeile

Labels: Aufgabe, PR2, vim

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

Informatikunterricht in der AHS

10 PRINT "HELLO WORLD"
20 END

Erstes Studienjahr

program Hello(input, output)
   begin
      writeln('Hello World')
   end.

Späteres Studienjahr

(defun hello
  (print
    (cons 'Hello (list 'World))))

Neuer Mitarbeiter

#include <stdio.h>
void main(void)
{
  char *message[] = {"Hello ", "World"};
  int i;

  for(i = 0; i < 2; ++i)
    printf("%s", message[i]);
  printf("\n");
}

Älterer Mitarbeiter

#include <iostream.h>
#include <string.h>

class string
{
private:
  int size;
  char *ptr;

public:
  string() : size(0), ptr(new char('\0')) {}

  string(const string &s) : size(s.size)
  {
    ptr = new char[size + 1];
    strcpy(ptr, s.ptr);
  }

  ~string()
  {
    delete [] ptr;
  }

  friend ostream &operator <<(ostream &o, const string &s);
  string &operator=(const char *);
};

ostream &operator<<(ostream &stream, const string &s)
{
  return(stream << s.ptr);
}

string &string::operator=(const char *chrs)
{
  if (this != &chrs)
  {
    delete [] ptr;
    size = strlen(chrs);
    ptr = new char[size + 1];
    strcpy(ptr, chrs);
  }
  return(*this);
}

int main()
{
  string str;

  str = "Hello World";
  cout << str << endl;

  return(0);
}

Chefprogrammierer

[
uuid(2573F8F4-CFEE-101A-9A9F-00AA00342820)
]
library LHello
{
     // bring in the master library
     importlib("actimp.tlb");
     importlib("actexp.tlb");

     // bring in my interfaces
     #include "pshlo.idl"

     [
     uuid(2573F8F5-CFEE-101A-9A9F-00AA00342820)
     ]
     cotype THello
  {
  interface IHello;
  interface IPersistFile;
  };
};

[
exe,
uuid(2573F890-CFEE-101A-9A9F-00AA00342820)
]
module CHelloLib
{

     // some code related header files
    importheader(<windows.h>);
    importheader(<ole2.h>);
    importheader(<except.hxx>);
    importheader("pshlo.h");
    importheader("shlo.hxx");
    importheader("mycls.hxx");
    // needed typelibs
    importlib("actimp.tlb");
    importlib("actexp.tlb");
    importlib("thlo.tlb");
    [
    uuid(2573F891-CFEE-101A-9A9F-00AA00342820),
    aggregatable
    ]
    coclass CHello
 {
 cotype THello;
 };
};


#include "ipfix.hxx"

extern HANDLE hEvent;

class CHello : public CHelloBase
{
public:
    IPFIX(CLSID_CHello);

    CHello(IUnknown *pUnk);
    ~CHello();

    HRESULT  __stdcall PrintSz(LPWSTR pwszString);

private:
    static int cObjRef;
};


#include <windows.h>
#include <ole2.h>
#include <stdio.h>
#include <stdlib.h>
#include "thlo.h"
#include "pshlo.h"
#include "shlo.hxx"
#include "mycls.hxx"

int CHello::cObjRef = 0;

CHello::CHello(IUnknown *pUnk) : CHelloBase(pUnk)
{
    cObjRef++;
    return;
}

HRESULT  __stdcall  CHello::PrintSz(LPWSTR pwszString)
{
    printf("%ws\n", pwszString);
    return(ResultFromScode(S_OK));
}


CHello::~CHello(void)
{

// when the object count goes to zero, stop the server
cObjRef--;
if( cObjRef == 0 )
    PulseEvent(hEvent);

 return;
}

#include <windows.h>
#include <ole2.h>
#include "pshlo.h"
#include "shlo.hxx"
#include "mycls.hxx"

HANDLE hEvent;

int _cdecl main(
int argc,
char * argv[]
) {
ULONG ulRef;
DWORD dwRegistration;
CHelloCF *pCF = new CHelloCF();

hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);

// Initialize the OLE libraries
CoInitializeEx(NULL, COINIT_MULTITHREADED);

CoRegisterClassObject(CLSID_CHello, pCF, CLSCTX_LOCAL_SERVER,
    REGCLS_MULTIPLEUSE, &dwRegistration);

// wait on an event to stop
WaitForSingleObject(hEvent, INFINITE);

// revoke and release the class object
CoRevokeClassObject(dwRegistration);
ulRef = pCF->Release();

// Tell OLE we are going away.
CoUninitialize();

return(0); }

extern CLSID CLSID_CHello;
extern UUID LIBID_CHelloLib;

CLSID CLSID_CHello = { /* >2573F891-CFEE-101A-9A9F-00AA00342820 */
    0x2573F891,
    0xCFEE,
    0x101A,
    { 0x9A, 0x9F, 0x00, 0xAA, 0x00, 0x34, 0x28, 0x20 }
};

UUID LIBID_CHelloLib = { /* >2573F890-CFEE-101A-9A9F-00AA00342820 */
    0x2573F890,
    0xCFEE,
    0x101A,
    { 0x9A, 0x9F, 0x00, 0xAA, 0x00, 0x34, 0x28, 0x20 }
};

#include <windows.h>
#include <ole2.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "pshlo.h"
#include "shlo.hxx"
#include "clsid.h"

int _cdecl main(
int argc,
char * argv[]
) {
HRESULT  hRslt;
IHello        *pHello;
ULONG  ulCnt;
IMoniker * pmk;
WCHAR  wcsT[_MAX_PATH];
WCHAR  wcsPath[2 * _MAX_PATH];

// get object path
wcsPath[0] = '\0';
wcsT[0] = '\0';
if( argc > 1) {
    mbstowcs(wcsPath, argv[1], strlen(argv[1]) + 1);
    wcsupr(wcsPath);
    }
else {
    fprintf(stderr, "Object path must be specified\n");
    return(1);
    }

// get print string
if(argc > 2)
    mbstowcs(wcsT, argv[2], strlen(argv[2]) + 1);
else
    wcscpy(wcsT, L"Hello World");

printf("Linking to object %ws\n", wcsPath);
printf("Text String %ws\n", wcsT);

// Initialize the OLE libraries
hRslt = CoInitializeEx(NULL, COINIT_MULTITHREADED);

if(SUCCEEDED(hRslt)) {


    hRslt = CreateFileMoniker(wcsPath, &pmk);
    if(SUCCEEDED(hRslt))
        hRslt = BindMoniker(pmk, 0, IID_IHello, (void **)&pHello);

    if(SUCCEEDED(hRslt)) {

        // print a string out
        pHello->PrintSz(wcsT);

        Sleep(2000);
        ulCnt = pHello->Release();
    }
    else
        printf("Failure to connect, status: %lx", hRslt);

        // Tell OLE we are going
        CoUninitialize();
    }

return(0);
}

Unerfahrener Hacker

#/usr/local/bin/perl
$msg="Hello, world.\n";
if ($#ARGV >= 0) {
  while(defined($arg=shift( ARGV))) {
    $outfilename = $arg;
    open(FILE, ">" . $outfilename) __ die "Can't write $arg:>$?\n";
    print (FILE $msg);
    close(FILE) __ die "Can't close $arg: $?\n";
  }
} else {
  print ($msg);
}
1;

Erfahrener Hacker

#include <stdio.h>
#define S "Hello, World\n"
main(){exit(printf(S) == strlen(S) ? 0 : 1);}

Älterer Hacker

% cc -o a.out ~/src/misc/hw/hw.c
% a.out

Hackerguru

% cat
Hello, world.
^D

Neuer Manager

10 PRINT "HELLO WORLD"
20 END

Höherer Manager

mail -s "Hello, world." vylmazal b12
Frau Meierhofer, könnten Sie mir bitte ein Programm schreiben, das "Hello, world." ausgibt?
Ich würde es schon morgen brauchen.
^D

Mitglied der Geschäftsleitung

% zmail czerny
Ich brauche ein "Hello, world." Programm bis heute Nachmittag.

Geschäftsführer

% letter
letter: Command not found.
% mail
To: ^X ^F ^C
% help mail
help: Command not found.
% gehtnix?
?: Event unrecognized
% logout

Labels: allgemeines, Programmiersprachen

# Eingestellt von Harald R. Haberstroh @ 12:44 0 Kommentare

Vim ist ein hervorragender Editor mit Syntaxhervorhebung und Vergleichsfunktionen, mehreren Darstellungsfenstern und vielen anderen nützlichen Funktionen. Leider ist der Einstieg damit nicht immer ganz leicht, da vim eine Weiterentwicklung des Editors vi ist, den es bereits in den 80er Jahren gab, wo Benutzerfreundlichkeit noch eine andere Bedeutung hatte als heute. Weiterhin erscheint vim im unkonfigurierten Zustand zunächst erstmal sehr langweilig und es ist mühselig eine passende Konfiguration zu erstellen.

Der vi ist praktisch auf jedem Linux-System verfügbar und kann von der Shell (Terminal) aus verwendet werden. Daher ist es praktisch, wenn man den vi(m) beherrscht, wenn man einen Server (z.B. Web-Server) über das Internet warten muss. Die wichtigsten Funkionen kann man probieren und üben mit vimtutor

Weitere Dokumentation finden Sie hier:
vim Kurzreferenz auf LinWiKi
vim Homepage www.vim.org
vim Quick Reference Card (2 Seiten)

Wir verwenden eine spezielle Konfigurationsdatei für den vim. Im Laufe dieses Schuljahres werden wir Ihnen diese Datei (eigentlich eine überarbeitete Version, denn die bisherige Version ist hauptsächlich für C-Programmierung eingerichtet) zur Verfügung stellen. Also, bleiben Sie dran oder suchen Sie auf www.vim.org/scripts nach passenden Scripts für den vim.

Labels: Aufgabe, PR2, vim

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