Beispiel

Wenn wir bspw. einen Zahlenstrahl von 2 bis 100 sieben wollen, so starten wir zunächst mit der 2. Diese wird als Primfaktor erkannt, woraufhin alle Vielfachen gestrichen werden, also 4,6,8,10,12 usw.
Sind alle Vielfachen der 2 eliminiert, fahren wir mit der 3 fort. Also werden 6,9,12,15,18,21 usw. gestrichen. Hierbei können die bereits als Vielfache von 2 identifizierten, also bereits gestrichenen, Zahlen natürlich übersprungen werden. Anschaulich visualisiert sieht das so aus:

Von https://en.wikipedia.org/wiki/de:User:SKopp“ als eigenes Werk im deutschen Wikipedia veröffentlich

Implementierung

Zahlenstrahl

Lasst uns das Ganze nun Step-by-Step als Programm umsetzen.
Hierfür definieren wir als erstes unsere Endzahl, also die Obergrenze des Zahlenstrahls den wir sieben möchten, sowie die Wurzel dieser Zahl. Denn wenn wir die Vielfachen aller Zähler, welche größer als die Wurzel der Zahl sind, eliminiert haben sind alle übrigen Elemente automatisch Primzahlen.

Wie anfänglich gesagt geht es um eine stark vereinfachte und keinesfalls optimierte Variante. Wir „streichen“ also als erstes die 1, damit diese abschließend nicht in der Ausgabe unserer Primfaktoren erscheint:

Durchlauf der potenziellen Primfaktoren

Nun benötigen wir zunächst eines äußere Schleife in der wir alle Potenziellen Primfaktoren, also die Zahlen von 2 bis zur Wurzel unserer Endzahl durchlaufen, gefolgt von einer Prüfung, ob die betreffende Zahl bereits „gestrichen“ wurde:

Streichen der Vielfachen

Ist die Zahl noch nicht als Vielfaches eines vorangegangenen Primfaktors erkannt und somit noch im Rennen, so streichen wir ihre Vielfachen:

Hierbei beginnen wir absichtlich mit dem zweifachen des Primfaktors, sodass dieser selbst in unserem Zahlenstrahl verbleibt.

Ausgabe des gesiebten Zahlenstrahl

Abschließend erfolgt eine Ausgabe aller verbliebenen Zahlen:

Inklusive der Ausgabe aller gefundenen Primzahlen, sowie der benötigten Laufzeit ergibt sich dann folgendes kleine Script:

Optimierungen

Um die Laufzeit und die Speichernutzung zu optimieren gibt es hier nun unterschiedliche Optimierungsansätze. Der erste, einfachste und effektivste wäre es alle geraden Zahlen bereits beim Aufbau des Zahlenstrahls außenvor zu lassen. Bei einem so kleinen Zahlenstrahl wie in unserem Beispiel fällt der Unterschied nicht wirklich auf, wenn man jedoch eine deutlich größere Menge Zahlen sieben möchte, so ist der Unterschied immens. Denn hier gilt die ersten Durchläufe benötigen am längst, da hier, wie oben in der Grafik schön abgebildet ist, die meisten Zahlen gestrichen werden müssen. Mit zunehmendem Fortschritt wird das Streichen der Vielfachen immer schneller und schneller.

Hat Euch dieser Beitrag gefallen? Dann lasst uns doch einen Like auf Facebook oder Instagram da, oder kommentiert einfach direkt hier! Schickt uns gerne Eure Implementierungen oder Verbesserungsvorschläge des Sieb des Eratosthenes. Welche Siebe kennt Ihr noch ? Habt ihr Interesse an einer schematischen Implementierung des Atkins Sieve? Schreibt uns!

Der Beitrag Sieb des Eratosthenes – Primzahlen sieben in PowerShell erschien zuerst auf Informatik Guru.

#Starten der "Stoppuhr" unter Zuhilfenahme der .NET-Klasse system.diagnostics.stopwatch$timetracker = [system.diagnostics.stopwatch]::startNew()

#In $elapsedtime werden die zur Verarbeitung benötigten Sekunden seit dem Start der Stoppuhr geschrieben

#Ausgabe der Laufzeit des Scripts
write-host $timetracker.Elapsed.seconds "Sekunden`t" $timetracker.Elapsed.Milliseconds "Millisekunden"

Als nächstes gehen wir das Hauptproblem an, das Hochzählen der Fibonacci-Reihe.
Die Fibonacci-Reihe ist die unendliche Folge natürlicher Zahlen, beginnend mit 0,1,1, in welcher sich die nächste Zahl immer aus der Summe der beiden vorangegangenen ergibt.
Sie weist einige interessante mathematische Besonderheiten auf und steht in Zusammenhang mit dem Pascalschen Dreieck, sowie dem goldenen Schnitt, aber das ist eine andere Geschichte.

Hierfür benötigen wir einen Ausgangspunkt, sowie drei Variablen. In einer der beiden speichern wir die Summe und tauschen dann die Werte durch vor der nächsten Summenbildung.
Bspw: A = 1; B = 1 => C = 2
Im nächsten Durchlauf wäre es dann: A = 1; B = 2 => C = 3

Um die Operation im Rahmen der Schleife, welche wir benötigen um den Durchlauf zu automatisieren bis zur Grenze von 4.000.000, zu wiederholen müssen wir also die Werte tauschen.
Anhand unseres obenstehenden Beispiels wäre das dann nach dem ersten Durchlauf
A = B; B = C
In Summe ergibt das:

$fibosumme = 1;
$fibonacci1 = 0;
$fibonacci2 = 1;

while($fibosumme -lt 4000000){
    $fibosumme = $fibonacci1 + $fibonacci2;
    $fibonacci1 = $fibonacci2;
    $fibonacci2 = $fibosumme;
}

Zuletzt müssen wir beim hochzählen der Fibonacci-Folge lediglich noch prüfen, ob die nächste gefundene Zahl gerade ist und diese gegebenenfalls aufaddieren.

if($fibosumme % 2 -eq 0){
    $gesamtsumme += $fibosumme;
}

Nun müssen wir das Ganze nur noch zusammensetzen und mit einer Ausgabe versehen, welche uns die Summe präsentiert und die Aufgabe ist gelöst:

Weitere Project Euler-Aufgaben und andere Tutorials und Tipps im Kontext Powershell werden zeitnah folgen.
Apropos folgen, folgt Ihr uns eigentlich schon auf Facebook oder Instagram?
Falls nicht ist jetzt der perfekte Zeitpunkt das nachzuholen.
Gerne könnt Ihr Euch mit Kommentaren hier oder auf einem der Social Media Kanäle mit Ideen, Wünschen oder Kritik einbringen.
Wenn Ihr eine konkrete Frage zu Powershell Scripting oder Programmierung allgemein habt, könnt Ihr diese ebenfalls gerne auf den oben genannten Kanälen stellen wo wir diese gerne aufgreifen und entweder persönlich beantworten oder im Rahmen eines Beitrags thematisieren!

Der Beitrag Project Euler 2 – Powershell Edition erschien zuerst auf Informatik Guru.

Wir starten hier nun erstmal bei Aufgabe 1 von Project Euler in Powershell.
Dafür sehen wir uns zunächst einmal die Problemstellung an die auf der Website ( Euler 1 ) wie folgt beschrieben wird:

If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23.
Find the sum of all the multiples of 3 or 5 below 1000.

Wir suchen also die Summe aller Vielfachen von 3 und 5 unter 1000.

Hierfür gibt es nun mehrere Ansätze, da es sich um eine Herangehensweise für Anfänger handeln soll, belassen wir es bei der einfachen Lösung.

Sehen wir uns die Bausteine des Scripts zunächst mal der Reihe nach an:

Zunächst starten wir unter Zuhilfenahme der .NET-Klasse system.diagnostics.stopwatch eine Stoppuhr um die Laufzeit unseres Scripts zu messen. Bei den ersten paar Aufgaben werden wir hier kaum merkliche Unterschiede feststellen mit unterschiedlichen Lösungsvarianten, was sich allerdings mit zunehmender Schwierigkeit und Komplexität der Probleme von Aufgabe zu Aufgabe drastisch ändert.

#Starten der "Stoppuhr" unter Zuhilfenahme der .NET-Klasse system.diagnostics.stopwatch$timetracker = [system.diagnostics.stopwatch]::startNew()

#In $elapsedtime werden die zur Verarbeitung benötigten Sekunden seit dem Start der Stoppuhr geschrieben
$elapsedtime = $timetracker.Elapsed.Seconds

#Ausgabe der Laufzeit des Scripts
write-host "Die Gesamtlaufzeit betrug " $elapsedtime " Sekunden."

Warum haben wir uns hier für eine entliehene .NET-Klasse entschieden anstatt das über ein Powershell-Kommando wie bspw. das CMDlet Measure-Command zu lösen?
Ganz einfach: Aus Gewohnheit und weil bei Measure-Command ohne weiteres pipen die Ausgabe der zu erfolgenden Kommandos nie im stdout, also für uns sichtbar in der Konsolenausgabe landen.

Als nächster Baustein folgt die Schleife mit der wir über die gewünschten Zahlen iterieren, das „Herzstück“ des Scripts. Hierbei initialisieren wir im Schleifenkopf einen Zähler, welcher auch als aktuell zu prüfende Zahl dient. Vorab deklarieren wir eine Summenvariable, in welcher wir gleich die entsprechenden Zahlen aufaddieren werden und weisen dieser den Wert 0 zu.

#Initialisieren der Summenvariable
$Summe = 0

#Kopf der For-Schleife, mit welcher wir die Zahlen von 1 bis 999 durchlaufen
for($zaehler = 1;$zaehler -lt 1000; $zaehler ++){

#Prüfung ob die aktuelle Zahl durch 3 oder 5 teilbar ist
    if($zaehler % 3 -eq 0 -or $zaehler % 5 -eq 0){

#Falls ja, wird die aktuelle Zahl zur bisherigen Summe addiert
        $Summe = $Summe + $zaehler
    }
}

Als letzten Baustein fügen wir abschließend noch eine Ausgabe unseres Ergebnisses hinzu.
Hier verwenden wir des Weiteren den Parameter -NoNewline für das Kommando Write-Host, welcher das automatische Anfügen eines Zeilenumbruches unterbindet. Dadurch können wir die Summe selbst farbig innerhalb der selben Zeile ausgeben wie die vorangestellte Info.
Das ist zwar nicht Teil der Aufgabe, dient aber der Übersichtlichkeit unserer zugegebenermaßen kleinen Ausgabe und wir lernen schonmal einen neuen Parameter kennen.

#Ausgabe der Info bzgl. der Summe
write-host "Die Summe der Vielfachen von 3 oder 5 unter 1000 lautet:`t" -NoNewline  

#Ausgabe der Summe selbst
write-host $Summe -ForegroundColor Yellow

Zusammengesetzt ergibt sich hieraus nun folgendes kleine Script, welches die Problemstellung der Aufgabe 1 von Project Euler erfolgreich absolviert:

Weitere Project Euler-Aufgaben und andere Tutorials und Tipps im Kontext Powershell werden zeitnah folgen.
Apropos folgen, folgt Ihr uns eigentlich schon auf Facebook oder Instagram?
Falls nicht ist jetzt der perfekte Zeitpunkt das nachzuholen.
Gerne könnt Ihr Euch mit Kommentaren hier oder auf einem der Social Media Kanäle mit Ideen, Wünschen oder Kritik einbringen.
Wenn Ihr eine konkrete Frage zu Powershell Scripting oder Programmierung allgemein habt, könnt Ihr diese ebenfalls gerne auf den oben genannten Kanälen stellen wo wir diese gerne aufgreifen und entweder persönlich beantworten oder im Rahmen eines Beitrags thematisieren!

Der Beitrag Project Euler 1 – Powershell Edition erschien zuerst auf Informatik Guru.

Innerhalb der ISE habt ihr, wie ihr es ggf. aus anderen IDEs gewohnt seid, viele Comfort-Funktionen, wie bspw. automatische Vorschläge von Parametern, eine Befehlsübersicht oder bspw. automatisches einfügen von Code-Snippets wenn Ihr STRG + J drückt.
Gerade letzteres kann ich aus meinem Alltag in der Nutzung von Powershell wärmstens empfehlen.

Zur Nutzung der Powershell kann ich alles in allem sagen, dass ich sie für die eierlegende Wollmilchsau der Script- bzw. Programmiersprachen für viele, viele Aufgaben unter Windows halte.

Unabhängig davon ob man nun Betriebssystemaufgaben automatisieren, davon unabhängige Tasks programmieren, einfach etwas rumspielen (bspw. Projekt Euler 😉 ) oder seine Azure Cloud orchestrieren möchte, Powershell hat für unwahrscheinlich viele Ansätze die richtigen Werkzeuge parat.

Zum einen gibt es wahnsinnig viele mitgelieferte sogenannte CMDlets, über welche Ihr euch mit dem Befehl Get-Command einen Überblick verschaffen könnt, zum anderen gibt es reichhaltige Angebote seitens einer stetig wachsenden Community aus Entwicklern.

Ich für meinen Teil arbeite dienstlich viel mit der iTextsharp-Bibliothek, welche unter anderem das automatisierte Auslesen und Befüllen von PDF-Dokumenten ermöglicht um nur ein Beispiel von vielen zu nennen.

In kommenden Block-Beiträgen werden werden wir auf Besonderheiten, Tipps, Kniffe und Code-Beispiele in Powershell eingehen.

Wenn ihr Vorschläge, Eindrücke, Wünsche oder Ideen zum Thema habt, postet diese gerne hier, oder auf einem unserer Social Media Kanäle als Kommentar und bringt euch ein.
Thematisch gilt hier ganz klar:

Der Beitrag Einstieg Powershell – Was ist diese blaue cmd? erschien zuerst auf Informatik Guru.

Each new term in the Fibonacci sequence is generated by adding the previous two terms. By starting with 1 and 2, the first 10 terms will be:

1, 2, 3, 5, 8, 13, 21, 34, 55, 89, …

By considering the terms in the Fibonacci sequence whose values do not exceed four million, find the sum of the even-valued terms.

Wir wollen also die Summe aller geraden Fibonacci-Zahlen unter 4.000.000 finden.

Eine mögliche Lösung kann man in Perl wie folgt umsetzen:

#Aufgabenstellung
#Each new term in the Fibonacci sequence is generated by adding the previous two terms. By starting with 1 and 2, the first 10 terms will be:

#1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ...

#By considering the terms in the Fibonacci sequence whose values do not exceed four million, find the sum of the even-valued terms.



#übliche Shebang-Zeile
#!/usr/bin/perl

#Compiler-Flags die übliche Programmierfehler erkennen und aufzeigen
use strict;
use warnings;

#Deklaration der Variablen
my $fiboone = 1;
my $fibotwo = 1;
my $result = 0;
my $sum = 0;
#Schleifenkopf der While-Schleife, welche läuft bis $result, unsere Variable für den Dreieckstausch der Zahlen 4.000.000 erreicht
while($result < 4000000){
  #If-Condition welche überprüft ob der in $result befindliche Wert gerade ist (Modulo 2 = 0)
  if(($result % 2) == 0){
    #Falls ja wird der $result befindliche Wert zur Summe aller bisher gefunden geraden Fibonacci-Zahlen addiert
    $sum += $result;
  }
  #Dreieckstausch der beiden Zahlen-Variablen sowie der Hilfsvariable
  $result = $fiboone + $fibotwo;
  $fibotwo = $fiboone;
  $fiboone = $result;
}
#Ausgabe des Ergebnis
print "\nDas Ergebnis lautet:  $sum";

Dies ist natürlich nur eine mögliche Lösung und sie wurde des Weiteren nicht in Sachen Performance optimiert.
Wenn Ihr Optimierungsvorschläge, oder alternative Lösungen habt, so postet sie doch hier oder lasst sie uns per Mail an senpai@informatik-guru.de zukommen.

Wenn Euch der Beitrag gefallen hat, so kommentiert ihn doch, oder lasst uns ein Like auf Facebook oder ein Follow auf Instagram da.
Gerne könnt Ihr auch unseren Newsletter abbonieren, um immer über die neuesten Entwicklungen des Informatik-Guru auf dem Laufenden gehalten zu werden.

Der Beitrag Project Euler 2 – Perl for beginners erschien zuerst auf Informatik Guru.

Find the sum of all the multiples of 3 or 5 below 1000.

Wir wollen also die Summe aller durch 3 oder 5 teilbaren Zahlen unter 1000 finden.

Eine mögliche Lösung kann man in Perl wie folgt umsetzen:

#übliche Shebang-Zeile
#!/usr/bin/perl

#Compiler-Flags, die übliche Programmierfehler erkennen und aufzeigen
use warnings;
use strict;

#Deklaration eines Zahlenfeldes von 1 bis 999 sowie der Variable, welche wir später für das Errechnen der Summe verwenden
my @zahlenfeld = 1..999;
my $summe = 0;

#Schleifenkopf einer Foreach-Schleife, welche alle Elemente des oben deklarierten Zahlenfeldes durchläuft
foreach(@zahlenfeld){
  #If-Condition, welche True liefert, also ausgelöst wird, wenn die aktuell bearbeitete Zahl weder durch 3 noch durch 5 teilbar ist
  if($_ % 3 != 0 && $_ % 5 != 0){
    #Die aktuelle Zahl als auf "undef" setzen, wonach sie keinen Wert mehr enthält
    $_ = undef;
  } #Ende IF
} #Ende der Schleife

#Schleifenkopf einer Foreach-Schleife, welche alle Elemente des oben deklarierten Zahlenfeldes durchläuft
foreach(@zahlenfeld){
  #If-Condition, welche ausgelöst wird, wenn das aktuelle Element einen Wert enthält, also nicht "undef" ist
  if($_){
    #Hier wird der Summe der aktuelle Wert hinzugefügt
    $summe += $_;
  } #Ende IF
} #Ende der Schleife

#Zum Abschluss eine Ausgabe, welche uns das Ergebnis präsentiert
print "Die Summe aller durch 3 oder 5 teilbaren Zahlen unter 1000 lautet:\n$summe\n";

Wir werden uns bald weiteren projecteuler-Aufgaben annehmen und diese in unterschiedlichen Programmier- und Scriptsprachen lösen.
Gerne könnt Ihr eure Variante der Lösung in den Kommentaren posten.
Falls Ihr eine coole Idee habt, welches Programmierproblem wir hier thematisieren könnten, so lasst uns davon wissen.

Wenn Euch der Beitrag gefallen hat, so kommentiert ihn doch, oder lasst uns ein Like auf Facebook oder ein Follow auf Instagram da.
Gerne könnt Ihr auch unseren Newsletter abbonieren, um immer über die neuesten Entwicklungen des Informatik-Guru auf dem Laufenden gehalten zu werden.

Der Beitrag Project Euler 1 – Perl for beginners erschien zuerst auf Informatik Guru.