Bonjour,

il faudrait la fonction qui retourne la partie entière d'un nombre.

As-tu ça ?

J'ai une fonction qui permet de faire la division entière.

C'est un peu embêtant si on ne connait pas le nombre de chiffres du nombre initial.

As-tu la fonction logarithme ? (ou mieux encore : le log décimal)

Sinon, j'ai aussi une autre idée qui permet d'éviter tout calcul.

Si le langage permet de convertir un entier en chaine de caractère, et ensuite une fonction qui permet d'extraire un caractère à une position donnée dans une chaine, puis de reconvertir ce caractère en chiffre, le tour est joué ! Beaucoup de langages ont ce type de fonctions ...

Non, je n'ai pas ces fonctions.
J'ai été bloqué au même endroit parce qu'on a pas le nombre de chiffres au départ...

Oui, j'y ai pensé aussi.. en java, cela aurait été assez simple à faire je pense.

Mais ici, on travaille avec une espèce de langage machine qui utilise des registres.
Par exemple, pour faire un chiffre A + un chiffre B, on doit d'abord charger A dans un registre, B dans un autre pour ensuite faire la somme.
Pour faire a+b+c ; on doit faire a+b et ensuite, le résultat + c.

En effet, le langage semble assez peu évolué ...

Quand tu parles du 4ème chiffre, c'est celui à partir de la gauche ou de la droite ?

Je pense que c'est celui à partir de la gauche, ce qui serait logique.

Mais si on part de la droite, on pourrait diviser le nombre par 1000 et prendre le reste.
Ensuite, on aurait un chiffre à virgule (le chiffre cherché en partie entière). La division entière avec 1 nous renverrait-elle seulement le chiffre cherché ?

C'est vrai que si c'est à partir de la droite, c'est plus simple car on n'a pas besoin de connaitre le nombre de chiffres.

Sinon, j'ai une idée. Car il est possible d'extraire les chiffres à partir de la droite l'un après l'autre.
Bon, ne connaissant pas le nombre de chiffres, on pourrait peut-etre supposer qu'il y en a un maximum (du genre 10 ou 20, je ne sais pas).
Exempe, si je prends le nombre 2636875 à 7 chiffres, il serait possible d'extraire 10 chiffres par la droite, ça donnerait :
5
7
8
6
3
6
2
0
0
0
(on finirait par des zéros).

Ensuite, si on stocke tout ça dans un tableau (ou des variables), on cherche, en partant de la fin, à partir de quand on n'a plus de 0, puis on compte le 4ème chiffre.

Un truc de ce genre est-il envisageable ?

Ca

Désolé pour le double-post, faute de frappe..

Ca ne me semble pas réalisable ou alors très difficilement vu le langage utilisé.
Mais j'ai aussi trouvé quelque chose.

On pourrait faire une boucle : tant que le chiffre divisé par 10 est plus grand que zéro, on incrémente une variable.
Ainsi, on peut savoir de combien de chiffres est composé l'entier.

Ensuite, on fait une autre boucle qui va encore diviser le chiffre par 10 jusqu'à arriver au 4e.

Ah oui, pas bête, ça permettrait de connaitre le nombre de chiffres.

Ensuite, une petite manip permettrait d'extraire le chiffre qu'il faut.

Bon, l'idée semble là, mais avec ce langage, je te souhaite bon courage pour le codage de tout ceci !

Pour satisfaire macuriosité, ça veut dire quoi LMA ? Je sais que ce sigle est utilisé au Canada pour désigner les canadiens bilingues de Langue Maternelle Anglaise... mais ça doit être autre chose

Pour en revenir au langage minimaliste de manto235, ça me fait penser à mes premiers pas en programmation où on ne disposait que de quelques instructions et d'une mémoire minuscule... (il y a 35 ans)

Bonsoir !
Si la division entière tronque le résultat et renvoie un entier alors j'ai une idée d'algo :

mem <- division entière du nombre par 10    'si on a abcde on aura abcd

Faire
mem <- mem-1000
tant que mem>1000          'A la fin on aura bcd

Faire
mem <- mem-100
tant que mem>100           'A la fin on aura cd

Faire
mem <- mem-10
tant que mem>10            'A la fin on aura d

Afficher mem

Et si il n'y a pas de do...loop while il faudra mettre 24 conditions à la place.

Ce langage me semble proche de l'assembleur avec les variables que l'on doit mettre dans le registre de travail pour calculer...etc

matovitch >> attention, la méthode que tu utilises suppose que le nombre de départ a 5 chiffres, alors qu'il a 5 chiffres au minimum (ce qui complique la chose).

Bon alors un autre :

mem1 <- 100000

Tant que nb > mem1
mem1 <- mem1 * 10
Fin tant que

mem2 <- division entière de nb  par (mem1/10000)

mem1 <- 1000

Faire
Faire
mem2 <- mem2-mem1
tant que mem2 > mem1
mem1 <- mem1/10
tant que mem1 différent de 1

Afficher mem2

Comme vous le voyez, ça marche en vb.

C'est bizarre, je n'ai pas reçu de notifications pour les nouveaux messages...
LMA veut dire : langage (de la) machine.

Notre prof a créé un logiciel en java qui émule le langage machine (en gros).
Pour voir à quoi ça ressemble, voici le code d'un petit programme que j'ai dû faire il y a quelques temps :