Generer un nombre à partir de la somme de ces chiffres

[lepiaf31]

Bonjour,

j'ai besoin de créer un algorithme qui va me générer un nombre à partir de la somme de ces chiffres. Je m'explique, j'ai un nombre (par exemple 12) et je voudrais générer un autre nombre qui quand on ajoute les chiffres qui le compose fasse le 1er nombre (par exemple 93: 9+3=12). Alors j'ai fait ceci:

Code : Tout sélectionner

Procedure test(somme)
  i = 1
  sommeRestante = somme
  nombre = 0
  
  Repeat
    If sommeRestante > 9
      max = 9
    Else
      max = sommeRestante
    EndIf
    
    rand = Random(max)
    nombre = nombre + rand*i
    sommeRestante = sommeRestante-rand
    i = i *10
  Until sommeRestante = 0
  
  ProcedureReturn nombre
EndProcedure

Debug test(12)

Ce code marche très bien, le problème c'est que si l'algorithme génère trente 0 d'affilé, et bien je vais obtenir un nombre qui va etre très grand (meme trop puisqu'il ne rentre pas dans un long). J'aimerai donc trouver un moyen de limiter la taille du nombre de sorti. (par exemple je voudrais qu'il soit inférieur à la taille maximale d'un long). Mais là je n'ai absolument aucune idée de comment m'y prendre.
Vous avez une idée ?
(J'espère avoir été compréhensible).

[SPH]

grrr, j'ai effacé mon post...

[lepiaf31]

Et comment on decomposerait par exemple 70 ?
Est ce que ca, ca te convient ? :

70 = 65+5 ce qui donne 655

Non cela ne convient pas justement, 70 pourrait se décomposer ainsi: 20883623679286
(2+0+8+8+3+6+2+3+6+7+9+2+8+6 = 70). Mais évidemment il y a plein de possibilités (c'est le but).

EDIT: humm ton 2e code m'a l'air d'être ce qu'il me faut =)

[Cls]

Ou alors tu exclus les '0' des chiffres possibles.

Code : Tout sélectionner

Procedure.s generateNombreFrom(nombre.l)
  Repeat 
    tmp.l = Random(nombre % 10) + 1
    res.s + Str(tmp)
    
    nombre - tmp
  Until nombre <= 0
  
  ProcedureReturn res
EndProcedure

Debug generateNombreFrom(12)

[lepiaf31]

Ou alors tu exclus les '0' des chiffres possibles.

Code : Tout sélectionner

Procedure.s generateNombreFrom(nombre.l)
  Repeat 
    tmp.l = Random(nombre % 10) + 1
    res.s + Str(tmp)
    
    nombre - tmp
  Until nombre <= 0
  
  ProcedureReturn res
EndProcedure

Debug generateNombreFrom(12)

Le problème reste entier: si (par malchance), l'algorithme ne génère que des 1, pour un nombre comme 70, je vais me retrouver avec un nombre composé de soixante-dix 1.


EDIT: @SPH tu as effacé tout ton post :s

[Cls]

Comme ça c'est mieux !

Code : Tout sélectionner

Procedure.s generateNombreFrom(nombre.l)
  Repeat 
    tmp.l = Random((nombre - 1) % 10) + 1
    res.s + Str(tmp)
    
    nombre - tmp
  Until nombre <= 0
  
  ProcedureReturn res
EndProcedure

Debug generateNombreFrom(5)

[SPH]

Code : Tout sélectionner

For i=1 To 200
nb=70
nb$=Str(nb)+" = "
While nb>9
nb1= Random(8)+1
nb-nb1
nb$+Str(nb1)+"+"
Wend
nb$+Str(nb)
Debug nb$
Next

[Cls]

Sinon pour info, mieux vaut utiliser un double pour stocker des nombres importants. Voir la doc pour les limites de taille des variables.

[lepiaf31]

Oui mais là j'ai absolument besoin d'un Long. En fait ce code me sert à générer un clé qui doit respecter un certain algorithme. Et la clé est composée de 4 Long.

@SPH : en fait ton code génère simplement 200 possibilités au pif et il faut que j'en choisisse une qui convient si j'ai bien compris ?

[SPH]

Oui mais là j'ai absolument besoin d'un Long. En fait ce code me sert à générer un clé qui doit respecter un certain algorithme. Et la clé est composée de 4 Long.

Le nombre de depart a decomposer, il est maximum de combien ??
Ton long est de maximum 10 chiffres (2140000000). DONC, tu ne pourras pas avoir un nombre de depart plus grand que 2+1+3+9+9+9+9+9+9+9

Donc, privilegie les '9', et met les plus petit a gauche pour reduire le nombre final...

le plus optimisé est probablement : 1+9+9+9+9+9+9+9+9+9

[MLD]

Salut lepiaf31

Dans ton cas, tu peux faire des additions partiels en transformant les chiffres en texte,et faire des troncatures de texte

par exemple:

Code : Tout sélectionner

chiffre1.d = 0000000000000001235
cf$ = Str(chiffre1.d)
For x = 1 To Len(cf$) 
 If Mid(cf$,x,1) <> "0"
  cf2$ = cf2$ + Mid(cf$,x,1)
 EndIf
Next
cf3.l = ValD(cf2$)  
Debug cf3.l

c'est une piste
Michel

[lepiaf31]

Le nombre à décomposé pourra en théorie être compris entre 5 et 50.

J'avais pensé à faire un algorithme comme ceci:
_il génère des chiffres aléatoires
_ plus on s'approche du nombre maximum qu'un Long peut contenir et plus l'algorithme va générer des chiffres grands (proches de 9).

[lepiaf31]

Bon j'ai une ptite idée, je vous l'expose et dites moi ce que vous en pensez.

Bon admettons que je veuille décomposer 70 avec 9 chiffres.
9 chiffres, cela signifie que je peux faire une somme maximale de 9*9=81.
Or 81-70 = 11 ce qui est plus grand que 10 donc pour le moment je génère un premier nombre compris entre 0 et 9.

Admettons que le 1er nombre généré soit 1. Il me reste donc à décomposer 70-1=69 avec 8 chiffres (j'en ai déjà généré un).
Avec 8 chiffres je peux faire une somme maximale de 8*9=72
Or 72-69=3 je vais donc générer un nombre compris en 9-3=6 et 9

Si le 2e chiffre générer est 9. Il me reste à décomposer 69-9 = 60 avec 7 chiffres.
Avec 7 chiffres je peux faire un somme maximale de 7*9=63 .
Et 63-60=3, je génère donc une nombre compris entre 9-3=6 et 9.

ect ...

Ainsi, je vais générer des chiffres grands quand je me rapprocherai du nombre maximale de chiffres que peut contenir mon nombre de sorti.
Vous en pensez quoi ?


Désolé pour le double-post :s

[SPH]

Le nombre maxi est 1+9+9+9+9+9+9+9+9+9 = 82
Si tu nous dis que ton nombre est 50 maxi, ca te donne plein de possibilité.
En effet, si tu as + de 10 additions, tu as echoué (car trop grand.l)
Si tu as 10 additions, il te faut un 1 en premier (fixe toi ca comme une obligation)
Si tu as moins de 10 additions, alors tu as une entiere liberté (tu ne planteras jamais ton long)

[lepiaf31]

Pour éviter de devoir mettre un 1 au début, je vais prendre 9 chiffres (au lieu de 10). Mais sinon mon algorithme va-t-il marcher correctement selon vous ?