Bitcoin und SHA

Das Bitcoin-Protokoll gilt als sicher. Zu verdanken hat das Protokoll diese Eigenschaft unter anderem einem speziellen Algorithmus. Bitcoin verwendet für den Miningprozess, das Kreieren von Adressen und der Verifikation von Transaktionen eine Sha-256 Funktion. Das Bitcoin-Protokoll nutzt eine doppelte SHA-256 Funktion, was bedeutet, die Funktion wird auf die Ausgabe der Funktion angewandt. SHA-256 findet jedoch auch Anwendung in manchen der meistgenutzten Authentifizierung und Sicherheitsprotokollen wie SSL, TLS, IPsec, SSH und PGP. Auch in Unix und Linux wird der Algorithmus zum hashen von Passwörtern genutzt. Wie der Name vermuten lässt, ist der Output der Funktion 256 Bits lang.

Eine kurze Historie zu SHA-256

SHA-256 wurde 2002 als Reaktion auf erfolgreiche Angriffe auf die SHA-1 Hashfunktionen von der NSA entwickelt und vorgestellt. Auf einer National Institute of Standards and Technology (NIST) Konferenz im Jahr 2005 wurde die Umstellung von SHA-1 auf SHA-2 empfohlen und als Standard etabliert. Im Jahr 2012 wurde Keccak zum SHA-3 Algorithmus gewählt. SHA-256 sowie einige andere Algorithmen der SHA-2 Familie werden vom Bundesamt für Sicherheit in der Informationstechnik (BSI) jedoch immer noch als sicher eingestuft.

Die Eigenschaften von SHA-256

Es gibt 3 Eigenschaften welche den Grundstein des SHA-256 Algorithmus und seiner Sicherheit liefern. Um die nachfolgenden Eigenschaften einzuordnen, hilft es sich zu verdeutlichen, dass 2²⁵⁶ mehr ist als die Anzahl der Atome in dem uns bekannten Universum.

1. Es ist nahezu unmöglich die ursprünglichen Daten aus dem Hashwert zu rekonstruieren. Angenommen dies wäre das Ziel eines Angreifers, so müsste dieser mit einer Exhaustionsmethode (Bute-Force Attack) 2²⁵⁶ Versuche durchführen. Die Anzahl der benötigten Versuche ist schier zu groß, um dies überhaupt in Erwägung zu ziehen.
2. Es ist äußerst unwahrscheinlich zweimal denselben Hashwert zu erhalten, da es 2²⁵⁶ verschiedene Möglichkeiten gibt.
3. Eine minimale Veränderung der Daten verändert den Hashwert so, dass nicht ersichtlich ist, dass der neue Hashwert aus einem ähnlichen Datensatz kreiert wurde.

Beispiel Output der SHA-256 Funktion

Um die Funktionsweise und Punkt 3 zu verdeutlichen ein Nehmen wir die Wörter „Beispiel“ und „Beispiele“.

Der Output der SHA-256 Funktion als Hexadezimal von „Beispiel“ ist: 2071c7736acd16f6cea3727d3b7ecde53f4c2e97b421f3550248e19d7309c636

Der Output der SHA-256 Funktion als Hexadezimal von „Beispiele“ ist: 147790983143d584d88c22ad1a14f128c3d55e3dea3d92ec400e930a04031fb9

Es lässt sich offensichtlich, anhand der Hashwerte, kein Rückschluss auf die Daten ziehen.

SHA Funktionen bilden das Fundament einer Vielzahl von Authentifizierung und Sicherheitsprotokollen.

Auch Blockchain Protokolle wie z.B. Bitcoin nutzen diese und ähnliche Algorithmen, um Sicherheit Ihrer Transaktionen und des Miningprozesses zu gewährleisten. Die SHA-256 Funktion bietet eine optimale Balance zwischen Kollisionsresistenz und Effizienz für das Bitcoin Protokoll. Die Länge der Daten welche gehasht werden ist für die Länge des Outputs irrelevant. Dieser beträgt immer 256 bits. Der 64 Zeichen lange Hexadezimalwert, welcher z.B. einen Block der Bitcoin Blockchain repräsentiert eignet sich somit optimal um zu gewährleisten das die Daten eines Blocks unverändert sind. Jeder Knotenpunkt (Node) kann somit die Integrität eines Blockes validieren. Da eine Blockchain neue Blöcke chronologisch ankettet und der Hash des aktuellen Blocks auf dem vorhergehenden Block basiert, sind Daten unveränderbar auf der Blockchain gespeichert.

Hat Euch dieser Beitrag gefallen? Lasst uns und dem Auto Stable Blocks ein Like da und kommentiert was das Zeug hält!

Der Beitrag SHA-256 und Bitcoin – feat. Stableblocks erschien zuerst auf Informatik Guru.

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.

Im folgenden möchte ich Euch Step-by-Step näher bringen, wie ihr PDFs automatisiert auslesen, filtern und verarbeiten könnt. Ziel ist es eine Funktion in PowerShell zu haben, welche Ihr ganz einfach in Eure bestehenden Ideen oder Abläufe einbinden könnt.

Hierfür verwenden wir im folgenden iTextSharp. iTextSharp könnt ihr hier herunterladen:
iTextSharp Download

iTextSharp einbinden

Um iTextSharp nun innerhalb unseres PowerShell Scripts zu verwenden um PDFs automatisiert auszulesen müssen die es zunächst einbinden.
Dies geschieht so:

Nun stehen uns im weiteren Verlauf Objekte und Methoden hieraus zur Verfügung.

Reader initialisieren

Zunächst beginnen wir mit einem Reader, der uns die jeweilige Datei erst einmal lesend zur Verfügung stellt. Hier kommt es darauf an ob wir von einem Datei-Objekt oder einem Pfad ausgehen. Wenn wir also bspw. in der Variable $filepath den Pfad zur Datei stehen haben legen wir so los:

Im Prinzip haben wir hier eine Dopplung und innerhalb des Reader-Aufrufs könnten wir auch einfach $filepath verwenden, auf die hier gezeigte Weise haben wir allerdings noch die Möglichkeit $filepath mit einem Wildcard zu übergeben(Kunde1234*.pdf).

Seitenweiser Durchlauf der PDF

Nun empfiehlt es sich meines Erachtens die Datei seitenweise zu durchlaufen. Bevor wir die weiteren Schritte erarbeiten sollten wir uns auch Gedanken darüber machen wie unsere entsprechende Datei strukturiert ist. Also welche wiederkehrenden Zeilen wir auslesen möchten und auf welchen Seiten diese sich befinden. In unserem Beispiel durchlaufen wir immer die ersten beiden Seiten einer Datei.

Zeilenweise durchlaufen

Innerhalb des seitenweisen Durchlaufs lesen wir jetzt jeweils den Inhalt der aktuell zu verarbeitenden Seite zeilenweise in ein String-Array. Um das fehlerfrei tun zu können müssen wir das Zeichen kennen, welches als Zeilenumbruch verwendet wird. Hier liegt nicht unbedingt ein Carriage Return oder ein Newline vor, je nach Quelle der PDF-Datei und somit ihrem Aufbau kann das Zeilen-Trennzeichen unterschiedlich sein. In unserem Fall ist es der Character 0x000A.

Zeilen identifizieren

Die Zeilen prüfe wir mit einem regulären Ausdruck auf einen Match unserer Wahl.
Nehmen wir als Beispiel eine PDF-Datei welche immer an einer beliebigen Position die Zeile „Kunden-Nr.:<unterschiedlich viel Whitespace>123456“ enthält.
Wir möchten also die 123456, bzw. in der Praxis natürlich echte Kundennummern auslesen.
Hierfür überprüfen wir zunächst ob die Zeile mit dem String „Kunden-Nr.:“ beginnt und verwenden vorangestellt den Anker ^. Dann trennen wir die Zeile mit .split anhand unseres Trennzeichens „:“ und wählen das zweile zurückgelieferte Element [1], woraufhin wir uns noch von überflüssigem Whitespace verabschieden mit -replace ‚\s‘,“.
Anschließend steht in unserer Variable $Kundennummer lediglich die gewünschte 123456.

Somit haben wir unsere PDF-Datei ausgelesen und übrig bleibt nur den Reader zu schließen mit $reader.close().

Zusammenfassung

Das Ganze lässt sich nun sehr einfach in eine wieder verwendbare Subfunktion wrappen.
Hier stellt sich dann nur die Frage, was wir als Parameter verwenden möchten.
Wollen wir bspw. die Anzahl Seiten die zu prüfen sind beim Aufruf direkt mit angeben?
Den regulären Ausdruck anhand dessen die Zeile identifiziert werden soll?
Das Trennzeichen?
Den Dateinamen sowie den gewünschten Rückgabewert benötigen wir in jedem Fall.
Zusammengefasst könnte die Funktion zum automatisierten Auslesen einer Kundennummer aus einer PDF in PowerShell bspw. so aussehen:

Diese Technik zum automatisierten Auslesen von PDF-Dateien lässt sich recht einfach auf den jeweiligen Anwendungsfall adaptieren und spart je nach Büroumgebung oder Auftrag im EDI-Kontext viel händische Arbeit.

Hat Euch dieser Beitrag gefallen?
Lasst uns gerne Feedback, Ideen oder Kritik zukommen.
Gerne könnt Ihr diesen Beitrag auch teilen und uns einen Besuch auf einem unserer Social Media Kanäle abstatten und wenn Ihr möchtet ein Herzchen oder einen Daumen nach oben da lassen.

Wenn Ihr Euch für mehr PowerShell- oder iTextSharp-Content interessiert schreibt uns!

Der Beitrag PDF-Dateien auslesen mit 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.