¿Qué programas de C tienen salidas inesperadas?

Los siguientes programas en C tienen salidas un poco inesperadas. El primer programa es determinar la solución del problema de la Torre de Hanoi , mover un número de discos de tamaño reducido continuamente, desde una torre de origen a una torre de destino utilizando una tercera torre como torre auxiliar, mientras se transfiere un disco a la vez y nunca mantener un disco más grande en un disco más pequeño. El segundo programa es una representación gráfica de El juego de la vida . El universo del Juego de la Vida es una cuadrícula ortogonal bidimensional infinita de celdas cuadradas, cada una de las cuales se encuentra en uno de los dos estados posibles, vivo o muerto . Cada celda interactúa con sus ocho vecinos , que son las celdas que están adyacentes horizontal, vertical o diagonalmente. En cada paso en el tiempo, ocurren las siguientes transiciones:

  1. Cualquier célula viva con menos de dos vecinos vivos muere, como si fuera causada por la subpoblación.
  2. Cualquier célula viva con dos o tres vecinos vivos vive hasta la próxima generación.
  3. Cualquier célula viva con más de tres vecinos vivos muere, como por hacinamiento.
  4. Cualquier célula muerta con exactamente tres vecinos vivos se convierte en una célula viva, como por reproducción.

El patrón inicial constituye la semilla del sistema. La primera generación se crea aplicando las reglas anteriores simultáneamente a cada célula de la semilla: los nacimientos y las muertes ocurren simultáneamente, y el momento discreto en el que esto sucede a veces se llama tic (en otras palabras, cada generación es una función pura de uno anterior). Las reglas continúan aplicándose repetidamente para crear más generaciones. Y el último programa es un ejemplo de un programa C ofuscado . El uso de la tecnología de impresión bonita y creación de perfiles de ruta es un ayudante muy útil para comprender la estructura y el comportamiento de este programa.

Torre de Hanoi:

#include

nulo toh (int n, int s, int a, int d) {

si (n == 1) {

printf (“\ nMOVE UN DISCO DE% d A% d \ n \ n”, s, d);

regreso;

}

toh (n-1, s, d, a);

printf (“MOVER UN DISCO DE% d A% d \ n”, s, d);

toh (n-1, a, s, d);

}

int main () {

int n, s, a, d;

printf (“\ n INGRESE EL NÚMERO DE DISCOS: \ t”);

scanf (“% d”, & n);

printf (“\ n INGRESE A LA POSICIÓN DE LA TORRE DE FUENTE: \ t”);

scanf (“% d”, & s);

printf (“\ n INGRESE A LA POSICIÓN DE LA TORRE AUXILIAR: \ t”);

scanf (“% d”, & a);

printf (“\ n INGRESE A LA POSICIÓN DE LA TORRE DE DESTINO:”);

scanf (“% d”, & d);

toh (n, s, a, d);

devuelve 0;

}

Juego de vida:

#include

#include

#include

principal(){

int i, j, suma, matriz [26] [81] = {0}, matriz1 [26] [81] = {0};

t largo;

t = tiempo (NULL);

srand (t);

para (i = 1; i <25; i ++) {

para (j = 1; j <80; j ++) {

matriz1 [i] [j] = rand ()% 2;

}

}

mientras que (1) {

para (i = 1; i <25; i ++) {

para (j = 1; j <80; j ++) {

if (matriz1 [i] [j] == 1)

printf (“% c”, 219);

más

printf (“”);

}

printf (“\ n”);

}

para (i = 0; i <90000000; i ++);

sistema (“cls”);

para (i = 1; i <25; i ++) {

para (j = 1; j <80; j ++) {

matriz [i] [j] = matriz1 [i] [j];

}

}

para (i = 1; i <25; i ++) {

para (j = 1; j <80; j ++) {

suma = 0;

suma = matriz [i-1] [j] + matriz [i + 1] [j] + matriz [i] [j-1] + matriz [i-1] [j-1] + matriz [i-1] [j + 1] + matriz [i + 1] [j-1] + matriz [i + 1] [j + 1] + matriz [i] [j + 1];

if (suma == 1 || suma> = 4)

matriz1 [i] [j] = 0;

más si (suma == 3)

matriz1 [i] [j] = 1;

}

}

}

}

Doce días de navidad:

#include

principal (t, _, a)

char * a;

{

return! 0 <t? t <3? main (-79, -13, a + main (-87,1 -_, main (-86,0, a + 1) + a)):

1, t <_? Main (t + 1, _, a): 3, main (-94, -27 + t, a) && t == 2? _ <13?

main (2, _ + 1, “% s% d% d \ n”): 9: 16: t <0? t <-72? main (_, t,

“@n ‘+, #’ / * {} w + / w # cdnr / +, {} r / * de} +, / * {* +, / w {% +, / w # q # n +, / # {l +, / n {n +, / + # n +, / # \

; # q # n +, / + k #; * +, / ‘r:’ d * ‘3,} {w + K w’K:’ +} e # ‘; dq #’ l \

q # ‘+ d’K #! / + k #; q #’ r} eKK #} w’r} eKK {nl] ‘/ #; # q # n’) {) #} w ‘) {) { nl] ‘/ + # n’; d} rw ‘i; # \

) {nl]! / n {n # ‘; r {# w’r nc {nl] ‘/ # {l, +’ K {rw ‘iK {; [{nl]’ / w # q # n’wk nw ‘\

iwk {KK {nl]! / w {% ‘l ## w #’ i; : {nl] ‘/ * {q #’ ld; r ‘} {nlwb! / * de}’ c \

;; {nl ‘- {} rw]’ / +,} ## ‘*} # nc,’, # nw] ‘/ + kd’ + e} +; # ‘rdq # w! nr ‘/’)} +} {rl # ‘{n’ ‘) # \

} ‘+} ## (!! / “)

: t <-50? _ == * a? putchar (31 [a]): main (-65, _, a + 1): main ((* a == '/') + t, _, a + 1)

: 0 <t? Main (2,2, "% s"): * a == '/' || main (0, main (-61, * a,

“! ek; dc [correo electrónico protegido] ‘(q) – [w] *% n + r3 # l, {}: \ nuwloca-O; m .vpbks, fxntdCeghiry”), a + 1);

}

Mira el primer código.

#include
principal() {
int num1 = 5, num2 = 0;
scanf (“% d% d”, & num1, & num2);
printf (“AMO MI INDIA \ n”); // aquí está ‘\ n’ después de la declaración
printf (“% d”, num1 / num2);
devuelve 0;
}

Y luego mira el segundo código.

#include
principal() {
int num1 = 5, num2 = 0;
scanf (“% d% d”, & num1, & num2);
printf (“AMO MI INDIA”); // aquí está ‘\ n’ después de la declaración
printf (“% d”, num1 / num2);
devuelve 0;
}

El hecho es que para el código 1sr la salida es:

Amo mi india

Excepción de coma flotante (núcleo volcado)

Y la salida para el segundo código es:

Excepción de coma flotante (núcleo volcado)

La única diferencia entre los códigos es que falta una ‘\ n’ en la quinta línea del segundo código.

En el primer caso, la nueva línea ‘\ n’ en printf () hace que el búfer de salida se vacíe a la salida antes de que ocurra el bloqueo. Entonces, tenemos que ver la declaración impresa.

En el segundo caso, la falta de ‘\ n’ hace que el búfer retenga los datos, y la siguiente declaración provoca la excepción y una terminación anormal del programa. Por lo tanto, los datos almacenados en el búfer no tuvieron la oportunidad de ser enviados al terminal de salida. Por lo tanto, no tenemos salida visual.

Dicho esto, una división por cero provoca un comportamiento indefinido.