Il nous est donné une grille de labyrinthe et le but renvoyer la même grille en remplacement les cases n'étant pas des murs par le nombre de cases vides qui lui sont adjacentes.
Exemple :
#0##0 #1##1
00#00 => 13#22
#000# #222#
Le but principal de mon approche est de traiter et renvoyer les informations en même temps qu'on les reçoit afin d'éviter les tours de boucles inutiles et le stockage d'importantes matrices sans nécessité.
Je me contente donc de récupérer le labyrinthe ligne par ligne. Lors que je reçoit une ligne, je la parcours et pour chaque case qui n'est pas un mur, j'ajoute 1 si:
#include
#include
#include
#include
int main() {
int width;
int height;
int i, j;
char line[256];
char prec_line[256] = "";
scanf("%d%d", &width, &height);
for (i = 0; i < height; i++) {
scanf("%s", line);
for (j=0; j < width; j++){
if (line[j] != '#'){
if (j != 0 && line[j-1] != '#'){
++line[j];
++line[j-1];
}
if (i != 0 && prec_line[j] != '#'){
++prec_line[j];
++line[j];
}
}
}
if (i != 0){
printf("%s\n", prec_line);
}
memcpy(prec_line, line, sizeof(prec_line));
}
printf("%s\n", line);
return 0;
}
Le but de ce deuxième exercice est de savoir combien de fois Detective Pikaptcha va passer sur chaque case sachant que Pikaptcha par par d'une case et suis un mur jusqu'à revenir à sa position de départ.
L'approche de cette résolution est assez simple. On cherche tant que Pikaptcha n'est pas revenu à son pont de départ si il est possile d'aller a sa case de droite ou gauche suivant le mur choisi. Si ce n'est pas possible, on tourne de 90 degrés, on rééssaie et ainsi de suite jusqu'à revenir au son point de départ.
#include
#include
#include
#include
bool in_array(char a[], char value, int length){
int i;
for (i=0; i < length; ++i){
if (a[i] == value){
return true;
}
}
return false;
}
int index_of(char a[], int length, char value){
int i;
for (i=0; i < length; ++i) {
if (a[i] == value){
return i;
}
}
return -1;
}
void printA(char a[256][256], int length){
int i;
for (i=0; i < length; ++i) {
printf("%s\n", a[i]);
}
}
bool check_empty(int position[], int n, char tab[256][256], int width, int height){
/*
* Renvoie true si la case demandée n'es pas un mur.
*/
if (position[1] + (n-1)%2 < 0 || position[1] + (n-1)%2 >= height){
return false;
}
if (position[0] + (n-2)%2 < 0 || position[0] + (n-2)%2 >= width){
return false;
}
return (tab[position[1] + (n-1)%2][position[0] + (n-2)%2] != '#');
}
int main() {
// --------------------------/ Variable /-----------------------------------------
int width;
int height;
int i, j;
int box_to_check;
int pika_dir;
int count_test_wall;
int position[2];
int start[2];
char tab[256][256];
char directions[4] = {'^', '<', 'v', '>'};
char wall;
// --------------------------/ Inputs /-------------------------------------------
scanf("%d%d", &width, &height);
for (i=0; i < height; ++i) { // On récupère le labyrinthe
scanf("%s", tab[i]);
for (j=0; j < width; ++j){
if (in_array(directions, tab[i][j], 4)){
position[0] = j, position[1] = i;
start[0] = j, start[1] = i;
pika_dir = index_of(directions, 4, tab[i][j]); // Direction dans laquelle Pikaptcha regarde
tab[i][j] = '0';
}
}
}
// --------------------------/ Code /---------------------------------------------
do {
if (wall == 'L'){
box_to_check = (pika_dir + 1)%4;
} else {
box_to_check = (pika_dir+3)%4;
}
count_test_wall = 0; // Compteur pour savoir si on a déjà regardé tout les murs
while (!check_empty(position, box_to_check, tab, width, height)){
if (count_test_wall == 4){
printA(tab, height);
return 0;
}
if (wall == 'L'){
box_to_check = (3 + box_to_check) % 4;
} else {
box_to_check = (1 + box_to_check) % 4;
}
++count_test_wall;
}
pika_dir = box_to_check; // On change la direction de pika
position[0] += (box_to_check-2)%2; // y
position[1] += (box_to_check-1)%2; // x
tab[position[1]][position[0]]++;
} while (start[1] != position[1] || start[0] != position[0]);
printA(tab, height);
return 0;
}