Please note that this website is still in development phase and might change even in V1
All .pdf subjects available in this repository are the exclusive property of the University of Bourgogne Franche Comte. Any reproduction, use outside the academic framework of the university, or without permission, is prohibited and may be considered as an infringement.
La procédure "Remplissage"
PROCEDURE Remplissage(NBMAX: EBTIER; VARIABLE TAB:TYPTAB; VARIABLE DIM:ENTIER);
VARIABLE
I:ENTIER
DEBUT
POUR I VARIANT DE 1 A NBMAX FAIRE
TAB[I]<- '';
FAIT;
REPETER
ECRIRE('ENTREZ LA VALEUR DE DIM:');
LIRE(DIM);
JUSQU'A ((DIM>0) ET (DIM <= NBMAX));
POUR I VARIANT DE 1 A DIM FAIRE
ECRIRE('TAB [',I, '] = ' );
LIRE(TAB[I]);
FAIT;
FIN;
Vu que NBMAX a été défini plus haut, il n'y a pas besoin de mettre VARIABLE par contre vu qu'on définit TAB et DIM là il faut mettre VARIABLE
La subtilité de la consigne est que l'utilisateur n'est pas obligé de remplir tout le tableau TAB donc il faut d'abord commené par l'initialiser
On ne peut pas utiliser un simple si car on veut que DIM soit 0< DIM<= NBMAX. Il nous faut donc un répéter jusqu'à car la consigne dit "Le nombre de caractères DIM est défini par lecture à l’intérieur de la procédure"
La procédure "Affichage"
PROCEDURE Affichage(TAB:TYPTAB; VARIABLE DIM:ENTIER);
VARIABLES
I:ENTIER;
DEBUT
POUR I VARIANT DE 1 A DIM FAIRE
ECRIRE(TAB[,I,]: , TAB[I]);
FAIT;
FIN;
On n'est plus obligé de mettre VARIABLE dans les paramètres car on a déjà mis VARIABLE pour DIM dans les réponses précédentes.
La procédure "Palindrome"
PROCEDURE Palindrome (TAB:TYPTAB; DIM:ENTIER;NBMMAX:ENTIER;VARIABLE BIS:TYPTAB)
VARIABLES
I,J:ENTIER;
STOP:BOOLEEN;
DEBUT
POUR I VARIANT DE 1 A NBMAX FAIRE
BIS[I] <- ' ';
FAIT;
J<-1;
POUR I VARIANT DE 1 A DIM FAIRE
SI (TAB[I]# ' ')
ALORS
BIS[J] <- TAB[I];
J<-J+1;
FIN SI
FAIT;
I <- 1;
J <- J-1;
STOP <- FAUX;
TANT QUE ((I< J) ET (STOP = FAUX ) ) FAIRE
SI (BIS[I] = BIS[J] )
ALORS
I<-I+1;
J<-J-1;
SINON
STOP<-VRAI;
FIN SI;
FAIT;
SI ( STOP = VRAI )
ALORS
ECRIRE('CECI N'EST PAS UN PALINDROME.');
SINON
ECRIRE('CECI EST UN PALINDROME.');
FIN SI;
FIN
La procédure "ComptageMots"
PROCEDURE ComptageMots (VARIABLE TAB:TYPTAB; VARIABLE DIM:ENTIER; VARIABLE NBMOTS : ENTIER);
VARIABLES
I:ENTIER;
C:ENTIER;
DEBUT
C<-1;
POUR I VARIANT de 1 A DIM FAIRE
SI(TAB[I]='') ALORS
C<-C+1;
FIN SI;
FAIT;
C<-C+1;
FIN;
Ne pas oublier d'incrémenter C après la boucle car si l'utilisateur veut juste écrire un mot il ne mettra pas forcément d'espace
La procédure "Inversion"
PROCEDURE Inversion (VARIABLE TAB:TYPTAB; DIM:ENTIER);
VARIABLES
I:ENTIER;
TAMPON:CARACTERE;
DEBUT
POUR I VARIANT de 1 A (DIM DIV 2 )FAIRE
TAMPON<-TAB[I];
TAB[I]<-TAB[DIM-I+1];
TAB[DIM-I-1]<-TAMPON;
FAIT;
FIN;
On passe par un caractère car le tableau contient des caractères
La procédure "NombreOccurences"
PROCEDURE NombreOccurrences (TAB:TYPTAB; DIM:ENTIER; VARIABLE VAL:CARACTERE ; VARIABLE NB:ENTIER);
VARIABLE
I:ENTIER;
DEBUT
NB<-0;
POUR I ALLANT DE 1 A DIM FAIRE
SI(TAB[I]=VAL) ALORS
NB<-NB+1;
FIN SI;
FAIT;
FIN;
La fonction "Bigramme"
FONCTION Bigramme (TAB:TYPTAB;DIM:ENTIER,VARIABLE NB: ENTIER) : BOOLEEN;
VARIABLES
BIG:TABLEAU [1 .. 2] DE CARACTERE;
I:ENTIER;
DEBUT
ECRIRE('ENTREZ LE PREMEIR CARACTERE DU BIGRAMME :');
LIRE(BIG[1]);
ECRIRE('ENTREZ LE SECOND CARACTERE DU BIGRAMME :');
LIRE(BIG[2]);
NB<-0;
POUR I VARIANT DE 2 A DIM FAIRE
SI ((TAb[I-1] = BIG [1]) ET ( TAB[I] = BIG[2]))
ALORS
NB<-NB+1;
FIN SI;
FAIT;
RENVOYER (NB);
FIN
PROGRAMME Conversion1;
CONSTANTE
MAX=20;
VARIABLES
N:ENTIER;
OCT:TYPTAB;
I,J: ENTIER;
AUX:ENTIER;
DEBUT
ECRIRE('ENTREZ UN NOMBRE EN BASE 10 : ');
LIRE(N);
POUR I VARIANT DE 1 A MAX FAIRE
OCT[I] <- 0;
FAIT;
I<-1;
TANT QUE (N >= 8) FAIRE
OCT[I]<- N MOD 8;
N <- N DIV 8;
I<- I+1;
FAIT;
POUR J VARIANT DE 1 A (I DIV 2) FAIRE
AUX <- OCT[J];
OCT[J] <- OCT[I-J+1];
OCT[I-J+1] <- OCT[AUX];
FAIT;
ECRIRE('NOMBRE EN BASE 8: ' );
POUR J VARIANT DE 1 A I FAIRE
ECRIRE(OCT[J], ' ');
FAIT;
FIN
On commence par initialiser le tableau OCT
La première boucle sert à transformer l'entier en base 8 mais met dans le mauvais ordre
La deuxième boucle sert à remettre le tableau oct dans l'ordre.
PROGRAMME Conversion2;
CONSTANTE
MAX = 20;
TYPE
TYPTAB = TABLEAU [1 .. MAX] DE ENTIER;
VARIABLES
OCT:TYPTAB;
I:ENTIER;
NB:ENTIER;
N:ENTIER;
EXP:ENTIER;
DEBUT
POUR I VARIANT DE 1 A MAX FAIRE
OCT[I]<-0;
FAIT;
ECRIRE ('ENTREZ UN NOMBRE EN BASE 8 : ');
REPETER
ECRIRE ('ENTREZ LE NOMBRE D'ELEMENTS A SAISIR : ');
LIRE(NB);
JUSQU'A (NB > 0);
POUR I VARIANT DE 1 A NB FAIRE;
REPETER
ECRIRE('OCT [',I,']=');
LIRE(OCT [I]);
JUSQU'A ( ( OCT [I] >=0) ET (OCT [I] <=7 )
FAIT;
N<-0;
EXP<-1;
POUR I VARIANT DE NB A 1 PAS -1 FAIRE
N <- N + OCT[I] * EXP;
EXP <- EXP * 8;
FAIT;
ECRIRE('NOMBRE EN BASE 10: ', N);
FIN.
On commence par initialiser le tableau OCT
On demande à l'utilisateur d'entrer le nombre d'éléments à saisir qui doit être > 0
Pour chaque demande on rentre le nomnbre en base 8 tout en faisant attention à ce uq el'utilisateur rentre un nombre entre 0 et 7
En partant de la droite du tableau on multiplie par 8 puissance I et on incrémente I à chaque case
PROGRAMME PARFAIT;
VARIABLES
NOMBRE,SOMME,I:ENTIER;
DEBUT
ECRIRE('ENTREZ UN NOMBRE:');
LIRE(NOMBRE);
SOMME<-1;
POUR I VARIANT DE 2 A (NOMBRE DIV 2) FAIRE
SI (NOMBRE MODULO I = 0)
ALORS
SOMME <- SOMME + I;
FIN SI;
FAIT;
SI ( SOMME = NOMBRE )
ALORS
ECRIRE(NOMBRE, 'EST PARFAIT');
SINON
ECRIRE(NOMBRE, 'EST NON PARFAIT');
FIN SI;
FIN
Ecrire une fonction qui calcule et renvoie la longueur d’une chaîne de caractères.
size_t my_strlen(const char *str){
size_t l = 0;
while (str[l] != '\0'){
++l;
}
return l;
}
Ainsi le type size_t est défini comme un entier non-signé suffisamment grand pour représenter la taille de n’importe quel objet en mémoire. Il sert également à indicer les tableaux
L’opérateur sizeof offre un intérêt : - lorsque l’on souhaite écrire des programmes portables dans lesquels il est nécessaire de connaître la taille exacte de certains objets, - pour éviter d’avoir à calculer soi-même la taille d’objets d’un type relativement complexe pour lequel on n’est pas certain de la manière dont il sera implémenté par le compilateur.
Ecrire une fonction qui convertit une chaîne de caractères numérique en entier.
int my_atoi(const char *s){
size_t i=0;
int n=0;
bool pos=true;
while(s[i] == ' '){
++i;
}
if(s[i] == '-'){
pos=false;
++i;
}
else if (s[i] == '+'){
++i;
}
while (s[i] >= '0' && s[i] <= '9'){
n=10*n + s[i] - '0';
++i;
}
if(!pos){
n=-n;
}
return n;
}
la boucle while(s[i] == ' '){ nous mène au nombre en évitant tous les espaces
on vérifie que le premeir caractère est plus ou moins. si nég pos false pour qu'on fasse l'opposé.
n=10*n + s[i] - '0';
Le 10*n c'est pour changer de digit
Le '0' c'est pour enlever le ASCII (0=30 en ASCII = 48 en hexa)
Ainsi pour 5400
n=10*0+'5'-'0'=4
n=10*5+'4'-'0'=54
n=10*54+'0'-'0'=540
n=10*540+'0'-'0'=5400
Ecrire une fonction qui convertit un entier en chaîne de caractères qui le représente en décimal.
void int_to_string(int n, char t){
if(n< 0)
n=-n;
*t='-';
++t;
}
size_t i=0;
do{
t[i] = n % 10 + '0';
++i;
n=/=10;
}while(n);
t[i]='\0';
for(size_t j =0; j< i/2; ++j){
char temp=t[j];
t[j]=t[i-j-1];
t[i*j-1]=temp;
}
}
On fait l'inverse d ela fonction précédente
On fait le modulo à 10 du nombre pour le mettre chiffre par chiffre en caractère avec '0'
Y a pu qu'à inverser le tableau pour tout remettre dans l'ordre.
Ecrire une fonction qui recherche la première occurrence d’une sous-chaîne needle dans une chaîne haystack.
const char *my_strstr(cosnt char *haystack, cosnt char *needle){
size_t l1= my_strlen(haystack);
size_t l2= my_strlen(needle);
if(l2>l1){
return NULL;
}
for (size_t i=0; i <= l1 - 12; ++i){
bool find=true;
for(size_t i=0;i<=l1 - l2; ++i)
bool find=true;
for(size_t j=0; j< l2 && find; ++j){
if (haystack[i+j] != needle[j]){
find=false;
}
}
if(find){
return haystack+i;
}
}
}
return NULL;
}
Ecrire une fonction main la plus simple poddible qui appelle la focntion définié dans Q3
int main(){
char tab[38]; //surdimensionné
int_to_string-12345,tab);
return 0;
}
Q1. Ecrire une fonction qui renvoie un entier aléatoire compris entre deux bornes B1 et B2 incluses (c'est-à-dire dans l'intervalle [B1 ; B2]).
int aleatoire(int B1, int B2){
if (B1 > B2){
temp = B1;
B1 = B2;
B2 = temp;
}
return rand() %(B2 - B1 + 1) + B1;
}
Il faut s'assurer que la borne minimale est vraiment la borne minimale
Si la borne minimale n'est pas la minimale on échange les valeurs entre les deux bornes
vu que rand() peut renvoyer 0 on met B1 en plus
On modulo le résultat de rand avec borne max - bornemin +1
Ecrire une focntion qui init un tab entiers avec nb aleat compris entre B1 et B2
void init (int *t, size_t size, int B1, int B2){
for(size_t i=0; i< size; ++i) {
t[i]=aleatoire(B1,B2);
}
}
En C, tout est fonction (Définition, Déclaration et Appel). Une fonction renvoie une valeur ou aucune. Une fonction renvoie une valeur ou aucune. plusieurs points de sortie (à l'aide du mot return).
On c'est déjà assurer que la borne minimale est vraiment la borne minimale dans la question précédente
Ecrire une focntion qui compte le nombre de valeurs d'un tabelau d'entiers égale à une valeur passé en paramètre.
size_t counti(const int *t, size_t size, int value, size_t *pind){
*pind=size;
size_t cpt = 0;
for(size_t i = 0; i < size; ++i){
if(t[i] == value){
++cpt;
if(*pind == size){
*pind = i;
}
}
}
return cpt;
}
Ecrire une version récursive de la fonction de la question précédente. Cette fonction ne doit pas utiliser de boucle for, while ou do while.
//Avant le premier appel de cette fonction, il faut initialiser la valeur
//située à l'adresse pind avec la taille du tableau.
//C'est fait par la focntion nommée countr.
size_t countrec(const int *t, size_t size, int value, size_t *pind){
if(size==0){
return 0;
}
if (t[size - 1] == value){
*pind = size -1;
return 1 + countrec(t, size-1, value, pind);
}
return countrec(t,size-1,value,pind);
}
size_t countr(const int *t, size_t size, int value, size_t *pind){
*pind=size;
return countrec(t, size, value, pind);
}
Ecrire la définition d’une fonction qui trie dans l’ordre croissant un tableau d’entiers suivant l’algorithme « tri par sélection ».
void tri_selection(int *tab, size_t size){
size_t ind_min;
int val_min;
for(size_t i=0; i+1< size; ++i){
ind_min=i;
val_min=tab[i];
for (size_t j = i + 1 ; j < size ; ++j){
if (tab[j] < val_min){
ind_min=j;
val_min=tab[j];
}
}
tab[ind_min]=tab[i];
tab[i]=val_min;
}
}
Je ne sais pas ce que l'enseignant entend par définition mais en faite cela revient à écrire la focntion.
Ecrire une définition main qui appelle les fonctions définies aux questions Q2 et Q3. La valeur recherchée sera saisie par l’utilisateur, et les résultats seront affichés sur la sortie standard
int main()
int tab[100];
init(tab,100,10,20);
int val;
printf("Saisissez une valeur à rechercher : ");
scanf("%d',&val);
size_t ind;
size_t cpt = counti(tab, 100, val, &ind);
printf("La valeur %zu est présente %zu fois.\n", val, cpt);
if (cpt > 0){
printf("La première occurrence est située à l'indice %zu.\n", ind);
}
return 0;
}
Pour printf un size_t on fait un %lu car on est en C99
size_t existait au moins depuis C89 mais le spécificateur de format %zu (spécifiquement le modificateur de longueur z) n'a été ajouté à la norme que depuis C99.
Donc, si vous ne pouvez pas utiliser C99 (ou C11) et que vous deviez imprimer size_t en C89, vous n'avez qu'à vous rabattre sur d'autres types existants, comme :
printf("%lu\n", (unsigned long)n) ;
test
size_t longueur (char *chaine ) {
int l=0;
while(chaine[l]!='\0') {
l=l+1;
{
return l;
}
int strToInt(char *chaine) {
char * subString(char* needle, charr *haystack) {
int main() {
char chaine[10]= "chaine1457";
int dec= strTodec(chaine);
printf(%"zu",dec);
int aleatoire( int B1, int B2) {
return rand()%B2+B2-B1;
}
int * init ( int B1,int B2) {
int tab[RND_MAX];
int i=0;
for (i=0; i< RND_MAX; i++) {
tab[i]=aleatoire(B1,B2);
}
return tab;
}
int occurrence(int *tab, int val) {
int i,cpunt=0; int indice=0;
for(i=0,i< sizeof(tab);i++) {
if(tab[i] == val) {
if(tab[i]==val) {
count=count+1;
indice=count;
}
return count,indice;
}
int * (int*tab,int B2); NON
int main() {
srand() NULL;
int tab[100] = init(16,32);
printf("Entrez la valeur recherchée dans le tableau");
scnaf("%d",&val);
int c, indice= occurrence(tab,val);
printf("Occurrence",val,":",c,"indice Numéro 1",indice);
}