Die Behauptung ist falsch. Und der Beweis dafür liefert ein einfaches Gegenbeispiel:



Eine Nullstelle ist da, wo die Funktion f(x) = 0 ist. Das setzt du dann einfach ein und löst nach x auf:

 Wenn du also x=3 in die Funktion einsetzt kommt 0 heraus:

 Somit ist deine Nullstelle bei x=3 und (logischerweise) bei y=0

Du nimmst als eigentlich immer deine Funktion, setzt sie mit 0 gleich und löst nach x auf. Zur Probe kannst du das herausgefundene x in die Funktion einsetzen und du müsstest 0 als Ergebnis erhalten

Wie du schon weißt, erbt jede eigene Klasse von der Klasse Object. Nun enthält die Klasse object zum Beispiel eine equals Methode, die man überschreiben kann:

public boolean equals(Object obj)

Du kannst im Prinzip jedes Objekt jeder Klasse übergeben.

Stell dir vor du hast eine Klasse Lehrer mit den Attributen vorname und nachname.

Dann kannst du innerhalb der Lehrer Klasse die equals Methode überschreiben und ein beliebiges Objekt einer beliebigen Klasse mit dem Lehrer Objekt zu vergleichen:

public class Lehrer() {
	public String name;
	public String nachname;
	
	public Lehrer(name, nachname) {
		this.name = name;
		this.nachname = nachname;
	}




	public boolean equals(Object obj){
		// Wenn obj auch ein Objekt der Klasse Lehrer ist
		if (obj instanceof Lehrer) {
			//obj nach Lehrer casten, da die Klasse Objekt nicht die Attribute name, nachname hat
			Lehrer obj_L = (Lehrer) obj
			// Vergleiche Vor- und Nachname und gebe das Ergebnis zurueck
			return (this.name.equals(obj_L.name) && this.nachname.equals(obj_L.nachname));
        }
		// Wenn obj ein Objekt einer anderen Klasse ist, kann es nicht gleich sein.
        return false;
      }
    }

Ja, du hast ja im Prinzip

 Somit stehen die Summanden alleine und man sieht direkt, dass man kürzen darf.

Wenn einer der Summanden kein x als Faktor hätte, sähe es so aus:



Du könntest in der Methode die Liste einmal durchlaufen und immer die Zeiten vergleichen.

Wenn die Zeit des gerade in der Schleife betrachteten Elements größer (oder gleich?) als die Zeit des einzufügenden Elements ist, fügst du das Element davor ein und brichst die Schleife ab bzw. beendest die Funktion/Methode mit einem return.

Sollte es kein Element geben, welches eine größere Zeit hat als das einzufügende Element (Also du Schleife ist einmal durchgelaufen), dann fügst du es am Ende ein.

Pseudocode:

abl_time = abl.time
for (index, element in liste)
  if (element.time >= abl_time)
    liste.insert(abl, index) // in Java wäre es liste.add(index, abl)
    return;
liste.append(abl)

Ein Ladezyklus ist ein Ladevorgang von 0% auf 100%, der also im Prinzip eine ganze Akkukapazität beinhaltet. Lädst du von 30% auf 80% auf lädst du quasi nur 50%, was ungefähr einem halben Ladezyklus entspricht. Das ganze ist eigentlich nicht linear, aber man kann es so annähern.

Wenn du jetzt dein Handy zweimal von 30 auf 80 lädst, dann wäre das ein Ladezyklus, was genau so viel wäre, wie den Akku einmal von 0 auf 100 zu laden.

Sprich, du lädst zwar öfter, aber nicht wirklich "mehr". Und da die Akkus in den extremen Ladezuständen mehr leiden also irgendwo in der Mitte, lebt der Akku im Schnitt länger bzw. hält seine Kapazität langer, wenn man ihn nicht in die Extreme kommen lässt.

Dem Akku schadet es also nicht , wenn du ihn zwar öfter auflädst, aber außerhalb der Extreme bleibst.

Wenn ich es richtig sehe brauchst du die Nullstellen an sich gar nicht berechnen, sondern nur angeben, wie man k wählen muss, dass sich gewisse Nullstellen ergeben.

Also wenn man den Graphen als gegeben betrachtet, also dass die Variablen a und b so gegeben sind, dass der Graph genau so aussieht wie abgebildet, also Nullstellen bei x=~-1,5 und x=~1,5 und eine doppelte bei x=0 (wobei das bei der Analyse erstmal egal ist, wo sich die beiden Nullstellen befinden) mit k=0, sowie die Extrempunkte bei (-2,2) und (2,2) sowie(0,0). Dann kann man folgendes sagen:

Um 4 beliebige Nullstellen zu erhalten, muss man k irgendwo im Intervall (-2,0) wählen (also ohne -2 und 0!). Dabei wird der Graph ja einfach nur nach unten geschoben, wobei die "Hochpunkte" sich noch immer oberhalb der x-Achse befinden! und es bilden sich 4 Nullstellen.

Um nur 2 einfache Nullstellen zu bekommen, wählt man k im Intervall (0, unendlich) oder anders gesagt k>0, dann wird der Graph nach oben verschoben und die Extremstelle bei (0,0) befindet sich oberhalb der X-Achse.

Für zwei doppelte Nullstellen schieben wir den Graphen so nach unten, dass sich die beiden "Hochpunkte" genau auf der X-Achse befinden. Das geschieht, indem wir k=-2 setzen, da die beiden Extrempunkte sich bei y=2 befinden.

Um keine (reelle) Nullstelle(n) zu erhalten, verschiebt man den Graph weiter nach unten, wählt also k im Intervall (-2, unendlich), also k< -2.

Das wäre die Analyse ohne die Parameter a und b der Funktion explizit zu kennen, du kannst aber anhand des Graphen trotzdem versuchen die explizite Funktion zu berechnen und meine Werte/Intervalle für k ausprobieren.

Hier mal mein Lösungsweg für die Aufgabe

Ich nehme mal an mit viel Bits und wenig Bits sind Redundanzbits gemeint, also zusätzliche Bits anhand derer man erkennen kann, ob (und ggf. wo ungefähr) sich bei der Datenübertragung Fehler eingeschlichen haben.

Wenig Bits:

Ein Vorteil ist die Übertragungsgeschwindigkeit, die - unter sonst gleichen Bedingungen - schneller sein sollte als bei einer Übertragung mit vielen (Redundanz-)Bits
Ein Nachteil wäre - je nachdem welches Verfahren man nutzt - dass die Fehlererkennung schwächer sein kann, also Fehler zum Beispiel gar nicht entdeckt werden. Hier als Stichwort zum Beispiel Paritätsbit.

Viele Bits:

Vorteil wäre, dass Fehler bei der Übertragung besser erkannt werden können. Man könnte zum Beispiel Redundanzbits für die Redundanzbits nutzen, was die Fehlererkennung verbessern könnte.

Nachteil ist, dass logischerweise mehr Daten gesendet werden und die Übertragung länger dauert.
Außerdem können ja auch die Redundanzbits Fehler nach der Übertragung enthalten und dann kann ein Fehler erkannt werden, obwohl die Originaldaten womöglich sogar richtig angekommen sind, oder es wird kein Fehler erkannt, obwohl es einen Fehler gab, weil zufällig die gleichen Bits in Original und Redundanz gedreht wurden.

Das ist im Prinzip egal, denn es geht letztendlich um das Verhältnis der Werte und diese bleiben immer gleich, egal wie groß oder klein das Dreieck ist bzw. an welcher Position entlang der Gerade es sich befindet. Du könntest es also auch bei x=2, y=8 einzeichnen.

Das Dreieck gibt einem ja das Verhältnis

(y2-y1) / (x2-x1) = Steigung der Geraden

Du kannst für die Punkte (x1, y1) und (x2, y2) also beliebige (zu der Geraden gehörenden!) Werte einsetzen.

Zum Beispiel

x2=5, y2=20 und x1=4, y1=16

(20-16) / (5-4) = 4

Oder

x2=5, y2=20 und x1=2, y1=8

(20-8) / (5-2) = 12/3 = 4

Bei manchen neueren Spielen gibt es in dem Grafikoptionen eine Einstellung - DRS oder Dynamic Resolution Scaling - oder zu deutsch Dynamische Auflösungsskalierung.

Damit wird bei in berechnungsaufwendigen Bereichen/Szenen die Auflösung verringert, damit man keinen (starken) Leistungseinbruch hat und eine stabilere Framerate hat.

Ich besitze FH5 nicht, aber ich kann mir gut vorstellen, dass dort so eine Einstellung existiert und bei dir aktiviert ist.

Alles was du aufgezählt hast wird früher oder später wichtig. Du solltest auch immer auf Vorzeichen achten, die sind oft Flüchtigkeitsfehler.

Und du solltest wissen was genau "Gleiche" bzw. ähnliche Ausdrücke überhaupt sind. Zum Beispiel:

Variablen mit gleichem Namen und gleichem Exponent sind ähnlich und können zusammengefasst werden (im Sinne von Addition und Subtraktion - je nach Vorzeichen der Ausdrücke) :

x ist ähnlich zu 2x, da der gleiche Exponent (x^1 = x)

x^2 ist ähnlich zu -6x^2, da gleicher Exponent (x^2 = x*x)

x ist nicht ähnlich zu x^2, da kein gleicher Exponent (x ungleich x*x)

x*y ist ähnlich zu 2x*y, da alle gleichen Variablen den gleichen Exponent haben

x*y ist nicht ähnlich zu x*y^2, da die beiden x zwar den gleichen Exponent haben, aber durch Multiplikation an das y gebunden sind, welches aber nicht die gleichen Exponenten hat (y ungleich y*y)

Wenn also vor einer Variablen eine einfache Zahl steht, ändert dies nicht die Ähnlichkeit eines Ausdrucks. Entscheidend sind die Exponenten der durch Multiplikation/Division an den Ausdruck gebundenen Variablen.

Beachte bitte die Vorzeichen!

4y*6 + 3*4 - 2y*3 - 5+2
24y + 12 - 6y - 10
Bis hier ist es noch richtig
Sortiere Gleiches zu gleichem und vergiss die Vorzeichen nicht!
+24y -6y +12 -10
18y + 2

Terme vereinfachen bedeutet im Prinzip nichts anderes, als gleiche Dinge entsprechend der allgemeinen Rechenregeln zusammen zu fassen. Oft hilft es auch gleiche Dinge erstmal zu sortieren. In deinem Beispiel also

4y*6 + 3*4 - 2y*3 - 5*2
Sortieren
4y*6 - 2y*3 + 3*4 - 5*2
Multiplikationen ausrechnen
24y - 6y + 12 - 10
Gleiches per Addition/Subtraktion Zusammenfassen
18y + 2

Wenn sich im Term Klammern befinden ist es auch sinnvoll diese erstmal aufzulösen/ausmultiplizieren/vereinfachen

Noch ein Beispiel:

3x - (x+y) - x*x + (x-1)*(x-1)
Erste Klammer auflösen:
3x - x - y - x*x + (x-1)*(x-1)
Ergebnis schonmal zusammen fassen
2x - y - x*x + (x-1)*(x-1)
Klammerausdrücke ausmultiplizieren (Binomische Formeln helfen) 
2x - y - x*x + x*x - 2x + 1
Gleiches zu Gleichem sortieren
2x - 2x - y - x*x + x*x + 1
Weiter zusammenfassen
0 - y + 0 + 1
Endergebnis
- y + 1
Endergebnis anschaulicher umsortiert
1 - y

Die Formel um das Volumen eines Quaders zu berechnen ist:

V = a*b*c

Nun stellst du die Formel nach der gesuchten Größe (in deinem Fall a) um und setzt die gegebenen Werte ein. Achte dabei auch unbedingt auf die Einheiten, also wenn du wie in b) cm und dm gegeben hast musst du vorher die Werte in eine der beiden Einheiten (oder z.B. alles in m) umrechnen, wobei es sich bei b) anbietet c in cm umzurechnen.

Befinden sich auf den anderen selbst gebrannten CDs auch Lieder im mp3 Format, oder haben diese ein anderes Format?

Mein Autoradio damals konnte zum Beispiel nicht mit mp3 umgehen und ich musste die CD nicht als MP3-CD (Dateiformat .mp3), sondern als Audio-CD brennen (Dateiformat .cda)
Das nervige daran ist, dass auf die CD dann nur im Schnitt 15-20 Lieder draufpassen, statt mehrere hundert wie bei mp3.

Wenn du dir den Term einmal ansiehst, solltest du erkennen, dass dort zwei Binome sind, die du direkt aufschreiben kannst:

(x+3)² = (x²+2*3*x+3²) | 1. Binomische Formel anwendbar
(x-2)² = (x²-2*2*x+2²) | 2. Binomische Formel anwendbar

Das Ganze kannst du nun wieder in den Term einsetzen, aber beachte: Da in dem Term vor dem zweiten Binom ein Minus steht, muss du da die Klammern setzen:

x²+6x+3² - (x²-4x+2²) | Klammern um das zweite Binom

Minus mal Minus ergibt Plus und Minus mal Plus ergibt Minus:

x²+6x+3² -x²+4*x-2² | Klammer auflösen

Und nun Gleiches zusammenfassen, also alles, was den gleichen Exponenten hat

x²-x² + 6x+4x + 9-4 = 10x + 5

Im Prinzip ist das nicht schwer, du musst nur die einzelnen Teile des Terms ausmultiplizieren, damit du das ² weg bekommst und dann alles was gleich aussieht zusammenrechnen. Oft hilft es vorher gleiches zu sortieren.

Wichtig: Der Dateiname der Java Datei, die du (compillieren und) ausführen willst, muss genau gleich heißen, wie die Klasse, die sie beinhaltet.

Wenn du versuchst die Chess.java mittels CMD auszuführen, musst du sie vorher in eine Chess.class compilieren. Das geht mit folgendem Befehl

javac Chess.java

Nun kannst du sie mit folgendem Befehl ausführen

java Chess 5

Wenn du dich in einer IDE befindest, also Eclipse, IntelliJ, etc. solltest du darauf achten, dass du die richtige Run Configuration ausgewählt hast. Ansonsten kann es sein (wie in dem letzten Bild zu sehen), dass die IDE versucht ein anderes (schon vorher irgendwann mal von dir ausgeführtes) Programm zu starten.

In Eclipse zum Beispiel kann man im Reiter Run -> Edit Run Configurations die Configurations ansehen und bearbeiten.

Dort erstellst du gegebenenfalls eine neue Configuration, vergibst ihr einen Namen und wählst die Hauptklasse mit der main Methode aus, die gestartet werden soll.

Danach, diese Config. auswählen und dein Programm sollte starten.

Wenn es in den Shaderoptionen nichts in der Richtung einzustellen gibt und du dich nicht zufällig mit der Programmierung von (GLSL-) Shadern auskennst, wirds problematisch.

Das sind deine WhatsApp Statistiken seit dem du WhatsApp nutzt. Die Netzwerkstatistiken zeigen dir nicht, was aktuell an Speicher auf deinem Handy verbraucht wird, sondern wie viel schon über das Internet versendet wurde. Löschen kannst du da nichts - es sind nur Statistiken.

Auf Google Drive werden Backups der Chats hochgeladen und ich vermute, dass bei dir täglich die Chats gesichert werden.

In den WhatsApp-Einstellungen unter Chats -> Chat-Backup siehst du zum einen wie groß dein Backup aktuell ist und wann zuletzt gesichert wurde. Unten kannst du dann einstellen wie oft, auf welches Konto und ob über Wlan und Mobile Daten, oder nur über Wlan gesichert werden soll.