Diese fünf Funktionen genügen, um den Hauptteil der Arbeit eines Computers nachvollziehen zu können. Das soll anhand einiger schöner Beispiele geschehen, die es euch auch ermöglichen, die Mathe-Hausaufgaben schneller zu erledigen.
Als Programmiersprache verwenden wir "Perl".
Falls ihr zu Hause weiterprogrammieren wollt, könnt ihr den Perl-Interpreter bei
Strawberry Perl (geht leichter) oder
Active Perl (muss man sich Einloggen, aber kostenfrei!)
herunterladen.
Ausführlichere Einweisungen gibt es im Internet sehr viele, z.B.:
www.mathe2.uni-bayreuth.de/perl/inhalt.htm
www.ssw.uni-linz.ac.at/Teaching/Lectures/Sem/2000/Katzmayr/
http://de.wikibooks.org/wiki/Perl-Programmierung
www.tutorialspoint.com/perl/perl_syntax.htm
hello.pl
======================================================================
print "Hello World!\n";
======================================================================
hello.pl
======================================================================
$satz = "Hello World!";
print "$satz\n";
======================================================================
hello.pl
======================================================================
$satz = "Hallo, wie geht es dir?";
print "$satz\n";
$antwort = <STDIN>;
chomp($antwort);
$satz = "Es freut mich, dass es dir ".$antwort." geht!";
print "$satz\n";
======================================================================
talk.pl
======================================================================
print "Was ist dein Lieblingsgericht?\n";
$antwort = <STDIN>;
chomp($antwort);
if($antwort eq "Sellerieschnitzel")
{
print "hmmm, lecker ".$antwort." liebe ich auch!!!\n";
}
if($antwort eq "Spaghetti")
{
print "igittigitt, ".$antwort."\n";
}
======================================================================
talk.pl
======================================================================
print "Was ist dein Lieblingsgericht?\n";
$antwort = <STDIN>;
chomp($antwort);
if($antwort eq "Sellerieschnitzel")
{
print "hmmm, lecker ".$antwort." liebe ich auch!!!\n";
}
elsif($antwort eq "Spaghetti")
{
print "igittigitt, ".$antwort."\n";
}
else
{
print "Aha, interessant, ".$antwort." kenne ich gar nicht!\n";
}
======================================================================
rechner.pl
======================================================================
$zahl1 = 5;
$zahl2 = 7;
$zahl3 = $zahl1*$zahl2;
print "Ergebnis: $zahl3\n";
======================================================================
rechner.pl
======================================================================
print "Erste Zahl:";
$zahl1 = <STDIN>;
chomp($zahl1);
print "Zweite Zahl:";
$zahl2 = <STDIN>;
chomp($zahl2);
$zahl3 = $zahl1*$zahl2;
print "Ergebnis von $zahl1 * $zahl2: $zahl3\n";
======================================================================
rechner.pl
======================================================================
print "---- Start Programm Taschenrechner ----\n";
print "Erste Zahl:";
$zahl1 = <STDIN>;
chomp($zahl1);
print "Operation:";
$zeichen = <STDIN>;
chomp($zeichen);
print "Zweite Zahl:";
$zahl2 = <STDIN>;
chomp($zahl2);
$ergebnis = 0;
$matherror = 1;
if($zeichen eq "+")
{
$ergebnis = $zahl1+$zahl2;
$matherror = 0;
}
if ($zeichen eq "-")
{
}
if($matherror == 0)
{
print "Ergebnis: $zahl1 $zeichen $zahl2 = $ergebnis\n";
}
else
{
print "MathError\n";
}
======================================================================
Aufgabe: Vervollständige das Programm so, dass es alle vier Grundrechenarten ausführen kann.
Zur Arbeitserleichterung ist es beim Programmieren vorteilhaft viel mit Copy and Paste zu arbeiten.
Wofür Menschen stundenlange Zeit zum Tippen brauchen, das schreibt ein Computer in einer Millisekunde.
Kopiere und teste das folgende Programm:
loop.pl
======================================================================
$satz = "Soll ich fortfahren? ";
$antwort = "ja";
while( $antwort eq "ja" )
{
print "$satz";
$antwort = <STDIN>;
chomp($antwort);
}
======================================================================
loop.pl
======================================================================
for($i=0;$i<14;$i=$i+1)
{
print "$i Semmeln weg\n";
}
======================================================================
nervmich.pl
======================================================================
$satz1 = "Soll ich ";
$satz2 = "fortfahren? ";
$satz = $satz1.$satz2;
$repeat = 0;
$antwort = "ja";
while( $antwort eq "ja" )
{
$satz = $satz1;
for($i=0;$i<$repeat;$i=$i+1)
{
$satz = $satz."wirklich ";
}
$satz = $satz.$satz2;
print "$satz";
$antwort = <STDIN>;
chomp($antwort);
$repeat = $repeat + 1;
}
print "Na, dann eben nicht!\n";
======================================================================
power.pl
======================================================================
$produkt = 0;
$faktor = 4;
$grenze = 7;
for($i=0;$i<$grenze;$i=$i+1)
{
$produkt = $produkt+$faktor;
}
print "$produkt\n"
======================================================================
wasistdas.pl
======================================================================
$k = 0;
$grenze = 7;
for($i=0;$i<$grenze;$i=$i+1)
{
$k = $k+2*$i+1;
print "$k\n";
}
print "Richtig gedacht?\n";
======================================================================
bewegung1.pl
======================================================================
$|++; # wichtig, zum Initialisieren
print "Warte! Ich arbeite gerade!\n";
$grenze = 5;
for($i=0;$i<$grenze;$i=$i+1)
{
print "|";
sleep(1); # 1 Sek Pause
}
print "\n";
print "Fertig!\n";
======================================================================
bewegung2.pl
======================================================================
sub printout
{
print '|';
}
$|++; # wichtig, zum Initialisieren
print "Warte! Ich arbeite gerade!\n";
$grenze = 5;
for($i=0;$i<$grenze;$i=$i+1)
{
printout;
sleep(1); # 1 Sek Pause
}
print "\n";
print "Fertig!\n";
======================================================================
bewegung3.pl
======================================================================
$|++; # wichtig, zum Initialisieren
$grenze = 5;
for($i=0;$i<$grenze;$i=$i+1)
{
print "$i", "\b";
select undef, undef, undef, 0.5;
}
print "\n";
print "Fertig!\n";
======================================================================
bewegung4.pl
======================================================================
$|++; # wichtig, zum Initialisieren
$wheel = 12;
for($j=0;$j<$wheel;$j=$j+1)
{
print substr( "-/|\\", $j % 4, 1 ), "\b";
select undef, undef, undef, 0.1;
}
print "\n";
print "Fertig!\n";
======================================================================
Aufgabe 1: Die Schlange soll sich mit jedem Biss nach vorne bewegen.
Aufgabe 2: Vor der Schlange soll sich irgendeine Schrift befinden, schrittweise soll die Schlange sich die Schrift einverleiben.
Ob die Schlange dabei länger wird (oder gar dicker) oder unverändert bleibt während der Bewegung, ist euch überlassen.
bewegung5.pl
======================================================================
$|++;
# wichtig, zum Initialisieren
print "xxx(",chr(248); # hierbei ist chr(248) das Grad-Symbol ° , man kann auch einfach "o" nehmen
for (0..10)
{
print "<";
select undef, undef, undef, 0.1;
print "\b";
print "-";
select undef, undef, undef, 0.1;
}
print "\n";
======================================================================
Die Syntax des for-loops hat sich auch ein wenig geändert, das geht so, wenn man den index als Zahl nicht braucht. Perl hat oft verschiedene Schreibweisen.
Letzter Punkt: Der ganze Bildschirm soll erobert werden. Das ist nun leider sehr Betriebssystem abhängig. Bei mir funktionieren unter Linux-Mint folgende Befehle:
bewegung6.pl
======================================================================
$|++;
# wichtig, zum Initialisieren
print "\033[2J"; #clear the screen
print "\033[0;0H"; #jump to 0,0
print "x";
select undef, undef, undef, 0.5;
print "\033[20;0H"; #jump to 20,0
print "x";
select undef, undef, undef, 0.5;
print "\b";
select undef, undef, undef, 0.5;
print "\033[10;45H"; #jump to 10,45
print "x";
======================================================================
Aufgabe: Entwerfe ein einfaches Strichmännchen, das gehen oder winken oder sich setzen kann.
Aufgabe: Lass die Schlange aus bewegung5.pl über der gesamten Bildschirm wandern, nicht nur eine Zeile.
arrays.pl
======================================================================
@blubb;
$blubb[0]='Bilbo';
$blubb[1]='Frodo';
$blubb[2]='Sam';
$blubb[3]='Peregrin Tuk';
print "$blubb[1] ist ein Hobbit \n";
print "Es gibt viele Hobbits, z.B.: \n";
for($i=0; $i<=3; $i=$i+1)
{
print "$blubb[$i] \n";
}
======================================================================
talk.pl
======================================================================
@gericht=('Spaghetti','Pommes Frites','Sellerieschnitzel','Brei');
@geschmack=('igittigitt','ja, das mag ich auch','hmmm, lecker','ja gehts noch');
print "Was ist dein Lieblingsgericht?\n";
$antwort = <STDIN>;
chomp($antwort);
if($antwort eq $gericht[1])
{
print "$geschmack[1], ".$antwort."!!!\n";
}
======================================================================
Arrays sind im Zusammenhang mit den Rechenfähigkeiten ein äußerst starkes Werkzeug.
Für Anfänger werden die Programme allerdings manchmal wegen der Indizes ein wenig schwer lesbar.
Versuche nachzuvollziehen, was das folgende Programm macht,
ohne es laufen zu lassen.
Danach setze es mit Perl in Bewegung und schau, ob deine Vorhersage stimmte!
sort.pl
======================================================================
# Zeilen, die mit diesem Zeichen beginnen, sind Kommentarzeilen.
# Sie dienen dazu, das Programm lesbarer zu gestalten
@blubb=(12,15,-33,0.4,2,-199,20000,-3017,529,1,-34,9090,12,13,-15,187321,-10862,0.002,100,-100);
# blubb ist ein array von gemischten Zahlen
$laenge = @blubb;
# laenge ist jetzt die Anzahl der Einträge in dem array blubb (derzeit 19 Stück)
for ($i=0;$i<$laenge;$i=$i+1)
{
print "$blubb[$i] \n";
}
# Erstmal alles ausgeben, was gespeichert wurde
$ende="nein";
while($ende eq "nein")
{
$ende="ja";
for($i=0;$i<$laenge-1;$i=$i+1)
{
if($blubb[$i]>$blubb[$i+1])
{
($blubb[$i],$blubb[$i+1])=($blubb[$i+1],$blubb[$i]);
$ende="nein";
# Genau hinschauen was passiert: Die Einträge im array blubb werden vertauscht!
}
}
}
print "\n";
print "Jetzt nochmal:\n";
print "\n";
for ($i=0;$i<$laenge;$i=$i+1)
{
print "$blubb[$i] \n";
}
======================================================================
zahlen.pl
======================================================================
$grenze = 10;
@zahlen;
$zahlen[0]=1;
for($i=1;$i <= $grenze;$i=$i+1)
{
$zahlen[$i] = $zahlen[$i-1]+2*$i+1;
}
for($i=0;$i <= $grenze;$i=$i+1)
{
print "$zahlen[$i] "
}
print "\n"
======================================================================
prim.pl
======================================================================
$k=4;
print "Zahl:";
$zahl=<STDIN>;
chomp($zahl);
$teilbar="nein";
if($zahl%$k==0)
{
$teilbar="ja";
}
if($teilbar eq "ja")
{
print "$zahl ist durch $k teilbar \n";
}
======================================================================
krypto1.pl
======================================================================
# kleine Vorübung
$str = "a";
$k = ord($str);
# die Funktion ord verwandelt einen Buchstaben in ASCII-Code
print "$k\n";
# die Funktion chr verwandelt wieder zurück
$str = chr($k);
print "$str\n";
# Jetzt das Ganze mit einem Satz
# Initialisiere einen String
$str = "Was soll denn das bedeuten?";
$laenge = length ($str);
print "$str\n";
# Umwandlung jedes einzelnen Buchstabens von in ein Array-Element und
# substr($str,$i,1)ist der i-te Buchstabe in dem String str
# Umwandlung jedes einzelnen dieser Array-Elemente mit "ord" in eine ASCII-Zahl:
for ($i=0; $i<$laenge; $i=$i+1)
{
@array[$i] = substr($str,$i,1);
@array[$i] = ord(@array[$i]);
}
print "@array\n";
# Ausgabe des Satzes in ASCII-Code
======================================================================
krypto2.pl
======================================================================
# Initialisiere einen String
$str = "Was soll denn das bedeuten?";
# Zerteile den String in ein array von Buchstaben
@array = split //,$str;
# Verwandle jeden Buchstaben mit "map" und "ord" in seine ASCII-Zahl
@array = map(ord, @array);
print "@array\n";
======================================================================
krypto3.pl
======================================================================
$abc = "abcdefghijklmnopqrstuvwxyz";
$satz = "wassolldenndasbedeuten";
$labc = length $abc;
$le = length $satz;
$shift = 3;
for ($i=0; $i<$le; $i=$i+1)
{
for ($j=0; $j<$labc; $j=$j+1)
{
if( substr($satz,$i,1) eq substr($abc,$j,1) )
{
$jneu = $j+$shift;
if( $jneu>=$labc ) {
$jneu = $jneu - $labc;
}
substr($satz,$i,1) = substr($abc,$jneu,1);
$j=$labc;
}
}
}
print "$satz\n";
======================================================================
krypto4.pl
======================================================================
$abc = "abcdefghijklmnopqrstuvwxyz";
$zufalls_abc = "sfrmdbwehcouykpzlqtigxvajn";
$satz = "wassolldenndasbedeuten";
$labc = length $abc;
$le = length $satz;
# chiffrieren, jeder Buchstabe von $satz wird durch den entsprechenden des Zufallsalphabetes ersetzt
for ($i=0; $i<$le; $i=$i+1)
{
for ($j=0; $j<$labc; $j=$j+1)
{
if( substr($satz,$i,1) eq substr($abc,$j,1) )
{
substr($satz,$i,1) = substr($zufalls_abc,$j,1);
$j=$labc;
}
}
}
print "$satz\n";
======================================================================
krypto5.pl
======================================================================
# knacken von zufalls_abc
$abc = "abcdefghijklmnopqrstuvwxyz";
# das normale abc
$hauf_abc_deutsch = "ensiratdhulcgmobwfkzpvjyxq";
# das abc in der Reihenfolge der Häufigkeit in der deutschen Sprache
$hauf_abc_satz = "abcdefghijklmnopqrstuvwxyz";
# das abc in der Reihenfolge der Häufigkeit in der vorgelegten geheimen Schrift (muss noch umgeordnet werden)
$satz = "msthtidhktpxdqqgdroidqtsinmstoqhdwiheqkhdqsgt";
# der Geheimtext (je mehr Buchstaben, desto besser klappt die Dechiffrierung)
@satz_hauf;
# ein array, dass für jeden Buchstaben ( a an erster Stelle, b an zweiter etc.)
# die Häufigkeit zählt, mit der dieser Buchstabe in dem Geheimtext vorkommt
$labc = length $abc;
$le = length $satz;
# initialisieren
for ($j=0; $j<$labc; $j=$j+1)
{
$satz_hauf[$j]=0;
}
# zähle die Buchstaben im Geheimtext
for ($i=0; $i<$le; $i=$i+1)
{
for ($j=0; $j<$labc; $j=$j+1)
{
if( substr($satz,$i,1) eq substr($abc,$j,1) )
{
$satz_hauf[$j]=$satz_hauf[$j]+1;
$j=$labc;
}
}
}
# ausgeben der Häufigkeiten
for ($j=0; $j<$labc; $j=$j+1)
{
print substr($abc,$j,1)." - $satz_hauf[$j]\n";
}
# Sortiere die Einträge im array @satz_hauf nach ihrer Größe
# parallel dazu wird auch das abc umgeordnet: Die im Geheimtext am häufigsten vorkommenden Buchstaben stehen vorn, die seltensten hinten
$ende="nein";
while($ende eq "nein")
{
$ende="ja";
for($i=0;$i<$labc-1;$i=$i+1)
{
if($satz_hauf[$i]<$satz_hauf[$i+1])
{
($satz_hauf[$i],$satz_hauf[$i+1])=($satz_hauf[$i+1],$satz_hauf[$i]);
($abc_array[$i],$abc_array[$i+1])=($abc_array[$i+1],$abc_array[$i]);
$ende="nein";
}
}
}
# abc neu schreiben für Satz
for ($j=0; $j<$labc; $j=$j+1)
{
substr($hauf_abc_satz,$j,1)=$abc_array[$j];
}
print "$hauf_abc_satz \n";
# das ist das Alphabet geordnet nach der Häufigkeit, wie die Buchstaben im Geheimsatz vorkommen
print "$hauf_abc_deutsch \n";
# das ist das Alphabet geordnet nach der Häufigkeit, wie die Buchstaben im Deutschen vorkommen zum Vergleich
print "$satz\n";
# Ausgabe Geheimtext original
# ersetze jetzt noch jeden Buchstaben von $satz mit der Häufigkeit $hauf_abc_satz durch $hauf_abc_deutsch
for ($i=0; $i<$le; $i=$i+1)
{
for ($j=0; $j<$labc; $j=$j+1)
{
if( substr($satz,$i,1) eq substr($hauf_abc_satz,$j,1) )
{
substr($satz,$i,1)=substr($hauf_abc_deutsch,$j,1);
$j=$labc;
}
}
}
print "$satz\n";
# Ausgabe Geheimtext entziffert
======================================================================
zufall.pl
======================================================================
$k = int (rand 20);
print "Zufallszahl $k";
======================================================================
satz.pl
======================================================================
@artikel=("der","die","das");
@haupt=("Hund","Pferd","Taube","Kaninchen","Angela Merkel","Chuck Norris","Justin Bieber");
@verb=("rennt","liest","frisst","schimpft","schreit");
# drei verschiedene Arrays, die Wörter der jeweils gleichen Art beinhalten
$rand_artikel1=int(rand @artikel);
$artikel1=$artikel[$rand_artikel1];
$rand_haupt1=int(rand @haupt);
$haupt1=$haupt[$rand_haupt1];
$rand_verb1=int(rand @verb);
$verb1=$verb[$rand_verb1];
# es wird für jedes array eine Zufallszahl bis max Größe des arrays erzeugt
# derjenige Eintrag des arrays, den die Zufallszahl bezeichnet, wird ausgewählt
print "$artikel1 $haupt1 $verb1. \n";
======================================================================
dialog.pl
======================================================================
@frage=("Wie geht es Dir?","Was machst Du grad?","Was ist Deine Lieblingsbeschaeftigung?");
@erwiderung=("Find ich klasse!!!","Das wuerde mir nie passieren!!!","Schaemst Du Dich nicht?","Bei mir genauso...","Das tut mir leid...");
$rand_frage=int(rand @frage);
$frage_jetzt=$frage[$rand_frage];
$rand_erwiderung=int(rand @erwiderung);
$erwiderung_jetzt=$erwiderung[$rand_erwiderung];
# es wird für jedes array eine Zufallszahl bis max Größe des arrays erzeugt
# derjenige Eintrag des arrays, den die Zufallszahl bezeichnet, wird ausgewählt
print "$frage_jetzt \n";
$antwort = <STDIN>;
print "$erwiderung_jetzt \n";
======================================================================
datei.pl
======================================================================
my $ausgabe_datei = "hierstehts.txt";
open AUSGABE, ">> $ausgabe_datei";
$satz = "hallihallo";
print AUSGABE "$satz\n";
close AUSGABE;
======================================================================
cellA.pl
======================================================================
print "hello\n";
system "perl cellA.pl";
======================================================================
cellB.pl
======================================================================
# die Nummer der Mutterzelle wird beim Programmaufruf uebergeben
$cellnumber = @ARGV[0];
# die Nummer wird um eins erhoeht
$cellnumber += 1;
print "Hello, I am cell number $cellnumber\n";
system "perl cellB.pl $cellnumber";
======================================================================
cellC.pl
======================================================================
# die Nummer der Mutterzelle wird beim Programmaufruf uebergeben
$cellnumber = @ARGV[0];
# die Nummer wird um eins erhoeht
$cellnumber += 1;
print "Hello, I am cell number $cellnumber\n";
system "perl cellC.pl $cellnumber &";
system "perl cellC.pl $cellnumber &";
======================================================================
cellD.pl
======================================================================
# die Nummer der Mutterzelle wird beim Programmaufruf uebergeben
$cellnumber = @ARGV[0];
# die Nummer wird um eins erhoeht
$cellnumber += 1;
print "Hello, I am cell number $cellnumber\n";
# Achtung; Hier ist das Neue: Der Prozess verzweigt sich (fork)
# und selbststaendig laufen zwei neue Programme los
# der Nachsatz "die" (sterben) ist nur fuer den Fall, dass etwas schief geht
defined(my $pid = fork) or die "fork not possible: $!";
unless ($pid) {
system "perl cellD.pl $cellnumber &" or die "system call not possible";
}
defined(my $pid = fork) or die "fork not possible: $!";
unless ($pid) {
system "perl cellD.pl $cellnumber &" or die "system call not possible";
}
======================================================================
cellE.pl
======================================================================
use File::Copy;
# Name der Zellkultur, da wir inzwischen verschiedene Generationen haben
$cell_name = "cellE";
# Die Urzelle aller Zellen
$motherfile = $cell_name.".pl";
# die Mutterzelle lebt weiter, in der 1.Verzweigung (fork)
# der Nachsatz "die" (sterben) ist nur für den Fall, das computertechnisch etwas schiefgeht
defined(my $pid = fork) or die "fork not possible: $!";
unless ($pid) {
system "perl $motherfile &" or die "cannot start motherfile";
}
# Die Zellteilung (fork zur 2.Verzweigung)
defined(my $pid = fork) or die "fork not possible: $!";
unless ($pid) {
# check wie viele Zellen es schon gibt, hierfür werden die vorangegangenen Dateien kurz geoeffnet
# dieser Schritt wird einige verwundern, geht das denn nicht leichter?
# nicht wirklich, wenn man moechte, dass jede einzelne Zelle autark ist,
# d.h. es soll keine Superzelle geben, die alles im Blick hat und Zellennummern vergeben kann etc.
$cellnumber = 0;
$newfile = $motherfile;
while (open(DATEI, $newfile)) {
$cellnumber += 1;
$newfile=$cell_name.$cellnumber.".pl";
close(DATEI);
}
# Der neue Name ist gefunden und die Mutterzelle wird verdoppelt (copy) und Kundgegeben (print)
# als obere Schranke gegen Festplattenschaeden und fuer korrekte Zaehlweise ist 1000 eingefuegt
if ($cellnumber<1000)
{
copy($motherfile, $newfile);
print $newfile."\n";
# Mit Erzeugen und Kundgeben der neuen Zelle ist es nicht getan:
# Sie muss auch zum Leben erweckt werden, der Nachsatz "die" (sterben) ist wieder nur für den Fall, das was schiefgeht
system "perl $newfile &" or die "cannot start newfile";
}
}
======================================================================
cellF.pl
======================================================================
use File::Copy;
# die Nummer dieser Zelle selber wird beim Programmaufruf uebergeben
# Man muss ab jetzt also unterscheiden zwischen Urmutterzelle und direkter Abstammungszelle
$oldcellnumber = @ARGV[0];
$cell_name = "cellF";
# die Urmutterzelle hat keine Nummer
# die Nachkommen haben Nummern, mit Nullen angefüllt damit mit den Zahlen eine alphabetische Reihenfolge entsteht
if (!($oldcellnumber>0)) {
$cellnumberstr = "";
}
else {
$cellnumberstr = "000";
substr($cellnumberstr,(3-length($oldcellnumber)),3) = "$oldcellnumber";
}
$motherfile = $cell_name.$cellnumberstr.".pl";
# die direkte Mutterzelle lebt weiter, in der 1.Verzweigung (fork)
# der Nachsatz "die" (sterben) ist nur für den Fall, das was schiefgeht
defined(my $pid = fork) or die "fork not possible: $!";
unless ($pid) {
system "perl $motherfile &" or die "cannot start $motherfile";
}
defined(my $pid = fork) or die "fork not possible: $!";
unless ($pid) {
# check wie viele Zellen es schon gibt
# Das Array "cells" enthält die Dateinamen aller Dateien von der Form "cellF..." stehen (Befehl glob)
# Die Anzahl der Dateien in diesem Array ist "@cells", das ist dann die Nummer der neuen Zelle
# als obere Schranke gegen Festplattenschaeden und fuer korrekte Zaehlweise ist 1000 eingefuegt
my @cells = glob $cell_name."*.pl";
$cellnumber = @cells;
if ($cellnumber<1000)
{
$cellnumberstr = "000";
substr($cellnumberstr,(3-length($cellnumber)),3) = "$cellnumber";
$newfile=$cell_name.$cellnumberstr.".pl";
# Der neue Name ist gefunden und die Mutterzelle wird verdoppelt (copy) und Kundgegeben (print)
copy($motherfile, $newfile);
print $newfile."\n";
# Mit Erzeugen und Kundgeben der neuen Zelle ist es nicht getan:
# Sie muss auch zum Leben erweckt werden, der Nachsatz "die" (sterben) ist nur für den Fall, das was schiefgeht
system "perl $newfile $cellnumber &" or die "cannot start cell $cellnumber";
}
}
======================================================================
my @cells = glob $cell_name."*.pl";
$cellnumber = @cells;
# mindestens 10 Zellen muss der Raeuber sehen, um eine zum Fressen zu erwischen
if ($cellnumber>10)
{
# bilde Zufallszahl aus Zellenmenge, um eine Zelle zum Fressen auszuwaehlen
$rand_cell=int(rand (@cells-1));
$prey = $cells[$rand_cell];
print "eat ".$prey."\n";
# die zufaellig ausgwaehlte Zelle ($prey) wird gefressen, sprich ihre Datei wird geloescht ("unlink")
unlink ($prey) or die "digestion problem";
}
tictactoe.pl
======================================================================
print "_____________\n";
print "| | | |\n";
print "| 1 | 2 | 3 |\n";
print "|___|___|___|\n";
print "| | | |\n";
print "| 4 | 5 | 6 |\n";
print "|___|___|___|\n";
print "\n";
======================================================================
tictactoe.pl
======================================================================
@mark=(' ','X','O','X',' ','O',' ',' ');
# das sind nur Markierungen, um zu zeigen, wie es prinzipiell geht
# eigentlich muss bei Spielbeginn das Spielfeld natürlich leer sein
$gameEnd = 0;
while ($gameEnd==0)
{
# zuerst wird die Nummerierung angezeigt
print "_____________\n";
print "| | | |\n";
print "| 1 | 2 | 3 |\n";
print "|___|___|___|\n";
print "| | | |\n";
print "| 4 | 5 | 6 |\n";
print "|___|___|___|\n";
print "\n";
print "\n";
# dann wird der momentane Spielstand angezeigt
print "_____________\n";
print "| | | |\n";
print "| ".$mark[0]." | ".$mark[1]." | ".$mark[2]." |\n";
print "|___|___|___|\n";
print "| | | |\n";
print "| ".$mark[3]." | ".$mark[4]." | ".$mark[5]." |\n";
print "|___|___|___|\n";
print "\n";
print "\n";
print "Spieler Kreuz: Welches Feld (1-9) soll markiert werden? (q=quit)\n";
$antwort = <STDIN>;
chomp($antwort);
if ($antwort eq "q")
{
$gameEnd=1;
}
for ($i=0; $i<9; $i=$i+1)
{
if ($antwort==$i)
{
$mark[$i-1]='X';
}
}
}
======================================================================
Contact: g.breitenbach@waldorf-ism.de
Last modified: March 2018