Praxisprojekte

program Sieb;
{$mode objfpc}{$H+}
const
  N = 50;
var
  prim: array[2..N] of Boolean;
  i, j, anzahl: Integer;
begin
  for i := 2 to N do prim[i] := True;
  for i := 2 to N do
    if prim[i] then
      for j := i * i to N do
        if j mod i = 0 then prim[j] := False;
  anzahl := 0;
  for i := 2 to N do
    if prim[i] then
    begin
      write(i, ' ');
      Inc(anzahl);
    end;
  writeln;
  writeln(anzahl, ' Primzahlen bis ', N);
end.

program Caesar;
{$mode objfpc}{$H+}

function Verschiebe(const text: String; schluessel: Integer): String;
var
  i: Integer;
  c: Char;
begin
  Result := text;
  for i := 1 to Length(text) do
  begin
    c := text[i];
    case c of
      'A'..'Z': Result[i] := Chr((Ord(c) - 65 + schluessel + 26) mod 26 + 65);
      'a'..'z': Result[i] := Chr((Ord(c) - 97 + schluessel + 26) mod 26 + 97);
    end;
  end;
end;

var
  geheim: String;
begin
  geheim := Verschiebe('Hallo Pascal!', 3);
  writeln(geheim);
  writeln(Verschiebe(geheim, -3));
end.

program Liste;
{$mode objfpc}{$H+}

type
  TKnoten = class
    Wert: Integer;
    Weiter: TKnoten;
    constructor Create(AWert: Integer);
  end;

  TListe = class
  private
    FKopf: TKnoten;
    FAnzahl: Integer;
  public
    destructor Destroy; override;
    procedure Vorn(AWert: Integer);
    procedure Umkehren;
    procedure Ausgeben;
    property Anzahl: Integer read FAnzahl;
  end;

constructor TKnoten.Create(AWert: Integer);
begin
  Wert := AWert;
  Weiter := nil;
end;

destructor TListe.Destroy;
var
  k, n: TKnoten;
begin
  k := FKopf;
  while k <> nil do
  begin
    n := k.Weiter;
    k.Free;
    k := n;
  end;
  inherited Destroy;
end;

procedure TListe.Vorn(AWert: Integer);
var
  k: TKnoten;
begin
  k := TKnoten.Create(AWert);
  k.Weiter := FKopf;
  FKopf := k;
  Inc(FAnzahl);
end;

procedure TListe.Umkehren;
var
  vorher, jetzt, naechster: TKnoten;
begin
  vorher := nil;
  jetzt := FKopf;
  while jetzt <> nil do
  begin
    naechster := jetzt.Weiter;
    jetzt.Weiter := vorher;
    vorher := jetzt;
    jetzt := naechster;
  end;
  FKopf := vorher;
end;

procedure TListe.Ausgeben;
var
  k: TKnoten;
begin
  k := FKopf;
  while k <> nil do
  begin
    write(k.Wert, ' ');
    k := k.Weiter;
  end;
  writeln;
end;

var
  l: TListe;
  i: Integer;
begin
  l := TListe.Create;
  try
    for i := 1 to 5 do l.Vorn(i * i);
    l.Ausgeben;
    l.Umkehren;
    l.Ausgeben;
    writeln(l.Anzahl);
  finally
    l.Free;
  end;
end.

program Worte;
{$mode objfpc}{$H+}
uses SysUtils, Classes;
var
  satz: String;
  woerter: TStringList;
  i, vokale: Integer;
  c: Char;
begin
  satz := 'Pascal macht Programmierung lesbar und strukturiert';
  woerter := TStringList.Create;
  try
    woerter.Delimiter := ' ';
    woerter.DelimitedText := satz;
    writeln(woerter.Count, ' Wörter');
    woerter.Sort;
    for i := 0 to woerter.Count - 1 do write(woerter[i], ' ');
    writeln;
  finally
    woerter.Free;
  end;
  vokale := 0;
  for c in LowerCase(satz) do
    if c in ['a', 'e', 'i', 'o', 'u'] then Inc(vokale);
  writeln(vokale, ' Vokale');
end.