Comment puis-je générer aléatoirement les éléments d'une division a/b=c où c n'a qu'une seule décimale ?

Question

Il s'agit plutôt d'une question de mathématiques/programmation de base. J'ai besoin de générer une division a/b=c. Je donne à l'utilisateur a et b et il doit répondre c, mais c ne peut avoir qu'une seule décimale. Par exemple, c=5,2 est acceptable, mais 5,23 est trop demandé, car les utilisateurs sont des enfants. J'ai donc besoin d'un algorithme capable de générer aléatoirement une division de ce type à partir de toutes les combinaisons possibles où a doit être inférieur à x, b doit être inférieur à y et c ne peut avoir qu'une seule décimale. De plus, a et b doivent être des entiers.

Je cherche une solution plus élégante que d'essayer des chiffres et de les vérifier jusqu'à ce qu'une bonne combinaison soit produite. En outre, il s'agit d'un contenu web, donc je préférerais le faire avec javascript, mais il peut être fait en php si nécessaire. Quelqu'un sait-il comment je pourrais le faire ? Je ne suis pas très bon en maths.

Merci beaucoup d'avance.

Answer 1

En gros, nous créons une liste de tous les facteurs premiers de A * 10, puis nous choisissons une combinaison aléatoire de facteurs pour créer B.

        int[] primes = new int[] { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997 };
        List<int> factors = new List<int>();
        int x = 1000;
        int y = 650;
        Random rand = new Random();
        int a = rand.Next(x);
        int _a = a * 10;
        int currentPrime = 0;

        //find all factors of a * 10
        while (_a > 1)
        {
            while (_a % primes[currentPrime] == 0)
            {
                factors.Add(primes[currentPrime]);
                _a /= primes[currentPrime];
            }
            currentPrime++;
        }

        int b = 1;
        foreach(int factor in factors)
        {
            if (b * factor > y) break;
            if (rand.Next(2) == 0)
            {
                b *= factor;
            }
        }

Answer 2

Essayez de générer C comme int/10 .
Puis générer B :

• juste int si (10 * C) % 10 == 0
• int * 2 si (10 * C) % 5 == 0
• int * 5 si (10 * C) % 2 == 0
• int * 10 sinon

Puis A = B * C et c'est int

PseudoCode :

tenC = rnd();
if(tenC % 10 == 0) B = rnd();
elseif(tenC % 5 == 0) B = rnd() * 2;
elseif(tenC % 2 == 0) B = rnd() * 5;
else B = rnd() * 10;
C = tenC / 10.0;
A = tenC * B / 10;

où rnd() génère un nombre entier comme vous le souhaitez

Answer 3

// Declare variables
var a, b, c, f = 1,
    highestCommonFactor = function(x, y) {
        var i;
        for (i = Math.min(x, y); i > 1; i--) {
            if (x / i == Math.round(x / i) && y / i == Math.round(y / i)) {
                return i;
            }
        }
        return false;
    };

// Pick two random numbers, b and c
// b should be a fairly small integer, i'll choose 5 as an upper limit
// c should be larger than 10 and not end with a 0
b = Math.floor((Math.random() * 5) + 1);
do {
    c = Math.floor(Math.random() * 100);
} while (c.toString().slice(-1) == "0");

// Multiply b by 10
b *= 10;

// Get a value for a
a = (c * b) / 10;

// Divide c by 10
c /= 10;

// Optional - Cancel a and b down to lowest possible integers
/*
while (f !== false) {
    a /= f;
    b /= f;
    f = highestCommonFactor(a, b);
}
//*/

Rien de tel qu'un bon défi mathématique pour vous tenir éveillé. Ce code a tendance à produire a y b où l'un d'entre eux est un multiple de 10, même si vous décommentez l'élément Facultatif - Annuler jusqu'aux plus petits nombres entiers possibles section ( b sera toujours un multiple de 10 si vous ne le faites pas). Cependant, je pense que cela est dans la nature de ce que vous faites, puisque pour que c pour avoir exactement un chiffre non nul après la virgule, il doit pouvoir être exprimé sous la forme suivante int / 10 .

Violon

Answer 4

function findEquation($maxA, $maxB){
    $x = 2;
    $e = NULL;

    do {
        $a = rand(1, $maxA);
        $b = rand(1, $maxB);
        $e = "$a / $b";
        $y = explode(".", $a/$b);
        if(count($y) > 1){
            $x = strlen($y[1]);
        }else {
            $x = 0;
        }
    } while($x > 1);

    return $e;
}

echo findEquation(100,100);

Mieux, cela permettra de trouver la première équation qui a une longueur de valeur décimale < 2.

Solution JavaScript :

function findEquation(maxA, maxB){
    var x = 2;
    var e = '';
    var a,b,c,d;

    do {
        a = Math.floor(Math.random() * maxA+1);
        b = Math.floor(Math.random() * maxB+1);
        e = a + '/' + b;
        c = (a/b).toString().split(".");
        if(c.length > 1){
            x = c[1].length;
        }else {
            x = 0;
        }
    } while( x > 1 );

    return e;
}

alert(findEquation(100,100));

Answer 5

http://jsfiddle.net/eX7fM/2/

var upper = getRandomInt(2, 100);

var lower;
var answer = 0.99; // sentinel

while (!numberHasOneOrNoDecimals(answer)) {
    lower = getRandomInt(1, upper);
    answer = upper / lower;
}

Cela implique toujours des boucles, mais c'est un peu plus élégant que la force brute pure et beaucoup plus simple à comprendre que ne le serait une approche sans boucle (la factorisation des nombres premiers et tout ce qui s'ensuit dépasse également mes compétences en mathématiques).