Übungen / Aufgaben zu Java

0 Lösungen
Ist Freitag der 13. ein Unglücks- oder Glückstag?
Anfänger - Java von hollst - Gestern 26.06.2017 um 13:14 Uhr
Wir betrachten den Gregorianischen Kalender mit den üblichen 12 Monaten und Schaltjahren.

Schaltjahr ist, wenn die Jahreszahl durch 4 teilbar ist, mit Ausnahme der Jahre, die durch 100,
jedoch nicht durch 400 teilbar sind. Im Schaltjahr hat der Februar 29 Tage.

Unsere Zeitrechnung beginne mit dem 1. Januar 00.

Frage: Welcher Wochentag fällt

a) am häufigsten auf einen 13. des Monats und
b) welcher bzw. welche am wenigsten.
4 Lösungen Lösungen öffentlich
Anfängeraufgabe FizzBuzz
Anfänger - Java von Nachbar - 11.06.2017 um 10:26 Uhr
Dies ist eine Anfängeraufgabe, die gerne für ein erstes Aussieben bei Bewerbungsgesprächen gestellt wird, da tatsächlich erstaunlich viele Bewerber die Aufgabe falsch
lösen oder zu viel Zeit dafür benötigen. Für jemanden der als Programmierer sein Geld verdienen will, sollte die Aufgabe in zwei Minuten lösbar sein.

Aufgabe:
Schreibe ein Programm das alle Zahlen von 1 bis 100 ausgibt. Wenn die Zahl allerdings ein Vielfaches von 3 ist, soll statt der Zahl das Wort "Fizz" ausgegeben werden. Wenn die Zahl ein Vielfaches von 5 ist, soll statt der Zahl das Wort "Buzz" ausgegeben werden. Ist die Zahl sowohl ein Vielfaches von 3 als auch von 5, soll statt der Zahl das Wort "FizzBuzz" ausgegeben werden.
0 Lösungen
Schneller als der Taschenrechner
Anfänger - Java von hollst - 16.05.2017 um 16:39 Uhr
Wenn ihr die folgende Aufgabe programmiert habt, könnt ihr auf jeder Party durch eure brilliante Kopfrechenleistung glänzend, ihr werdet schneller sein als jeder andere, selbst wenn er einen Tscherechner oder euren benutzen darf.

Zu programmieren ist ein kleiner, aber sehr spezieller Taschenrechner (Bild 1), der folgendes kann:

1) Entgegennahme einer dreistelligen positiven, geraden Ganzzahl (Bild 2).
2) Vergrößern der Dreistellenzahl auf sechs Stellen, indem die Zahl einfach noch einmal angehängt wird (Bild 3).
3) … 5) (komplizierte) Division der Sechstellenzahl nacheinander durch 22, 7 und 13. Reihenfolge spielt keine Rolle, aber nur jeweils 1x (deshalb deuten rote Buttons auf „nicht mehr benutzbar“ hin).

Im Beispiel (Bild 1 … 6) habt ihr allerdings das Ergebnis (117) wesentlich schneller per Kopf ausgerechnet als euer Freund mit dem Taschenrechner. Das liegt nicht daran, dass der Rechner so langsam rechnet, sondern daran, das das Buttondrücken so lange dauert.

Die ganze Übung vor größerem Publikum solltet ihr allerdings nach etwa höchstens 10 Vorführungen zunächst abbrechen, also noch bevor jemand hinter den Trick kommt. Was der Trick ist? Nun, bitte erst einmal selber nachdenken.
0 Lösungen
Roboterfabrik Programmieraufgabe
Fortgeschrittener - Java von azy5679 - 08.05.2017 um 23:31 Uhr
In einem Zeitungsartikel lesen Sie, dass die Firma ASDF123-Roboter AG, junge und kreative Mitarbeiter
fur den Aufbau einer Roboterfabrik sucht. Von der Stellenausschreibung ganz hingerissen, machen Sie sich
sofort auf den Weg und reichen Ihre Bewerbungsunterlagen ein. Tatsachlich meldet sich die Firma kurz
darauf bei Ihnen und ladt Sie zu einem Bewerbungsgesprach ein. Fur Sie lauft scheinbar alles perfekt und
Sie konnen es kaum erwarten Ihren zukunftigen Arbeitgeber von Ihren Qualitaten zu uberzeugen. Jedoch
zeigt dieser keinerlei Interesse an Ihren Zeugnissen, sondern knupft vielmehr Ihre Einstellung an die Losung
folgender Aufgabe.
Die Firma ASDF123-Roboter AG mochte eine neue Roboterfabrik aufbauen, benotigt dazu aber ein Softwaremodell,
welches den Produktionsprozess und die Roboter simuliert. Es handelt sich nur um eine einzige
Fabrik, die
exibel auf Bestellungen der Kunden reagieren kann. Die Roboterfabrik bietet ihren Kunden
zwei verschiedene Modelle an, beide aus der Star-Wars-Produktreihe: die Modelle heien C3PO und R2D2.
Alle Roboter haben eine einfache Schnittstelle (Robot), mit der sie gesteuert werden konnen. Diese Schnittstelle
sieht wie im folgenden dargestellt aus.

Quellcode ausblenden Java-Code
    
public interface Robot extends RobotControl, RobotInstructions {
// keine eigenen Methoden
}
/**
* Das Interface reprasentiert einen einfachen Roboter mit seinen Funktionen.
*
* Jeder produzierte Roboter hat einen Namen, der vom Besteller frei gewahlt
* werden kann. Der Name bleibt uber die gesamte Lebensdauer des Roboters
* unveranderlich. Man kann einen Roboter jederzeit uber die
* <code>getName()</code>-Methode nach seinem Namen fragen.
*
* Zusatzlich zum frei gewahlten Namen, hat jeder Roboter noch eine
* Seriennummer. Diese wird bei der Produktion festgelegt und hat einen vom
* Roboter-Typ abhangigen Bereich moglicher Werte. Innerhalb des Bereiches wird
* die Seriennummer zufallig vergeben. Die Seriennummer kann auch bei
* ausgeschalteten Roboter uber <code>getId()</code>gelesen werden.
*
* Ein Roboter hat einen Hauptschalter, der mithilfe der
* <code>triggerPowerSwitch()</code>-Methode bedient werden kann. Direkt nach
* der Produktion ist der Roboter ausgeschaltet. Druckt man einmal auf den
* Schalter, wird er eingeschaltet. Ein weiterer Druck schaltet ihn wieder aus, usw.
*
* Die aktuelle Position des Hauptschalters kann man mit der Methode
* <code>isPowerOn()</code> abfragen. Hierbei bedeutet <code>true</code>, dass
* der Roboter eingeschaltet ist und <code>false</code>, dass er nicht
* eingeschaltet ist.
*
1
* Falls ein Fehler auftritt, kann der Nutzer des Roboters den letzten
* aufgetretenen Fehler uber eine Blackbox (Fehlerspeicher) auslesen. Dies
* geschieht mithilfe der <code>getLastException()</code>-Methode. Der
* Fehlerspeicher kann auch bei ausgeschaltetem Roboter benutzt werden. Gab es
* noch keinen Fehler, ist der Fehlerspeicher leer (<code>null</code>).
*
* Alle Methoden dieses Interfaces konnen auch auf einem Roboter aufgerufen
* werden, der ausgeschaltet ist (d.h. wenn <code>isPowerOn()</code> == false).
*/
public interface RobotControl {
/**
* Gibt die ID (Seriennummer) des Roboters zuruck.
*
* @return Eine eindeutige Identifikation in Form einer Zahl.
*/
public int getId();
/**
* Gibt den Namen des Roboter-Exemplars zuruck.
*
* @return Der Name des Roboters.
*/
public String getName();
/**
* Betatigen den An-/Ausschaltknopf.
*/
public void triggerPowerSwitch();
/**
* Pruft ob der Roboter eingeschaltet ist.
*
* @return <code>true</code> bedeutet, dass der Roboter eingeschaltet ist,
* <code>false</code>, dass er nicht eingeschaltet ist.
*/
public boolean isPowerOn();
/**
* Ruft die zuletzt aufgetretene Ausnahme aus der Blackbox ab.
*
* @return zuletzt aufgetretene Ausnahme oder <code>null</code> falls noch
* keine aufgetreten ist.
*/
public RobotException getLastException();
}
/**
* Das Interface reprasentiert den Befehlssatz eines einfachen Roboters.
*
* Jeder Roboter kann zwei grundlegende Operationen durchfuhren: das Umwandeln
* einer Menge von Zahlen in einen String (<code>speak(...)</code>) und das
* sortieren eines Arrays von Zahlen (<code>think(...)</code>). Wie genau das
* Sortieren oder die Umwandlung erfolgt, hangt vom jeweiligen Typ des Roboters ab.
*
* Zu beachten ist, dass die Methoden dieses Interfaces nur auf Robotern benutzt
* werden konnen, die eingeschaltet sind. Versucht man sie auf einem
* ausgeschalteten Roboter zu benutzen, werfen sie eine {@link RobotIllegalStateException}.
*
* Weiterhin haben alle Roboter einen kleinen technischen Defekt, der dazu fuhrt
* dass die Methoden dieses Interfaces absturzen, wenn in den Eingabedaten ein
* spezieller Wert vorkommt. Immer wenn (<code>speak(...)</code>) oder (
* <code>think(...)</code>) mit einem Array aufgerufen werden, das irgendwo die
* Zahl {@literal 42} enthalt, verweigern sie ihren Dienst und werfen eine
* {@link RobotMagicValueException}.
*/
2
public interface RobotInstructions {
/**
* Gibt ein Array von Zahlen als String zuruck. Die Zahlen werden
* <b>nicht</b> sortiert.
*
* @param zahlen Zahlen, die ausgegeben werden sollen.
* @return Zahlen als String
* @throws RobotException wenn der Roboter in einem ungultigen Zustand ist,
* oder das Array nicht seinen Vorstellungen entspricht.
*/
public String speak(int[] zahlen) throws RobotException;
/**
* Sortiert ein Array von Zahlen. Die Reihenfolge hangt von dem Typ des
* Roboters ab.
*
* @param zahlen Zahlen, die sortiert werden sollen.
* @return Sortierte Zahlen
* @throws RobotException wenn der Roboter in einem ungultigen Zustand ist,
* oder das Array nicht seinen Vorstellungen entspricht.
*/
public int[] think(int[] zahlen) throws RobotException;
}


Die Fabrik ist von ihren Fertigungsanlagen her so konzipiert, dass jeder Roboter einzeln gefertigt wird.
Ubergeben wird lediglich das gewunschte Roboter-Modell und der Name und schon erhalt der Kunde den
von ihm gewunschten Roboter.
Der Unterschied zwischen den angebotenen Modellen liegt in der Ausfuhrung der Befehle aus dem Interface
RobotInstructions. Wahrend R2D2 Arrays immer aufsteigend sortiert und bei der Umwandlung in ein
Array den Inhalt durch Kommas trennt (z. B. 1, 2, 3, 4, 5, 6), sortiert C3PO Arrays stets absteigend
und wandelt deren Inhalt in einen String mit Semikolon als Trennzeichen um (z. B. 6; 5; 4; 3; 2; 1).
Die Seriennummern der R2D2-Modelle bewegen sich im Bereich von 0{9999, die der C3PO-Modelle von
10000{19999.
(a) Schreiben Sie die in den Interfaces referenzierten Klassen fur die Ausnahmen. Sorgen Sie dafur, dass die
Ausnahmen den Namen des Roboters tragen in dem sie entstanden sind und dass man diesen Namen
uber die Methode getRobotName() wieder auslesen kann.
(b) Programmieren Sie zwei Klassen R2D2 und C3PO, die beide das Interface Robot implementieren. Lesen
Sie bitte sorgfaltig die Dokumentation der Interfaces, damit Sie die beschriebene Semantik in Ihrer
Implementierung einhalten.
Tipp: Denken Sie daran, keinen Code zu duplizieren und fuhren Sie gegebenenfalls weitere Klassen ein,
um dies zu vermeiden.
(c) Entwickeln Sie eine Klasse RobotFactory mit deren Hilfe man Instanzen der beiden Roboter-Typen
erzeugen kann. Eine Enumeration mit dem Namen RobotType dient dazu, bei der Erzeugung anzugeben,
ob man einen R2D2- oder einen C3PO-Roboter haben mochte.
Vergessen Sie nicht, dass jeder Roboter eine Seriennummer aus dem jeweiligen Bereich benotigt und
dass er bei der Erzeugung seinen unveranderlichen Namen bekommt.
Verbergen Sie die Implementierung der Roboter vor dem Verwender und erlauben Sie nur Zugri auf
die Factory, die Interfaces und die Ausnahmen. Wahlen Sie entsprechende Pakete gema ihrem Schema,
um dies zu realisieren.
(d) Zusatzlich zu den beiden produzierten Roboter-Modellen R2D2 und C3PO steht in der Firma noch
ein alter Nexus-6-Roboter mit dem Namen Pris herum, der leider seit einer Begegnung mit einem
Blade-Runner irreparabel defekt ist und nicht eingeschaltet werden kann (man kann den Schalter zwar
drucken, dies hat aber keine Wirkung). Da es nur dieses eine Exemplar gibt, konnen auch keine weiteren
Nexus-6-Modelle hergestellt werden.

Implementieren Sie den Nexus-6-Roboter (Klassenname Nexus6) als Singleton. Beachten Sie, dass die
speak- und think-Methoden nicht funktionieren, sondern grundsatzlich eine Ausnahme (RobotIllegal-
StateException) werfen.
(e) Schreiben Sie automatisierte JUnit-Tests mit denen Sie die korrekte Funktionsweise der Implementierungen
und der Factory-Klasse uberprufen. Legen Sie die Tests in ein anderes Paket als die Implementierung.
Denken Sie daran, auch die Ausnahmen zu testen.
(f) Angenommen, Ihre Firma mochte eine weitere Produktlinie ero nen und in Zukunft auch noch T1000-
Roboter herstellen { die naturlich auch das Roboter-Interface implementieren. Welche Anderungen
mussten Sie an Ihrem Projekt durchfuhren?
Sie brauchen keine Implementierung durchzufuhren. Sie sollen aber kurz erlautern, an welchen Stellen
Sie Ihr Projekt erweitern mussten. Gehen Sie dabei auch auf die Frage ein, welche Auswirkungen dies
auf die bereits produzierten Roboter und deren Verwender hatte.
0 Lösungen
Konvexe Hüllkurve um Punktwolke
Fortgeschrittener - Java von hollst - 04.05.2017 um 10:36 Uhr
In der X-Y-Ebene seinen N Punkte zufällig verteilt (Bild 1). Man schreibe ein Programm, das die konvexe Hüllkurve um diese Punktwolke zeichnet (Bild 2).

Zum Verständnid, was die konvexe Hüllkurve um eine Punktwolke ist, stelle man sich die Punkte als fixierte Push-Pins oder Nägel auf einem Pinbord (möglichst nicht aus Kork) oder Holzbrett vor. Jetzt nehme man einen Gummiring (z. B. vom Einweckglas) und spanne diesen so um die Pins, dass sich alle im „Inneren“ des Gummiringes befinden (eine „360-Grad-Umwicklung“ eines Pins ist nicht erlaibt). Der so verformte Gummiring ergibt aus physikalischen Gründen einen geschlossenen Linienzug. Dieser Linienzug wird konvexe Hüllkurve um die Punktwolke genannt.
0 Lösungen
Validierung der abc-Vermutung
Anfänger - Java von hollst - 01.05.2017 um 16:44 Uhr
Die sogenannte abc-Vermutung sorgte in den letzten Jahren zu ungewöhnlich viel
Wirbel, Stress und Zank bei Zahlentheoretikern mit vielleicht sogar etwas skandalösem Touch.

Gelänge ein Beweis, dann könnte ein solcher in die Top-Charts der jüngeren Mathematikgeschichte
aufsteigen. Die abc-Vermutung wurde erst vor Kurzem aufgestellt (etwa 1985, also vor gut 30 Jahren,
was in der Mathematikgeschichte quasi nichts ist). Verblüffend für mich ist, dass man bei einem Beweis
damit die berühmte Große Fermatsche Vermutung von 1635, bewiesen erst 1993 auf mehreren hundert DIN-A4-Seiten
(wobei zuvor bereits mehr als 5.000 fehlgeschlagene Beweisversuche bekannt sind), auf einer einzigen
DIN-A4-Seite aufschreiben könnte und dass selbst ein Laie (wie ich) den Beweis verstehen würde.

Kommen wir (kurz) zum skandalösem Touch: 2012 reichte ein Japaner auf über 500 DIN-A4-Seiten einen (angeblichen)
Beweis der abc-Vermutung ein. Es stellte sich schnell heraus, dass er dabei (bewiesenes) Nebenwissen anwandte,
dass jedoch kaum bekannt war und in der Beweisführung hätte etwas mehr Platz und Erörterung finden sollen. Dies korrigierte
der Japaner dann wohl auch, womit sich sein Beweis auf über 1.000 Seiten aufblähte. Verständlich, dass sich damit kaum jemand
beschäftigte.

Darüber frustiert, beschimpfte der Japner zunächst die mathematische Welt als einen Haufen talentloser
Idioten (also nicht wörtlich, so etwas macht ein Japaner nicht, sondern sinnbildlich) und lud 2015 eine Reihe von Mathematikern,
die er selbst aussuchte und für ev. für fähig hielt, zu mehrtägigen Workshops ein. In ellenlangen Vorträgen erläuterte er
diesen Experten seinen Beweis der abc-Vermutung.

Jedenfalls sollen sich nach den Workshops einige der ausgesuchten Experten in die Richtung geäußert haben,
dass sie einen Ansatz zum Verständnis und zur Prüfung des Beweises sehen und sich an die Arbeit machen wollen.
Man hat abgeschätzt, dass, wenn man sich täglich etwa fünf Stunden damit beschäftigen würde, etwa in einem halben Jahr
durchsein könnte.

Nun gut, bis heute ist keiner durch, allerdings hat sich auch noch niemand geäußert, einen Fehler gefunden zu haben.
Somit ist alles noch in der Schwebe. Dass die jetzt beweissuchenden Experten zuvor vom Japaner gebrieft worden sind, stellt
allerdings das eigentlich Zweifelhafte und nicht Akzeptierbare dar, der Geruch von Bestechlichkeit ist nicht wegzuwischen.

Soweit die kleine Vorgeschichte. Natürlich wollen auch wir nicht die abc-Vermutung beweisen, soldern lediglich etwa überprüfen.
Würden wir bei der Überprüfung auch nur ein einziges Gegenbeispiel finden, so hätte es sich mit dem Beweis ja sowieso erledigt.
Aber keine zu große Vorfreude, ich denke weder ihr noch ich werden wahrscheinlich ein Gegenbeispiel finden.


Die ABC-Vermutung: Gegeben seien zwei positive Ganzzahlen a und b mit 0 < a < b und die außerdem teilerfremd (ggT(a, b) = 1) sind.
Diesen zwei Zahlen a und b sind zwei Eigenschaften zugeordnet, genannt "Summe" (c) und "Radikal" (rad).

Die Eigenschaft "Summe" ist weiter nichts als die ordinäre Summe von a und b, also c = a + b. Interessanter ist das "Radikal",
es ist eine spezielle Multiplikationsvorschrift für a, b und c. Würde man das ordinäre Produkt a * b * c bilden, so würde immer
gelten

a * b * c > c (es sei den a = b = 1, was aber wegen a < b untersagt ist).

Beim Radikal rad(a * b * c) werden jedoch nur alle unterschiedlichen Primzahlen, in die a * b * c zerlegt werden kann,
miteinander multipliziert.

Z. B. rad(100) = rad (2 * 2 * 5 * 5) = 2 * 5 = 10;

Bei einer so definierten Multiplikation ist es dann in der Tat möglich, dass sich für bestimmte positiv ganzzahlige
Tripel (a, b, c) wahre Ungleichungen bzw. Gleichungen der Form rad(a * b * c) <= c ergeben. Man nennt derartige Tripel abc-Treffer.

Allerdings gibt es "reativ wenige" solcher abc-Treffer. Es kann jedoch bewiesen werden, dass es immer noch unendlich viele sind
(deshalb machen Beschreibungen wie "reativ wenige" keinen Sinn in der Mathematik). So, bis jetzt ist alles noch "relativ" unspannend.

Spannend wird es, wenn man rad(a * b * c) potenziert, also (rad(a * b * c))^(1 + epsilon). Mit epsilon = 0 haben wir wieder den
Fall unendlich vieler mögliche abc-Treffer. Ist jedoch epsilon auch nur ein "My" größer als Null gibt es nur noch endlich viele abc-Treffer
(so die abc-Vermutung).

Wäre dies tatsächlich so (also bewiesen), zöge das einen ganz gewaltigen Schwanz an neuen mathematischen Erkenntnissen u. a. in der
Zahlentheorie nach sich (worauf wir hier natürlich nicht eingehen wollen, wer dbzgl. mehr wissen möchte, kann zunächst am Besten bei
Wikipedia einsteigen).


Die Programmieraufgabe lautet:

1.) Zähle alle abc-Treffer mit epsilon = 0 für die c < c_max (z. B. c_max = 10.000) ist.

2.) Führe das Gleiche durch mit wachsendem epsilon, z. B. epsilon = {0.1, 0.2 ... 0.9, 1.0} (interessant wäre zu erkunden, ob bei
steigendem epsilon die Anzahl der abc-Treffer linear abnimmt).


Viel Erfolg!
0 Lösungen
Crowdfunding für Fibonacci-Uhr
Fortgeschrittener - Java von hollst - 24.04.2017 um 12:22 Uhr
Erneut FIBONACCI, jedoch diesmal in einem ganz anderen Zusammenhang.

Im Zuge von Crowdfunding ist in Kanada die sogenannte Fibonacci-Clock (Bild 1)
entwickelt und in die Produktion überführt worden.

(https://www.kickstarter.com/projects/basbrun/fibonacci-clock-an-open-source-clock-for-nerds-wit)

Es sollten für dieses Projekt innerhalb eines Monates (05 - 06/2015) 5.000 CAD
gesammelt werden (ca. 3.500 €), zusammengekommen sind aber sage und schreibe
(über) unglaubliche 125.000 €. Man lernt daraus, dass man mit einer guten (verrückten)
Idee manchmal auch einiges an Geld aquirieren kann.

Dabei ist an der Fibonacci-Clock nichts Kompliziertes dran. Im Grunde besteht sie
lediglich aus einem Display, das in fünf Quadrate mit unterschiedlicher
(variabler) Farbe und (fixer) Kantenlänge aufgeteilt ist.

Die Kantenlängen der Quadrate sind 1, 1, 2, 3 und 5, entsprechen also dem Beginn der
Fibonacci-Sequenz. Es lassen sich damit die Dezimalzahlen 0 ... 12 codieren.

Das Interessante an dem Display ist, dass man damit gleichzeitig
die Stunden und (teilweise) die Minuten darstellen kann. Dies geschieht mittels
wechselnder Farbcodierung der Quadrate und Aufaddition der den Quadraten zugeordnete
Fibonaccizahl. Die Farbe Rot steht für die Stunden, die Farbe Grün für die Minuten.
Wird ein Quadrat sowohl für die Stunden- als auch für die Minutensummation benötigt,
wird dies durch die Farbe Blau angezeigt (Bild 2). Weiß steht für "Nichtnutzung" des
Quadrates. Die Minutenzahl erhält man durch Multiplikation der Minutenzahlsumme mit 5,
somit ist die Genauigkeit der erfindungsgemäßen Uhr auf +- 2.5 Minuten begrenzt,
Vor- und Nachmittagszeiten sind identisch.

Mit den fünf Fibonaccizahlen lassen sich wie gesagt alle Werte von 0 bis 12 darstellen,
d. h. die Minutenanzeige "springt" lediglich alle fünf Minuten. Dies bedeutet allerdings nicht,
dass die Anzeige nicht schneller wechseln darf, denn es gibt mit den Ausnahmen für die
Null und die Zwölf für jede Zahl mehrere Möglichkeiten der Fibonacci-Codierung, die der
kanadische Erfinder auch in kurzen Intervallen und zufällig wechseln läßt.


Die Programmieraufgabe besteht darin, die Fibonacci-Clock mit einer Grafik-Applikation zu
simulieren. Der Minutenwechsel soll allerdings nicht im 5-Minuten-Takt, sondern sogar minütlich
erfolgen. Damit könnte man die Uhr vielleicht als Tester für Schnelldenker einsetzen.

Neben den vier Grundfarben des Erfinders (Weiß, Rot, Grün und Blau (Bild 3))werden also
vier weitere Farben zur Kodierung der fehlenden Additivzahlen 1, 2, 3 und 4 für den Minutenzähler
benötigt. Im Beispiel (Bild 4) sind es die Farben

Yellow (steht für Überlagerung mit Weiß),
Pink (steht für Überlagerung mit Rot),
Purple (steht für Überlagerung mit Grün) und
SkyBlue (steht für Überlagerung mit Blau)

Viel Erfolg!

0 Lösungen
Wieder (vielleicht) Erstaunliches vom Fibonacci
Anfänger - Java von hollst - 19.04.2017 um 15:47 Uhr
Gegeben sei eine Folge von N Strings der Längen 1, 2, 3 ... N. Jedes Char eines Strings beinhaltet lediglich entweder eine '0' oder eine '1',
jedoch dürfen zwei benachbarte Chars nicht beide eine '1' beinhalten.

Man zeige für N bis 25, dass die Anzahl möglicher (unterschiedlicher) Strings einer Längenklasse der Fibonacci-Reihe ab der 2 folgen
(2, 3, 5, 8 ...).

Also:

Länge = 1, zwei Möglichkeiten ("0", "1")
Länge = 2, drei Möglichkeiten ("00", "01", "10")
Länge = 3, fünf Möglichkeiten ("000", "001", "010", "100", "101")
...

Wieviele unterschiedliche Strings der oben genannten Art gibt es mit einer Stringlänge von 999?
0 Lösungen
Gray-Code bei Analog-Digital-Konvertierung
Anfänger - Java von hollst - 15.04.2017 um 15:00 Uhr
Bei der Analog-Digital-Konvertierung sollte die Abtastfrequenz in der Regel
wesentlich höher sein als die zeitliche Änderung des Messsignals (Nyquist-Kriterium).
Aus diesem Grunde ergeben zwei benachbarte Abtastungen zumeist entweder den gleichen (Digital)wert
oder einen um +/- 1 geänderten Wert. Ist dies nicht der Fall, so kann man mit sehr hoher
Wahrscheinlichkeit von einem Fehler bei der Messung (größer Rauscheinfluss) oder bei der Analog-
Digital-Konvertierung ausgehen.

Fehler bei der Analog-Digital-Konvertierung können bevorzugt dann entstehen, wenn bei einer
Messwertänderung um +/- 1 gleichzeitig mehrere Binärwerte switschen müssen. Z. B. bei einem
Messwert 7, der sich auf 8 ändert (7 -> 8) ändert sich der Binärwert von 0111 -> 1000, d. h.
es müssen quasi parallel vier Bits gekippt werden.

Um diese Fehlerquelle zu minimieren, werden die Messwerte zumeist nicht direkt in eine
Binärzahl konvertiert, sondern zunächst in den sogenannten Gray-Code. Der Gray-Code garantiert, dass sich bei
einer Messwertänderung um +/- 1 nur ein einziges Bit im Code ändert.

Das Kodierungsschema lässt sich u. a. leicht aus folgender Tabelle ableiten:

Dezimal Binär-Code Gray-Code

00 0000 0000
01 0001 0001
02 0010 0011
03 0011 0010
04 0100 0110
05 0101 0111
06 0110 0101
07 0111 0100
08 1000 1100
09 1001 1101
10 1010 1111
11 1011 1110
12 1100 1010
13 1101 1011
14 1110 1001
15 1111 1000

Wie ersichtlich, switscht bei der Gray-Kodierung lediglich ein Bit, wenn sich die Dezimal-Kodierung
um eine Einheit ändert.

Der Gray-Code geht auf einen Herren namens Frank Gray (1887 -1969) zurück, der sich den Code 1953
patentieren ließ, obwohl er in der Mathematik längst bekannt war. Aus meiner Sicht eine sehr bedenkliche Patenterteilung.

Die Programmierungsaufgabe besteht darin ein Programm zu schreiben,
das ein positives Integer entgegennimmt und die Gray-Code-Folge zurückgibt.

Optional kann auch die inverse Transformation programmiert werden.
0 Lösungen
Symmetrische Primzahlen
Anfänger - Java von hollst - 03.04.2017 um 13:55 Uhr
Wieviele Primzahlen P < 1.000.000 sind rückwärts gelesen auch eine Primzahl, jedoch ungleich sich selbst?

Anmerkung: Die (Prim)zahlen 2, 3, 5, 7, 11 erfüllen nicht die Bedingungen (sind rückwärts gelesen sich selbst gleich),
als erste erfüllt die 13 die Bedingungen.
0 Lösungen
Endliche Kettenbrüche rationaler Zahlen
Anfänger - Java von hollst - 30.03.2017 um 11:10 Uhr
Mit einem Kettenbruch K = a0 + 1/(a1 + 1/(a2 + 1 /(....))) - mit a0 als ganze Zahl und a1, a2 ... als
positve natürliche Zahlen ungleich Null - lässt sich bekanntlch jede reelle Zahl darstellen.
In der Praxis sind Kettenbrüche etwas unhandlich und man bevorzugt die Schreibweise
K = [a0; a1, a2, a3 ...]. Ist der Kettenbruch endlich, können damit alle rationale Zahlen beschrieben werden.

Die meisten Anwendungen finden Kettenbrüche in der Zahlentheorie, aber auch für Informatiker können sie
nutzbringend sein, insbesondere wenn man Rundungsprobleme umgehen muss. Z. B.

Quellcode ausblenden C#-Code
Double x = 1.0E+15 + 1.0 / 3;
WriteLine(x.ToString());
WriteLine((x / 1.0E+15).ToString());


gibt als Ergebnisse 1E+15 und 1 hervor. Der Term (1.0 / 3) wird ohne jegliche Vorwarnung einfach verschluckt
und man bekommt gegebenenfalls am Ende einer Rechnung völligen Unfug heraus, ohne es zu merken
(einer der schlimmsten Fallstricke für den Programmierer).

Würde man x als Kettenbruch darstellen

x = 3.000.000.000.000.001 / 3 = [1.000.000.000.000.000; 3]

blieben alle Informationen erhalten und die Welt wäre wieder in Ordnung.

Nun, wir wollen keine komplette Algebra mit Kettenbruchobjekten entwickeln,
sonder lediglich folgende Aufgabenstellungen lösen:

Schreibe ein Programm, das

1.) zwei Zahlen (ZAEHLER und NENNER mit NENNER != 0) entgegennimmt
und eine entsprechende Kettenbruchdarstellung zurückgibt und

2.) diese Kettenbruchdarstellung wieder rücktransformiert.

Das Interessante an Teilaufgabe 2.) ist, dass sich der Bruch ZAEHLER/NENNER
automatisch selbst kürzt, also z. B. ZAEHLER = 50 und NENNER = 100 -> [0; 2],
rücktransformiet führt dies richtig zu ZAEHLER = 1 und NENNER = 2. Bei negativen
Zahlen ist allerdings nicht entscheidbar, ob der ZAEHLER oder der NENNER negativ ist
(möglicherweise ein neuer Fallstrick, das Programmiererleben ist manchmal sehr schwer).
0 Lösungen
Gewinn durch multiblen Devisenhandel
Fortgeschrittener - Java von hollst - 26.03.2017 um 14:02 Uhr
Derzeit gibt es weltweit über 160 offizielle Währungen, wobei ein gutes Dutzend voll konvertierbar ist.
In der Tabelle sind die Kaufopsionen für acht von ihnen aufgelistet (leider bessere Formatierung in dieser Ansicht wohl nicht möglich,
hier sollte Gustl dankenswerter Weise noch etwas tun):

EUR USD JPY GBP CHF CAD AUD NZD
EUR 1,0000 1,0795 120,184 0,8658 1,0701 1,4423 1,4141 1,5323
USD 0,9264 1,0000 111,329 0,8021 0,9909 1,3377 1,3120 1,4234
JPY 0,0083 0,0090 1,00000 0,0072 0,0089 0,0120 0,0118 0,0127
GBP 1,1545 1,2467 138,860 1,0000 1,2361 1,6687 1,6354 1,7718
CHF 0,9335 1,0083 112,310 0,8081 1,0000 1,3486 1,3216 1,4357
CAD 0,6933 0,7478 83,2120 0,5993 0,7402 1,0000 0,9816 1,0647
AUD 0,7061 0,7622 84,7950 0,6110 0,7545 1,0188 1,0000 1,0803
NZD 0,6503 0,7025 78,2000 0,5629 0,6965 0,9392 0,9208 1,0000

http://www.onvista.de/devisen/cross-rates/

Durch geschickte Ausnutzung von Kursschwankungen ist es denkbar, dass man durch einen gestaffelten
Kauf und Weiterverkauf von Währungen einen Gewinn erzielen kann. In der Praxis wird dieser Gewinn
im Falle kurzfristiger Aktionen allerdings sofort durch Transaktionsgebühren wieder aufgefressen. Für die
folgende Aufgabe seien Transaktionsgebühren unberücksichtigt.

Wir steigen mit einer beliebigen Einheit einer Währung ein und suchen einen Handelsweg, der uns am Ende
mehr abwirft, als wir am Anfang eingesetzt haben. Grundlage sei die momentane Währungstabelle,
auch cross-rates-table genannt.

Folgende Einschränkungen: Es müssen nicht alle möglichen Währungspaare in der Kette auftauchen, jedoch
jedes Paar höchstens einmal. Die letzte Transaktion muss wieder zu unsere Ausgangswährung zurückführen.

Aufgabe: Schreibe ein Programm, dass dir alle Transaktionswege mit positivem Ergebnis ausgibt bzw.,
wenn es keinen einzigen Weg gibt, dies entsprechend mitteilt.