Zunächst habe ich eine BackEnd-Klasse erstellt, die für die gesamte Arbeit des Programms verantwortlich ist. Es hat Felder:
private int length; //
private int[] mas; //
private int[] inputArray; //, Die Idee ist wie folgt: Der Computer generiert eine Zahl mas Länge Länge, der Benutzer gibt die Zahl inputArray ein und sieht, wie viele Bullen und Kühe es gibt, wonach er gewinnt oder weiter spielt. Zuerst geben wir das mas-Array aus, um die Nummer zu sehen und den Code zu debuggen. dann werden wir diese Zeile entfernen. Schreiben wir die Ausgabe eines Arrays beliebiger Länge:
private void printMas(int[] mas) {
for (int i = 0; i < length; i++) {
System.out.print(mas[i] + " ");
}
} Wir übergeben dieser Methode ein Array, das wir über die for-Schleife ausgeben. Es hätte über das Feld erfolgen können, aber da wir zuerst mas und dann inputArray ausgeben, habe ich mich dazu entschlossen.
Jetzt müssen wir eine Zahlengenerierung erstellen. Sie können dies mit Standardfunktionen tun, aber vergessen Sie nicht, dass wir unterschiedliche Ziffern in der Nummer benötigen. Dies bedeutet, dass die Nummer 45566 nicht funktioniert, aber 45367 genau richtig ist. Schreiben wir eine Methode zum Generieren einer solchen Zahl mit der Überprüfung der Ziffern, aber zuerst wollen wir herausfinden, wie lange der Benutzer die Zahl erraten möchte:
private void getMas() {
Scanner scanner = new Scanner(System.in);
do {
System.out.println(" 1 10");
while (!scanner.hasNextInt()) {
System.out.println(" ");
scanner.next();
}
length = scanner.nextInt();
} while (length <= 0 || length > 10);
setMas(createMas());
}
Wir erstellen ein Scannerobjekt, mit dem wir die Nummer von der Konsole erhalten. Als nächstes verwenden wir eine Schleife mit einem do während der Nachbedingung. Ich werde erklären, warum dies etwas später ist. Im Körper der Schleife sehen wir eine while-Schleife. Es wird verwendet, um zu überprüfen, ob eine Zahl in die Konsole eingegeben wurde, kein Bruch, keine Buchstaben usw. Nachdem wir überprüft haben, dass die Nummer in die Konsole eingegeben wurde, schreiben wir ihren Wert in die Länge. Und jetzt überprüfen wir mit der Funktion do while postcondition, ob sie zum Intervall [0,10] gehört. Wenn eine Zahl eingegeben wird, die nicht im Intervall enthalten ist, werden Sie erneut aufgefordert, die Länge einzugeben. Wenn die Nummer sofort korrekt eingegeben wird, generieren wir die Nummer mit der Methode createMas und ändern den Wert des Felds mas:
public void setMas(int[] mas) {
this.mas = mas;
}private int[] createMas() {
int[] arr = new int[length];
for (int i = 0; i < this.length; i++) {
arr[i] = (int) (Math.random() * 10);
}
boolean checkMas = false;
while (!checkMas) {
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr.length; j++) {
if (i != j) {
if (arr[i] == arr[j]) {
arr[j] = (int) (Math.random() * 10);
}
}
}
}
boolean check = false;
for (int i = 0; i < arr.length && !check; i++) {
for (int j = 0; j < arr.length && !check; j++) {
if (i != j) {
if (arr[i] == arr[j]) {
check = true;
checkMas = false;
} else checkMas = true;
}
}
}
}
return arr;
}Lassen Sie mich erklären, wie createMas funktioniert. Zuerst erstellen wir ein Array mit Längenlängen und füllen es mit Zufallszahlen aus dem Intervall [0,10]. Math.random () generiert eine Zufallszahl aus dem Intervall [0,1], und multipliziert mit 10 erhalten wir eine Zahl im Intervall [0,10]. Wir haben jetzt ein Array arr, das aus zufälligen Ziffern besteht. Der nächste Schritt besteht darin, zu überprüfen, ob sich die Zahlen wiederholen. Ich habe mich dazu entschlossen, boolesche Variablen zu verwenden. Zuerst vergleichen wir jedes Element mit jedem und ändern im Falle einer Übereinstimmung das Element, mit dem wir vergleichen, durch eine Zufallszahl. Nachdem wir alle Elemente verglichen haben, überprüfen wir das Array auf Eindeutigkeit der Ziffern. Dazu habe ich auch die Prüfvariable angelegt. Dann vergleichen wir einfach jedes Element mit jedem. Wenn Sie 2 identische Elemente finden, beenden Sie das zum Vergleich (da! Check false zurückgibt und die Schleifen enden),und kehren Sie zu den for-Schleifen zurück, um die gleichen Nummern zu ändern. Nachdem alle Zahlen im Array unterschiedlich sind, wird die Variable checkMas wahr und die Prüfung des Arrays endet. Jetzt geben wir das arr-Array zurück und machen das Feld mas = arr.
Wir haben jetzt eine vom Computer konzipierte Nummer. Lassen Sie uns das Erraten dieser Zahl durch den Benutzer implementieren. Schreiben Sie dazu die checkInput-Methode:
private void checkInput() {
Scanner scanner = new Scanner(System.in);
int[] arr = new int[length];
if (length == 1) System.out.println(" " + length + " ");
else {
if (length > 1 && length < 5) {
System.out.println(" " + length + " ");
} else {
if (length > 4 && length < 11) {
System.out.println(" " + length + " ");
}
}
}
boolean checkMas = false;
while (!checkMas) {
for (int i = 0; i < length; i++) {
do {
System.out.println(" ");
while (!scanner.hasNextInt()) {
System.out.println(" ");
scanner.next();
}
arr[i] = scanner.nextInt();
if(arr[i] < 0 || arr[i]>=10) System.out.println(" 0 9 ");
} while (arr[i] < 0 || arr[i] >= 10);
}
boolean check = checkInputArray(arr);
if (check) {
checkMas = true;
} else {
System.out.println(" ");
System.out.println(" ");
}
}
setInputArray(arr);
}In ähnlicher Weise erstellen wir einen Scanner und ein Hilfsarray mit einer Länge von Länge. Als nächstes kommt eine Reihe von Wenns, die dafür verantwortlich sind, dass nur eine Zahl und eine Phrase übereinstimmen. Danach erfolgt eine direkte Eingabe und Überprüfung der Benutzernummer. Damit es in der Logik keine Meinungsverschiedenheiten mit dem Benutzer gibt, habe ich beschlossen, dies so zu gestalten, dass der Benutzer jede Nummer separat eingibt.
for (int i = 0; i < length; i++) {
do {
System.out.println(" ");
while (!scanner.hasNextInt()) {
System.out.println(" ");
scanner.next();
}
arr[i] = scanner.nextInt();
if(arr[i] < 0 || arr[i]>=10) System.out.println(" 0 9 ");
} while (arr[i] < 0 || arr[i] >= 10);
}In diesem Abschnitt des Codes wird die Nummer eingegeben und überprüft. Die Arbeit ähnelt der Eingabe der Länge des Arrays, daher sehe ich keinen Grund, dies zu erklären. Anschließend wird das Benutzerarray auf identische Nummern überprüft. Schreiben Sie dazu die checkInputArray-Methode:
private boolean checkInputArray(int[] arr) {
boolean checkMas = false;
boolean check = false;
for (int i = 0; i < arr.length && !check; i++) {
for (int j = 0; j < arr.length && !check; j++) {
if (i != j) {
if (arr[i] == arr[j]) {
check = true;
checkMas = false;
} else checkMas = true;
}
}
}
return checkMas;
}Das Überprüfen ähnelt dem Überprüfen eines versteckten Arrays, daher werde ich nicht weiter darauf eingehen. Wenn die Nummer des Benutzers doppelte Nummern enthält, bitten wir Sie, die gesamte Nummer erneut einzugeben. Und so weiter, bis es richtig eingegeben wird. Dann ändern wir den Wert des Feldes inputArray in unser Hilfsarray arr. Nur für den Fall, ich werde den Code geben:
public void setInputArray(int[] inputArray) {
this.inputArray = inputArray;
}Zu diesem Zeitpunkt haben wir zwei Arrays: das versteckte Array und das Eingabearray. Es ist Zeit herauszufinden, wie viele Bullen und wie viele Kühe der Benutzer gefunden hat.
Wir werden dies mit der checkCowAndBull-Methode herausfinden:
private int[] checkCowAndBull() {
int[] arr = new int[2];
int cow = 0;
int bull = 0;
for (int i = 0; i < length; i++) {
for (int j = 0; j < length; j++) {
if (mas[i] == inputArray[j]) {
if (i == j) bull++;
else cow++;
}
}
}
arr[0] = cow;
arr[1] = bull;
return arr;
}Wir erstellen ein zusätzliches 2-Element-Array. Das erste ist die Anzahl der Kühe, das zweite ist die Anzahl der Bullen. Dann iterieren wir über beide Arrays und vergleichen die Elemente. Wenn die Elemente gleich sind und ihre Indizes gleich sind, erhöhen wir die Anzahl der Bullen, andernfalls erhöhen wir die Anzahl der Kühe. Danach schreiben wir die Werte in das Array und geben es zurück.
Es ist Zeit herauszufinden, was die ganze Zeit im Konstruktor der BackEnd-Klasse war.
public BackEnd() {
getMas();
//printMas(mas);
boolean win = false;
while (!win) {
checkInput();
System.out.println(" :");
printMas(inputArray);
System.out.println();
int[] arr = checkCowAndBull();
if (arr[1] == length) {
win = true;
System.out.println("! !");
} else {
System.out.println(" " + arr[0] + " , " + arr[1] + " ");
System.out.println(" ");
}
}
}Zuerst generieren wir das beabsichtigte Array. Ich gebe es zum Debuggen aus, aber diese Funktion wird für das Spiel nicht benötigt. Da wir nicht wissen, ab welchem Versuch der Benutzer die Zahl erraten wird, starten wir die while-Schleife bis zum entsprechenden Zeitpunkt. Dann bitten wir den Benutzer, seine Nummer einzugeben, das eingegebene Array anzuzeigen und die Anzahl der Bullen und Kühe zu überprüfen. Wenn die Anzahl der Bullen mit der Länge des Arrays übereinstimmt, wird die Anzahl erraten und das Spiel endet. Andernfalls wird die Anzahl der Bullen und Kühe angezeigt und das Spiel fortgesetzt.
Es bleibt nur die Erstellung einer Instanz der Klasse zum Menschen hinzuzufügen:
public class main {
public static void main(String[] args) {
BackEnd bk = new BackEnd();
}
}Wir starten, überprüfen, spielen.
Vielen Dank für Ihre Aufmerksamkeit, der zweite Teil wird bald kommen.