Finde ich absolut OK, und esse selbst auch häufiger Insekten (im Ausland). Bin aber kein Veg(an|etari)er. :)

Du bildest einfach die Differenz aller Kanäle zu dem, was du erwartest.

Zum Beispiel ist Blau als RGB Integer 0x0000FF. Du hast also drei Teile, die in einem Bereich von 0x00 bis 0xFF liegen können.

Das heißt, die maximale Differenz einer Farbe kann bei dem 3-fachen davon liegen, also 768.

Hättest du jetzt Cyan (bestehend aus Rot und Blau) mit 0xFF00FF, liegt der Rot-Kanal um 255 daneben, der Grün-Kanal pass (also Abweichung Null) und der Blau-Kanal passt ebenfalls.

Das heißt, Cyan weicht um 33% von Blau ab.

Damit kannst du die Differenzen von jeder Farbkombination berechnen und danach entscheiden, was du damit tun willst.

Aber noch ein Wort zu BufferedImage: Der pixelweise Zugriff darauf ist saulahm!

Deshalb solltest du dich mit Filtern und den Funktionen des Grafikkontextes befassen, denn damit kannst du solche Aufgaben an die GPU delegieren, was viiiiieeeel schneller ist.

Auf BufferedImages Pixel für Pixel zu arbeiten macht wirklich keinen Spaß! Fang so früh wie möglich an, Funktionalitäten der GPU einzuschalten!

Auf jeden Fall Assembler. Allerdings pfuschen Skriptkiddies in den letzten Jahren auch gerne mit C# oder ähnlichem Müll rum.

Früher wurde man ausgelacht, wenn man Malware nicht in Assembler, sondern in C++ oder Delphi gebaut hat, und diese dann nicht mehr ein bis zwei KB, sondern bei gleicher Funktionalität über 100 KB groß war.

Seit einigen Jahren läuft mir aber oft Malware über den Weg, welche die 30 Megabyte-Grenze sprengt. Weit mehr als 20 MB sind durchaus üblich ... leider.

Irgendwie wird überall nur noch gepfuscht, auch bei den Malwareautoren.

Fazit: Meine erste Wahl wäre Assembler. Danach kommt erst mal sehr sehr lange nichts, und dann irgendwann vielleicht C oder C++.

Eine mehrere Megabyte große Malware mit einer gemanageten Sprache wie C# oder Java zu schreiben ist zwar möglich, aber nichts für Leute, die etwas auf sich halten. (Es sei denn natürlich, man möchte mit Hilfe von z. B. Reflection bestimmte Dinge an anderer Software, geschrieben in eben einer dieser Sprachen, etwas manipulieren ... dann ist das natürlich völlig legitim.)

Aber die Standard-Trojaner-Funktionen, wie Screenshot, Dateibrowser, und und und macht man mit Assembler, und am Ende purzelt eine schön kleine Executable raus.

Du meinst doch mit µc sicherlich ein Mikrocoulomb, oder?

Dann schreib lieber µC mit großem C, überlege dir was "mikro" eigentlich bedeutet, und wie groß ein Coulomb ist. :)

Du hättest das Zink vorher ablösen sollen. Das geht entweder über einen längeren Zeitraum mit Entkalker aus der Drogerie (Zitronensäurepulver) oder schneller mit Salzsäure aus dem Baumarkt. (Säure vorher aber verdünnen und dabei gut lüften, da Chlor frei wird, was du nicht einatmen solltest!)

Direkt nach "cmp" sollte ein "jz" zu einem Label hinter das Ende deiner Schleife stehen.

Außerdem willst du nicht das Byte an der Adresse, auf die "dl" zeigt nach [eax] schreiben, sondern "dl" direkt, also lass die eckigen Klammern weg.

Dann fehlt da noch ein "byte ptr", da du ja die Intel, und nicht die AT&T Syntax nutzt.

Und ein XOR mit 0 bringt jetzt auch nicht soooo viel. :)

Alles in allem, zu viele Fehler. Fang als Einsteiger lieber mit etwas Einfacherem an!

Weil viele Leute leider noch nicht erkannt haben, dass Donald "Grab'em by the Pussy" Trump in Wahrheit nicht nur ein absoluter Fachmann für Business-, Auslands-, Waffen- und Twitter-Angelegenheiten, sondern eben auch fürs Klima ist.

Nur weil er manchmal etwas mit Zahlen, Fakten und Halluzinationen durcheinander kommt, muss man ja noch lange nicht schlecht über ihn reden.

Gott schütze ihn!

Ich habe gerade nochmal - einfach aus Sport - eine Template-Funktion geschrieben, welche die Parität entweder als konstanten Ausdruck oder auf Wunsch auch zur Laufzeit von einem beliebigen vorzeichen-behafteten oder -losen Ganzzahltypen berechnet:

#include <ios> // boolalpha
#include <iostream> // cout, endl

#include <limits> // numeric_limits
#include <type_traits> // is_integral, is_signed

#include <cstdlib> // size_t

template <typename INT>
constexpr bool parity(const INT n) noexcept {
  using namespace ::std;
  static_assert(is_integral<INT>());

  using UINT = make_unsigned_t<INT>;
  using limits = numeric_limits<UINT>;

  static_assert(2 == limits::radix);
  constexpr size_t bits { limits::digits };

  UINT par { static_cast<UINT>(n) };
  for (size_t i { bits >> 1 }; i; i >>= 1) {
    par ^= par >> i;
  }

  return par & 1;
}

int main() {
  using namespace ::std;

  cout << boolalpha;

  const long l = 0b0101;
  cout << parity(l) << endl;

  const int i = 0b1011;
  cout << parity(i) << endl;

  const short s = 0b1001;
  cout << parity(s) << endl;

  const char c = 0b0100;
  cout << parity(s) << endl;
}

Die Funktion dürfte im Schnitt maximal-effizient sein und hat eine Laufzeitkomplexität von O(1) mit exakt log2(sizeof(INT)) durchläufen, also praktisch 5 "Faltungen" bei einem 32 Bit Integer.

Um den Code übersetzen zu können, ist aber ein C++17 Compiler notwendig.

Wie gesagt, das war jetzt nur Sport, weil "KarlRanseierIII" in seiner Antwort etwas von "aufgehübschter" und "lesbarer" geschrieben hat. Darunter verstehe ich als C++ler "effizienter" und "portabler", was mich soz. getriggert hat. ;)

Der Fragensteller kann meinen Template-Code getrost ignorieren! Das ist noch ganz weit von dem jetzigen Kenntnisstand entfernt. Aber weil ich das jetzt sowieso geschrieben hatte, kann ich es auch gleich hier veröffentlichen. :)

Ich habe deinen Code nur grob überflogen, aber du hast einen sehr interessanten Fehler gemacht, der vom Compiler vermutlich nicht angekreidet werden wird, da es sich um korrektes C++ handelt:

if(bits[0,1,2,3] == bits[4,5,6,7]) // ...

Genau genommen entspricht dieser Code ...

if(bits[3] == bits[7]) // ...

... und ist damit nicht das, was du erreichen willst.

Du willst sicherlich diesen Vergleich hier haben:

if(bits[0] == bits[4] &&
   bits[1] == bits[5] &&
   bits[2] == bits[6] &&
   bits[3] == bits[7]) // ...

Das ist etwas länger, tut aber sicherlich eher das, was du erwartest.

Der Kommaoperator in deinem Code ist etwas tückisch und macht oft nicht das, was Einsteiger von ihm erwarten. :)

Ansonsten muss ich sagen, dass es bessere Ansätze für die Lösung deiner Problemstellung gibt, aber ich will dich jetzt nicht überfordern. Versuch einfach immer schön am Ball zu bleiben, auch wenn dein Lehrer nicht sonderlich gut erklärt! :)

Das Format "muss" gar nicht aussehen. Du kannst dir irgendetwas Beliebiges aus den Fingern saugen. Solange du gut damit arbeiten kannst, ist es völlig Wurst, wie deine Datentypen aussehen. :)

Da du Wordpress nutzt, gehe ich mal davon aus, dass du Zugriff auf eine Shell hast, egal ob lokal oder über SSH aufm Server.

Vermutlich handelt es sich dabei um die BASH. Falls ja, kannst du alle Dateien ohne Endung in ein möglichst leeres Verzeichnis kopieren, dich dann mithilfe von "cd /pfad/zu/den/Dateien" dorthin bewegen, und folgenden Einzeiler abfeuern:

for f in +([^.]); do mv -v $f $f.jpg; done

Das benennt dir alle Dateien ohne Punkt (also ohne Endung) so um, dass am Ende ein ".jpg" rangehängt wird. Durch den "-v" Switch vom "mv" Kommando wird dir die Änderung für jede Datei angezeigt.

Bei mir sieht die Ausgabe eines Tests so aus:

$ for f in +([^.]); do mv -v $f $f.jpg; done
‘bar’ -> ‘bar.jpg’
‘baz’ -> ‘baz.jpg’
‘feep’ -> ‘feep.jpg’
‘foo’ -> ‘foo.jpg’
‘oink’ -> ‘oink.jpg’

Falls du eine andere vernünftige unixoide Shell außer BASH nutzt, funktioniert höchstwahrscheinlich dieser (etwas längere) Einzeiler:

find . -type f -regex '.*/[^.]+' -exec mv -v {} {}.jpg \;

Eins von beiden sollte funktionieren. :)

Als was liegt denn dein Punkt vor?

Falls es eine Liste, ein Tupel, ein Generator oder ein ähnliches Objekt ist, dann geht das ganz einfach so, wie in meinem Kommentar unter der Antwort von "ChePhyMa":

p = [123, 456]
x, y = p

Danach hat x den Wert 123 und y den Wert 456.

Falls dein Punkt als String vorliegt, kannst du die split() Methode nutzen, und die Werte anschließend parsen:

p = '123,456'
x, y = (int(i) for i in p.split(','))

Falls die Koordinaten deines Punktes nicht als Ganz- sondern als Kommazahlen vorliegen, kannst du sie mit float() parsen:

p = '12.34 x 56.78'
x, y = (float(f) for f in p.split(' x '))

Falls nichts davon klappt, bitte das nächste mal dazu schreiben, in welcher Form deine Variable eigentlich vorliegt. Sonst kann man leider nur raten. :)

Bei der Deklaration deines Arrays wird bereits der Defaultkonstruktor aufgerufen. Das heißt, dass in dieser Zeile ...

Buch buch[100];

... bereits 100 mal hintereinander der Konstruktor aufgerufen wird.

Kurz nebenbei noch zwei Anmerkungen:

1. Variablennamen möglichst immer auf Englisch.
2. Das Array enthält nicht nur ein einziges Buch, sondern mehrere, also nenne die Variable "buecher" bzw. auf Englisch noch besser "books".

Aber das nur am Rande ...

Dieses Beispiel hier sollte dir beim Verständnis helfen:

#include <iostream>
#include <string>
#include <utility> // move

using namespace ::std;

class Book {

public:

  Book(string title="default")
    : title_ { move(title) }
  {
    cout << "Created: " << title_ << endl;
  }

  Book & operator = (const Book & book) {
    cout << "Copied: " << book.title_ << " to " << title_ << endl;

    this->title_ = book.title_;

    return *this;
  }

  Book & operator = (Book && book) {
    cout << "Moved: " << book.title_ << " to " << title_ << endl;

    this->title_ = move(book.title_);

    return *this;
  }

  ~Book() {
    cout << "Destroyed: " << title_ << endl;
  }

  const string & title() const noexcept {
    return title_;
  }

private:
  string title_;

};

ostream & operator << (ostream & os, const Book & book) {
  return os << "Book<" << book.title() << ">";
}

int main() {
  cout << "[before array]" << endl;
  Book books[2];
  cout << "[after array]" << endl << endl;

  cout << "[before loop 1]" << endl;
  for (const Book & book : books) {
    cout << book << endl;
  }
  cout << "[after loop 1]" << endl << endl;

  cout << "[before move assignement]" << endl;
  books[1] = Book { "Beautiful Code" };
  cout << "[after move assignment]" << endl << endl;

  cout << "[before loop 2]" << endl;
  for (const Book & book : books) {
    cout << book << endl;
  }
  cout << "[after loop 2]" << endl << endl;
}

Das liefert dir folgende Ausgabe:

[before array]
Created: default
Created: default
[after array]

[before loop 1]
Book<default>
Book<default>
[after loop 1]

[before move assignement]
Created: Beautiful Code
Moved: Beautiful Code to default
Destroyed: default
[after move assignment]

[before loop 2]
Book<default>
Book<Beautiful Code>
[after loop 2]

Destroyed: Beautiful Code
Destroyed: default

Der Übersichtlichkeit zuliebe enthält das Array nicht 100, sondern nur 2 Bücher. Wie du sehen kannst, wird der Default-Konstruktor sofort bei der Deklaration des Arrays für jedes Element aufgerufen, also zwei mal!

So, mehr erkläre ich jetzt nicht, weil dich das nur verwirren wird, und das ist sogar NORMAL. Denn das Ganze Thema hat etwas mit sog. Kopier- und Verschiebe-Semantik zu tun, einem Konzept, welches es in vielen anderen Programmiersprachen gar nicht gibt und Einsteiger am Anfang IMMER verwirrt ... also mach dir jetzt bloß keinen Kopf! Irgendwann wirst du das schon alles verstehen! ;)

Für den Moment musst du leider damit leben, nicht jeden Aspekt von C++ sofort durchschauen zu können. C++ ist eben eine sehr mächtige und mit Features vollgepackte Sprache. Aber irgendwann wird es "Klick!" machen, und dir wird alles klar werden. Garantiert!

Lerne einfach immer schön weiter und versuch am Ball zu bleiben! ;)

Das geht im einfachsten Fall sehr sicher mit einem Python- / Ruby- / Perl- / PHP- / Shell-Skript von weniger als 30 Zeilen länge.

Aber selbst wenn du dir noch ein paar mehr Features einbaust, wirst du kaum über 100 Zeilen kommen.

Alles in allem überhaupt keine große Sache, wenn es wirklich nur das tun soll, was du in deiner Frage geschrieben hast. :)

Ja, das ist möglich, sogar mit mehreren völlig unterschiedlichen Ansätzen.

Aber da der Schutz ja nur ein paar Schüler abhalten soll, und DDoS sowieso die primitivste aller Angriffsarten ist, die ja nur von Kindern genutzt wird, reichen die Maßnahmen des Lehrers sicher aus.

Wie du effektiv den IP-Blocker und / oder den DDoS Schutz umgehen kannst, bzw. einfach den Server down bekommst, würde dich aber vermutlich überfordern. Deshalb versuche lieber auf anderem Wege an eine "Eins in Englisch" zu kommen. :)

PS: Hab gerade die anderen Antworten überflogen, und möchte nochmal hinzufügen, dass im Idealfall ein einziger Request (oder wenn man es anders anstellt, nur eine Hand von Clients, keine Tausenden!) ausreicht, um den Server abzuschießen.

Dafür bringt jede gute Programmiersprache standardmäßig ein Werkzeug wie "2to3" mit ... und da PHP alles andere als eine "gute Programmiersprache" ist, lautet die Antwort natürlich: Nein. :)

Es gibt zwar ein paar Knickei-Lösungen von Drittanbietern, aber trotzdem wirst du zum größten Teil per Hand frickeln müssen. Also genau das, was man im PHP-Lager erwarten dürfte. ;)

Ich stimme bewusst nicht ab und ich werde dir auch keine Antwort auf deine Frage geben. Nur ein paar Hinweise:

Du solltest dich von dem Gedanken verabschieden, dass C etwas mit C++ zu tun hat. Die sind historisch zwar irgendwie miteinander verbunden, aber inzwischen gibt es so dermaßen viele und gewaltige Unterschiede, dass man C und C++ als völlig voneinander unabhängige und inkompatible Sprachen ansehen sollte. Der Erfinder von C++ - Bjarne Stroustrupp - sieht das neben vielen anderen aus dem C++ Standardisierungs-Komitee - wie Herb Sutter - übrigens auch so.

C++ beherrscht einen großen Teil der C Syntax, umgekehrt kann man das nicht unbedingt behaupten. Aber vor allem die Konzepte und Herangehensweisen bei der Programmierung an sich sind VÖLLIG unterschiedlich!

Allein schon das kleinstmögliche Programm (abgesehen von einigen Leerzeichen) sieht in C so aus:

int main(void) { return 0; }

... in C++ hingegen so:

int main() {}

Du kannst in C nicht wie in C++ programmieren, und umgekehrt gilt das gleiche. Nichtsdestotrotz tun das viele Einsteiger, und es ist das beste Merkmal, um Anfängercode erkennen zu können.

Beruflich und privat entwickle in in beiden Sprachen sehr gerne, vermische diese aber nie und habe für beide Sprachen einen gänzlich anderen Stil, bzw. eine inkompatible Herangehensweise.

Wenn ich etwas Schlankes ohne Abhängigkeiten mit maximaler Portabilität schreiben will, dann nehme ich C89. Auch wenn die neueren Standards wie C99 und vor allem C11 wunderbare Features bieten, ist es aus verschiedenen Gründen oft sinnvoll, selbst Hand anzulegen. Aber natürlich auch nicht immer. Mit genügend Erfahrung weiß man einfach, wann man was am besten einsetzen sollte.

Falls ich hingegen etwas größeres schreibe, bei dem moderene Konzepte umgesetzt werden sollen, und was maximal effizient mit den Ressourcen umgehen soll, dann nehme ich C++17. Funktionalitäten von C++11 und C++14 sind zwar ebenfalls enorm wichtig und richtig, aber bei C++ möchte ich ohne einige C++17 Features gar nicht mehr entwickeln.

Wie du siehst, setze ich bei C auf den ältesten Standard, bei C++ hingegen auf den neuesten. Das hat sich bei mir im Laufe der Jahre als optimale Herangehensweise herauskristallisiert. Aber auch hierbei gilt natürlich wieder: Man muss im Einzelfall abwägen, ob nicht vielleicht doch C++11 oder C99 geeigneter ist. Hängt natürlich auch immer vom Projekt ab.

Auf jeden Fall solltest du C und C++ als völlig unabhängige Programmiersprachen auffassen, die rein gar nichts miteinander zu tun haben. Es wird kaum eine Aufgabe geben, die länger als 2 Zeilen ist, und in C und C++ identisch gelöst werden wird. Wie gesagt, Anfänger machen das zwar trotzdem oft, weil sie es nicht besser wissen, aber als erfahrener Entwickler sollte man genügend Wissen mitbringen, um die Unterschiede kennen und nutzen zu können.

C ist vom Umfang her wesentlich überschaubarer als C++, und C++ dürfte eine der Feature-reichsten Sprachen sein, die du finden kannst. Hinzu kommt, dass die Standardbibliothek von C++ um ein Vielfaches größer ist, als die recht Schlanke von C.

Das heißt, für Einsteiger ist vermutlich C am Anfang leichter, da du hierbei mit sprachübergreifenden Grundkonzepten wie Bedingungen, Schleifen, und solchem Kram in Berührung kommst.

Falls du danach aber C++ lernst, musst du teilweise völlig umdenken, vor allem bei Themen wie der Fehlerbehandlung, dem Programmfluss, uvm.

Aber die Reihenfolge, bleibt letztendlich dir allein überlassen. :)

Gerade µC verfügen oft über einen sehr schlanken und überschaubaren Befehlssatz, weshalb sich disassemblierter Binärcode oft sehr komfortabel fast wie C-Code lesen lässt.

Das gilt insbesondere für die üblichen Verdächtigen: PICs, AVRs, MSP430, usw.

Decompiler funktionieren erfahrungsgemäß eher "solala" und liefern oft keine zufriedenstellenden Ergebnisse. Falls du aber einen für deinen µC findest, probiere es doch einfach aus.

Trotzdem kommst du mit Assembler meist noch am leichtesten weiter, und gerade HEX-Dateien lassen sich vortrefflich disassemblieren. :)