Cómo crear un patrón de matriz de hélice con solo entrada de fila y columna

Answer 1

Gracias por el A2A.
No quiero escribir el código, pero me gustaría darle un algoritmo basado en el código para resolver el problema de “rata en un laberinto”.
[1] Rellene la matriz con valores 0 (cero). 0 indicará que la celda está vacía.
[2] Implemente un código para mover como se muestra en su figura.
(a) Deberá almacenar las coordenadas xey de la posición actual y la dirección del movimiento (1 a 4 para N, E, S y W).
(b) Necesitarás 3 funciones
avanzar (avanza un paso en la dirección actual
giro a la izquierda (cambia la dirección del movimiento)
checknextcell – vacío o COMPLETO (devuelve booleano)
si la siguiente celda está fuera de los límites de la matriz O no está vacía, giraremos a la izquierda
más
avanzar
(c) pare si ha ejecutado 3 giros a la izquierda consecutivos.

Espero que esto haya ayudado! ¡La mejor de las suertes!

Answer 2

Según lo prometido, aquí tienes. Aquí está el código (en C):

#include

#define NUM_ROWS 7
#define NUM_COLS 9
#define MAX_NUM (NUM_ROWS * NUM_COLS)

/ * Esta es la matriz que rellena para formar la hélice * /

matriz de int [NUM_ROWS] [NUM_COLS];

/ * Esto define aquí las restricciones para que la hélice se convolucione. Arriba a la izquierda
* esquina ‘min’ y esquina inferior derecha ‘max’. * /

int lower_limit [] = {0, 0};
int upper_limit [] = {NUM_ROWS – 1, NUM_COLS -1};

/ * Las direcciones pueden ser 1 (horizontal) y 0 (vertical). Estamos convolucionando en el
* dirección antihoraria. El paso puede ser +1 o -1. Cuando la dirección es
* horizontal, +1 indica movimiento hacia la derecha, mientras que -1 indica izquierda-
* movimiento de sala. Para la dirección vertical, +1 está bajando y -1 viene
* arriba */

void changeStepAndDirection (int * step, int * dir)
{
conmutador (* paso + * dir) {
caso 0: // a la izquierda. Bajar.
* paso = 1; * dir = 0;
rotura;
caso 1: // bajando. Ve a la derecha.
* paso = 1; * dir = 1;
rotura;
caso 2: // a la derecha. Subir.
* paso = -1; * dir = 0;
rotura;
caso -1: // Subiendo. Ve a la izquierda.
* paso = -1; * dir = 1;
rotura;
}
}

/ * Hacemos esto solo una vez, cuando estamos en la esquina inferior derecha. * /

nulo ajustarLimits ()
{
límite_inferior [0] ++; límite_inferior [1] ++;
límite_superior [0] -; límite_superior [1] -;
}

/ * Función auxiliar para volcar la matriz en forma legible para humanos. * /

void displayMatrix ()
{
int i, j;

para (i = 0; i para (j = 0; j printf (“% d \ t”, matriz [i] [j]);
fflush (stdout);
}
printf (“\ n”);
}
}

int main ()
{
/ * El problema quiere que comencemos en la esquina superior derecha. * /
int paso = -1, dir = 1, num;

/ * lee esto como coordenadas, si quieres. * /
int current_pos [] = {0, NUM_COLS – 1};

para (num = 1; num <= MAX_NUM; num ++) {
matriz [current_pos [0]] [current_pos [1]] = num;

/ * Avanzar un paso. * /
current_pos [dir] + = paso;

if (paso == 1) {
if (current_pos [dir] == upper_limit [dir]) {
changeStepAndDirection (& step, & dir);

/ * ¿Estamos en la esquina inferior derecha? * /
if (paso + dir == -1)
ajusteLímites ();
}
}
else {// Es decir, paso == -1
if (current_pos [dir] == lower_limit [dir])
changeStepAndDirection (& step, & dir);
}
}

/* Todo listo. Veamos que tenemos … * /
displayMatrix ();

devuelve 0;
}

Y aquí está el resultado:

sh} $ gcc -g -o matrix_helix matrix_helix.c
sh} $ ./matrix_helix
9 8 7 6 5 4 3 2 1
10 35 34 33 32 31 30 29 28
11 36 53 52 51 50 49 48 27
12 37 54 63 62 61 60 47 26
13 38 55 56 57 58 59 46 25
14 39 40 41 42 43 44 45 24
15 16 17 18 19 20 21 22 23
sh} $