Huhu Leute,
ich bin es mal wieder 
Ich soll ein Programm erstellen was eine Zahl zwischen -100 und 100 auswählt und damit dann eine bestimmte Aufgabe löst
Da ist mein Problem: Was muss ich tun damit die Zahl zwischen -100 und 100 liegen kann ? Es soll zufällig sein.
Math.random() ← das ist mein einziger Hinweis. Ich weiß auch wie ich Zahlen zwischen 0-100 kriege, aber nicht zwischen -100 - 100. Jemand ein Tipp?
Ich bedanke mich!
MFG Queblo
würde dir eine Zufallszahl aus dem Bereich 0-200 irgendwie helfen? 
ein Thementitel ‚Aufgabe wie zu lösen?‘ ist reichlich aussagelos, geändert
Mal eine völlig verrückte Idee: Wie wäre es, wenn du eine Zufallszahl von 0 bis 200 erzeugst, und dann davon 100 abziehst?
@SlaterB
Entschuldigung kommt nicht mehr vor 
Ach mann ich Idiot
@Landei
Daran habe ich echt nicht gedacht Oh man…hab da deutlich komplexer gedacht
Ich danke euch beiden
Anscheinend nicht komplex genug
Okay, Werdegang den weiß ich jetzt nicht. Aber hierbei bedenken, was ist die Mitte von 200? gerade, ungerade. Und dann brauchst du eine Zahl/Wert zwischen 0 und exklusiv 201.
((int) (Math.rand() * 201.0)) - 100 z. B. oder new Random(). 100, 0 und/oder -100 ist möglich (~ Test).
Wenn du wirklich ganze Zahlen zwischen -100 und 100 haben möchtest, die beide Grenzen mit einschließen, musst du ein bisschen aufpassen.
Möglich wäre auf jeden Fall, wenn du eine zwischen 0 und 100 bestimmen kannst, mit einer zweiten Entscheidung das Vorzeichen zu vergeben.
Wobei man sich dann beachten muss, dass die Null mit “+0” und “-0” doppelt so oft auftreten kann wie jede andere Zahl.
Tipp für Anfänger: immer genau die Doku lesen…
Man will Zahlen von (einschließlich) -100…100, aber was man implementiert hat liefert möglicherweise -99…101 oder -100…99 oder -101…99 oder…
Das ist ein schwer zu entdeckender Fehler, denn man braucht sehr viele Tests, bis der Fehler mal auftaucht
eine kühne Aussage, wo es doch schon im ersten der Fall sein kann 
oder für -100…99 nie, jedenfalls kein Wert außerhalb des Wertebereichs (falls dieser -100…100 ist)
Mit Testen meine ich, dass man -100…100 dadurch testet, dass man solange prüft bis die -100 und die +100 gefallen sind. Angenommen du würdest zufällig die Zahlen 1,2,3,4,5 auswählen wollen. Ein Test, der nicht prüft, ob 1 und 5 tatsächlich vorkommen ist wertlos, ob die Zufallszahlen lediglich im Intervall liegen 1 <= x <= 5 ist zwar nett (von daher sind viele schon zufrieden damit :-), aber irgendwie zu wenig.
Für das Testen muss man den Zufall raus nehmen. Ich würde dem eigenen Random-Generator ein java.util.Random-Objekt als Konstruktor-Parameter mit geben, dann kann ich das im Test gegen ein Fake-Objekt austauschen, dass eben keine zufälligen Werte zurück gibt und mit dem sich dann die Grenzen testen lassen.
ich stelle mir das so vor:
[spoiler]```public class RandomTest {
private class FakeRandom extends Random { /* innere Klasse im Test, nicht static! */
private final int resultOfJavaUtilRandom;
FakeRandom(int resultOfJavaUtilRandom) {
this.resultOfJavaUtilRandom = resultOfJavaUtilRandom;
}
@Override
public int nextInt(int upperBound) {
upperBoundPassedToRandom = upperBound;
return resultOfJavaUtilRandom;
}
}
private int upperBoundPassedToRandom;
@Test
public void testGetNextRandom_whenJavaUtilRandomReturns0_minus100() {
final int resultOfJavaUtilRandom = 0;
Random fakeRandom = new FakeRandom(resultOfJavaUtilRandom);
ProductionRandomGenerator generator = new ProductionRandomGenerator(fakeRandom);
int randomInt = generator.getRandomInt();
assertEquals("upper bound passed to Random Object",
ProductionRandomGenerator.UPPER_BOUND, upperBoundPassedToRandom);
assertEquals("calculated Randon Number", -100, randomInt);
}
@Test
public void testGetNextRandom_whenJavaUtilRandomReturns200_plus100() {
final int resultOfJavaUtilRandom = ProductionRandomGenerator.UPPER_BOUND - 1;
Random fakeRandom = new FakeRandom(resultOfJavaUtilRandom);
ProductionRandomGenerator generator = new ProductionRandomGenerator(fakeRandom);
int randomInt = generator.getRandomInt();
assertEquals("upper bound passed to Random Object",
ProductionRandomGenerator.UPPER_BOUND,
_upperBoundPassedToRandom);
assertEquals("calculated Randon Number", 100, randomInt);
}
}
// produktiver Code
class ProductionRandomGenerator {
static final int UPPER_BOUND = 200;
private final Random random;
public ProductionRandomGenerator(Random random) {
this.random = random;
}
public int getRandomInt() {
// diese Implementierung ist bewuss falsch!
// nach den KISS-Prinzip dürfte man aber nicht darauf kommen…
switch (random.nextInt(UPPER_BOUND)) {
case 0:
return -100;
case 199:
return 100;
default:
return 0;
}
}
}```[/spoiler]
bye
TT
Also ich würde sagen int zahl = (int) ((Math.random() * 201) - 100) reicht vollkommen aus, da Math.random() definitiv nur Werte zwischen 0 inklusive und 1 exclusive liefert.
Genau deshalb habe ich das ja geschrieben: 201 und nicht 200, na so was! Das ist gerade die Fehlerquelle für Anfänger.
Hoffentlich geht es jetzt nicht darum, eine Zufalls"schaltung" “zu testen”. ~ 100 tritt nach ganz vielen Durchlaufen nicht auf => falsch.
Aber sich double bits einmal zu visualisieren, “63 zufällige Bits”, kann auch schon sehr helfen. @ TT : Danke für Deinen Test.
Ja, Testen, entsprechend dem Klassiker Dilbert Comic Strip on 2001-10-25 | Dilbert by Scott Adams
Ansonsten gibt es natürlich durchaus Tests, die erkennen, ob etwas wirklich einer Gleichverteilung entspricht, oder signifikant (sic!) davon abweicht, da kann man bei Kontingenztafel – Wikipedia anfangen zu suchen (und beliebig weit in die Tiefe gehen, was ich bisher noch nicht getan habe…)
[quote=Marco13]Ja, Testen, entsprechend dem Klassiker Dilbert Comic Strip on 2001-10-25 | Dilbert by Scott Adams[/quote]Deshalb testet mein Test ja auch nicht den Zufallsgenerator von Java (dem gestehe ich nämlich eine ausreichende Betrieberprobung zu), sondern den Algorythmus, mit dem die Zufallszahl in den geforderten Wertebereich übersetzt wird…
bye
TT
Fixed it.
Hat nichts mit „Rhythmus“ zu tun, sondern mit Herrn al-Chwarizmi. Und für alle, die das für Haarspalterei halten: Würdet ihr einem Arzt trauen, der „Operazion“ schreibt?
[OT][quote=Landei]Algorithmus …
Fixed it.[/quote]Danke!
Ging mir früher in der Schule schon so: Inhalt/Ausdruck = 1, Form = 3, Rechschreibung/Grammatik = 5.
bye
TT[/OT]
[OT]Ich hab ja auch “Durchlaufen” anstatt Durchläufen geschrieben, mit dem Handy ist das manchmal 3x schwieriger. Rechtschreibprüfung hilft
und/oder == auch falsch, eine Methode kann ja nicht 3 Zahlen gleichzeitig zurückgeben.
Um die 100 (Werte) ist doch praktisch nicht sooo viel, hier könnte man -101, -100, -99, -98, 0, 98, 99, 100 und 101 testen. Will nicht immer das letzte Wort habn[/OT]
[OT]Edit: Nur genau ein Methodenaufruf kann nicht mehrere “Zahlen” zurückgeben, ein “Objekt” kann hingegen schon zurückgegeben werden, ohne Parallelität
Test (im Bereich -3 bis +3 [#7
[spoiler]):"]```import java.util.*;
public static void main(String[] args) {
Random r = new Random();
int[][][] iaaa = new int[10][7][2];
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 7; j++) {
iaaa**[j][0] = j - 3;
}
}
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 100; j++) {
if (j % 2 == 0) {
iaaa**[(int) (Math.random() * 7.0) - 3 + 3][1]++;
} else {
iaaa**[r.nextInt(7) - 3 + 3][1]++;
}
}
}
for (int[][] iaa : iaaa) {
Arrays.sort(iaa, new Comparator<int[]>() {
@Override
public int compare(int[] o1, int[] o2) {
return Integer.valueOf(o1[1]).compareTo(o2[1]);
}
});
}
/*Arrays.sort(iaaa, new Comparator<int[][]>() {
@Override
public int compare(int[][] o1, int[][] o2) {
return -Integer.valueOf(o1[0][0]).compareTo(o2[0][0]);
}
});*/
System.out.println("In der (ersten) Spalte sollte kein Muster stehen:");
System.out.println("In der (ersten) Spalte sollte nur -3..+3 stehen:");
for (int[][] iaa : iaaa) {
System.out.println(Arrays.deepToString(iaa));
}
}```[/spoiler]
[/OT]
*** Edit ***
Jetzt kann ich wieder nich editieren, also man zählt die Zufallszahlen, da sollten “vernünftige” Zahlen eingetragen werden:
int[][][] iaaa = new int[28][7][2];```
``` for (int i = 0; i < iaaa.length; i++) {```
``` for (int i = 0; i < iaaa.length; i++) {
for (int j = 0; j < 100000; j++) {
if (j % 2 == 0) {```
``` // nach Zelle sortieren
for (int[][] iaa : iaaa) {
Arrays.sort(iaa, new Comparator<int[]>() {```
``` // nach Spalte sortieren
Arrays.sort(iaaa, new Comparator<int[][]>() {```
So, und dann **sollte gelten**:
Die Anzahl(en) in der ersten Spalte sollten nicht wirklich klein sein.
Alle Zahlen aus -3 bis 3 sollten vorhanden sein.
Jede Zahl aus -3 bis 3 sollte nicht wirklich selten und/oder wirklich oft vorhanden sein.
wirklich == "wesentlich". sChönen Samstag.