Salut à tous,

Je suis en BTS Sio, en spécialisation réseau. Nous avons encore un poil de développement et j'aurais besoin d'aide pour mes exercices...Je suis complètement pommé :

Ecrire la fonction booléenne qui reçoit en paramètre un vecteur de noms de 100 cases, ainsi qu'un paramètre numérique contenant le nombre de cases effectivement remplies dans le vecteur précédent, et qui retourne vrai si le vecteur est trié dans l'ordre alphabétique.

Si j'ai bien compris, il faut compter sur la valeur ASCII des pour pouvoir vérifier l'ordre alphabétique ? Je manque de syntaxe et je ne trouve pas comment faire...

Le but est d'écrire la procédure Change qui reçoit en paramètre le montant de la monnaie à rendre (en francs) ainsi que le vecteur Argent décrit plus bas, et qui affiche le nombre de billets et/ou pièces correspondants.

Le vecteur argent contient toutes les valeurs existantes des billets et/ou pièces dans l'ordre décroissant :

Argent = [500 ; 200 ; 100 ; 50 ; 20 ; 10 ; 5 ; 2 ; 1 ; 0,5 ; 0,2 ; 0,1 ; 0,05]

Il existe bien sûr beaucoup de solutions. Le but est d'afficher la solution minimale
(rendre le moins de billets et/ou pièces possibles).

Exemple : pour 492,23F, vous devez afficher : 2*200F + 1*50F + 2*20F + 1*2F + 1*0,05F
(rendre 492,23 suppose rendre 492,25 car il n'existe pas de plus petite pièce que 0,05F)

Vous avez à votre disposition la fonction Arrondi qui reçoit en paramètre un montant et qui retourne le montant arrondi au 5 centimes supérieur.
Exemple : Arrondi(25,12) va retourner 25,15.

Alors là, je vois pas du tout comment faire....Une division puis une lecture du tableau du rendu pour rendre ?

Je ne demande pas que vous me fassiez les exo mais j'aimerais être aiguillé un minimum sur la marche à suivre car je trouve ces exercices un poil dur pour nous autres, réseau, qui n'avons vu que très peu de dev (en langage papier...)

Merci

Pour le premier oui c'est ça. Faut voir chaque nom comme une suite de chiffre, et faire une boucle qui compare le nom actuel au précédent et les teste. Pour les tester, t'as meilleur temps de créer une fonction qui teste deux chaînes de caractères, ce sera plus clair que tout faire dans le if. Tu as toujours 3 cas, soit le 1er char de l'indice i est plus petit que celui de i+1, soit il est plus grand donc là tu retournes false direct, pas besoin de finir les comparaisons, ou soit la première lettre est la même que pour i+1, auquel cas il faut comparer la deuxième lettre (puis la 3ème, etc etc). Je ferais ça avec des boucles for, tant que tu n'as pas étudié la récursivité.

Pour le change, fais ça avec des modulo et des divisons.

Tu as ta somme d'argent, appelons-la "somme".

nb de billets de 200 = somme / 200
puis somme = somme % 200 (que tu peux écrire somme %= 200
Pareil avec chaque valeur de billet/monnaie. Tu vois le principe ?

Pour le premier, j'ai décidé d'utiliser ToUpper et Strcmp ce qui me permet de mettre tous les caractères en majuscules en bouclant et le reste coule de source..

Bon le second, je bloque totalement ! Mais c'est pas grave, j'arriverais surement à une bonne appréciation de la prof, merci à toi Tikim.

Tu as ta somme d'argent, par exemple double somme = 492.23F.

Et ton vecteur vArgent qui contient chaque valeur.

Tu peux créer un vecteur ou tableau de même taille que le vecteur argent, et chaque case indiquera le nombre de billets/pièces de telle valeur. Appelons ce vecteur, vNbArgent. Pour simplifier je vais l'utiliser comme un tableau, par indice, mais bien entendu tu devras travailler avec les méthodes du Vecteur.

vNbArgent[0] = somme / vArgent[0]; // Ca donne 0 : aucun billet de 500

somme %= vArgent[0]; //Ce qui donne 492.23 francs, on retire rien.

vNbArgent[1] = somme / vArgent[1]; // Ca donne 2 : on peut mettre deux billets de 200

somme %= vArgent[1]; //Ce qui donne 92.23 francs, on retire les 400.- du dessus.

vNbArgent[2] = somme / vArgent[2]; // Ca donne 0 : aucun billet de 100 puisqu'on a plus que 92.23

somme %= vArgent[2]; //Ce qui donne 92.23 francs, on retire rien.

vNbArgent[3] = somme / vArgent[3]; // Ca donne 1 : on peut mettre une fois 50.- dans 92.23

somme %= vArgent[3]; //Ce qui donne 42.23 francs, on retire rien.

Etc etc. Bien sûr là j'ai développé pour t'expliquer le principe, mais le plus pratique serait d'utiliser une boucle qui effectue ça autant de fois qu'il n'y a de billets/pièces dans ton vecteur vArgent.

Un détail : lors du dernier passage de la boucle il te faudra arrondir au 5 centimes du dessus si t'as pas 00 ou 05, je te laisse faire ça.

Ca me parait clair comme ça, je vois pas où est le soucis

Le soucis étant que je suis débutant et que j'ai un très très bas niveau ^^'

Merci à toi je vais tenter

Le plus dur est surtout de trouver l'algorithme, une fois que t'as une idée précise de l'algo, écrire le code c'est plus qu'une question de syntaxe et de connaissance des outils du langage/de la programmation en général.

La division par exemple, pour rappel, te retourne un entier, pas un nombre à virgule (float par ex.). Donc 9/4 = 2, parce que dans 9 il y a au maximum 2x4. Mais en faisant ça, tu oublies le reste (de 1 ici).

Le reste tu le trouves grâce au modulo, qu'on note avec le %. 9%4 te donne le reste de la division, donc 1.

Donc avec l'algo que je t'ai donné, tu regardes combien de fois on peut mettre le plus gros billet pour ta somme, puis ta somme devient le reste de la division. Ensuite tu regardes combien de fois tu peux mettre le second plus grand billet dans ta nouvelle somme, et ta somme devient le reste, et ainsi de suite. Avec juste la subtilité qu'à la fin tu dois arrondir aux 5ct, mais tu peux contourner ça au début en mettant des pièces de 1ct, ou en ayant une somme qui se termine par xxx.x0 ou xxx.x5. Juste le temps de faire le reste juste.

Tu comprends mieux ?

Je suis également dans sa classe, et je confirme que ce n'est pas évident pour nous ^^.

Mais avec tes explications, au moins, je vois maintenant mieux le principe, reste à développer ça sous forme d'algo et après le tester T_T...