Generieren Sie automatisch Loto 6-Kaufpläne mit Java, die Super-Anfänger gelernt haben

Einführung

Freund (Erfahrung in der Programmierung) "Hast du angefangen zu programmieren?"

Ich "Ja"

Freund "Dann machen wir eine Programmierung, die die Anzahl von Loto6 bestimmt."

Ich kann es mir leisten : wink: "

Am Anfang

Lotto 6 ist eine Lotterie vom Typ Zahlenauswahl, bei der Sie 6 verschiedene Zahlen von 1 bis 43 auswählen können.

Wie der Titel schon sagt, bin ich neu in der Programmierung. Schreiben wir also Code, der die Auswahl von Lotterie-6-Zahlen in Java sehr einfach macht! Es ist ein Artikel von. Natürlich kratze ich nicht an Gewinnzahlen vorbei. ~~ Was ist Schaben? ~~

Es sieht aus wie ein Kampf, also hoffe ich, dass Sie sich daran erinnern, als Sie Anfänger waren, und es mit warmen Augen sehen.

Vorschlag 1 (Gori Push)

Ich werde den Code sofort schreiben.

I "Nun, erst ein Array erstellen, um 6 Zahlen zu speichern ..." Ich sagte: "Natürlich ist die Zufallsklasse unverzichtbar, da die Zahlen von 1 bis 43 zufällig ausgewählt werden."


int[] numbers = new int[6];
for (int i = 0; i < numbers.length; i++) {
	Random random = new Random();
	numbers[i] = random.nextInt(43)+1;
}

Ich sagte: "Oh, ist das komplett? Die Programmierung ist einfach : Sonnenbrille:"

Ich "ausführen"

result



39
18
7
18
34
11

Ich "Ah ... das ist richtig ... : schluchz:"

Dies wird natürlich die Zahlen abdecken. Wie oben erwähnt, hat Lotto 6 6 verschiedene Nummern, daher kann nicht gesagt werden, dass es abgeschlossen ist.

Ich sagte: "Wenn Sie dann leiden, müssen Sie es erneut auswählen. Was soll ich tun?"

Ich "drücke oder : Muskel:"


do {
	for (int i = 0; i < numbers.length; i++) {
		Random random = new Random();
		numbers[i] = random.nextInt(43)+1;
	}
} while (numbers[0] == numbers[1] || numbers[0] == numbers[2] || numbers[0] == numbers[3] ||
		 numbers[0] == numbers[4] || numbers[0] == numbers[5] || numbers[1] == numbers[2] ||
		 numbers[1] == numbers[3] || numbers[1] == numbers[4] || numbers[1] == numbers[5] ||
		 numbers[2] == numbers[3] || numbers[2] == numbers[4] || numbers[2] == numbers[5] ||
		 numbers[3] == numbers[4] || numbers[3] == numbers[5] || numbers[4] == numbers[5]);

Komplett. Ich habe bekommen, wonach ich gesucht habe. Die Zahlen werden nie abgedeckt.

Ich "Schau es dir an ~ ich konnte ~ : entspannt:"

Freund "Oh, es war schnell. Welches ...?"

Freund "······"

Freund Sie ..."

Ich sagte: "Nun, habe ich wieder etwas getan? : Triph:"

Freund "Ba! Ka! Ya! Ro! U!"

Freund "Was ist Programmieren? Du musst dich nicht bewegen! ~~ (Predigen) ~~"

I ": dizzy_face: : dizzy_face: : dizzy_face:"

Vorschlag 2 (Methode / Verallgemeinerung)

Vorschlag 1 ist ein Mist geworden.

Ich "Ich weiß nicht was es ist, aber ich wurde wütend"

Ich sagte: "Aber es war ein Ärger beim Schreiben, und es fühlt sich nicht nach der Programmierung an, die ich mir vorstelle."

Ich sagte: "Lassen Sie uns zuerst den Ablauf sortieren. Ich möchte überprüfen, ob die Zahlen im Array wie zuvor beschrieben abgedeckt sind. Wenn ja, ändern Sie eine der Zahlen. Und überprüfen Sie sie erneut von Anfang an. ""

Ich sagte: "Nun, sollte ich eine Methode erstellen, um zu überprüfen, ob sich die 0. bis 4. Zahl im Array mit anderen Zahlen überschneiden!"

I "Erstellen Sie eine Methode, um vorerst eine Zufallszahl zu erhalten, und fügen Sie sie in ein Array ein ..."

int[] numbers = new int[6];
	for (int i = 0; i < numbers.length; i++) {
		numbers[i] = getNumbers();
        }

private static int getNumber() {
	Random random = new Random();
	return random.nextInt(43)+1;
}

I "Lassen Sie uns eine Prüfmethode machen"



private static void checkNumber0(int numbers[]) {
	for(int i = 1;i < numbers.length;i++) {
		if(numbers[0] == numbers[i]) {
			numbers[i] = getNumber();
			checkNumber0(numbers);
		}
	}
	checkNumber1(numbers);
}

private static void checkNumber1(int numbers[]) {
	for(int i = 2;i < numbers.length;i++) {
		if(numbers[1] == numbers[i]) {
			numbers[i] = getNumber();
			checkNumber0(numbers);
		}
	}
	checkNumber2(numbers);
}

private static void checkNumber2(int numbers[]) {
	for(int i = 3;i < numbers.length;i++) {
		if(numbers[2] == numbers[i]) {
			numbers[i] = getNumber();
			checkNumber0(numbers);
		}
	}
	checkNumber3(numbers);
}

private static void checkNumber3(int numbers[]) {
	for(int i = 4;i < numbers.length;i++) {
		if(numbers[3] == numbers[i]) {
			numbers[i] = getNumber();
			checkNumber0(numbers);
		}
	}
	checkNumber4(numbers);
}

private static void checkNumber4(int numbers[]) {
	for(int i = 5;i < numbers.length;i++) {
		if(numbers[4] == numbers[i]) {
			numbers[i] = getNumber();
			checkNumber0(numbers);
		}
	}
}

Ich getan!"

Ich sagte: "Aber das ist nicht länger als zuvor ...? Wenn ich das zeige, werde ich wieder wütend ..."

Ich sagte: "Der Inhalt von checkNumber 〇 () ist ähnlich programmiert, daher frage ich mich, ob er zu einem kombiniert werden kann."

Denken Sie hier ruhig. Die verschiedenen Methoden haben viele Gemeinsamkeiten. Es scheint, dass gemeinsame Elemente extrahiert werden können, auch wenn die Zahlen unterschiedlich sind.

Ich "Ich denke, ich sollte das programmieren!"



private static void checkNumbers(int index, int[] numbers) {
	for (int i = index + 1; i < numbers.length; i++) {
		if (numbers[index] == numbers[i]) {
			numbers[i] = getNumbers();
			checkNumbers(0, numbers);
		}
	}
	index++;
	if (index < numbers.length - 1) {
		checkNumbers(index, numbers);
	}
}

Komplett. Es ist viel sauberer als zuvor. Der Level-Up-Sound von Drakue wird im Gehirn reproduziert.

Ich sagte: "Es ist alles erledigt, lass es uns einem Freund zeigen ~ : grinsen:"

・ ・ ・

Freund "Hmm. Die Menge an Code selbst hat sich vielleicht nicht viel geändert, aber jetzt ist sie ziemlich vielseitig. Dies macht es einfacher, selbst wenn sich die Spezifikationen ändern."

Ich sagte: "Das heißt, es ist vorbei !? : Zufrieden:"

Mein Freund sagte: "Nun, für einen Anfänger gibt es einen Slogan, aber selbst wenn Sie bestehen, ist es ein Punkt."

Ich sagte: "Nun, ich habe mein Bestes gegeben. Oder kann ich es einfacher schreiben?"

Freund "Oh, ich werde es prägnanter nennen. Bitte geben Sie Ihr Bestes, um darüber nachzudenken."

I ": dizzy_face: : dizzy_face: : dizzy_face:"

Vorschlag 3 (fertige Version)

Plan 2 blieb nicht unbemerkt, aber mein Freund gab mir nur eine gute Punktzahl. Ich möchte ein überraschendes Programm für meine Freunde machen, wenn ich hier bin.

Ich "was soll ich tun?"

Wenn Sie den Ablauf hier organisieren

  1. Deklarieren Sie ein Array
  2. Weisen Sie dem Inhalt des Arrays eine Zufallszahl zu
  3. Überprüfen Sie, ob sich der Inhalt des Arrays mit anderen Inhalten überschneidet
  4. Wenn dies abgedeckt ist, schreiben Sie den Inhalt eines der Arrays neu
  5. Wiederholen Sie [3,4]

Ich sagte: "Hmm. Es kann ein wenig verschwenderisch sein."

Ich sagte: "Ist es möglich, es präziser zu gestalten, indem überprüft wird, ob es mit den Zahlen bedeckt ist, die beim Zuweisen von Variablen zum Array in [2] eingegeben wurden?"



for(int i = 0;i < numbers.length;i++) {
    numbers[i] = getNumber();
    for(int j = 0 ; j < i ;j++) {
        if(numbers[j] == numbers[i]) {
        	numbers[i] = getNumber();
        }
    }
}

Es ist noch nicht fertig ... Natürlich das zweite Mal


numbers[i]=getNumber();

Und es besteht die Möglichkeit, dass die Nummern wieder abgedeckt werden.

Ich sagte: "Hmm. Es scheint, als sollte ich dies zu einer Methode wie Plan 2 machen und von vorne beginnen, wenn (wahr) ..."

Ich sagte "Von Grund auf neu ...? : Flushed :! Nein, ich muss es nur reduzieren!


for(int i = 0;i < numbers.length;i++) {
	numbers[i] = getNumber();
	for(int j = 0 ; j < i ;j++) {
		if(numbers[j] == numbers[i]) {
			i--;
			break;
		}
	}
}

Ich "Dekrement ...! Übrigens gab es so etwas."

Ich sagte: "Wie auch immer, ich kann sagen, dass dies die endgültige Fertigstellung ist. Ich konnte schönen Code ohne Verschwendung schreiben! : Blush:"

Loto6


public class Loto6{
	public static void main(String[] args) {
		int[] numbers = new int[6];
		for(int i = 0;i < numbers.length;i++) {
			numbers[i] = getNumber();
			for(int j = 0 ; j < i ;j++) {
				if(numbers[j] == numbers[i]) {
					i--;
					break;
				}
			}
		}
		for (int i : numbers) {
			System.out.println(i);
		}
	}

	private static int getNumber() {
		Random random = new Random();
		return random.nextInt(43)+1;
	}
}

Freund "Oh! Ich könnte einen ziemlich guten Code schreiben"

Ich "Ehehe : kissing_closed_eyes:"

Freund "Wie ist es? Die Freude an dieser Art von Denkprozess oder wenn der Code, den Sie an sich selbst dachten, richtig funktioniert, wäre riesig."

Ich sagte: "Ja! Ich konnte denken, dass das Programmieren Spaß macht."

Freund "Es war gut. Bitte geben Sie weiterhin Ihr Bestes."

Ich sagte: "Natürlich. Was für ein Programm würdest du übrigens schreiben, wenn du ein Freund wärst?"

Freund "Bin ich es? Das ist richtig für mich ..."

Loto6


public class Loto {
	public static void main(String[] args) {
		List<Integer> numbers = new ArrayList<Integer>();
		for(int i = 1;i <= 43;i++) {
			numbers.add(i);
		}
		
		Collections.shuffle(numbers);
		
		for(int i = 0;i < 6;i++) {
			System.out.println(numbers.get(i));
		}
	}
}

Freund "Nun, ich frage mich, ob ich die List-Klasse und die Collections-Klasse verwenden kann, um es herauszubekommen."

** Ich "Ahokusa" **

Fazit

Programmierspaß!

Recommended Posts

Generieren Sie automatisch Loto 6-Kaufpläne mit Java, die Super-Anfänger gelernt haben
Die Leute sind besorgt, die Leute machen Builder-Muster-Tools, die automatisch Java Builder-Muster generieren.
Ist es möglich, Getter / Setter automatisch mit Java Interface zu generieren?