Das \ wird für die Escape-Sequenz (kann man googlen, wenn man den Begriff kennt ;-)) benötigt um andere Sachen darzustellen (z.B. einen Zeilenvorschub). Um ein\ darzustellen, musst du es selber "escapen", also \\ schreiben.
In einem PC läuft alles immer sehr geordnet, ein echter Zufall ist nicht möglich, es ist eher eine Simulation. Vereinfacht dargestellt: Du hast einen Seed (Anfangswert) und der wird immer nach einem Algorithmus durchgemischt - wenn dieser Seed aber bekannt ist, lassen sich die Zufallswerte errechnen.
Das ist vor allem in der Kryptographie ein Problem, da es Angriffvektoren schafft, deswegen lohnt es sich mal nach Zufall+Kryptographie zu googlen.
Ein genereller Ansatz ist es, diesen Algorithmus mit Entropie anzureichern. Diese wird aus externen Quellen erzeugt, z.B. Mausbewegungen, Tastatureingaben, Temperaturen und sonstigen, was sich algorithmisch nicht vorhersehen lässt. Mit dem Wissen über dieses Vorgehen ist der Zufall trotzdem angreifbar (aber ungleich schwerer).
In der Quantenmechanik sollte es meines Wissens möglich sein echten Zufall zu erreichen - aber abgesehen davon, dass du wahrscheinlich keinen Quantenrechner im Wohnzimmer stehen hast, ist mein Wissen bei der Thematik eher auf Halb-Wissen beschränkt.
PNG basiert im wesentlichen auf RLE (RunLengthEncoding). D.h. zusammenhängende Blöcke mit der gleichen Farbe werden verlustfrei zusammengefasst.
JPEG komprimiert nicht verlustfrei komprimiert. Stark vereinfacht passiert das wie folgt:
Durch die Beschreibung durch eine Welle haben JPEGs ein gewisses Rauschen, was sie für RLE (oder halt PNG) ungeeignet macht. Man kann bei einem Bild natürlich den Farbbereich einschränken um das Rauschen wieder zu entfernen, das macht aber nur begrenzt Sinn (bei Comics z.B.).
Grundsätzlich ist das vom Ausgangsmaterial abhängig, ein Disney-Comic würde ich PNG-komprimieren, bei einem Gradienten-behafteten Manga lohnt sich wahrscheinlich eher JPEG - bei Photos ist in der Regel JPEG überlegen.
Grundsätzlich machst du mit keinen der 3 Sprachen was falsch.
Ich bin kein großer Fan von Java (war es aber mal) und habe das Gefühl, dass es seinen Zenit überschritten hat (kann aber auch selektive Wahrnehmung sein, gibt ja auch z.B. Scala was auf Java basiert). Durch die syntaktische Nähe zu C# oder C++ lohnt sich ein Blick trotzdem.
JavaScript geht gerade ziemlich gut im Kontext HTML5 steil und man kann (insbesonders mit node.js) ziemlich fix beeindruckende Webseiten (bzw auch Standalone-Applikationen) erschaffen. Hat neben dem Namen übrigens nicht viel mit Java gemein. Bin hier aber selber relativ unerfahren, persönlich habe ich damit "nur" managementfreundliche Visualisierungen erstellt. Ist für mich persönlich aber nur eine "Hilfs-Sprache"
Mein persönlicher Favorit ist Python - und es freut mich gelesen zu haben, dass das auch dein Favorit ist ;-). Bis heute ist es für tägliche Aufgaben für mich unersetzlich (sowohl beruflich, als auch Privat). Für mich sind das idR eher "langweilige" Konsolenprogramme, das kann aber auch zu interessanten Projekten (auch Semi-Bot) führen (Cross-Postings nach Reddit würde ich hier vermeiden wollen mangels Wissens über irgendwelche Richtlinien, bei Interesse gerne nachfragen)
Es lässt sich nicht direkt auf andere Sprachen umsetzen wie Java/C++/C# - aber die Paradigmen lassen sich transferieren. Es lassen sich nicht so fix fancy Ergebnisse erreichen wie mit JS. Aber es ist schnell erlernt und zum experimentieren ideal. Es gibt auch viele Bibliotheken für alles mögliche (u.a. GUIs, Spiele, MachineLearning) - wobei ich das den anderen nicht absprechen will, habe da nur keine Erfahrung. Lässt sich übrigens wunderbar mit JS verbinden...die oben genannte Management-Visualisierungen erzeuge ich mit Python.
Buchempfehlungen finde ich schwierig. Heutzutage gibt es viele Ressourcen (eBooks, Youtube) die sich von etwas gedruckten in der Qualität kaum unterscheiden. Wenn es ein Buch sein soll, schau mal nach "Schrödinger programmiert Python". Kenne nur die C++ Version, die fand ich sehr erfrischend - etwas kindlich, dennoch fachlich und motivierend. Ich weiß nicht ob die Python Version taugt, aber neben den Online-Ressourcen, wäre das das einzige was sich (meines Wissens) von anderen Printmedien abhebt.
Da gab es mal unter Win7 eine Funktion namens ReadyBoost, die genau das Problem adressiert hat. Kurze Google-Recherche hat ergeben, dass das auch mit Win10 möglich ist.
Wird aber nur was bringen, wenn dein System nicht mit einer SSD ausgestattet ist.
Programmiersprachen "lernt" man nicht im eigentlichen Sinne. Man lernt Paradigmen und das Wissen verschiedene Probleme in ein Programm umzusetzen. Im Falle von C# ist das Paradigma im Wesentlichen die Objektorientierte Programmierung.
Die Idee dahinter ist recht fix erklärt: man hat verschiedene Objekte mit Attributen und Methoden, die sich gegenseitig beeinflussen. Dieses Konzept kann aber beliebig komplexer werden.
Nehmen wir als Beispiel das Spiel Pacman: Es gibt Objekte auf dem Spielfeld, dass kann ein Geist sein, eine Pille oder der Spieler selbst. Das Spielfeld selber ist auch ein Objekt, was all diese Objekte darstellt. Das Spielfeld selber weiß aber recht wenig von den Objekten, seine Aufgabe ist nur die Objekte darzustellen - dazu sollte jedes Objekt verschiedene Basismethoden bereitstellen wie Position oder die Grafik, die gerendert wird. Da spricht man Vererbung oder Schnittstellen (je wie man das Problem angeht, wahrscheinlich Mix aus beiden). Dann gibt es noch das Spiel-Objekt, was alle Spielfeld-Objekte + das Spielfeld verwaltet und Punkte zählt und dem Spielfeld sagt wann gerendert werden muss etc. pp.
Das ist jetzt ein sehr abstraktes, vereinfachtes, konstruiertes Beispiel - stellt aber hoffentlich die Idee etwas dar. Wie gesagt: Die Grundidee ist schnell verstanden, das komplett und all umfänglich zu verinnerlichen Bedarf aber reichlich Erfahrung (falls man das überhaupt jemals erreicht, ich würde das nicht von mir behaupten).
Zum lernen: Du brauchst natürlich Wissen um die Syntax der wesentlichen Sprachkonstrukte. Wenn man bei Null anfängt würde ich bei deinen Ambitionen davon ausgehen, dass du nach einer Woche 80% der wesentlichen Konstrukte zumindest kennst (Syntax, Bedingungen, Schleifen, Datentypen, Klassen, Funktionen/Methoden, Exceptions, Generics) - gemäß der 80-20-Regel. Wann was anzuwenden ist wirst du dann auch ziemlich schnell begreifen.
Was dann noch dazukommt sind die Bibliotheken. Es sollte offensichtlich sein, das du keine Low-Level-Funktionen benutzen musst, um ein ein einzelnes Pixel auf dem Bildschirm darzustellen oder eine Datei bis zur Festplatte zu bringen. Ein HelloWorld ist halt ein 1-Zeiler (wenn man die Boilerplate, also den Standardcode drumherum, weglässt). Aber du kannst auch etwas größer denken und aus einer Struktur eine XML erstellen ohne dich darum kümmern zu müssen wie die XML aussieht.
Dazwischen gibt es noch die "Standards"...Listen, Dictionaries, Arrays, ... Die wirst du immer wieder finden und brauchen. Auch hier gilt die 80-20-Regel, diesmal andersherum: Dir werden 20% der Standardbibliotheken reichen um 80% deiner Zeile zu erreichen (wobei ich in Betracht der Größe, je wie man die Standarbibliothek definiert, eher auf 95-5 tippen würde).
Wie kommst man auf die Bibliotheksfunktionen? Kommt auf die eigene Erfahrung an. Wenn wenig da ist: Tutorials, da wird man in das wesentliche eingeführt. Später hilft google massiv, am besten auf Englisch - stackoverflow ist eine geniale Community, man kann daraus wortwörtlich ganze Programme zusammenkopieren (wenn man weiß, was man kopieren muss). Wenn deine Erfahrung sogar das übertrifft oder deine Probleme sehr speziell sind, hilft eine Dokumentation meist weiter.
Letztendlich ist mein Rat aber: Nicht lernen - MACHEN! Lese/schaue Tutorials (und versuche sie nachzuvollziehen), denk dir Probleme aus/frag Bekannte nach Problemen und versuche sie umzusetzen. Programmieren ist vor allem Erfahrung (und Kreativität).
Das ist keine Fremdsprache wie italienisch, wo du Vokabeln lernen musst und einen Italiener brauchst der dir dann nur sagt, dass das irgendwie falsch klingt. Du hast einen Compiler, der dir jederzeit sagt, was ihm nicht passt. Wenn es für den Compiler passt das Ergebnis trotzdem unerwartet ist, hast du zumindest direktes Feedback. Es gibt (ins besonders in der Visual Studio Welt) wundervolle Möglichkeiten Fehler auszuspüren (aber das würde jetzt den Rahmen sprengen)
Sammel einfach Erfahrung, das bringt dir mehr als jedes Lehrbuch. Ich würde nicht sagen, dass du nach 2 Wochen ein 3D Game zustande bringst...aber ein primitiver Snake-Clone auf der Konsole? Da bin ich bei deiner Motivation optimitisch.
Das Problem ist nicht unbedingt das autonome Fahren an sich, sondern der Weg dahin. Was haben wir momentan? Genau: Assistiertes Fahren - oder anders formuliert: Dein Auto fährt für dich, aber wenn es Fehler macht und nicht nicht rechtzeitig eingreifst, bist du dran.
Es gibt Leute, die fahren schon seit Jahrzehnten unter solchen Bedingungen...die nennen sich Fahrlehrer. Ich würde mal behaupten: Die fahren entspannter, wenn sie selber die komplette Zeit die Kontrolle haben.
Es fehlt einfach am rechtlichen Hintergrund. Das Wiener Abkommen sieht momentan noch nicht vor den Fahrzeugführer aus der Pflicht zu nehmen. Und selbst wenn ist mir momentan nur ein Hersteller bekannt, der dazu bereit wäre selber die Haftung zu übernehmen (und das auch nur in einem sehr definiertem Umfeld). Dieser Hersteller kommt übrigens aus Deutschland, ich rede hier nicht von Tesla o.ä., die im assistiertem Fahren zwar große Sprünge wagen, sich aber nicht zum pilotiertem Fahren commiten wollen (aus sehr guten Gründen, wenn man sich mal mit der verwendeten Sensortechnik auseinandersetzt) - den Anschluss verlieren wir hier keinesfalls.
Assistenzsysteme zur Gefahrenabwendung sind gut und wichtig. Zum Komfort muss vor allem rechtlich (und das zumindest Europaweit, von Weltweit will ich hier gar nicht sprechen) was getan werden.
Das ist gar nicht mal so kompliziert in einem Programm umzusetzen.
Du hast je 10er-Potenz ein (1, 5)-Paar. Du brauchst also nur die einzelnen Ziffern betrachten. Als Beispiel nehme ich mal die Zahl 1947.
Wir fangen hinten an, du beginnst bei der Potenz 0. DIe Numerale sind hier (I, V): Die letzte Ziffer lässt sich mit Modulo 10 ermitteln. Also: 1943%10 => 7.
Wir wollen nicht, dass das gleiche Numeral 4 mal vorkommt...das wäre bei 4 oder 9..also alles gut. Passt 5 in die Zahl rein? Ja, also schreiben wir V auf und ziehen 5 vom Rest ab. Nun füllen wir auf mit Rest mal I, also kommt VII raus.
Anschließend dividieren wir die Zahl durch 10, es bleibt 194. Und wir springen zur nächsten Potenz.
Potenz 1 --> (X, L):
Wir haben die 194 finden die Ziffer 4, die wollen wir nicht. Der Trick ist hier, die Zahl einfach um eins Hochzuzählen und uns zu merken, dass wir noch einen Übertrag haben. Und nochmal neu zu beginnen.
Also von vorn, wir haben nun die 195 und einen Übertrag. Übrig bleibt die 5. Ein L. Den Übertrag werden wir los, wenn wir vor das letzte Numeral ein X packen. Also ist das Ergebnis aus dieser Potenz XL (bzw mit dem vorherigem Ergebnis XLVII). Zur Nächsten Potenz mit der 19.
Potenz 2 --> (C, D)
Wir haben die 19, finden 9. Wollen wir nicht, also inkrementieren und Übertrag.
Es bleibt 20, eine 0 am Ende, nix zu tun. Für den Übertrag würden wir gern C vor das letzte Numeral einsetzen, macht aber bei 0 keinen Sinn, den merken wir uns. Weiter mit 2
Potenz 3 --> (M, ?)
Wir haben 2 und einen Übertrag. 5 passt nicht rein, also 2 mal M. Wir haben noch den Übertrag in Form C übrig. den setzen wir vor das letzte Numeral. Also MCM. Kombiniert mit unserem letzten Zwischenergebnis als MCMXLVII.
Der Vorgang lässt sich einfach in ein Programm packen, wenn du hängst, kann ich dir bestimmt ein Beispiel geben.
Ich widerspreche mal mir selber (wenn man meine älteren Antworten zum Thema "Programmieren lernen" betrachtet wo meine Tendenz eher Richtung Java/C# gingen) und empfehle Python.
Python ist ideal für Rapid-Prototyping geeignet (ins besonders mit dem Jupyter Notebook). Das heißt: Man kommt schneller zu einem Ergebnis. Das wird durch überragende Vielfalt von Bibliotheken extrem unterstützt.
Das ist natürlich für Anfänger besonders motivierend. Mit dem Notebook kann man seine Programme iterativ aufbauen - man kann sein Programm in einzelne Schritte aufteilen und kann in einem neuen Schritt auf den Inhalt bisheriger Variablen zugreifen ohne das Programm bis zu dem Punkt erneut auszuführen. Wenn man mit großen Datenmengen arbeitet oder einfach Rechenprozesse etwas länger dauern (eher im fortgeschrittenen Stadium) spart das viel Zeit. Aber auch im Anfängerstadium hilfreich da man so immer mal überprüfen kann was bisher passiert ist.
Aber: es ist nicht alles Gold was glänzt. Für Spiele-Entwicklung ist Python nicht ideal. Bei der Syntax ist Python auch eher verschieden zu Java/C#/C++ (diese 3 Sprachen sind relativ ähnlich). Und Debugging (zur Laufzeit in den Inhalt von Variablen reinschauen) ist bei Python auch nicht so schön gelöst.
Trotzdem: Python halte ich für ideal für Anfänger. Du hast schnelle Ergebnisse. Größere Spiele werden kein Kurzzeitziel sein. Und am wichtigsten: Die Grundideen lassen sich zwischen den Sprachen einfach transferieren, mann muss es nur in die entsprechende Sprache umwandeln - Python ist da etwas einfacher, deswegen gibt es beim Umstieg eine kleine Lernkurve - ist aber relativ trivial, wenn man von den Bibliotheken absieht (und du kannst dich am Anfang mehr auf die Programmier-Paradigmen/Prinzipien konzentrieren)
______________________ (<-- Strich)
Unterm Strich hat jede Sprache Vor- und Nachteile. Ich bin jetzt nicht im Detail auf Unterschiede zwischen Java/C#/C++ eingegangen, sondern habe diese mal unter dem Begriff C-Type-Sprachen (spontan erfundener Begriff - bitte nicht daran festnageln) zusammengefasst und mit Python verglichen.
Wenn du professionell in die Programmierung einsteigen willst wirst du dich mit allem auseinandersetzen müssen. Um sich selbst mit schnellen Erfolgen zu motivieren empfehle ich Python. Fúr Spiele kommt es auf die Plattform an, aber tendenziell sind C-Type-Sprachen zu empfehlen.
Eventuell passt das Tastaturlayout nicht? Wenn du Sonderzeichen, Umlaute oder z/y im Passwort hast und während der Installation ein DE-Layout verwendet wurde, nun aber ein US Layout aktiv ist (bzw möglicherweise auch andersherum), musst du entsprechend anpassen.
Also mal von vorne nach hinten ;-)
Ein 2D Array in Java lässt sich mit
char[][] data = new char[n][n];
bzw.
char[][] data = {
"*****".toCharArray(),
"* ".toCharArray(),
"*** ".toCharArray(),
"* ".toCharArray(),
"* ".toCharArray()};initialisieren (oder man holt sich die Daten Zeile für Zeile aus dem Inputbuffer oder wie auch immer das die Aufgabe genau will, dass ist mir nicht ganz klar).
Für alles weitere ist es hilfreich eine Klasse zu erstellen:
public class ImageArray {
private int _size = 0;
private char[][] _data = null;
public ImageArray(int size, char[][] data) throws IllegalArgumentException {
_size = size;
if (_size < 5) {
throw new IllegalArgumentException();
}
if (data.length != _size) {
throw new IllegalArgumentException();
}
for (char[] a : data) {
if (a.length != _size) {
throw new IllegalArgumentException();
}
}
_data = data;
}
public void print() {
for (char[] a : _data) {
for (char c : a) {
System.out.print(c + " ");
}
System.out.println();
}
}
}Der Konstruktor sollte hierbei überprüfen, dass die Daten Sinn ergeben, damit man das später nicht jedes mal tun muss (und wenn man das komplett weglässt knallt es irgendwann). Die print-Funktion gibt den ganzen Spaß einfach aus.
Anwenden kann man das wie folgt:
ImageArray arr = new ImageArray(5, data);
arr.print();und man bekommt das F angezeigt.
Nun kann man die Klasse um die Transformationen erweitern, z.B. für das spiegeln entlang der vertikalen Achse. Dazu Element für Element durchgehen und entsprechend austauschen.
public ImageArray flipHorizontal() {
char[][] tmpArr = new char[_size][_size];
for(int i=0; i<_size; i++) {
for(int j=0; j<_size; j++) {
tmpArr[i][j] = _data[i][_size-j-1];
}
}
return new ImageArray(_size, tmpArr);
}Ausgegeben werden kann es dann mit
arr.flipHorizontal().print();Für die horizontale Achse ist es das gleiche, nur das andere Elemente ausgetauscht werden:
tmpArr[i][j] = _data[_size-i-1][j];Ähnlich auch für die Rotation im Uhrzeigersinn:
tmpArr[i][j] = _data[_size-j-1][i];Jetzt könnte man das genauso für alle weiteren Transformationen machen, da Programmierer aber faul sind gibt es einen noch bequemeren Weg. Denn diese 3 Transformationen sind ausreichend um alle weiteren Transformationen durchzuführen.
Eine Rotation gegen den Uhrzeigersinn ist so durch 3 mal mit dem Uhrzeigersinn rotieren zu erreichen. Eine Spiegelung an der Hauptdiagonalen durch spiegeln an der horizontalen Achse und einer Rotation im Uhrzeigersinn (bzw spiegeln an der vertikalen Achse und Rotation gegen Uhrzeigersinn. Für die Nebendiagonale horizontale Achse und gegen Uhrzeigersinn (bzw. vertikale Achse und im Uhrzeigersinn).
Sicher ist das nicht die optimalste Lösung, aber die einfachste und die Funktionalität ist auch gegeben ;-)
Jetzt mal ganz vereinfacht beschrieben....eine Adresse ist grob in 3 Teile unterteilt:
subdomain.domain.topleveldomain
Das sind dann auch Hierarchiestufen in der Verwaltung. Die Topleveldomain (TLD) kannst du schwer beeinflussen...du musst dir eine existierende aussuchen (.de, .org, .com, ...).
Eine Domain kannst du buchen (insofern der Name frei ist).
Subdomains kannst du beliebig aussuchen, wenn du die Domain besitzt (hier gibt es natürlich bekannte Konventionen, z.B. leitet ein Browser auf www um wenn du die subdomain weglässt - glaube ich, da bin ich mir nicht 100%ig sicher).
Vorteile hier ist die logische Strukturieren von Inhalten, wenn man sich nur auf eine Domain beziehen will.
Ist jetzt etwas vereinfacht dargestellt, sollte aber die Grundidee verdeutlichen.
Es ist natürlich theoretisch möglich. Aber der Aufwand ist enorm - insbesondere wenn man sieht wie weit es nach oben skalieren kann.
Fangen wir mal im kleinen an. Du hast eine Textdatei und willst darin was suchen. Gut...erstmal einfach. Jetzt kommt eine andere Datei (HTML/PDF/DOC/...) - macht die Sache schon komplizierter - aber noch machbar.
Nun aber: Du willst eine Ordnerstruktur durchsuchen. Schonmal die Windowssuche benutzt? Das kann ewig dauern und die Ergebnisse sind nicht besonders durchschaubar. Da muss man indizieren also schon (plump gesagt) im Hintergrund relevante Metadaten sammeln (und auch sinnvoll abspeichern) damit die schnell verfügbar sind. Das alleine ist schon eine Aufgabenstellung die ich mir nicht zutrauen würde wirklich gut umsetzen zu können (und ich bin nebenbei von meinen Fähigkeiten sehr überzeugt). Also da ist schon sehr viel Algorithmenmagie notwendig.
Du brauchst Schlüsselworte um die Suche zu präzisieren. Zugegeben, das ist eine der einfacheren Aufgaben. Praktisch trotzdem ein riesen Aufwand.
Was google noch kann...Ähnlichkeiten erkennen...nun vllt nicht etwas was man Anfangs haben muss - aber erwähnenswert.
Nun aber der Coup de grâce: Du beschränkst das nicht auf deinen PC, nicht auf ein lokales Netzwerk, sondern es soll das WWW umschließen. Und während alles zuvor mehr oder weniger auf deine Fähigkeiten und Zeit beschränkt ist (wobei ich überzeugt bin, dass sich das mit einem Menschenleben nicht erreichen lässt) - bist du hier auch Rechenpower angewiesen. Gehen wir einen Schritt hoch: indizieren. Das heißt regelmäßig alle Seiten abfragen die es gibt und die Daten abspeichern...viel Spass.
Ich gebe zu: Ein interessantes Gedankenexperiment. Und durchaus auch eine interessante Projektidee eine lokale Dateisuche zu implementieren - aber darüber hinaus für eine Einzelperson absolut unrealistisch....
Das offensichtliche zuerst: KEIN GOTO!!! Und zur Sicherheit wiederhole ich es nochmal: KEIN GOTO!!!!
Sei mir nicht böse, aber es ist eine Schande, dass dieses Schlüsselwort in C++ überhaupt existiert. Es ist äußerst gefährlich und man sollte es nur benutzen wenn man wirklich(!) weiß, was man tut. Und selbst dann...wer weiß was er tut wird darauf dankend verzichten. Das Problem damit ist: Es macht Code unleserlich. Und noch schlimmer: Wenn es an falschen Stellen verwendet wird führt es zu fiesen Problem, die schwer zu debuggen sind (ist soweit ich überblicke bei dir nicht der Fall...aber trotzdem...)
Auch deine if-else Strukturen...mit einem switch statement wären die sehr viel lesbarer.
Aber dein Problem ist ein ganz anderes. Du benutzt den Zufallsgenerator...seedest (also initialisierst) ihn nicht. Zu rand gehört immer ein srand...ansonsten wirst du immer die gleiche Ergebnisse sehen.
Am Anfang des Programmes ein
srand((unsignedtime NULL));
(inkludiere <time.h>) kann hier Wunder bewirken.
100km ist definitiv am Tag schaffbar. Ich persönlich bin habe ohne besonderes Training letztes Jahr 70km MTB in etwas über 6h abgerissen (da habe ich gerade mit MTB angefangen). Mit 16 hatte ich eine (Trekking)Radtour mit Freunden, wobei wir an einem Tag 130km gefahren sind - in unter 8h (war "begünstigt" durch einen persönlichen Notfalls eines Teilnehmers).
Wenn ich heute meine Radtouren plane, rechne ich mit 13km/h im Schnitt (im Gelände mit Berg hoch fahren usw), im Trekkingbereich würde ich mir einen höheren Schnitt zutrauen (und ich bin nicht besonders gut trainiert, plane die Touren auf Spaß, nicht auf Stress).
Wenn du also den ganzen Tag Zeit hast - die Tage sind nicht lang. Je nach Strecke schaffst du das sicher in unter 8h...und wenn es 10h sind passt es auch noch (und das ist dann tatsächlich sehr gemütlich).
Was ich allerdings zu bedenken geben möchte: So eine Strecke kann alleine sehr tröge werden. Und vor allem: Was deine Oberschenkel problemlos mitmachen -> Dein Gesäß ist nicht unbedingt der gleichen Meinung sein.
Ich beantworte mal meine Frage selbst, falls jemand in eine ähnliche Situation kommt.
Es handelt sich hierbei wohl um einen Bug in einer neueren Version der libCairo, die irgendwann zwischen GIMP 2.8.10 und 2.8.14 eingeführt wurde.
Ich werde das Problem detaillierter betrachten und, insofern ich sie finde, weitere Infos als Kommentar geben. Bis dahin: Falls jemand das gleiche Problem hat, einfach GIMP 2.8.10 installieren.
Grundsätzlich: Die Syntax ist die gleiche. Da du Code::Blocks ansprichst, nehme ich mal als Sprache C++ an. Da ist es sogar so, dass du unter Windows wahrscheinlich Cygwin oder MinGW verwendest, was eine Unixoides System emuliert. MacOS selber ist ein solches System, also sollte die Unterstützung dort sogar besser sein - da nativ (Vorsicht: Halbwissen).
Ich verwende Code:Blocks nicht, habe es ausprobiert - hat mir nicht gefallen (ist aber Geschmackssache). Unter Windows nutze ich fast ausschließlich Visual C++ mit dem entsprechenden Compiler. Ich gehe fest davon aus das der in deiner Schule nicht verwendet wird, sondern ein GCC (evtl clang?) - da müsstest du mal nachschauen/deinen Lehrer fragen. Das wäre dann exakt der gleiche Compiler, den du auch im Mac zur Verfügung hast.
Meine Antwort besteht zwar aus vielen könnte/müsste/sollte, aber selbst wenn das nicht zutrifft. Die Syntax ist 100% die gleiche. Bei den Bibliotheken gibt es tatsächlich Unterschiede im Detail (insbesondere wenn der MS Compiler verwendet wird, was ich nicht glaube - da gibt es auch einige Unterschiede in Standardfunktionen, z.B. gibt es bei VS ein sscanf_s - ein besseres sscanf - was leider keine Standardfunktion im C++ Standard ist).
In 98% (grob über den Daumen) unterscheiden sich die Programme überhaupt nicht (und wenn doch kann man leicht daran vorbei arbeiten)
Unterm Strich: Ja, du kannst deinen Mac direkt verwenden. Und wenn mal der unwahrscheinliche Fall eintritt, das es nicht passt, kann dir hier schnell geholfen werden. Anders herum kann es schwieriger sein, da der GCC neue C++ Standards besser unterstützt als der MS Compiler, aber das ist ja bei dir nicht der Fall.
Wenn du frisch geboren bist, bist du im 1. Lebensjahr, nach dem 1. Geburtstag im 2. Lebensjahr.
Das ist genauso wie das 20. Jahrhundert bis 1999 geht.
Also bist du nicht mehr im 18. Lebensjahr.
Die 0/1 lassen sich tatsächlich in einem Bit unterbringen. Dafür gibt es allerdings eine Vorraussetzung: Du definierst, dass der komplette Text nur aus Nullen und Einsen besteht.
Wieviele Bits pro Zeichen benutzt werden hängt aber von der Kodierung ab. Da gibt es viele kreative Möglichkeiten sowas zu tun. Zum Beispiel kannst du sagen: Dein Text besteht nur aus 0,1,A und B. Dann kann man definieren, dass 0->0, 1->1, 2->A und 3->B ist - du brauchst nur 2 Bit pro Zeichen.
Willst du den kompletten ASCII Code abdecken brauchst du 8 Bit pro Zeichen.
Bei Unicode wären es 8*x Bit pro Zeichen.
Unicode ist hier eine interessante Idee. Als simplifiziertes Beispiel: Du hast einen Text, der fast nur aus 1en und 0en besteht, aber es sind auch einzelne ASCII Zeichen dabei. Dann könnte man definieren: Jedes Zeichen hat ein einzelnes Bit vorangestellt: Wenn es 0 ist, kommt danach ein Bit und es ist Binär, wenn es 1 ist, kommen danach 8 Bit für den ASCII Code. Nachteil: Jedes Zeichen ist ein Bit länger, als es sein sollte, Vorteil: Wenn 0/1 oft vorkommt, kann man im Endeffekt Platz sparen. So funktioniert im groben auch Unicode, genau gesagt UTF-8 (die ersten 127 Zeichen sind immer 8-Bit lang, danach können es mehrere Bytes Werden).
Andersherum kann man von einem existierendem Text schauen, welche Zeichen besonders oft verwendet werden und diese aus entsprechend wenige Bits reduzieren, wenn ein Zeichen nur 5-mal in 30.000 Zeichen verwendet wird, ist es auch nciht so schlimm, wenn dieses Zeichen 10-Bit braucht. Ein klassische Beispiel hierfür ist die Huffmann-Kodierung, die im ZIP-Algorithmus einen wichtigen Anteil spielt. Deswegen lassen sich auch Texte so gut Zippen, weil die Entropie (Informationsgehalt, im ASCII sind viele Kontrollsignale und sonderzeichen, die nie benutzt werden, du brauchst für einem durchschnittlichen Text keine 8-Bit pro Zeichen) dort realtiv gering ist.
Ein Dodekaeder hat 12 Seiten (wenn ich nicht grad total falsch gewickelt bin).
Also...wieviel Möglichkeiten hast du um ein positives Ergebnis zu erreichen?
1.) 1, 2, 3, 4, 10, 11, 12 -> 7 Möglichkeiten
2.) 2, 3, 4, 5, 7, 8, 11, 12 -> 8 Möglichkeiten
3.) 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 -> 11 Möglichkeiten
4.) 2, 4, 6, 8, 10, 12 -> 6 Möglichkeiten
Nun must du das nur noch in eine Wahrscheinlichkeit umrechnen. Ab jetzt, entschuldige bitte meinen Mathematik-Slang, ich bin aus der Schule raus und muss mich nicht mehr mit den exakten Formulierungen befassen, bin daher eher pragamatisch. Ich gehe jetzt von relativer Wahrscheinlichkeit aus, bei einem gleichverteiltem Dodekaeder.
P = Anz_posErgebnisse / Anz_Ergebnisse. Anz_Ergebnisse ist immer 12.
Für 1) wäre das 7/12 = ~58.33%
Und den Rest bekommst du dann auch sicher selbst heraus ;-)