Fiche C6

C6.1.c

@@ -0,0 +1,28 @@
+#include <stdio.h>
+
+#define N 100
+
+int divisible(int n, int q){
+	return n%q==0;
+}
+
+int premier(int n){
+	if(n<2)return 0;
+	for(int k=2;k*k<=n;k++){
+		if(divisible(n,k))
+			return 0;
+	}
+	return 1;
+}
+
+int main() {
+	int n;
+	do{
+		printf("Quel nombre ? ");
+		scanf("%d",&n);
+	}while(0>=n || n>=1000);
+	
+	for(int k=2;k<=n;k++)
+		if(premier(k))printf("%d, ", k);
+	printf("et c'est tout ce que vous m'avez demandé.\n");
+}

C6.2.c

@@ -0,0 +1,18 @@
+#include<stdio.h>
+
+#define N 30
+
+int fib(int k){
+	if(k<2)
+		return 1;
+	return fib(k-1)+fib(k-2);
+}
+
+int main() {
+	int n;
+	do{
+		printf("Quel nombre ? ");
+		scanf("%d",&n);
+	}while(0>=n || n>=1000);
+	printf("Voilà votre %d\n", fib(n));
+}

C6.6.c

@@ -0,0 +1,43 @@
+#include <stdio.h>
+
+#define N 50
+
+/**
+ * Renvoie le couple (F_k, F_k+1)
+ */
+void fiboRec(int aa[N], int k){
+	if(k<=1)aa[k] = 1;
+	else aa[k] = aa[k-2]+aa[k-1];
+	if(k+1<N)fiboRec(aa, k+1);
+}
+
+/**
+ * Est-ce ce qui a été demandé ? Si oui, c'est très long.
+ */
+int fiboRecMoche(int k){
+	if(k<=1) return 1;
+	return (fiboRecMoche(k-1) + fiboRecMoche(k-2));
+}
+
+void fiboPlain(int aa[N]){
+	aa[0] = aa[1] = 1;
+	for(int k=2;k<N;k++)
+		aa[k] = aa[k-2] + aa[k-1];
+}
+
+int main() {
+	
+	int fiboArr[N];
+	int fiboArrRec[N];
+	
+	fiboRec(fiboArrRec,0);
+	fiboPlain(fiboArr);
+	
+	printf("Fibo récursif : %d\n", fiboArrRec[N-1]);
+	printf("Fibo non récursif : %d\n", fiboArr[N-1]);
+	
+	// Avec cette ligne ça met trop de temps. Complexité exponentielle, miam miam. 
+	printf("Fibo très moche : %d\n", fiboRecMoche(N-1));
+	
+	return 0;
+}

C6.7.c

@@ -0,0 +1,172 @@
+#include<stdio.h>
+#include<stdlib.h>
+
+#define N 5
+#define BATEAUX_COUNT 2
+#define BATEAUX_LENGTHES_ARR {2,2}
+#define J_atoi(x) printf("-----------------------------------\n\e[1;1H\e[2JJoueur %d, c'est à vous: \n",x)
+#define printclear() printf("\e[1;1H\e[2J")
+
+/*
+ * g==0 -> eau
+ * g==1 -> eau torpillée
+ * g==2 -> bateau
+ * g==3 -> bateau torpillé
+ */
+typedef int Grille[N][N];
+
+void initialiserGrille(Grille grille){
+	for(int i=0; i<N; i++)
+		for(int j=0; j<N; j++)
+			grille[i][j] = 0;
+}
+
+void afficherGrille(Grille grille, int secret){
+	printf("╔");
+	for(int i=0; i<N; i++)printf("═");
+	printf("╗\n");
+	for(int j=0; j<N; j++){
+		printf("║");
+		for(int i=0; i<N; i++){
+			switch(grille[i][j]){
+				case 0:
+					printf(" ");break;
+				case 1:
+					printf("░");break;
+				case 2:
+					printf(secret?" ":"█");break;
+				case 3:
+					printf("▓");break;
+				default:
+					printf("?");
+			}
+		}
+		printf("║\n");
+	}
+	printf("╚");
+	for(int i=0; i<N; i++)printf("═");
+	printf("╝\n");
+}
+
+int viserCase(Grille grille, int x, int y){
+	if(grille[x][y]%2==1)return 0;// On ne retouche pas
+	grille[x][y] += 1;
+	return grille[x][y]>=2;
+}
+
+/**
+ * dir==0 -> Horizontal
+ * dir==1 -> Vertical
+ */
+int setBateau(Grille grille, int longueur, int px, int py, int dir){
+	int coefx = dir==0;
+	int coefy = dir==1;
+	if((dir!=0) && (dir!=1))return 0;
+	if((px<0) || (py<0))return 0;
+	if((px+coefx*longueur >N) || (py+coefy*longueur>N)) return 0;
+	
+	for(int i=0; i<longueur; i++)
+		if(grille[px+coefx*i][py+coefy*i]==2)return 0;
+	for(int i=0; i<longueur; i++)
+		grille[px+coefx*i][py+coefy*i] = 2;
+	return 1;
+}
+
+void demandeRemplirGrille(Grille g, int bateauxLength[BATEAUX_COUNT]){
+	int px,py,dir;
+	for(int k=0; k<BATEAUX_COUNT; k++){
+		printclear();
+		afficherGrille(g, 0);
+		do{
+			printf("Placez un bateau de taille %d (x y dir) avec (dir==0 pour horizontal):", bateauxLength[k]);
+			scanf("%d %d %d", &px, &py, &dir);
+		}while(!setBateau(g, bateauxLength[k], px, py, dir));
+	}
+}
+
+void remplirAupif(Grille g, int bateauxLength[BATEAUX_COUNT]){
+	int k=0;
+	while(k<BATEAUX_COUNT){
+		int tx = rand() % N;
+		int ty = rand() % N;
+		int dir = rand() % 2;
+		if(setBateau(g, bateauxLength[k], tx, ty, dir))k++;
+	}// Presque sûr que ça finit
+}
+
+int main(){
+	
+	
+	int jeu;
+	do{
+		printf("1 pour jouer contre un humain, 2 pour jouer contre l'ordinateur, 0 pour quitter : ");
+		scanf("%d", &jeu);
+	}while(jeu<0 || jeu>2);
+	
+	if(jeu==0)return 0;
+	
+	Grille g1, g2;
+	
+	initialiserGrille(g1);
+	initialiserGrille(g2);
+	
+	int bateauxLength[BATEAUX_COUNT] = BATEAUX_LENGTHES_ARR;
+	
+	int tx, ty;
+	
+	demandeRemplirGrille(g1,bateauxLength);
+	//remplirAupif(g1, bateauxLength);
+	
+	if(jeu==1){
+			J_atoi(2);
+			demandeRemplirGrille(g2, bateauxLength);
+	}else{
+		remplirAupif(g2, bateauxLength);
+	}
+	
+	int batCount=0;
+	for(int k=0; k<BATEAUX_COUNT; k++)batCount+=bateauxLength[k];
+	
+	int bateaux[2] = {batCount, batCount};
+	
+	int joueur = 0; // Inutile si contre un ordinateur.
+	
+	while(bateaux[0]!=0 && bateaux[1]!=0){
+		
+		if(jeu==1)J_atoi(joueur);
+		printf("Base: \n");
+		afficherGrille(joueur==0?g1:g2,0);
+		printf("Objectif: \n");
+		afficherGrille(joueur==0?g2:g1,1);
+		printf("Où voulez-vous tirer ? (x y) ");
+		scanf("%d %d",&tx, &ty);
+		
+		if(viserCase(joueur==0?g2:g1 ,tx, ty)){
+			printf("Touché !\n");
+			bateaux[(joueur+1)%2]--;
+		}else
+			printf("Plouf !\n");
+		
+		if(jeu==2){
+			//Faire le coup de l'ordinateur
+			do{
+				tx = rand() % N;
+				ty = rand() % N;
+			}while(g1[tx][ty]%2!=0);
+			if(viserCase(g1, tx, ty)){
+				printf("L'ordinateur a touché un bateau !\n");
+				bateaux[joueur]--;
+			}else
+				printf("L'ordinateur a tiré dans l'eau !\n");
+			
+		}else{
+			joueur = (joueur+1)%2;
+		}
+		
+	}
+	
+	printf("Victoire du joueur %d !\n", (joueur+1)%2)
+		
+	
+	
+}

C6.md

@@ -0,0 +1,67 @@
+C 6
+=
+
+### Exercice 3
+
+Le programme suivant ne compile pas, car la fonction `f` appelée dans la fonction `main` n'est pas déclarée. Le compilateur `C` en crée donc une, et râle quand il en croise une nouvelle. Il suffit donc d'ajouter la ligne suivante juste au dessus de la fonction `main` pour définir correctement la fonction `f` qui sera utilisée et définie à posteriori.
+
+```
+float f(float x);
+```
+
+### Exercice 4
+À la fin de ce programme, `x` vaut `0` parce que le paramètre `int x` indique que l'appel à `f(x)` transmet *la valeur* de `x`. Afin de passer la référence, il aurait fallu mettre un parametre de type `int* x` et ensuite appeler `*x = *x+1`. (pourquoi y a t'il un `float` d'ailleurs ?)
+
+### Exercice 5
+À la fin de ce programme, tab vaut `[1, 2]`. Le tableau est un pointeur déguisé, et ce sont donc des références qui sont passées.
+
+
+### Exercice 6
+
+Calculer la suite de fibonnaci avec une boucle se fait en complexité O(n). Ça va.
+
+Calculer la suite de fibonnaci avec une (mauvaise) récursivité, complexité exponentielle. Le coût suit en effet la relation de récurence `M_n = M_n-1 + M_n-2`. On peut aussi faire une récurence plus sympa en renvoyant deux termes de la suite.
+
+```
+#include <stdio.h>
+#define N 50
+
+/**
+ * Renvoie le couple (F_k, F_k+1)
+ */
+void fiboRec(int aa[N], int k){
+	if(k<=1)aa[k] = 1;
+	else aa[k] = aa[k-2]+aa[k-1];
+	if(k+1<N)fiboRec(aa, k+1);
+}
+
+/**
+ * Est-ce ce qui a été demandé ? Si oui, c'est très long.
+ */
+int fiboRecMoche(int k){
+	if(k<=1) return 1;
+	return (fiboRecMoche(k-1) + fiboRecMoche(k-2));
+}
+void fiboPlain(int aa[N]){
+	aa[0] = aa[1] = 1;
+	for(int k=2;k<N;k++)
+		aa[k] = aa[k-2] + aa[k-1];
+}
+
+int main() {
+	
+	int fiboArr[N];
+	int fiboArrRec[N];
+	
+	fiboRec(fiboArrRec,0);
+	fiboPlain(fiboArr);
+	
+	printf("Fibo récursif : %d\n", fiboArrRec[N-1]);
+	printf("Fibo non récursif : %d\n", fiboArr[N-1]);
+	
+	// Avec cette ligne ça met trop de temps. Complexité exponentielle, miam miam. 
+	printf("Fibo très moche : %d\n", fiboRecMoche(N-1));
+	
+	return 0;
+}
+```