Bonjour,

je commence tout juste l'informatique et le langage C et j'ai beaucoup de mal.

On me de mande dans un exercice d'écrire un programme C permettant de décomposer un nombre à 4 chiffres saisi par un utilisateur en unité-dizaine-centaine-millier. On doit absolument trouvé une solution ne faisant intervenir ni les boucles, ni les tests, ni les tableaux, ni la division, ni le modulo...

Je suis complètement perdue, alors si quelqu'un pouvait m'aider et me mettre sur la voie se serait avec grand plaisir!!

Merci d'avance!

Bonjour,

J’ai une boîte à outils remplie de tournevis en tous genres et je dois visser une vis cruciforme sans utiliser de tournevis cruciforme ni de tournevis plat. Mais je débute, c’est sûrement pour ça que je n’y arrive pas…

Je te laisse tout le plaisir de l'écrire en C, mais voici la marche à suivre :


Saisie de l'utilisateur (nombre)
milliers = nombre/1000; // Division entière retourne le nombre de milliers
nombre = nombre - milliers * 1000;
centaines = nombre /100 ;
...

Je te laisse finir

Citation

On doit absolument trouvé une solution ne faisant intervenir ni les boucles, ni les tests, ni les tableaux, ni la division, ni le modulo...

Alors tu as le droit d'utiliser quoi ? Nan sérieusement, encore, même sans les boucles et les test ça serait possible, mais alors sans les tableaux, ni la division, ni le modulo !!! Autant réiventer la roue pendant qu'on y est.

@Achan : il n'y a pas le droit à la division.

edit : tant qu'à faire vérifie si tu as le droit à l'éditeur de texte, au compilo, au clavier, à la souris et à l'ordinateur, un débutant doit certainement savoir faire sans...

Je pars du principe qu'il (elle?) a mal lu l'énnoncé

Edit : Au pire il lui reste l'opérateur et/ou/non

En effet ça risque d'être chaud. Mais sinon, il t'a jamais interdit d'utiliser les opérateurs logiques bit à bit, il doit y avoir moyen de faire quelque chose avec (mais ce serait ultra tordu je pense)

variable unité, dizaine, centaine, millier

millier = lire 1 seul caractère
centaine = lire 1 seul caractère
dizaine = lire 1 seul caractère
unité = lire 1 seul caractère

Voilà qui est fait, sans boucles ni rien.

il y a peut-être moyen avec une fonction récursive? oO

fonction récursive + pointeur + soustractions seulement?

je ne sais pas si c'est faisable... mais sacrément c**


J'AI TROUVE! convertit ton nombre en chaine de caractères (il y a une fonction pour écrire dans uns chaine de caractère de la même façon que dans la console, je te laisse chercher par toi même). tu coup tu aura déja tout découpé.. il te restera plus qu'a récupérer les données du tableau

Merci de me répéter ((:

Il va quand même devoir mettre des conditions pour controler que c'est bien des entiers qu'il entre, donc c'est déjà perdu

Edit : Il parait qu'on fait un processeur entier avec 3 portes logiques (NAND et les deux autres je sais plus) (en tout cas un processeur avec division/soustraction/mul/add), tu peux toujours essayer avec les opérateurs x)

Et puis surtout, ça utilise les tableaux, qui sont interdits…

ha mer** j'avais oublié le coup des tableaux

Si on malloc, calloc, c'est considéré comme un tableau aussi?

• Récupérer le nombre sous forme d’une chaîne et lire les caractères un par un : interdit (utilise les tableaux).
• Diviser par 1000 pour obtenir les milliers, et jouer avec les modulos pour le reste : interdit (utilise les divisions et les modulos).

Avec une liste de contraintes aussi longue, bon courage…

@Achan : Je ne vois pas trop ce que tu veux allouer dynamiquement…

au lieu de diviser par 1000 ... multiplie par 0.001 et ainsi de suite . 100 -> 0.01 ; 10 -> 0.1

lexicalement c'est pas une division

Sauf que tu multiplies par un double, donc le résultat ne sera pas arrondi… Ça remplace la division décimale, pas la division entière…

Édition — Au temps pour moi, il suffit de rajouter un cast vers int…

bah ca oblige a tronquer après en passant par des fonctions de math.h. Mais je pense qu'il y a une bonne piste par là

@Nicolas M. : De l'allocation dynamique en dur Ainsi on utilise plus "réellement" de tableaux
@Nejaa : Pas mal, pas mal

void main(){
    int nombre;
    int m,c,d,u;

    printf("Entrer un nombre entier 0-9999 : ");
    scanf("%d", &nombre);

    m=nombre * 0.001;
    nombre -= m*1000;
    c= nombre * 0.01;
    nombre -= c*100;
    d= nombre * 0.1;
    nombre -= d*10;
    u= nombre;

    printf("m : %d\n", m);
    printf("c : %d\n", c);
    printf("d : %d\n", d);
    printf("u : %d\n", u);


}

@Nicolas M (second post) : Le résultat est tronqué dés que le résultat est mis dans un entier

La solution la plus simple serait un truc du genre :

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    char u,d,c,m;
    scanf("%c%c%c%c",&m,&c,&d,&u);

    printf("unites: %c\ndizaines: %c\ncentaines: %c\nmilliers: %c\n",
           u,d,c,m);

    return 0;
}

mais bon, là c'est à la limite de l'interprétation de la consigne...

@Bin-r : J'adore ta solution <3 quand le prof veut jouer au con... <3 le bon coté de ma méthode c'est que si l'utilisateur entre 124 554 il va dire que le nombre de milliers est 124, ce qui est juste du coup je découpe bien en 4 n'importe quel nombre entré. si c'est 1 245 556 alors il va dire qu'il y a 1245 milliers, ce qui est toujours juste

@achan : c'est exactement ce que je viens de coder mais tu aurai du laisser le PO chercher ;p

@nicolas_M : oui en effet le cast brutal vers un int marche aussi j'ai préféré faire un floor même si fondamentalement... ca ne change rien ici x)

Bin-R > C'est exactement ce que j'ai proposé plus haut, sans le code.

Citation : Pouet_forever

Bin-R > C'est exactement ce que j'ai proposé plus haut, sans le code.

exact, mais là je réfléchis à une solution encore plus loufoque.

a coup de rotation des bits?

j'ai déjà réfléchi à la rotation de bits et ça m'a l'air galère, par contre émuler la division par d'autres fonction marche plutôt bien.

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define division(a,b)   (int)(a*(double)pow(b,-1))

int main(void)
{
    int n,u,d,c,m;
    scanf("%d",&n);

    m = division(n,1000);
    c = division(n,100) - 10*m;
    d = division(n,10) - 100*m - 10*c;
    u = n - 1000*m - 100*c - 10*d;

    printf("unites: %d\ndizaines: %d\ncentaines: %d\nmilliers: %d\n",
           u,d,c,m);

    return 0;
}

ça part du principe que a / b = a * b^-1 tout simplement.

Citation

quand le prof veut jouer au con...

On est bien d'accord.

ta nouvelle solution est précisément celle que j'ai proposé ;p mais sans fonction pour ma part x)

(EDIT : en fait non x) moi je part du principe que a/b = a * (1/b) sauf que ici le 1/b on le connait, c'est les sous multiples de 10 ^^)

m'enfin si le PO retourne a son prof une solution a coup de rotation de bits ca claque ;D

Là tu utilises plein de trucs interdit ! xD

Citation : Pouet_forever

Là tu utilises plein de trucs interdit ! xD

Citation

On doit absolument trouvé une solution ne faisant intervenir ni les boucles, ni les tests, ni les tableaux, ni la division, ni le modulo...

je n'utilise ni les boucles, ni les test, ni les tableaux, j'ai fabriqué ma propre division, et il n'y a pas de modulo. En fait ça revient au même que de multiplier par des nombres inférieurs à 1 si on y réfléchit.

Citation

m'enfin si le PO retourne a son prof une solution a coup de rotation de bits ca claque ;D

généralement les codes avec les bitwise ont une certaine classe , mais si c'est un débutant, il va avoir du mal à coder ça.

Ah ouais, il me semblait avoir vu la multiplication ! Pardon sir ! :))

même sans être un débutant j'en ai encore jamais utilisé ^^'

Même pas pour utiliser des flags ?