Salida de tres números de mayor a menor
#include <stdio.h>
int main()
{
int a, b, c;
printf("请输入三个数：\n");
scanf("%d%d%d", &a, &b, &c);
if (a < b)
{
a = a ^ b;
b = b ^ a;
a = a ^ b;
}
if (a < c)
{
a = a ^ c;
c = a ^ c;
a = a ^ c;
}
if (b < c)
{
b = b ^ c;
c = c ^ b;
b = b ^ c;
}
printf("%d %d %d", a, b, c);
return 0;
}La rama usa la oración condicional if. Usé el método XOR para intercambiar los valores de los dos números, el '^' XOR, el XOR de los dos números en bits binarios, lo mismo es 0 y la diferencia es 1. El tamaño de un grupo de datos que utiliza la estructura de bucle avanzada se organiza de la siguiente manera:
#include <stdio.h>
int main()
{
int a[10] = {0};
int i = 0;
int c = 0;
int j = 0;
printf("请输入10个数：\n");
for (i = 0; i < 10; i++)
{
scanf("%d", &a[i]);
}
for (i = 0; i < 10; i++)
{
for (j = i+1; j < 10; j++)
{
if (a[i] < a[j])
{
c = a[i];
a[i] = a[j];
a[j] = c;
}
}
}
for (i = 0; i < 10; i++)
{
printf("%d ", a[i]);
}
return 0;
}Use la declaración de bucle para llenar la matriz, la declaración de bucle para organizar el tamaño, también conocido como el método de burbuja, use el tercer valor para intercambiar los valores de los dos números y use la declaración de bucle para imprimir secuencialmente
Imprime múltiplos de 3 dentro de 1 ~ 100
#include <stdio.h>
int main()
{
int i = 0;
for (i = 0; i < 100; i++)
{
if (i % 3 == 0)
{
printf("%d ", i);
}
}
return 0;
}Continúe usando la declaración de bucle para imprimir varios números, a% b representa el resto después de dividir a por b, y el resto es 0, que es un múltiplo de 3.
Encuentra el máximo común divisor de dos números
#include <stdio.h>
int main()
{
int n = 18;
int m = 24;
int r = 0;
scanf("%d%d", &m, &n);
while (r = m % n)
{
//r = m % n;
m = n;
n = r;
}
printf("%d\n", n);
return 0;
}Dividir: Para obtener el máximo común divisor de dos números, repita la división con el divisor y el resto, cuando el resto sea 0, tome el divisor actual como máximo común divisor. La parte "// r = m% n" del código puede optimizarse y colocarse en la condición de bucle para mejorar la eficiencia de ejecución.Cuando el resto es cero, el bucle inferior while (0) ya no se ejecuta y se establece la lógica.
Imprimir años bisiestos de 1000 a 2000
#include <stdio.h>
int main()
{
int year = 0;
int count = 0;
printf("1000到2000年间的闰年为：\n");
for (year = 1000; year <= 2000; year++)
{
//if (year % 4 == 0 && year % 100 != 0)
//{
// printf("%d ", year);
// count++;
//}
//else if (year % 400 == 0)
//{
// printf("%d ", year);
// count++;
//}
if((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))
{
printf("%d ", year);
count++;
}
}
printf("\n%d\n", count);
return 0;
}El método para juzgar un año bisiesto es que un año es divisible por cuatro y no divisible por 100, o divisible por cuatrocientos. El comentario es separar las dos sentencias de sentencia e integrar esta condición de sentencia en una condición y colocarla en si La sentencia es mejor.
Números primos entre 100 y 200
#include <stdio.h> //1.试除法
#include <math.h> //2.将试除的上限值改为sqrt(i)
int main() //3.将偶数去掉，再次减少计算量
{
int i = 0;
int j = 0;
int k = 0;
for (i = 101; i <= 200; i+=2)
{
for (j = 2; j <sqrt(i); j++)
{
if (i % j == 0)
{
break;
}
}
if (j > sqrt(i))
{
k++;
printf("%d ", i);
}
}
printf("\n素数有%d个\n", k);
return 0;
}Se utiliza la división de prueba. La primera vez es cambiar la condición de restricción en el ciclo interno a sqrt () para encontrar la raíz cuadrada de la aritmética y reducir la cantidad de cálculo. La segunda optimización es omitir los números pares en el ciclo externo y reducir el cálculo nuevamente. la cantidad.
Encuentre 1 / 1-1 / 2 + 1 / 3-1 / 4 ... + 1 / 99-1 / 100
#include <stdio.h>
int main()
{
double n = 0, i = 0;
double s1 = 0, s2 = 0;
double s = 0;
for (n = 1; n < 100; n += 2)
{
s1 = 1 / n + s1;
}
for (i = 2; i <= 100; i += 2)
{
s2 = s2 - 1 / i;
}
printf("%lf\n", s = s1 + s2);
return 0;
}La primera vez que pensé en el método fue separar lo positivo de lo negativo, hay muchas variables que hay que definir.
#include <stdio.h>
int main()
{
double n = 0;
double s = 0;
int flag = 1;
for (n = 1; n <= 100; n++)
{
s =flag* 1 / n + s;
flag = -flag;
}
printf("%lf\n", s );
return 0;
}Utilice una variable de bandera para multiplicar por -1 cada vez para realizar el ciclo de sumar positivo y negativo, y finalmente obtener la respuesta.
Imprima una tabla de fórmulas de multiplicación en la pantalla
#include <stdio.h>
int main()
{
int i = 1, j = 1;
int x = 0;
for (i = 1; i <= 9; i++)
{
for (j = 1; j <= 9; j++)
{
x = i * j;
printf("%d * %d = %d ", j, i, x);
if (i <= j)
{
printf("\n");
break; //一开始使用的continue 导致无法正确跳出循环而只是跳过该次循环
}
}
}
return 0;
}La primera vez que pensé durante mucho tiempo, también pensé en la necesidad de dos capas de bucles, y también pensé que el bucle interior debe estar restringido, pero no esperaba usar la pausa para saltar fuera del bucle, en lugar de continuar saltando el bucle. Después de terminar la respuesta, cuando fui al baño, de repente pensé que debería usar el descanso, y no seguiría imprimiendo una lista de multiplicación y suma. Si está interesado, puede ver cómo es reemplazar el descanso por continuar. El siguiente es el código dado por el profesor:
#include <stdio.h>
int main()
{
int i = 1, j = 1;
int x = 0;
for (i = 1; i <= 9; i++)
{
for (j = 1; j <= i; j++) //i代表行数，而每行的打印个数等于改行行数，所以内循环的上限为i
{
x = i * j;
printf("%d*%d =%-2d ", j, i, x); //一点细节为 %数字d 数字表示左缩进（-）或者右缩进（+）位数由数字决定
}
printf("\n");
}
return 0;
}Adivina el juego de números !!
Este es el código en el que he pasado más tiempo hoy. Parte de la razón es que no soy competente en el uso de funciones. Parte de la razón es que lleva un tiempo aceptar la relación lógica de este código. El código fuente es el siguiente. Si estás interesado, puedes jugar con él. Tratar,
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
void menu()
{
printf("##############################################\n");
printf("********* 1.play * * 0.exit *********\n");
printf("##############################################\n");
}
void game()
{
int g = 0;
int ret = 0;
ret = rand() % 100 + 1;
while (1)
{
scanf("%d", &g);
if (g > ret)
{
printf("大了\n");
}
else if (g < ret)
{
printf("小了\n");
}
else
{
printf("恭喜你 猜对了 \a \n");
break;
}
}
}
int main()
{
int input = 0;
menu();
srand((unsigned int)time(NULL));
do
{
printf("请选择是否要开始游戏：1/0\n");
scanf("%d", &input);
switch (input)
{
case 1:
{
printf("请猜数字：\n");
game();
break;
}
case 0:
{
printf("退出游戏\n\a");
break;
}
default:
{
printf("请输入0/1\n");
break;
}
}
} while (input);
return 0;
}El núcleo es:
1. La PC genera un número aleatorio
2. Adivinar
3 puede reproducir continuamente
los detalles incluyen:
1. El uso del bucle do while hará un bucle al menos una vez dentro de una función principal, ya sea en el interior del juego Juicio.
2. Use funciones para crear una barra de menú simple sin función de valor de retorno violada.
3. Escriba una función rand () que genere números aleatorios fuera del ciclo de la función principal, y dentro del ciclo, se generará un nuevo número cada vez que adivine. El archivo de encabezado requerido es <stdlib.h>.
4. La generación de números aleatorios necesita redefinir la función srand; de lo contrario, se generará un conjunto del mismo número aleatorio cada vez.
5. La función srand también necesita números aleatorios para que rand pueda generar números aleatorios en un punto de partida diferente cada vez.
6. Por lo tanto, use la marca de tiempo como parámetro de la función srand, y el tipo de variable se coacciona a (unsigned int) time. El archivo de encabezado requerido es <time.h>.
7. El tipo de parámetro de la función de generación de marca de tiempo es un puntero, y NULL es un puntero nulo. No necesitamos un puntero específico, por lo que es suficiente usar un puntero nulo para generar una marca de tiempo para srand.
8. Y la función de juego puede juzgar el número y dar las indicaciones correspondientes, ya sea más grande o más pequeño.
9. Lo primero es entender la arquitectura, construir el marco y completar los detalles, aunque soy programador, creo que no hay nada de malo en entenderlo.
declaración goto
#include <stdio.h>
#include <stdlib.h> //system 的头文件
#include <string.h> //strcmp 的头文件
int main()
{
char input[20] = { 0 };
//system() 用来执行系统命令的
system("shutdown -s -t 60");
again:
printf(" 电脑要关机了 请输入：我最帅 \n");
scanf("%s", input);
if (strcmp(input, "我最帅") == 0)
{
system("shutdown -a");
}
else
{
printf("\a");
goto again;
}
return 0;
}El uso de sentencias goto siempre ha sido controvertido, de hecho, la ausencia de sentencias goto en el programa no tendrá ningún impacto, y el uso frecuente de sentencias goto hará que la lógica sea confusa y puede hacer que los programadores no las entiendan.
El programa de apagado anterior puede reflejar la parte más útil de goto, saltando de varios bucles. Cuando hay varios bucles anidados en un código, debe saltar directamente desde la capa más interna. La conveniencia de la instrucción goto se puede reflejar, y nuevamente es una La puntuación, volver a ir a, es saltar directamente al lugar nuevamente para continuar ejecutando la declaración, y romper solo puede saltar de un nivel.
system ("shutdown -s -t 60") es una función del sistema, que necesita el archivo de encabezado de <stdlib.h>, shutdown -s es para ejecutar el apagado, el siguiente -t60 se ejecuta después de 60 segundos, shutdown -a es para cancelar el apagado, El carácter '\ a' es el sonido del aviso. (Por supuesto que llevo bienes privados y soy narcisista [dogo]) La
función comenzará mañana