Random bereich und for schleife

[MrClave]

Hallö'chen,

Ich habe derzeit 2 verschiedene Probleme, die mich beschäftigen.
Diese wären einmal eine Random Zahlenreihe beschränken (zB. 10 - 20) und das andere Problem wäre, wie ich mir endlich mal die for-Schleife merken kann, sprich, was genau ich in dieser deklarieren muss.

Random problem:

Bisher habe ich meine ersten Random Zahlenreihe so beschränkt:
Aufgabe aus der Schule = 10 Random Zahlen im Bereich 10, 20

public class RandomGenerator 
{
	public static void main(String[] args) 
	{
		int count = 0;
		int min = 10;
		int max = 20;
		
		while( count < 10 )
		{
			int zahl = min + (int) ( min - Math.random() * ( ( max - min) + 1) );
			System.out.println(zahl);
			count++;
		}
		
	}
}

Allerdings finde ich das ganze sehr umständlich und er gibt mir auch nur Zahlen von 10 bis 19 aus.
Hat jemand eine leichtere Methode, bzw. eine die man sich leichter merken kann ?
Ich weiß, dass es alles nur Übungssache ist, allerdings lernen wir zur Zeit soviel, dass ich mir einfach nicht alles einprägen kann gerade.

For-Schleife:
Jaaa, bisher habe ich da kein Beispiel für, allerdings kann ich mit dieser Schleife auch wenig anfangen, da ich sie schlichtweg nicht wirklich verstehe.
Hat jemand eine Erklärung, die man sich leicht merken kann ? So eine Art Eselsbrücke ?
Und wann genau brauch man eine for-schleife ?

Bin dankbar für jede Hilfe!

 

[pro2]

Zu deinem Random Problem:
Random (Java Platform SE 7 ))

the next pseudorandom, uniformly distributed int value between 0 (inclusive) and n (exclusive) from this random number generator's sequence

Das sollte helfen. 🙂

 

[ssoul26]

Random rand= new Random();
int zw = rand.nextInt(20); // Zahl zwischen 0 und 20
int zw2 = rand.nextInt(20)+20; // Zahl zwischen 20 und 40

 

[Schandro]

Erstmal grundsätzlich: Beim Programmieren geht es nicht um auswendig lernen, dass ist völlig unwichtig. Du musst die Logik hinter dem ganzen verstehen, dann kannst du dir alles selber zusammen bauen. Das ist der einzig richtige Weg.

Wegen den Zufallszahlen:

(int)(Math.random()*(max+1-min)+min)

Das gibt dir ein int zwischen inklusive min und inklusive max.

Wegen der for-Schleife:
Musst du einfach benutzen, dann wirst du schon bald merken wie sie funktioniert. Grundsätzlich kann man jede for-Schleife aber auch mit

while

schreiben:

		for(int i=0;i<5;++i) {
			System.out.println(i);
		}

ist genau dasselbe wie

		int i=0;
		while(i<5) {
			System.out.println(i);
			++i;
		}

(jedenfallls wenn man den scope von i ignoriert, dass braucht dich aber erstmal nicht zu interessieren)

 

[MrClave]

Zu deinem Random Problem:
Random (Java Platform SE 7 ))


Das sollte helfen. 🙂

Ich will ja keine Zahlen zwischen 0 und Y, sondern zwischen X und Y.
Und einige Teile der Codes hatten wir noch nicht im Unterricht, daher weiß ich gerade nicht genau, was ich damit anfangen soll ^^

 

[ssoul26]

Random rand= new Random();
int zw = rand.nextInt(20); // Zahl zwischen 0 und 20
int zw2 = rand.nextInt(20)+20; // Zahl zwischen 20 und 40

rand.nextInt(x) -> Zufallszahlen zwischen 0 und X. Wenn ich nun dazu ein Y addiere dann folgt->
rand.nextInt(x)+y -> Zufallszahlen zwischen x und y

 

[MrClave]

Erstmal grundsätzlich: Beim Programmieren geht es nicht um auswendig lernen, dass ist völlig unwichtig. Du musst die Logik hinter dem ganzen verstehen, dann kannst du dir alles selber zusammen bauen. Das ist der einzig richtige Weg.

Wegen den Zufallszahlen:

(int)(Math.random()*(max+1-min)+min)

Das gibt dir ein int zwischen inklusive min und inklusive max.

Wegen der for-Schleife:
Musst du einfach benutzen, dann wirst du schon bald merken wie sie funktioniert. Grundsätzlich kann man jede for-Schleife aber auch mit

while

schreiben:

		for(int i=0;i<5;++i) {
			System.out.println(i);
		}

ist genau dasselbe wie

		int i=0;
		while(i<5) {
			System.out.println(i);
			++i;
		}

(jedenfallls wenn man den scope von i ignoriert, dass braucht dich aber erstmal nicht zu interessieren)

Ja, da hast du recht ! 🙂
Könntest du mir vielleicht noch erklären, wie genau diese Zeile zustande kommt ? Ich selbst hatte diese nämlich auch nur von Google 😉
(int)(Math.random()*(max+1-min)+min)
typecasten und eine Zahl generieren und den Rest verstehe ich dann nicht wirklich.

Ok, nun wo du das Anhand der while Schleife erklärt hast, fange ich langsam an, die Logik hinter for zu verstehen.

 

[MrClave]

rand.nextInt(x) -> Zufallszahlen zwischen 0 und X. Wenn ich nun dazu ein Y addiere dann folgt->
rand.nextInt(x)+y -> Zufallszahlen zwischen x und y

Aber dann habe ich das Problem, dass X und Y nicht mit inbegriffen sind, sondern (X + 1) und (Y - 1)
Und ich komm' einfach auf keine annehmbare Lösung auf diese Weise :/

 

[Firephoenix]

bei

rand.nextInt(x)+y

ist y sehr wohl inbegriffen, es wird das intervall [y,y+x-1] erreicht.
willst du das Intervall [y,y+x] musst du nur x noch um 1 verschieben, also

rand.nextInt(x+1)+y

(Dokumentation der Methode lesen und kurz nachdenken dürfte hier aber schon reichen)

Gruß

 

[pro2]

Ich will ja keine Zahlen zwischen 0 und Y, sondern zwischen X und Y.
Und einige Teile der Codes hatten wir noch nicht im Unterricht, daher weiß ich gerade nicht genau, was ich damit anfangen soll ^^

Richtig. Aber wenn du doch weißt, dass du eine zwischen 0 (inklusive) und Y (exklusive) bekommst, dann wird es doch nicht mehr so schwer für dich sein, daraus X bis Y zu machen. 🙂
Lösung wurde aber eh schon gepostet.

 

[MrClave]

Irgendwie ja nicht...

Wenn ich das so schreibe, dann addiert er Y zu X und gibt mir Zahlen zwischen Y und (Y + X) aus.

int zahl = rand.nextInt(min)+max;

Das wollte ich ja nicht... Soll ja weiterhin zwischen und inklusive X und Y sein, was so nicht funktioniert.
Die Lösung habe ich, aber auf eine andere Weise, wie die obige.

Und bitte nicht zerfleischen 😉 Hab Welpenschutz!

EDIT:
Habe nun die Lösung auf diese Weise!

int zahl = rand.nextInt(min)+ (max-min+1);

 

[Firephoenix]

Da lag ich mit meiner ersten Antwort falsch, ich dache du willst X bis X+Y haben
Allerdings:

int zahl = rand.nextInt(min)+ (max-min+1);

ist nicht korrekt, rand.nextInt(min) produziert [0,min-1]
Du erreichst also das Intervall [0+max-min+1 , min-1+max-min+1]
was [max-min+1 , max] entspricht.
Bei min = 5 und max = 8 also [8-5+1,8] = [4,8]

Korrekt wäre

int zahl = rand.nextInt(max-min+1)+min;

damit erreichst du das Intervall [0+min , max-min+1-1+min] = [min,max]

Gruß

 

[Marco13]

EDIT:
Habe nun die Lösung auf diese Weise!

int zahl = rand.nextInt(min)+ (max-min+1);

Setz mal min=0 und max=100 :autsch:

Das letzte von Firephoenix stimmt.

 

[MrClave]

Da lag ich mit meiner ersten Antwort falsch, ich dache du willst X bis X+Y haben
Allerdings:

int zahl = rand.nextInt(min)+ (max-min+1);

ist nicht korrekt, rand.nextInt(min) produziert [0,min-1]
Du erreichst also das Intervall [0+max-min+1 , min-1+max-min+1]
was [max-min+1 , max] entspricht.
Bei min = 5 und max = 8 also [8-5+1,8] = [4,8]

Korrekt wäre

int zahl = rand.nextInt(max-min+1)+min;

damit erreichst du das Intervall [0+min , max-min+1-1+min] = [min,max]

Gruß

Mit meiner Lösung bekomme ich aber genau die Zahlen, die ich wollte, also ist meine Lösung doch korrekt 😉
Und es werden auch alle im Bereich [10,20] ausgedruckt
Es funktioniert vielleicht nicht auf alles, aber in diesem Fall, hat es zumindest geklappt ^^

int zahl = rand.nextInt(min)+ (max-min+1);

min = 10 / max = 20
(10) + (20-10+1) -> [10,21)

 

[ARadauer]

das funktioniert nur weil zufällig min = max-min ist...

also so ungefähr...
int zahl = rand.nextInt(max-min)+ min;

+/- 1 ;-)

 

[bone2]

Mit meiner Lösung bekomme ich aber genau die Zahlen, die ich wollte, also ist
min = 10 / max = 20
(10) + (20-10+1) -> [10,21)

falsch, du bekommst so
0-9 + 11 = [11,20]

 

[TryToHelp]

Es funktioniert nur, da es ein Sonderfall ist, aber willst du nur für die bestimmten Zahlen programmieren oder lieber richtig, dann nehme den Vorschlag von Firephoenix weil wie Marco13 schon beschrieben hat funktioniert deine Lösung nicht immer, die von Firephoenix funktioniert immer ;-)

 

[tfa]

Es funktioniert vielleicht nicht auf alles, aber in diesem Fall, hat es zumindest geklappt

In diesem speziellen Fall. Und wenn du später mal den Bereich in [0,100) ändern willst, wunderst du dich, dass gar nichts mehr klappt. Dann mach es doch gleich richtig.

 

[MrClave]

das funktioniert nur weil zufällig min = max-min ist...

also so ungefähr...
int zahl = rand.nextInt(max-min)+ min;

+/- 1 ;-)

Na, das ist doch eine Aussage, mit der was anfangen kann.


@bone2
Leider bist du falsch ^^ Ich bekomme Zahlen im Intervall von [10,20]
Hab's ja schon getestet.

@tfa
[0,100) kann man auch ganz anders und einfacher definieren 😉

Aber hat sich dann nun auch erledigt mit dem Random. Danke an Firepheonix für die korrekte Lösung 🙂

 

[Crian]

Deshalb ist so ein gewurschtel in einer Zeile auch nur sinnvoll, wenn man genau weiß, was man da macht.

Korrekt wäre

int zahl = rand.nextInt(max-min+1)+min;

damit erreichst du das Intervall [0+min , max-min+1-1+min] = [min,max]

Auch wenn das in diesem Fall vielleicht auch nicht viel übersichtlicher aussieht, lässt sich der Code quasi durch sich selbst dokumentieren, indem man sowas in eine Methode auslagert und dort sprechende Zwischenergebnisse verwendet. Etwa so:

    private int generateIntBetweenMinAndMaxIncludingBoth(int min, int max) {
        int difference = max - min;
        int differenceWithMax = difference + 1;
        int randomBetweenZeroAndDifferenceWithMax = random.nextInt(differenceWithMax);
        int randomMovedToMin = randomBetweenZeroAndDifferenceWithMax + min;
        return randomMovedToMin;
    }

Kein Beweis, aber ein ganz guter Test:

package forumProblems;

import java.util.Random;

public class RandomProblem {

    private Random random;

    public RandomProblem() {
        random = new Random();
        testcase(10,      20,  1000);
        testcase(0,      100, 10000);
        testcase(-1,       1,   100);
        testcase(-1000, 1000, 10000);
    }

    private void testcase(int min, int max, int numberOfTestcases) {
        int minCase = 0;
        int maxCase = 0;
        for (int i=0; i<numberOfTestcases; ++i) {
            int number = generateIntBetweenMinAndMaxIncludingBoth(min, max);
            if (0 == i || number < minCase) {
                minCase = number;
            }
            if (0 == i || number > maxCase) {
                maxCase = number;
            }
        }
        System.out.println("Testcase [" + min + ", " + max
                + "], erreicht wurde [" + minCase + ", " + maxCase + "] in "
                + numberOfTestcases + " Versuchen.");
    }

    private int generateIntBetweenMinAndMaxIncludingBoth(int min, int max) {
        int difference = max - min;
        int differenceWithMax = difference + 1;
        int randomBetweenZeroAndDifferenceWithMax = random.nextInt(differenceWithMax);
        int randomMovedToMin = randomBetweenZeroAndDifferenceWithMax + min;
        return randomMovedToMin;
    }

    public static void main(String[] args) {
        new RandomProblem();

    }

}

Ausgabe:

Testcase [10, 20], erreicht wurde [10, 20] in 1000 Versuchen.
Testcase [0, 100], erreicht wurde [0, 100] in 10000 Versuchen.
Testcase [-1, 1], erreicht wurde [-1, 1] in 100 Versuchen.
Testcase [-1000, 1000], erreicht wurde [-1000, 1000] in 10000 Versuchen.

 

[bone2]

Na, das ist doch eine Aussage, mit der was anfangen kann.


@bone2
Leider bist du falsch ^^ Ich bekomme Zahlen im Intervall von [10,20]
Hab's ja schon getestet.

Nein, bin ich nicht.

{11, 12, 13, 14, 15, 16, 17, 18, 19, 20} sind mit deiner Lösung und min=10 max = 20 möglich
das entspricht diesem Intervall: ]10,20] bzw (10,20] bzw [11,20]