Estudio de Zhao Dachao Zhou Zhi (1)
Esta semana es la primera semana de aprendizaje básico de Java. El contenido de aprendizaje incluye palabras clave e identificadores, tipos de datos, operadores, entrada estándar, números aleatorios, declaraciones de rama, declaraciones de bucle, etc., y un comienzo simple para la matriz. La mayor parte del contenido se ha aprendido y básicamente dominado en la etapa de prueba, por lo que el aprendizaje es relativamente fácil. Hay dos preguntas difíciles en los ejercicios relacionados de la matriz del último día. La búsqueda de registros es la siguiente:
1. Problema del anillo de Joseph
Tema: Hay 500 personas sitiando la ciudad en un círculo y cuéntelas por turno. Cada persona que cuente hasta un múltiplo de 3 abandona el círculo. Después de contar un círculo, continúe contando desde 1 hasta que quede la última persona en el círculo. Pregunte al resto Posición en el círculo (problema del anillo de Joseph)
Lógica de implementación: La
clave para la implementación está en cómo indicar si el participante es eliminado y cómo lograr el informe del círculo , y es necesario registrar el número del ganador final . El valor almacenado del elemento se puede utilizar para registrar el estado del jugador del juego . Si el valor es 0, significa que no se ha eliminado. Si se elimina, el valor del elemento se cambia a 1, lo que significa que ha sido eliminado. El estado del jugador se juzga antes del recuento del juego. Si ha sido eliminado, no entrará en el juego. Si no ha sido eliminado, se informará el número. Si se considera que el número es un múltiplo de 3, se eliminará el número. El número se informa +1, el índice de matriz es +1 y se ingresa el siguiente ciclo. Cada vez, independientemente de si se elimina el elemento subíndice actual, el subíndice debe incrementarse automáticamente para garantizar que es el turno del elemento subíndice para hacer juicios y garantizar el progreso normal del juego. Siempre que el subíndice alcance la longitud de la matriz -1, la próxima vez Es el turno del elemento cuyo subíndice es 0 para emitir un juicio que asegure el efecto del informe circular. Finalmente, cuando no se elimina el restante, finaliza el bucle y se registra el subíndice del array correspondiente del jugador, ganando el subíndice + 1 persona.
① Si 500 personas rodean e informan el número, defina una matriz con una longitud de 500.Si no se asigna ningún valor, el valor inicial predeterminado es 0.Si el valor del elemento se establece en 0, significa que el estado no ha sido eliminado y el valor es 1 para el estado eliminado.
②El valor inicial de la variable count se define como la longitud de la matriz, lo que significa el número de personas que no han sido eliminadas; el valor inicial de la variable num es 1, que representa el número reportado actualmente; el valor inicial de la variable índice se define como 0, que se utiliza para registrar el subíndice del elemento actual.
③Utilice el bucle para jugar. Cuando el número de números no eliminados es igual a 1, el bucle finaliza; el bucle determina si se elimina el elemento subíndice actual, si se elimina, determina si el elemento actual es el último jugador y, de ser así, restablece el índice a 0 para comenzar desde Continúe informando el número en la siguiente vuelta, si de lo contrario, el índice + 1 se juzgará en el siguiente elemento; si no se elimina, ingrese al juego para determinar si el número informado del elemento actual es un múltiplo de 3, y si es un múltiplo de 3, el estado cambiará de 0 Establecer en 1 significa ser eliminado, y contar-1 para reducir el número de personas que no han sido eliminadas; después de eso, juzgue si el elemento actual es el último jugador, la operación es como la anterior, y finalmente num + 1 se usa como el número del próximo informe personal, y el índice + 1 ingresa al siguiente. El juicio del elemento.
④ Recorre los valores del elemento de la matriz. Cuando el valor del elemento es 0, sale del bucle y registra el índice de subíndice actual. El ganador es el primer subíndice + 1 persona.
Código:
//定义数组
int[] arr = new int[500];
//未被淘汰人数
int count = arr.length;
//当前已报数
int num = 1;
//当前数组索引
int index = 0;
//未淘汰人数仅剩1人时退出循环
while(count != 1) {
//未被淘汰则参与游戏
if(arr[index] == 0) {
//报数被3整除
if(num % 3 == 0) {
//状态置1，淘汰
arr[index] = 1;
//未淘汰人数-1
count --;
}
//若当前报数人为最后一人
if(index == arr.length - 1) {
//下标置0，实现围圈报数
index = 0;
//下一任所报数
num ++;
//跳出本次进入下次循环
continue;
}
//下一任所报数
num ++;
}else{
//若为已被淘汰者
if(index == arr.length - 1) {
index = 0;
continue;
}
}
//下标+1，保证游戏向下进行
index ++;
}
int i;
for (i = 0; i < arr.length; i++) {
//找出未淘汰者则记录下标，退出循环
if(arr[i] == 0) {
break;
}
}
//胜利者为第该下标+1人
System.out.println("第" + (i + 1) + "个玩家获得胜利");
Luego comparé el código de timbre de Joseph escrito por el maestro anterior, de la siguiente manera:
// 约瑟夫环
Scanner scanner = new Scanner(System.in);
// 确定游戏参数
System.out.print("请输入参与人数：");
int n = scanner.nextInt();
System.out.print("请输入淘汰数值：");
int outN = scanner.nextInt();
// 定义一个数组保存玩家的状态: 0-未淘汰 1-淘汰
int[] states = new int[n];
// 定义一个变量记录当前玩家所报的数
int number = 0;
// 定义一个变量纪录玩家的下标
int index = 0;
while (true) {
// 如果玩家没有被淘汰，则进入游戏报数
if (states[index % states.length] == 0) {
// 如果玩家报的数等于淘汰值，则淘汰玩家
if (++number == outN) {
// 修改玩家状态，让玩家淘汰出局
states[index % states.length] = 1;
// 玩家淘汰，游戏人数-1，判定游戏是否结束
if (--n == 1) {
break;
}
// 游戏继续，重置报数值
number = 0;
}
}
// 游戏继续，让后一个玩家继续游戏
index++;
}
for (int i = 0; i < states.length; i++) {
if (states[i] == 0) {
System.out.println("第" + (i + 1) + "个玩家取得胜利！");
break;
}
}
Los resultados comparativos en el código se pueden modificar de la siguiente manera:
para lograr un índice I se restablece a 0 se logrará cuando el número de vueltas alrededor de los paquetes, mientras que el maestro es el índice módulo la longitud de la matriz , el número resultante de paquetes es el siguiente elemento de vuelta La indexación también evita juzgar si el índice excede la longitud de la matriz cada vez, lo cual es más conciso e ingenioso.
2. Cómo generar la cadena de caracteres ingresada por el teclado
Tema: definir una matriz, asignar valores mediante la entrada del teclado y generar los valores de la matriz
Lógica de implementación: al
diseñar el tema, el maestro solo debería querer definir una matriz de longitud conocida y luego asignar los elementos de entrada a la matriz, pero agregué un poco de dificultad al implementarla. Una es ingresar la matriz en forma de cadena. Compruebe cómo determinar la longitud de la matriz o cómo generar solo el valor que ingresó al generar la matriz en forma de cadena, sin generar el valor nulo inicializado predeterminado "0"; la otra es cómo hacer que el usuario finalice el elemento de entrada. La solución a la longitud de la matriz es crear primero una matriz lo suficientemente grande como para almacenar la matriz inicialmente, o definir una matriz dinámica , es decir, definir primero una matriz más pequeña y luego crear una longitud actual cuando el número de valores exceda la longitud de la matriz. Para las matrices que tienen 1,5 veces la longitud, la desventaja del primer método es que la longitud puede ser insuficiente y la longitud definida durante la inicialización será demasiado larga para desperdiciar memoria. Por lo tanto, es mejor utilizar el segundo método para matrices dinámicas. Esta vez, para la conveniencia de la introducción Utilice el primer método para definir la longitud como 1000 y publique el código de implementación de la matriz dinámica la próxima vez. La forma de finalizar la matriz de entrada del teclado es pedirle al usuario que ingrese "over" cuando se le pide al usuario que ingrese un número entero, y luego usar el método Scanner.nextLine () para recibir el elemento, si es un número entero, almacenarlo en la matriz, si es " "over" salta del bucle y ya no entra en él, y registra el número de veces de almacenamiento. La matriz obtenida es una matriz con un valor nulo "0". Si desea que la longitud de la matriz sea la longitud del número de elementos de entrada, cree una nueva matriz. La longitud de la matriz es la cantidad de veces que la entrada se registró cuando se acaba de ingresar el valor. Hay dos formas de generar la salida: si solo genera el valor no vacío "0" en la matriz original, puede usar el empalme de cadenas, o puede usar el método Arrays.toString () para generar la salida.
el código se muestra a continuación:
Scanner sc = new Scanner(System.in);
/*
* 尽量将数组长度定义的大些保证够用，确定是浪费空间内存
* 也可以先定义一个长度较小数组，
* 再编写一个长度不足时增加一半数组长度的方法进行调用
*/
int[] tempArr = new int[1000];
int count = 0;
String str = null;
System.out.println("输入存入数组的值(输入\"over\"结束输入)：");
for (int i = 0; i < tempArr.length; i++) {
str = sc.nextLine();
//当比较引用数据类型的值时使用equals方法，直接使用"=="比较的话比较的是引用地址
if(str.equals("over")) {
break;
}
tempArr[i] = (Integer.parseInt(str));
count ++;
}
System.out.print("生成的数组为：[");
/*
* 若要使新数组没有初始化的值，即数组长度等于用户输入数的次数，
* 则定义新数组，通过循环将老数组中非0值(指初始化的0，手动输入的0不影响)传入其中，
* 使用循环方式输出数组中非0(指初始化的0，手动输入的0可以输出)的数
* 也采用Arrays.toString()方法以字符串形式输出新数组
*/
int i = 0;
while(i < count) {
System.out.print(tempArr[i ++]);
if(i != count)
System.out.print(",");
}
System.out.print("]");
int[] arr = new int[count];
El problema encontrado en la implementación del código es: la condición de juicio al juzgar si se ingresa la cadena "over" es if (str == "over"), y se informa un error después de ingresar "over" en tiempo de ejecución, y se encuentra después de depurar. , Cuando no se cumple el criterio de str == "over", no se sale del bucle sino que continúa convirtiendo "over" en un error de tipo int, por lo que se informa un error. Se encuentra que el tipo de referencia no se puede comparar con "==" al comparar valores. De esta manera, se comparan dos valores de dirección de referencia, por lo que no se cumplirán las condiciones para salir del bucle. Después de la consulta, se encuentra que el método equals () de String debe usarse para comparar los valores. Una vez que se cumplen las condiciones, el programa se ejecuta normalmente.