Allein die Tatsache, dass du hier fragen musst, zeigt, dass es dir an Erfahrung mangelt. (Das ist NICHT böse gemeint, sondern nur eine Feststellung! Jeder hat mal klein angefangen, ich auch!)

Normalerweise ist es für Einsteiger ohne besagte Erfahrung sehr riskant, eigene Websites mit PHP zu entwickeln, weil sie sich überhaupt nicht über gängige Sicherheitslücken im Klaren sind, und unter Garantie auch in kleinere / einfachere Seiten, entsprechend ausnutzbare Fehler einbauen werden.

Von daher würde ich in deinem Falle für eine fertige Lösung plädieren.

Aaaaaber, WP ist mit gaaaaaaaanz weitem Abstand das CMS (was selbst eigentlich kein CMS sein will), welches am häufigsten gehackt wird. Das passiert in größerem Umfang alle paar Wochen oder spätestens Monate. Oft sind daran schlampig programmierte Plug-Ins schuld, oft aber auch wieder nicht, und es handelt sich wirklich um schwere Fehler in der Kern-Software.

Fazit: Du hast die Wahl zwischen Teufel und Beelzebub. :)

Egal wofür du dich entscheidest, du kannst sicher davon ausgehen, dass deine Website gehackt werden wird. Und das sogar - wenn du Pech hast - relativ zeitnah.

Bei WP oder einer anderen fertigen Lösung, kannst du die Schuld zwar teilweise auf andere schieben, aber das bringt dir die geklauten Nutzerdaten auch nicht zurück, bzw. musst du dann so oder so deine gesamte Website neu aufsetzen, um sicher zu stellen, dass keine Seiten trojanisiert wurden und munter Malware an die Besucher verteilen.

Was auch immer du tust, mache dir VORHER einen detaillierten Plan, was du tun wirst, wenn es soweit ist, dass deine Website gehackt wird:

  • Wie wirst du registrierte Nutzer informieren?
  • Haust du eine Art Pressemitteilung raus, die du als Textbausteine ja auch schon mal vorbereiten kannst?
  • Automatisierst du ein Rückspielen deiner Webpräsenz aus einem "sauberen" Backup?
  • ... Es gibt unzählige Fragen, über die du dir bei Zeiten Gedanken machen solltest.

Die einzige Möglichkeit, die Gefahr "gehackt" zu werden, auf ein erträgliches Maß zu senken, ist a) Profis für viel Geld anstellen oder b) selbst zum Profi werden. Aber da Punkt b) viele Jahre Zeit in Anspruch nehmen wird, bleibt dir nur Punkt a) oder du musst - wie oben erwähnt - mit einem erhöhten Risiko leben.

Sei dir auf jeden Fall der Gefahr bewusst, ob du etwas dagegen unternimmst, oder nicht. Wordpress installieren und ab dann "Augen zu" wird nicht funktionieren. Außerdem gibt es mit der neuen DSGVO empfindliche Strafen, auch für Blogbetreiber, wenn sich diese nicht entsprechend um die Sicherheit kümmern.

Ich weiß, das war jetzt nicht die Antwort, die du haben wolltest, aber du konntest hoffentlich etwas mitnehmen. :)

Schönen Tag noch, und trotzdem viel Erfolg mit deiner Website! :)

...zur Antwort

Die bedeuten das gleiche wie "quod erat demonstrandum". :)

...zur Antwort

Wenn die Zahlen als Strings in einer Liste vorliegen, kannst du ganz einfach mit ...

int_list = list(int(x) for x in str_list)

... eine int-Liste daraus machen. :)

Hättest du mal ein paar Zeilen des Inhalts deiner Textdatei gepostet, wüsste man das genaue Format und könnte evtl. auch noch sagen, wie du die möglichst elegant parsen kannst, aber ohne weitere Infos geht das leider nicht. Sorry. ><

...zur Antwort

AOL hat schon IMMER den Inhalt deiner E-Mails und deine Kontakte durchsucht und weiter verkauft. Hast du dir nie die Nutzungsbedingungen durchgelesen?

Das einzige, was sich jetzt ändert ist, dass du zustimmen musst ... oder den Dienst eben nicht mehr nutzen kannst.

Aber am Verhalten von AOL wird sich rein gar nichts ändern. Das war schon immer so. :)

...zur Antwort

Gleitpunktzahlen - zumindest die Sorte, von der wir hier reden - kannst du in sehr vielen Fällen sowieso nicht exakt runden.

Außerdem würde ich an deiner Stelle keinen ellenlangen Formel-Schwanz produzieren, sondern die eigentliche Berechnung und die Rundung in (mindestens) zwei getrennte Zeilen aufteilen.

Nach der Berechnung sähe eine Annäherung auf drei Nachkommastellen so aus:

gz = Math.round(gz * 1000.0) / 1000.0;

Aber nochmal, exakte Rundungen wirst du prinzipbedingt mit den gängigen Gleitpunkttypen Javas nicht hinbekommen können. (ob mit oder ohne "strictfp") Außerdem hängt das bei der IEEE 754 Repräsentation auch noch extrem stark vom eigentlichen Wert ab.

Java bietet eine genauere Klasse für Gleitpunktzahlen an, nämlich BigDecimal, die auch über mehr Rundungsmöglichkeiten verfügt, aaaaaber soweit ich mich recht erinnere, arbeitet diese Klasse intern nicht wie IEEE 754-2008, also dezimal, sondern binär, was eine exakte Rundung unmöglich macht.

Du müsstest dir also entweder eine eigene Klasse bauen (was gar nicht soooo schwer ist!) oder auf eine fertige Bibliothek zurück greifen. Allerdings dürfte für deinen Falle die Rundung aus dem Einzeiler-Snippet locker ausreichen, und man muss ja nicht mit Kanonen auf Spatzen schießen. :)

Naja, trotzdem viel Erfolg! :)

...zur Antwort

Vorweg: Du meinst keine Variablen-, sondern Literal-Suffixe. Zu Variablensuffixen gibt es auch viel zu erzählen, aber das ist ein anderes Thema ...

Literalsuffixe sind - gerade bei "float" - extrem wichtig!

Wenn du einen double-Literal nutzt, um eine float-Variable zu initialisieren oder einen neuen Wert zuzuweisen (oder umgekehrt), dann kommt es intern zu einem impliziten Casting, der in sehr vielen Fällen einige Bits Datenverlust mit sich führt.

Demonstration:

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

int main(void) {
	using namespace ::std;

	cout << boolalpha;

	float a = 0.1234f;
	cout << "a: " << (a == 0.1234f) << endl;

	float b = 0.1234;
	cout << "b: " << (b == 0.1234) << endl;
}

Die Ausgabe lautet:

a: true
b: false

Und das nur, wegen dem ollen Suffix! Gemein, oder? Guck dir bitte ganz genau an, welche Literale über ein angehängtes "f" verfügen, und welche nicht!

Der obige Effekt ist übrigens einer der Gründe dafür, warum man Gleitpunktzahlen niemals direkt mit "==" auf Gleichheit prüfen sollte, aber das nur am Rande ...

Wie du siehst, ist dieses "sinnlose" Suffix doch manchmal gar nicht sooooooooo "sinnlos". :)

Fazit:

Wenn du innerhalb von Berechnungen / Algorithmen schwer auffindbare Fehler vermeiden willst, nutze immer die Suffixe (falls vorhanden), die zu deinen Variablentypen passen.

Das gilt insbesondere bei C++ noch viel stärker, als bei C, allein schon wegen der neuen universellen Initialisierung, der Überladung aus dem Beispiel von Isendrak oder noch extremer bei der Programmierung mit Templates. (Nichts dieser exklusiven C++ Features existiert bei C.)

Meine und die Antworten der anderen decken übrigens nicht alle Gründe FÜR die Literalsuffixe ab, es gibt dazu noch mehr zu wissen, aber ich will das hier jetzt nicht zu sehr in die Länge ziehen. (Habe unter der Antwort von PeterLustig1999 schon einen Roman verfasst ... sorry!) ><

Also dann ... schönen Tag noch! :)

...zur Antwort

Solange du ausschließlich in deinem eigenen Netzwerk rumfummelst, ist das überhaupt gar kein Problem.

Allerdings ist dein Mietserver bei irgendeinem Provider ausdrücklich NICHT dein eigenes Netzwerk, sondern einfach nur dein Server am öffentlichen Internet, und in so einem Falle verkneifst du dir bitte bestimmte Pentests, oder du darfst dich nicht wundern, wenn dir eine Anzeige ins Haus flattert.

Also sei dir bitte zu 100% darüber im klaren, worum es sich bei dem Begriff "dein eigenes Netzwerk" überhaupt handelt, bevor du anfängst.

...zur Antwort

Beide Verfahren funktionieren komplett unterschiedlich, und weil RSA extrem rechenaufwändig ist, wird meistens nur der Schlüssel für einen der AES-Algorithmen damit verschlüsselt, um damit anschließend wiederum die eigentlichen Daten ver- und entschlüsseln zu können.

Außerdem ist AES ein Blockchiffre und um das selbe mit RSA schaffen zu können, müsste man einen nicht sonderlich optimalen / effizienten der vielen Betriebsmodi nutzen.

Kauf dir mal dieses Buch, und lies es dir durch:

https://www.amazon.de/Kryptografie-Verfahren-Protokolle-Infrastrukturen-iX/dp/3864903564/ref=sr_1_2

Ist recht dick, aber auch recht anspruchslos. Mathematik brauchst du dafür fast gar keine, und wenn du mehr ins Detail gehen willst, solltest du danach noch andere Bücher lesen. Nichtsdestotrotz bietet es einen sehr guten Überblick über das Thema, und du wirst danach auch wissen, warum man deine Frage eigentlich nicht beantworten kann.

Um Grundbegriffe wie S-Boxen oder Feistelchiffre verstehen, und den grundlegenden Aufbau gängiger Algorithmen nachvollziehen zu können, ist das Buch aber sehr gut geeignet. Es hat zwar viele Seiten, liest sich aber auch ohne größeren Hirneinsatz sehr leicht.

Viel Spaß beim Lesen! ;)

PS: Deine Frage erinnert mich an meine Experimente mit großen Schlüssellängen. Der hier hat 32768 Bit:

-----BEGIN PUBLIC KEY-----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-----END PUBLIC KEY-----

GPG hat Probleme damit, solche großen Schlüssel zu erzeugen, weshalb man erst eine total sinnlose Prüfung auf einen Maximalwert (von 8192 glaube ich) rauspatchen muss, aber danach kommt sowohl GPG als auch OpenSSL und auch alle anderen Softwaren damit klar. :)

...zur Antwort

Die anderen Antworten mit <climits> bzw. <limits.h> beziehen sich auf die veralteten Makrodefinitionen aus C-Zeiten und sollten ausdrücklich nicht mehr genutzt werden. Zumal du diese nicht bei der Template-Programmierung einsetzen kannst und sie viele weitere Nachteile mit sich bringen.

Nutze bei C++ bitte ausschließlich "numeric_limits" aus <limits>, so wie aus der Antwort von "Destranix".

Beispiel um den Minimal- und Maximalwert eines Integers auszugeben:

#include <iostream> // cout, endl
#include <limits> // numeric_limits

// ...

using namespace ::std;

cout << "int min: " << numeric_limits<int>::min() << endl;
cout << "int max: " << numeric_limits<int>::max() << endl;

Beachte auch die anderen praktischen Member des numeric_limits-Templates hinter dem Link aus Destranix' Antwort. :)

Schönen Tag noch! :)

...zur Antwort

Ich finde die Aufgabenstellung etwas merkwürdig, da sie gerade für Anfänger nicht lösbar ist. Sogar für viele Fortgeschrittene dürfte die Aufgabe ohne schmutzige Tricks kaum lösbar sein.

Hier ist mein Ansatz mithilfe der Reflection-API:

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

public class Main {

	private static String findValueFieldName() throws Exception {
		for (final Field field : Integer.class.getDeclaredFields()) {
			if (!Modifier.isPrivate(field.getModifiers())) {
				continue;
			}

			final Class<?> type = field.getType();
			if (!type.isPrimitive() || !type.toString().equals("int")) {
				continue;
			}

			return field.getName();
		}

		throw new RuntimeException("no value field found");
	}

	public static void swap(Integer a, Integer b) throws Exception {
		final String valueName = findValueFieldName();

		Field valField = Integer.class.getDeclaredField(valueName);
		valField.setAccessible(true);

		Field modField = Field.class.getDeclaredField("modifiers");
		modField.setAccessible(true);

		modField.setInt(valField, valField.getModifiers() & ~Modifier.FINAL);

		final Integer tmp = new Integer(a);

		valField.set(a, b);
		valField.set(b, tmp);
	}

	public static void main(String[] args) throws Exception {
		Integer a = 123;
		Integer b = 456;
		System.out.printf("a = %d; b = %d\n", a, b);

		swap(a, b);
		System.out.printf("a = %d; b = %d\n", a, b);
	}

}

Dabei mache ich mir das java-typische Autoboxing zunutze. Die Ausgabe lautet:

a = 123; b = 456
a = 456; b = 123

Dazu noch folgende Bemerkungen:

  • Ja, ich weiß, dass man einem Entwickler dafür den Kopf abreißen sollte, wenn er so anfängt. :)
  • Ein Anfänger muss das noch lange nicht nachvollziehen können.
  • Die Funktionsweise ist sehr fragil und hängt sowohl von der Implementierung einiger Klassen im JRE als auch den Optimierungen des Compilers ab. (Deshalb auch notgedrungen die merkwürdige Deklaration der Variablen "tmp", die normalerweise vom Compiler wegoptimiert wird.)
  • Ich werde das Gefühl nicht los, dass die Aufgabe einfach nur total schlecht formuliert ist ... kann mir beim besten Willen nicht vorstellen, dass es sich um eine Frage für Einsteiger handeln soll.

Naja, viel Erfolg noch beim Lernen, und lass dich bitte nicht vom obigen (grauenhaften) Reflection-Code abschrecken. Normalerweise läuft dir so etwas bei ordentlicher Programmierung eigentlich niemals über den Weg. Nimm meinen Code einfach als "schlechtes und abschreckendes" Beispiel! ;)

Schönen Tag noch! :)

...zur Antwort
[...] ich bräuchte ein Antivirenprogramm für mein[en] Laptop.

Sei dir bitte auch darüber im Klaren, dass es keine Antivirensoftware gibt, die auch nur annähernd 50% aller aktuellen Bedrohungen erkennt. Das gilt insbesondere für alle von dir aufgezählten.

Mit oder ohne Antivirenprogramm wird also sowieso spätestens jeder 2te "Angriff" erfolgreich verlaufen.

Sei lieber vorsichtig, lerne wie man einen AdBlocker nutzt und halte dein System auf dem neuesten Stand. Allein mit diesen drei Hinweisen wirst du wesentlich sicherer unterwegs sein, als mit jedem Antivirenprogramm.

Außerdem sind diverse Antivirenprogramme immer wieder in den Schlagzeilen, weil sie durch schlampige Programmierung dein System wesentlich unsicherer machen, als ohne sie.

PS: Bitte beachte auch, dass 99% der Leute, die dir hier eine Antivirensoftware empfehlen, selbst über kein Fachwissen im Bezug auf Schadsoftware verfügen, und einfach nur die bunten Werbeanzeigen der Hersteller nachplappern!

...zur Antwort
abfallstoff abscheidungsstoff absorptionsfarbstoff 
abwehrstoff adsorbatimpfstoff allergiestoff alpakastoff 
anilinfarbstoff ansteckungsstoff anstrichstoff anzugstoff 
aromastoff arsenwasserstoff augenreizstoff ausgangsstoff 
auslegungsbrennstoff bambuszellstoff bandagenstoff 
basisrohstoff bastelklebstoff baumwollhalbstoff 
baumwollstoff baumwollzellstoff baustoff bauststoff 
bedruckstoff bergangswerkstoff berträgerstoff 
beschichtungsstoff betonzuschlagstoff betriebsstoff 
bezugsstoff biokraftstoff bisulfitzellstoff bitterstoff 
blattinhaltsstoff blaufarbstoff blutfarbstoff 
bodennährstoff bootsverdeckstoff bremsbelagklebestoff 
brennstoff brokatstoff buchbinderklebstoff chemierohstoff 
chlorkohlenwasserstoff chlorwasserstoff chromfarbstoff 
cyanacrylatklebstoff cyanwasserstoff dekostoff dichtstoff 
dieselkraftstoff direktfarbstoff dispersionsklebstoff 
dotierungsstoff druckwasserstoff duftstoff düsentreibstoff 
eigenimpfstoff eisenwerkstoff elastikstoff 
elastomerwerkstoff elektroisolierstoff elektronikgrundstoff 
elektronikklebstoff energierohstoff epoxidharzklebstoff 
ersatzbrennstoff explosivstoff farbstoff faserstoff 
faserverbundwerkstoff feststoff filzstoff 
fleischersatzstoff fremdstoff füllstoff füllsüßstoff 
futterstoff gallenfarbstoff gärungsstoff gefahrstoff 
gelbfieberimpfstoff gerbstoff gerinnungsstoff geruchsstoff 
geschmacksstoff geschmackstoff gesprächsstoff giftstoff 
grundstoff grundwerkstoff gummistoff harnstoff hemdenstoff 
hemmstoff hilfsstoff holzwerkstoff hopfenbitterstoff 
hornstoff huminstoff impfstoff inlettstoff isolierstoff 
isolierwerkstoff jacquardstoff jeansstoff kampfstoff 
kationfarbstoff kernbrennstoff klebstoff kohlenstoff 
kohlenwasserstoff konfliktstoff konservierungsstoff 
kontaminationsstoff kraftstoff krankheitsstoff 
kühlschmierstoff kunststoff küpenfarbstoff 
lebensmittelfarbstoff lebensmittelrohstoff 
lebensmittelzusatzstoff lehrstoff leichtzuschlagstoff 
lernstoff lesestoff leuchtstoff luftschadstoff mineralstoff 
monotreibstoff nährstoff nahrungskettenschadstoff 
oberstoff ottokraftstoff plastiksprengstoff prüfungsstoff 
raketentreibstoff reaktivfarbstoff reaktorwerkstoff 
reizstoff reststoff rohbrennstoff rohstoff rötelnimpfstoff 
rötelnlebendvirusimpfstoff sauerstoff säurefarbstoff 
schadstoff schaumkunststoff schaumstoff schichtpressstoff 
schichtpreßstoff schichtstoff schmierstoff schmutzstoff 
schutzstoff schwebstoff schwefelfarbstoff 
schwefelkohlenstoff schwefelwasserstoff 
schweißzusatzwerkstoff seidenstoff sicherheitssprengstoff 
spengstoff sprengmittelkennstoff sprengstoff spurenstoff 
stickstoff stoff suchtstoff süßstoff 
tetrachlorkohlenstoff trägerstoff treibstoff trockenstoff 
unterrichtsstoff urstoff velourstoff verbandstoff 
verbundwerkstoff verseuchungsstoff vliesstoff wasserstoff 
weichstoff werkstoff wertstoff wirkstoff wollstoff 
zellstoff zündstoff zusatzstoff zuschlagsstoff 
zuschlagstoff zwischenlagenwerkstoff 
...zur Antwort

Für Kali-Linux reicht auch ein mehrere Jahre alter gebrauchter Laptop für 20€ bis 30€ völlig aus, und es wird absolut flüssig laufen.

Ich nutze zwar kein Kali, aber diverse andere Linuxe und BSDs laufen bei mir auf Rechnern von 2008 absolut problemlos ... und ab und zu mal einen Videostream gucken geht auch Problemlos damit.

Fazit: Für dein Budget von 200€ bis 300€ bekommst du bei eBay gleich 10 ausreichende Laptops! ;)

PS: Ein RasPi oder andere Einplatinencomputerchen sind auch schicke Alternativen, falls du mal irgendwas auf einer ARM-Plattform ausprobieren willst. :)

...zur Antwort

Umgangsspachlich hört man fast täglich irgendwo "ドジ" oder "ドジっ子". Ein anderes sehr häufig verwendetes Wort wäre "おちょこちょい".

Beide bedeuten u. a. "tollpatschig" bzw. "Tollpatsch" und dürften in den meisten Fällen nicht böse, sondern eher liebevoll gemeint sein. (Wenn man jemanden wirklich beschimpfen wollen würde, müsste man etwas anderes wählen.)

...zur Antwort

Du verwendest grundsätzlich die Datentypen, die am besten geeignet sind. Und was genau "geeignet" bedeutet, hängt vom Einzelfall ab. :)

Als grobe Richtlinien kannst du folgende Hinweise beachten, die sich wohlgemerkt nicht ausschließlich auf die reinen Typen beziehen:

  • Keine Gleitkommatypen als Zählvariablen in Schleifen verwenden.
  • Niemals Gleitpunkttypen mit "==" vergleichen.
  • Variablen (egal welchen Typs) immer als "const" deklarieren, falls diese später nicht mehr geändert werden. Das gleiche gilt für Funktionsparameter. "Recycling" von Variablen vermeiden.
  • Ganzzahltypen immer so klein wie möglich wählen, aber so, dass der höchstmögliche Wert des vorliegenden Anwendungsfalls immer noch darin Platz findet.
  • Vorzeichenbehaftete Typen nur dann nutzen, wenn Vorzeichen auch benötigt werden.
  • Bei einer Division von Vorzeichenbehafteten Ganzzahlen nicht nur darauf prüfen, ob der Divisor Null ist, sondern auch, ob dieser den Kleinstmöglichen Wert darstellt. (Im Falle von "int" wäre das dann INT_MIN aus <limits.h>)
  • "char" oder "int" (auch als "unsigned") verwenden, wenn es auf Geschwindigkeit ankommt. (siehe dazu auch die [u]int_fastX_t Typdefinitionen aus <stdint.h>)
  • Einen Index mit kleinem Typen (z. B. "unsigned char") in eine Tabelle einem "dicken" Zeiger vorziehen, vor allem, wenn es sehr viele davon gibt. (z. B. Bitmaps mit Farbpalette)
  • Eventuell Festkomma-Aritmetik mit stinknormalen Integern in Betracht ziehen.
  • Falls nötig, Bibliotheken für sehr große Typen mit beliebiger Genauigkeit nutzen. (gibt es sowohl für Ganz- als auch Gleitpunktzahlen)
  • Unter Umständen mit Nibbles und Shifting / Maskierungen arbeiten, wenn es auf Speicherplatz ankommt. (Denke auch an Dinge wie BCD-Zahlen.)
  • Nicht vergessen, dass es auch (nicht Standard-C) Minifloats (oft 8 oder 16 Bit breit) und Gleitpunkttypen mit erweiterter Genauigkeit (meist 80 oder 128 Bit breit) gibt, je nach Compiler- und Plattform-Unterstützung.
  • Nutze für weitestgehende Plattformunabhängigkeit die Typdefinitionen aus <stdint.h>, falls du nicht auf ein eingeschränktes Subset von C angewiesen bist.
  • Verwende NIEMALS wchar_t von C++. (falls du nach C irgendwann mal auf C++ umsattelst)
  • Die Schlüsselwörter "auto", "volatile" und "register" nicht nutzen, es sei denn, du weißt genau, dass diese veraltet sind, was sie bedeuten, und kannst Nebeneffekte einschätzen.
  • Lerne die Eigenheiten und Unterschiede von / zwischen Zeigern und Arrays.
  • Beschäftige dich damit, was Speicherklassen sind, wie Paging funktioniert, was W^X oder ASLR heißt, was ein Program-Break ist und denke immer daran, dass es neben Stack und Heap auch noch allerhand "andere" Segmente gibt.
  • Informiere dich, was ptrdiff_t aus <stddef.h> mit void-Zeigern zu tun hat.
  • Setze das "restrict" Schlüsselwort sinnvoll ein, wenn du mit Puffern arbeitest.

... das sind aber alles keine feststehenden Naturgesetze, und u. U. kann / sollte / darf / muss man dagegen verstoßen. Mit der Zeit wirst du ein Gefühl dafür bekommen.

Viele der obigen Punkte werden ich jetzt vermutlich erschlagen, aber du musst diese (noch lange nicht vollständige!) Liste ja auch nicht an einem Abend durchackern. :)

Ich weiß, dass Code-Beispiele mehr als tausend Worte sagen, aber ich habe jetzt keine Zeit mehr, mir zu jedem der obigen Punkte ein Snippet aus den Fingern zu saugen. Falls noch Fragen offen sind, und ich nicht auf Kommentare reagieren sollte (habe in letzter Zeit viel zu tun) stell hier einfach direkt auf GF noch eine weitere Frage zu dem Thema ... irgendjemand wird dir schon Antworten. :)

Viel Spaß! :)

...zur Antwort