Discussion :

[LittleTatsumi]

Bonjour, est-il possible d'arrondir une valeur à la plus proche contenue dans un tableaux
par exemple
{20,48,69,90} et si on à 25 ça nous l'arrondirais à 20

[dalfab]

Bonjour,

Oui. Et il est plus préférable de partir d'un tableau trié.

[LittleTatsumi]

Mon tableaux est déjà trier mais je ne sais pas comment arrondir à la valeur la plus rpoche

[Matt_Houston]

Qu'est-ce qui te bloque ? Comment ferais-tu avec une feuille et un crayon ?

[LittleTatsumi]

sur le papier je le ferrais soit avec un système qui prend la différence entre ce que je veux classer et les différent membre du tableaux, la valeur a comparé prendrait celle de la plus faible différence, soit un système qui comparerait la valeur a celle du tableaux et qui l’attribuerait toujours a celle strictement inférieur (puisque je dois toujours arrondir à la valeur plus faible) mais je me demandais s'il n'y avait pas un moyen moins lourd de le faire comme une fonction près faite

[Matt_Houston]

S'il s'agit d'un exercice que l'on te demande de réaliser, tu te doutes bien que ça ne se résume dans doute pas à un appel de fonction auprès de la bibliothèque standard.

(puisque je dois toujours arrondir à la valeur plus faible)

Il s'agit donc non pas d'arrondir, mais de tronquer. L'algorithme en devient d'autant plus simple.

1. Quelles sont les informations en entrée ?
2. Quelles sont celles en sortie ?
3. Comment effectuer le traitement : obtenir 2 à partir de 1 ?

Analyse la procédure que ton cerveau utilise pour effectuer la tâche, identifie les étapes élémentaires et note-les. Tu y verras sans doute plus clair.

[Sve@r]

Bonjour

sur le papier je le ferais soit avec un système qui prend la différence entre ce que je veux classer et les différent membre du tableaux, la valeur a comparé prendrait celle de la plus faible différence, soit un système qui comparerait la valeur a celle du tableaux et qui l’attribuerait toujours a celle strictement inférieur (puisque je dois toujours arrondir à la valeur plus faible)

Attention, les deux façons de faire sont différentes car une même entrée produit des résultats différents selon l'un ou l'autre algo. Avec ton tableau {20,48,69,90}, pour la valeur 40 le premier algo te donnera 48 et le second te donnera 20.

Donc tu ne peux pas utiliser l'un ou l'autre au petit bonheur. Tu dois n'utiliser que celui qui produira un résultat conforme à ton besoin...

mais je me demandais s'il n'y avait pas un moyen moins lourd de le faire comme une fonction près faite

Ca reste aussi lourd (que ce soit toi qui le fasse ou la fonction, le travail reste le même). Donc la vraie phrase devrait être "mais je me demandais si quelqu'un avait déjà fait le boulot à ma place pour pas que je m'y cogne"...

[LittleTatsumi]

j'ai fait ma fonction pour arrondir cependant j'ai une erreur, "error conflicting type for 'round'"

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
int round(int value,Disk *x) {
	int result;
	for (int i=0;i<DisksNumber;i++) {
		int comparator = value;
		if (x[i].width-value < comparator) {
			comparator = x[i].width - value;
			result = x[i].width;
		}
	}
	return result;
}

*Disk est le nom de ma structure

[Sve@r]

j'ai fait ma fonction pour arrondir cependant j'ai une erreur, "error conflicting type for 'round'"

Probablement ton prototype ne correspond pas à la signature de la fonction. C'est un petit peu le "B+A=BA" d'un dev C. Tu vas venir ici poser des questions chaque fois que ton compilo t'indique que t'as raté une étape élémentaire ???

Accessoirement la variable "DisksNumber" n'est pas définie (globale ??? ) et la variable "comparator" est écrasée à chaque itération (en fait, tu l'affectes deux fois de façon différente sans utiliser sa valeur entre temps).

Sinon pourquoi tu testes tout le tableau ? Il est trié (tu as dit). Donc te suffit de te placer sur l'élément pile poil supérieur à la valeur à arrondir et regarder qui de l'élément avant ou après est le plus proche. Avec un petit test pour les extrémités du tableau et c'est réglé.

*Disk est le nom de ma structure

Sans blague ? Là ça me coupe le sifflet. Je pensais que c'était un disque dur...

[LittleTatsumi]

DisksNumber est en define au début du programme puisqu'elle intervient souvent, mon tableaux est trier mais son nombre d'élément peux changer à chaque lancement puisqu'il contient DisksNumber élément et je vais devoir arrondir DisksNumber élément, j'ai pensez qu'il serrait plus simple de tester tout le tableaux.
J'ai corriger "comparator", j'ai bien copier la signature de la fonction pour son prototype mais j'ai toujours le conflicting type
C'est la première fois que je rencontre cette erreur


* Le nom "round" était déjà prit par une fonction des bibliothèque importer d'où l'erreur

[Sve@r]

DisksNumber est en define au début du programme puisqu'elle intervient souvent,

La convention pour les macros est de les écrire en tout majuscule. Justement pour qu'un autre lecteur ne se pose pas de question.

j'ai pensé qu'il serrait plus simple de tester tout le tableaux.

Un algo qui ne teste que 2 nombres sera toujours plus efficace qu'un algo qui teste tous les nombres. Et en plus, intuitivement comparer 2 distances sera plus simple que toutes les comparer (obligation de créer une variable qui mémorise la meilleure comparaison etc). Donc là encore, c'est plus simple de ne regarder que 2 éléments que de tester tout le tableau.

Maintenant si tu montres ta solution (et qu'elle fonctionne) je te montre la mienne et on verra laquelle des deux est en final la plus simple...

[LittleTatsumi]

Je pense que cela fonctionne, j'ai juste une erreur de segmentation mais je ne pense pas que cela vien de la fonction mais de comment je l'utilise après

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
int test(int value,Disk *x) {
	int result;
	int comparator = value;
	for (int i=0;i<DisksNumber;i++) {
		if (x[i].width-value < comparator) {
			comparator = x[i].width - value;
			result = x[i].width;
		}
	}
	return result;
}

[gerald3d]

Sans répondre directement transmets aussi à ta fonction la variable DisksNumber. Ca t'évitera de la déclarer en variable globale .

[emixam16]

Si tu as un segfault, c'est surement que quelque chose se passe mal en mémoire...

Au hasard, regarde du coté du seul tableau de ton programme comment sont fait les accès...

Au fait, je ne pense pas que ton code fasse ce que tu veux qu'il fasse ... Mais je te laisse faire tes tests

--

Je présume que tu essaye de suivre les conseils du génial guide pour écrire un code déguelasse. C'est assez réussi !


Par exemple, belle performance sur la catégorie Be Abstract.

Be Abstract

In naming functions and variables, make heavy use of abstract words like it, everything, data, handle, stuff, do, routine, perform and the digits e.g. routineX48, PerformDataFunction, DoIt, HandleStuff and do_args_method.

Mais tu as encore des centaines de catégories à étudier afin de devenir un professionnel du code non maintenable. Rappelle toi, si personne ne peut comprendre ton code, tu es indispensable à l'entreprise donc cela t'assure un boulot à vie.

[Sve@r]

Je pense que cela fonctionne, j'ai juste une erreur de segmentation mais je ne pense pas que cela vien de la fonction mais de comment je l'utilise après

Sans doute. Il faudrait que tu montres comment tu l'utilises après...

Mais pour ce qui est de "fonctionner"... sais pas trop quoi. Quand tu calcules x[i] - value tu t'es demandé ce qui se passera quand "x[i]" est plus petit que "value" (comme quand par exemple on cherche l'arrondi de 40 et qu'on le compare à 20)

Toutefois rien ne vaut le test grandeur nature. Donc j'ai recopié ton algo (arrondi1) puis ai mis le mien (arrondi2) et fait des tests...

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#include <stdio.h>
#define NB		(4)
 
int arrondi1(int value, int *x) {
	int result;
	int comparator = value;
	int i;
	for (i=0;i<NB;i++) {
		if (x[i]-value < comparator) {
			comparator = x[i] - value;
			result = x[i];
		}
	}
	return result;
}
 
int arrondi2(int value, int *x) {
	int i;
 
	// Positionnement sur l'élément pile poil supérieur à la valeur à arrondir
	for (i=0; i < NB && x[i] < value; i++);
 
	// Si on est au premier élément alors c'est le plus proche de la valeur
	if (i == 0) return x[0];
 
	// Si on est au dernier élément alors pareil
	if (i == NB) return x[NB - 1];
 
	// On a deux éléments qui encadrent la valeur => on choisi le plus proche
	return (value - x[i-1]) < (x[i] - value) ?x[i-1] :x[i];
}
 
int main(int argc, char *argv[]) {
	int v=atoi(argv[1]);
 
	int tab[]={20,48,69,90};
	printf("Tsunami: %d => %d\n", v, arrondi1(v, tab));
	printf("Svear: %d => %d\n", v, arrondi2(v, tab));
}

Donc déjà du point de vue efficacité, il y a d'un côté un algo qui fait juste une boucle sans instruction, puis 3 tests en série ; et de l'autre un algo qui fait une boucle dans laquelle on trouve du calcul, du test, de l'affectation. Mais on va laisser ça de côté pour se concentrer sur le résultat des tests de l'un et de l'autre des deux algos...


Je pense donc qu'il n'y a pas photo quant à l'efficacité de l'un ou de l'autre...

[LittleTatsumi]

Sans répondre directement transmets aussi à ta fonction la variable DisksNumber. Ca t'évitera de la déclarer en variable globale .

DiskNumber est utiliser dans presque toute les fonction et ne varie jamais du coup autant la mettre en globale non ?

[Sve@r]

DiskNumber est utiliser dans presque toute les fonction et ne varie jamais du coup autant la mettre en globale non ?

Bien sûr. Tant qu'à faire n'importe quoi, autant y aller à fond...

Les variables globales sont les pires idées des mauvaises idées du prog C. Elles existent OK mais elles ne doivent être mises en application que s'il n'y a aucun moyen de faire autrement. Parce que leur utilisation produit 10 fois plus de soucis qu'elles n'en résolvent...

[LittleTatsumi]

Je pense donc qu'il n'y a pas photo quant à l'efficacité de l'un ou de l'autre.

En effet ^^, je regarderais plus en détail il y a de droit chose que je n'ai pas compris.
Comme le

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

return (value - x[i-1]) < (x[i] - value) ?x[i-1] :x[i];

mais je doit déjà m'occuper d'un autre problèmes, j'ai beau réfléchir je ne trouve aucun moyen de récupérer la largeur du disque inférieur (pour le jeux de la tour de Hanoï) mais c'est un autre problème

[Sve@r]

Comme le

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

return (value - x[i-1]) < (x[i] - value) ?x[i-1] :x[i];

Opérateur ternaire bool ?v1 :v2 => vaut v1 si bool est vrai sinon vaut v2.
Sinon tu remplaces par if ((value - x[i-1]) < (x[i] - value)) return x[i-1] else return x[i].

je ne trouve aucun moyen de récupérer la largeur du disque inférieur (pour le jeux de la tour de Hanoï)

Pas besoin de la récupérer si tu l'as stockée. Si par exemple tes disques sont numérotés de 1 à n, alors tu ne peux pas poser un disque x sur un disque y avec x > y...

[gerald3d]

DiskNumber est utiliser dans presque toute les fonction et ne varie jamais du coup autant la mettre en globale non ?

S’il ne varie jamais alors c’est une constante.
Si tu la déclares en minuscule alors je considère que c’est une variable. De là je maintiens mon commentaire.
Si tu la déclares en globale alors il faut la transformer en macro et l'écrire en majuscule. La typographie ne change rien pour le compilateur mais pour nous pauvres humains ça nous permet de retrouver plus facilement nos petits 😉.

Après tout ceci il serait aussi possible de se passer totalement de cette variable en utilisant directement ton tableau x. Tu pourrais ajouter un dernier élément qui pourrait contenir une valeur adéquate signifiant la fin du tableau.