je suis un tout débutant du bac 1,cette année est toute ma première, en surfant sur internet faisant quelques documentations sur la programmation, suis tombé sur cette page aussi instructive que je ne le savais;
Je voudrais avoir un peu de guide svp,
un exercice m'a semblé tout difficile au point je ne sais ou commencer mais j'ai quand-meme envi de savoir comment procéder pour le résoudre; aidez mois svp:
Exercice
Un nombre Vampire est un nombre qui est égal à un produit de ses chiffres.
Exemple : 126 = 21 x 6
Écrire un programme Pascal qui permet de déterminer tous les nombres Vampires de trois chiffres.
Bonjour, Merci d'indiquer un titre de sujet en rapport avec votre problématique ainsi que le code que vous avez écrit.
Le message qui suit est une réponse automatique activée par un membre de l'équipe de modération. Les réponses automatiques leur permettent d'éviter d'avoir à répéter de nombreuses fois la même chose, ce qui leur fait gagner du temps et leur permet de s'occuper des sujets qui méritent plus d'attention. Nous sommes néanmoins ouverts et si vous avez une question ou une remarque, n'hésitez pas à contacter la personne en question par Message Privé. Pour plus d'informations, nous vous invitons à lire les règles générales du forum
Mauvais titre
Le titre est un élément important qui ne doit pas être négligé. N'oubliez pas cette règle simple : le titre idéal résume la question que vous allez poser en une petite phrase. Il doit permettre aux visiteurs de se repérer facilement dans le forum visité et d'identifier le sujet à sa seule lecture.
Vous pouvez utiliser divers préfixes comme [Erreur], [MySQL], [Compatibilité], etc... Aussi, pensez à consulter les règles propres à chaque forum (visibles dans les topics épinglés en haut des sections).
De plus, choisir un bon titre permet de rendre plus faciles les recherches des autres membres.
Les titres de type "besoin d'aide" ou "problème" ne sont pas tolérés.
Merci de modifier votre titre. Pour cela, éditez le premier message de votre sujet.
Il n'y a pas de catégorie sur le langage Pascal. Tu es dans la catégorie sur le langage C. On peut obtenir les chiffres d'un nombre par divisions successives par 10 d'un nombre et en utilisant l'opérateur qui calcule le modulo. Tu peux toujours essayer de poster ton code et on verra ce qu'on peut faire. Et n'oublie pas les recommandations du modérateur AbcAbc6
Le Tout est souvent plus grand que la somme de ses parties.
Tu n'as pas besoin du tableau tab, utilises directement les indices i, j, m Tes boucles testent <= 10 alors que ça devrait être < seulement. Inutile de multiplier par 1, ça ne change rien. Sais-tu ce que donnerait: n/100%10 et n/10%10 ? Tu pourrait le faire avec une seule boucle de 1 à 999 inclus.
Le Tout est souvent plus grand que la somme de ses parties.
Tu as fait la première partie qui est relativement simple. Il faut tester toutes les permutations et recombinaisons. Ce qui est beaucoup moins évident. Trouver toutes les permutations, ça se fait. Avec 3 chiffres, la recombinaison est facile: 1 chiffre vs 2 chiffres. Pour un nombre à 6 chiffres, on aurait: 1 vs 5, 2 vs 4, 3 vs 3 (on ne considère pas les simétriques).
Le Tout est souvent plus grand que la somme de ses parties.
Je l'ai modifié pour donner quelque chose qui ressemble à un générateur Python. Ce n'est sans doute pas l'algo le plus efficace, mais il facilite la résolution du problème de MandelaFanuel. - #include <stdio.h> #include <stdbool.h> #include <stdlib.h>
bool permutations(int array[], int length) { static int step =1, level; static int *saved, *counter; if(step == 1) { saved = malloc(length * sizeof(int)); for(int i = 0; i < length; i++) saved[i] = array[i]; counter = malloc(length * sizeof(int)); for(int i = 0; i < length; i++) counter[i] = 0; step = 2; return true; } else { int p = length - 2; while(p >= 0) { counter[p]++; if(counter[p] >= length - p) { counter[p--] = 0; } else { p = -2; } } if(p == -1) { free(saved); free(counter); step =1; return false; } for(int i = 0; i < length; i++) array[i] = saved[i]; for(int i = 0; i < length-1; i++) { if(counter[i] > 0) { int swap = array[i]; array[i] = array[i+counter[i]]; array[i+counter[i]] = swap; } } } }
Pour le problème originel (les nombres vampires de longueur 3 en base 10), la solution la plus simple est, àmha, de vérifier en force brute tous les cas (d'autant plus que cela semble être un exercice pour débutants). Ici un exemple de solution en rust :
fn check(num: i32, a: i32, b: i32, c: i32) -> bool {
num == a * (10 * b + c)
}
fn vamp(a: i32, b: i32, c: i32) -> Option<(i32, i32)> {
let num = 100 * a + b * 10 + c;
if check(num, a, b, c) {
Some((a, 10 * b + c))
} else if check(num, a, c, b) {
Some((a, 10 * c + b))
} else if check(num, b, a, c) {
Some((b, 10 * a + c))
} else if check(num, b, c, a) {
Some((b, 10 * c + a))
} else if check(num, c, a, b) {
Some((c, 10 * a + b))
} else if check(num, c, b, a) {
Some((c, 10 * b + a))
} else {
None
}
}
fn main() {
for a in 1..=9 {
for b in 0..=9 {
for c in 0..=9 {
if let Some((o1, o2)) = vamp(a, b, c) {
println!("{a}{b}{c} = {o1}×{o2}");
}
}
}
}
}
Maintenant le problème est intéressant, autant pour trouver des nombres plus grands (1206, 1255, 1260, 1395, 1435, 1503, 1530, 1827, 2187, 3159, 3784, 6880, 10251, 10255, 10426, 10521, 10525, 10575, 11259, 11439, 11844, 11848, 12006, 12060, 12384, 12505, 12546, 12550, 12595, 12600, 12762, 12768, 12798, 12843, 12955, 12964, …) de façon efficace, ceux qui ont plusieurs représentations (1260 = 21×60 = 6×210, 1395 = 5×9×31 = 15×93, …), les nombres vampires binaires (159, 175, 287, 303, 315, 318, 319, 343, 350, 351, 375, 567, 574, 575, 591, 603, 606, 623, 627, 630, 636, 638, 679, 686, 687, 699, 700, 702, 735, 750, 763, 765, …), les nombres vampires multibases (1260,1395, …).
Mon propos était de trouver une fonction non récursive pour enumérer toutes les permutations d'une liste de nombres. L'algorithme que j'ai donné ci-haut demande beaucoup d'échanges mais garantit la séquence si on modifie les éléments au retour. Le code suivant ne le garantit pas mais le nombre d'échanges est nettement moins élevé. Je me suis inspiré du problème des 8 (ou N) dames qui était récursif mais que j'ai rendu itératif avec une "pile" (le tableau counter). - #include <stdio.h> #include <stdbool.h> #include <stdlib.h>
void exchange(int *a, int *b) {int t = *a; *a = *b; *b = t;}
Ca revient à regarder les permutations d'indices du tableau contenant les valeurs.
Enumerer les permutations, c'est un exercice classique. Il est même assez facile de
partir de la première permutation dans l'ordre "alphabetique", exemple (1 2 3 4 5) pour 5 élements
passer d'une permutation à la suivante
jusqu'à arriver la dernière (5 4 3 2 1)
Idée : pour les permutations qui commencent par (4 6 3 ), ça va de (4 6 3 1 2 5) - en complétant par les 3 manquants dans l'ordre croissant - à (4 6 3 5 2 1) - en complétant en sens inverse.
Pour passer d'une permutation à la suivante, l'algo n'est pas compliqué.
Exemple pratique : qui est le suivant de la permutation p = (4 5 2 6 3 1) ?
On part de la droite et on remonte tant que c'est une suite croissante, ça nous donne une permutation en 2 parties (4 5 2 | 6 3 1).
p est donc la dernière qui commence par le préfixe (4 5 2). Il va falloir changer de préfixe.
on remplace le dernier élément du préfixe par 3, le premier du suffixe qui lui soit immédiatement supérieur. Le nouveau préfixe est donc (4 5 3)
et on le complète par ceux qui manquent, dans l'ordre croissant (4 5 3 1 2 6)
Faudrait une définition qui tienne debout, pour commencer.
- Edité par michelbillaud il y a environ 8 heures
Je pense qu'on peut raisonnablement partir sur quelque chose comme : «un entier n est un nombre vampire ssi n admet au moins une factorisation dont tous les chiffres en base 10 sont exactement ceux de n en base 10».
Là clairement on voit apparaître l'utilité d'utiliser une liste de diviseurs propres >1 de n. Par exemple avec 126 on obtient la liste 2,63 , 3,42 , 6,21 , 7,18 , 9,14 ;
2 est un chiffre de 126, mais 63 contient un 3 qui ne l'est pas ; on cherche les diviseurs propres >1 de 63 et on obtient 3,21 , 7,9 ⇒ on ne peut plus rien faire
3 n'est pas un chiffre de 126 … next
6,21 nous tombe tout cuit dans le bec, on peut chercher une autre solution en décomposant 21 (le faire pour 6 n'est pas utile car on est assuré d'avoir déjà fait les diviseurs de 6) mais cela n'aboutit pas.
7 n'est pas un chiffre de 126 … on zappe
idem pour 9.
Une solution unique (à l'ordre près des facteurs) pour 126=6×21.
Ici plus la peine de jongler avec des combinaisons ou des permutations.
> Ici plus la peine de jongler avec des combinaisons ou des permutations. Ben, tu as raison ... Ça simplifie le problème. Trouver les diviseur est plus simple que de trouver les permutations. Faut seulement s'assurer que les chiffres apparaissent le même nombre de fois dans les facteurs et dans le nombre. ex. 86 * 8 = 688 -> 2 '8' et 1 '6'
Le Tout est souvent plus grand que la somme de ses parties.
Le Tout est souvent plus grand que la somme de ses parties.
Le Tout est souvent plus grand que la somme de ses parties.
Le Tout est souvent plus grand que la somme de ses parties.
Le Tout est souvent plus grand que la somme de ses parties.
Le Tout est souvent plus grand que la somme de ses parties.
Le Tout est souvent plus grand que la somme de ses parties.
Le Tout est souvent plus grand que la somme de ses parties.
Le Tout est souvent plus grand que la somme de ses parties.